From a3dc02d282f886d3b4842ec70976cfa84f2e4099 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Wed, 1 May 2019 16:11:17 +0700
Subject: [PATCH 01/17] Add addressable lists

---
 lib/pleroma/web/activity_pub/activity_pub.ex  | 74 +++++++++++++------
 .../web/activity_pub/transmogrifier.ex        |  5 +-
 lib/pleroma/web/common_api/common_api.ex      | 28 +++----
 lib/pleroma/web/common_api/utils.ex           | 15 ++++
 lib/pleroma/web/salmon/salmon.ex              |  8 +-
 5 files changed, 92 insertions(+), 38 deletions(-)

diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
index 604ffae7b..84d7f47b1 100644
--- a/lib/pleroma/web/activity_pub/activity_pub.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
@@ -28,19 +28,16 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do
   # For Announce activities, we filter the recipients based on following status for any actors
   # that match actual users.  See issue #164 for more information about why this is necessary.
   defp get_recipients(%{"type" => "Announce"} = data) do
-    to = data["to"] || []
-    cc = data["cc"] || []
+    to = Map.get(data, "to", [])
+    cc = Map.get(data, "cc", [])
+    bcc = Map.get(data, "bcc", [])
     actor = User.get_cached_by_ap_id(data["actor"])
 
     recipients =
-      (to ++ cc)
-      |> Enum.filter(fn recipient ->
+      Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
         case User.get_cached_by_ap_id(recipient) do
-          nil ->
-            true
-
-          user ->
-            User.following?(user, actor)
+          nil -> true
+          user -> User.following?(user, actor)
         end
       end)
 
@@ -48,17 +45,19 @@ defp get_recipients(%{"type" => "Announce"} = data) do
   end
 
   defp get_recipients(%{"type" => "Create"} = data) do
-    to = data["to"] || []
-    cc = data["cc"] || []
-    actor = data["actor"] || []
-    recipients = (to ++ cc ++ [actor]) |> Enum.uniq()
+    to = Map.get(data, "to", [])
+    cc = Map.get(data, "cc", [])
+    bcc = Map.get(data, "bcc", [])
+    actor = Map.get(data, "actor", [])
+    recipients = [to, cc, bcc, [actor]] |> Enum.concat() |> Enum.uniq()
     {recipients, to, cc}
   end
 
   defp get_recipients(data) do
-    to = data["to"] || []
-    cc = data["cc"] || []
-    recipients = to ++ cc
+    to = Map.get(data, "to", [])
+    cc = Map.get(data, "cc", [])
+    bcc = Map.get(data, "bcc", [])
+    recipients = Enum.concat([to, cc, bcc])
     {recipients, to, cc}
   end
 
@@ -917,22 +916,55 @@ def should_federate?(inbox, public) do
     end
   end
 
-  def publish(actor, activity) do
-    remote_followers =
+  defp recipients(actor, activity) do
+    Pleroma.Web.Salmon.remote_users(activity) ++
       if actor.follower_address in activity.recipients do
         {:ok, followers} = User.get_followers(actor)
         followers |> Enum.filter(&(!&1.local))
       else
         []
       end
+  end
 
+  def publish(actor, %{data: %{"bcc" => bcc}} = activity) when is_list(bcc) and bcc != [] do
     public = is_public?(activity)
-
     {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
+
+    recipients = recipients(actor, activity)
+
+    recipients
+    |> Enum.filter(&User.ap_enabled?/1)
+    |> Enum.map(fn %{info: %{source_data: data}} -> data["inbox"] end)
+    |> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
+    |> Instances.filter_reachable()
+    |> Enum.each(fn {inbox, unreachable_since} ->
+      %User{ap_id: cc} =
+        Enum.find(recipients, fn %{info: %{source_data: data}} -> data["inbox"] == inbox end)
+
+      json =
+        data
+        |> Map.put("cc", [cc])
+        |> Map.put("directMessage", true)
+        |> Jason.encode!()
+
+      Federator.publish_single_ap(%{
+        inbox: inbox,
+        json: json,
+        actor: actor,
+        id: activity.data["id"],
+        unreachable_since: unreachable_since
+      })
+    end)
+  end
+
+  def publish(actor, activity) do
+    public = is_public?(activity)
+    {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
+
     json = Jason.encode!(data)
 
-    (Pleroma.Web.Salmon.remote_users(activity) ++ remote_followers)
-    |> Enum.filter(fn user -> User.ap_enabled?(user) end)
+    recipients(actor, activity)
+    |> Enum.filter(&User.ap_enabled?/1)
     |> Enum.map(fn %{info: %{source_data: data}} ->
       (is_map(data["endpoints"]) && Map.get(data["endpoints"], "sharedInbox")) || data["inbox"]
     end)
diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
index b1e859d7c..3b7193eaa 100644
--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
@@ -741,13 +741,16 @@ def prepare_object(object) do
 
   def prepare_outgoing(%{"type" => "Create", "object" => object_id} = data) do
     object =
-      Object.normalize(object_id).data
+      object_id
+      |> Object.normalize()
+      |> Map.get(:data)
       |> prepare_object
 
     data =
       data
       |> Map.put("object", object)
       |> Map.merge(Utils.make_json_ld_header())
+      |> Map.delete("bcc")
 
     {:ok, data}
   end
diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
index cfbc5dc10..4ca59110f 100644
--- a/lib/pleroma/web/common_api/common_api.ex
+++ b/lib/pleroma/web/common_api/common_api.ex
@@ -119,6 +119,10 @@ def get_visibility(%{"visibility" => visibility})
       when visibility in ~w{public unlisted private direct},
       do: visibility
 
+  def get_visibility(%{"visibility" => "list:" <> list_id}) do
+    {:list, String.to_integer(list_id)}
+  end
+
   def get_visibility(%{"in_reply_to_status_id" => status_id}) when not is_nil(status_id) do
     case get_replied_to_activity(status_id) do
       nil ->
@@ -149,6 +153,7 @@ def post(user, %{"status" => status} = data) do
              visibility
            ),
          {to, cc} <- to_for_user_and_mentions(user, mentions, in_reply_to, visibility),
+         {:ok, bcc} <- bcc_for_list(user, visibility),
          context <- make_context(in_reply_to),
          cw <- data["spoiler_text"],
          full_payload <- String.trim(status <> (data["spoiler_text"] || "")),
@@ -174,19 +179,16 @@ def post(user, %{"status" => status} = data) do
                Map.put(acc, name, "#{Pleroma.Web.Endpoint.static_url()}#{file}")
              end)
            ) do
-      res =
-        ActivityPub.create(
-          %{
-            to: to,
-            actor: user,
-            context: context,
-            object: object,
-            additional: %{"cc" => cc, "directMessage" => visibility == "direct"}
-          },
-          Pleroma.Web.ControllerHelper.truthy_param?(data["preview"]) || false
-        )
-
-      res
+      ActivityPub.create(
+        %{
+          to: to,
+          actor: user,
+          context: context,
+          object: object,
+          additional: %{"cc" => cc, "bcc" => bcc, "directMessage" => visibility == "direct"}
+        },
+        Pleroma.Web.ControllerHelper.truthy_param?(data["preview"]) || false
+      )
     end
   end
 
diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
index 887f878c4..83a745b58 100644
--- a/lib/pleroma/web/common_api/utils.ex
+++ b/lib/pleroma/web/common_api/utils.ex
@@ -8,6 +8,7 @@ defmodule Pleroma.Web.CommonAPI.Utils do
   alias Pleroma.Activity
   alias Pleroma.Config
   alias Pleroma.Formatter
+  alias Pleroma.List
   alias Pleroma.Object
   alias Pleroma.Repo
   alias Pleroma.User
@@ -102,6 +103,20 @@ def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
     end
   end
 
+  def to_for_user_and_mentions(_user, _mentions, _inReplyTo, _), do: {[], []}
+
+  def bcc_for_list(user, {:list, list_id}) do
+    with {_, %List{} = list} <- {:list, List.get(list_id, user)},
+         {:ok, following} <- List.get_following(list) do
+      {:ok, Enum.map(following, & &1.ap_id)}
+    else
+      {:list, _} -> {:error, "List not found"}
+      err -> err
+    end
+  end
+
+  def bcc_for_list(_, _), do: {:ok, []}
+
   def make_content_html(
         status,
         attachments,
diff --git a/lib/pleroma/web/salmon/salmon.ex b/lib/pleroma/web/salmon/salmon.ex
index 0a9e51656..4d89f4bdb 100644
--- a/lib/pleroma/web/salmon/salmon.ex
+++ b/lib/pleroma/web/salmon/salmon.ex
@@ -157,10 +157,12 @@ def encode(private_key, doc) do
   end
 
   def remote_users(%{data: %{"to" => to} = data}) do
-    to = to ++ (data["cc"] || [])
+    cc = Map.get(data, "cc", [])
+    bcc = Map.get(data, "bcc", [])
 
-    to
-    |> Enum.map(fn id -> User.get_cached_by_ap_id(id) end)
+    [to, cc, bcc]
+    |> Enum.concat()
+    |> Enum.map(&User.get_cached_by_ap_id/1)
     |> Enum.filter(fn user -> user && !user.local end)
   end
 

From 23276e8d6848fa8eae390c16b6e0619c12546e4a Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 13 May 2019 16:15:14 +0700
Subject: [PATCH 02/17] Use pseudo ap id of a list in BCC

---
 lib/pleroma/list.ex                          | 32 ++++++++++++++
 lib/pleroma/web/activity_pub/activity_pub.ex | 46 ++++++++++++++++----
 lib/pleroma/web/common_api/common_api.ex     |  8 ++--
 lib/pleroma/web/common_api/utils.ex          | 11 +----
 lib/pleroma/web/salmon/salmon.ex             | 19 ++++++--
 5 files changed, 92 insertions(+), 24 deletions(-)

diff --git a/lib/pleroma/list.ex b/lib/pleroma/list.ex
index a5b1cad68..81b842e9c 100644
--- a/lib/pleroma/list.ex
+++ b/lib/pleroma/list.ex
@@ -12,6 +12,8 @@ defmodule Pleroma.List do
   alias Pleroma.Repo
   alias Pleroma.User
 
+  @ap_id_regex ~r/^\/users\/(?<nickname>\w+)\/lists\/(?<list_id>\d+)/
+
   schema "lists" do
     belongs_to(:user, User, type: Pleroma.FlakeId)
     field(:title, :string)
@@ -32,6 +34,12 @@ def follow_changeset(list, attrs \\ %{}) do
     |> validate_required([:following])
   end
 
+  def ap_id(%User{nickname: nickname}, list_id) do
+    Pleroma.Web.Endpoint.url() <> "/users/#{nickname}/lists/#{list_id}"
+  end
+
+  def ap_id({nickname, list_id}), do: ap_id(%User{nickname: nickname}, list_id)
+
   def for_user(user, _opts) do
     query =
       from(
@@ -55,6 +63,19 @@ def get(id, %{id: user_id} = _user) do
     Repo.one(query)
   end
 
+  def get_by_ap_id(ap_id) do
+    host = Pleroma.Web.Endpoint.host()
+
+    with %{host: ^host, path: path} <- URI.parse(ap_id),
+         %{"list_id" => list_id, "nickname" => nickname} <-
+           Regex.named_captures(@ap_id_regex, path),
+         %User{} = user <- User.get_cached_by_nickname(nickname) do
+      get(list_id, user)
+    else
+      _ -> nil
+    end
+  end
+
   def get_following(%Pleroma.List{following: following} = _list) do
     q =
       from(
@@ -125,4 +146,15 @@ def update_follows(%Pleroma.List{} = list, attrs) do
     |> follow_changeset(attrs)
     |> Repo.update()
   end
+
+  def memberships(%User{follower_address: follower_address}) do
+    Pleroma.List
+    |> where([l], ^follower_address in l.following)
+    |> join(:inner, [l], u in User, on: l.user_id == u.id)
+    |> select([l, u], {u.nickname, l.id})
+    |> Repo.all()
+    |> Enum.map(&ap_id/1)
+  end
+
+  def memberships(_), do: []
 end
diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
index 84d7f47b1..3b71e0369 100644
--- a/lib/pleroma/web/activity_pub/activity_pub.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
@@ -783,9 +783,7 @@ defp maybe_preload_objects(query, _) do
   end
 
   def fetch_activities_query(recipients, opts \\ %{}) do
-    base_query = from(activity in Activity)
-
-    base_query
+    Activity
     |> maybe_preload_objects(opts)
     |> restrict_recipients(recipients, opts["user"])
     |> restrict_tag(opts)
@@ -807,9 +805,29 @@ def fetch_activities_query(recipients, opts \\ %{}) do
   end
 
   def fetch_activities(recipients, opts \\ %{}) do
-    fetch_activities_query(recipients, opts)
+    list_memberships = Pleroma.List.memberships(opts["user"])
+
+    fetch_activities_query(recipients ++ list_memberships, opts)
     |> Pagination.fetch_paginated(opts)
     |> Enum.reverse()
+    |> maybe_update_cc(list_memberships, opts["user"])
+  end
+
+  defp maybe_update_cc(activities, [], _), do: activities
+  defp maybe_update_cc(activities, _, nil), do: activities
+
+  defp maybe_update_cc(activities, list_memberships, user) do
+    Enum.map(activities, fn
+      %{data: %{"bcc" => bcc}} = activity when is_list(bcc) ->
+        if Enum.any?(bcc, &(&1 in list_memberships)) do
+          update_in(activity.data["cc"], &[user.ap_id | &1])
+        else
+          activity
+        end
+
+      activity ->
+        activity
+    end)
   end
 
   def fetch_activities_bounded(recipients_to, recipients_cc, opts \\ %{}) do
@@ -917,13 +935,23 @@ def should_federate?(inbox, public) do
   end
 
   defp recipients(actor, activity) do
-    Pleroma.Web.Salmon.remote_users(activity) ++
+    followers =
       if actor.follower_address in activity.recipients do
         {:ok, followers} = User.get_followers(actor)
-        followers |> Enum.filter(&(!&1.local))
+        Enum.filter(followers, &(!&1.local))
       else
         []
       end
+
+    Pleroma.Web.Salmon.remote_users(actor, activity) ++ followers
+  end
+
+  defp get_cc_ap_ids(ap_id, recipients) do
+    host = Map.get(URI.parse(ap_id), :host)
+
+    recipients
+    |> Enum.filter(fn %User{ap_id: ap_id} -> Map.get(URI.parse(ap_id), :host) == host end)
+    |> Enum.map(& &1.ap_id)
   end
 
   def publish(actor, %{data: %{"bcc" => bcc}} = activity) when is_list(bcc) and bcc != [] do
@@ -938,12 +966,14 @@ def publish(actor, %{data: %{"bcc" => bcc}} = activity) when is_list(bcc) and bc
     |> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
     |> Instances.filter_reachable()
     |> Enum.each(fn {inbox, unreachable_since} ->
-      %User{ap_id: cc} =
+      %User{ap_id: ap_id} =
         Enum.find(recipients, fn %{info: %{source_data: data}} -> data["inbox"] == inbox end)
 
+      cc = get_cc_ap_ids(ap_id, recipients)
+
       json =
         data
-        |> Map.put("cc", [cc])
+        |> Map.put("cc", cc)
         |> Map.put("directMessage", true)
         |> Jason.encode!()
 
diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
index 4ca59110f..d47d5788c 100644
--- a/lib/pleroma/web/common_api/common_api.ex
+++ b/lib/pleroma/web/common_api/common_api.ex
@@ -153,7 +153,7 @@ def post(user, %{"status" => status} = data) do
              visibility
            ),
          {to, cc} <- to_for_user_and_mentions(user, mentions, in_reply_to, visibility),
-         {:ok, bcc} <- bcc_for_list(user, visibility),
+         bcc <- bcc_for_list(user, visibility),
          context <- make_context(in_reply_to),
          cw <- data["spoiler_text"],
          full_payload <- String.trim(status <> (data["spoiler_text"] || "")),
@@ -197,7 +197,7 @@ def update(user) do
     user =
       with emoji <- emoji_from_profile(user),
            source_data <- (user.info.source_data || %{}) |> Map.put("tag", emoji),
-           info_cng <- Pleroma.User.Info.set_source_data(user.info, source_data),
+           info_cng <- User.Info.set_source_data(user.info, source_data),
            change <- Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_cng),
            {:ok, user} <- User.update_and_set_cache(change) do
         user
@@ -230,7 +230,7 @@ def pin(id_or_ap_id, %{ap_id: user_ap_id} = user) do
          } = activity <- get_by_id_or_ap_id(id_or_ap_id),
          true <- Enum.member?(object_to, "https://www.w3.org/ns/activitystreams#Public"),
          %{valid?: true} = info_changeset <-
-           Pleroma.User.Info.add_pinnned_activity(user.info, activity),
+           User.Info.add_pinnned_activity(user.info, activity),
          changeset <-
            Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_changeset),
          {:ok, _user} <- User.update_and_set_cache(changeset) do
@@ -247,7 +247,7 @@ def pin(id_or_ap_id, %{ap_id: user_ap_id} = user) do
   def unpin(id_or_ap_id, user) do
     with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
          %{valid?: true} = info_changeset <-
-           Pleroma.User.Info.remove_pinnned_activity(user.info, activity),
+           User.Info.remove_pinnned_activity(user.info, activity),
          changeset <-
            Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_changeset),
          {:ok, _user} <- User.update_and_set_cache(changeset) do
diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
index 83a745b58..32c3b4b98 100644
--- a/lib/pleroma/web/common_api/utils.ex
+++ b/lib/pleroma/web/common_api/utils.ex
@@ -8,7 +8,6 @@ defmodule Pleroma.Web.CommonAPI.Utils do
   alias Pleroma.Activity
   alias Pleroma.Config
   alias Pleroma.Formatter
-  alias Pleroma.List
   alias Pleroma.Object
   alias Pleroma.Repo
   alias Pleroma.User
@@ -106,16 +105,10 @@ def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
   def to_for_user_and_mentions(_user, _mentions, _inReplyTo, _), do: {[], []}
 
   def bcc_for_list(user, {:list, list_id}) do
-    with {_, %List{} = list} <- {:list, List.get(list_id, user)},
-         {:ok, following} <- List.get_following(list) do
-      {:ok, Enum.map(following, & &1.ap_id)}
-    else
-      {:list, _} -> {:error, "List not found"}
-      err -> err
-    end
+    [Pleroma.List.ap_id(user, list_id)]
   end
 
-  def bcc_for_list(_, _), do: {:ok, []}
+  def bcc_for_list(_, _), do: []
 
   def make_content_html(
         status,
diff --git a/lib/pleroma/web/salmon/salmon.ex b/lib/pleroma/web/salmon/salmon.ex
index 4d89f4bdb..ca51255f3 100644
--- a/lib/pleroma/web/salmon/salmon.ex
+++ b/lib/pleroma/web/salmon/salmon.ex
@@ -156,9 +156,22 @@ def encode(private_key, doc) do
     {:ok, salmon}
   end
 
-  def remote_users(%{data: %{"to" => to} = data}) do
+  def remote_users(%User{id: user_id}, %{data: %{"to" => to} = data}) do
     cc = Map.get(data, "cc", [])
-    bcc = Map.get(data, "bcc", [])
+
+    bcc =
+      data
+      |> Map.get("bcc", [])
+      |> Enum.reduce([], fn ap_id, bcc ->
+        case Pleroma.List.get_by_ap_id(ap_id) do
+          %Pleroma.List{user_id: ^user_id} = list ->
+            {:ok, following} = Pleroma.List.get_following(list)
+            bcc ++ Enum.map(following, & &1.ap_id)
+
+          _ ->
+            bcc
+        end
+      end)
 
     [to, cc, bcc]
     |> Enum.concat()
@@ -220,7 +233,7 @@ def publish(%{info: %{keys: keys}} = user, %{data: %{"type" => type}} = activity
       {:ok, private, _} = keys_from_pem(keys)
       {:ok, feed} = encode(private, feed)
 
-      remote_users = remote_users(activity)
+      remote_users = remote_users(user, activity)
 
       salmon_urls = Enum.map(remote_users, & &1.info.salmon)
       reachable_urls_metadata = Instances.filter_reachable(salmon_urls)

From d474995efa83e03f8aeaf57c1437aaa483960f7a Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Tue, 14 May 2019 20:12:47 +0700
Subject: [PATCH 03/17] Add Tests

---
 test/list_test.exs                            | 29 +++++++++++++++++++
 test/web/activity_pub/activity_pub_test.exs   | 14 +++++++++
 test/web/activity_pub/transmogrifier_test.exs | 12 ++++++++
 test/web/common_api/common_api_test.exs       | 13 +++++++++
 4 files changed, 68 insertions(+)

diff --git a/test/list_test.exs b/test/list_test.exs
index 1909c0cd9..0e72b6660 100644
--- a/test/list_test.exs
+++ b/test/list_test.exs
@@ -113,4 +113,33 @@ test "getting own lists a given user belongs to" do
     assert owned_list in lists_2
     refute not_owned_list in lists_2
   end
+
+  test "get ap_id by user nickname and list id" do
+    nickname = "foo"
+    list_id = 42
+
+    expected = Pleroma.Web.Endpoint.url() <> "/users/#{nickname}/lists/#{list_id}"
+
+    assert Pleroma.List.ap_id(%Pleroma.User{nickname: nickname}, list_id) == expected
+    assert Pleroma.List.ap_id({nickname, list_id}) == expected
+  end
+
+  test "get by ap_id" do
+    user = insert(:user)
+    {:ok, list} = Pleroma.List.create("foo", user)
+    ap_id = Pleroma.List.ap_id(user, list.id)
+
+    assert Pleroma.List.get_by_ap_id(ap_id) == list
+  end
+
+  test "memberships" do
+    user = insert(:user)
+    member = insert(:user)
+    {:ok, list} = Pleroma.List.create("foo", user)
+    {:ok, list} = Pleroma.List.follow(list, member)
+
+    list_ap_id = Pleroma.List.ap_id(user, list.id)
+
+    assert Pleroma.List.memberships(member) == [list_ap_id]
+  end
 end
diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
index 0f90aa1ac..e38de388b 100644
--- a/test/web/activity_pub/activity_pub_test.exs
+++ b/test/web/activity_pub/activity_pub_test.exs
@@ -1156,6 +1156,20 @@ test "it can create a Flag activity" do
     end
   end
 
+  test "fetch_activities/2 returns activities addressed to a list " do
+    user = insert(:user)
+    member = insert(:user)
+    {:ok, list} = Pleroma.List.create("foo", user)
+    {:ok, list} = Pleroma.List.follow(list, member)
+
+    {:ok, activity} =
+      CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
+
+    activity = Repo.preload(activity, :bookmark)
+
+    assert ActivityPub.fetch_activities([], %{"user" => user}) == [activity]
+  end
+
   def data_uri do
     File.read!("test/fixtures/avatar_data_uri")
   end
diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
index c24b50f8c..e93189df6 100644
--- a/test/web/activity_pub/transmogrifier_test.exs
+++ b/test/web/activity_pub/transmogrifier_test.exs
@@ -1028,6 +1028,18 @@ test "the directMessage flag is present" do
 
       assert modified["directMessage"] == true
     end
+
+    test "it strips BCC field" do
+      user = insert(:user)
+      {:ok, list} = Pleroma.List.create("foo", user)
+
+      {:ok, activity} =
+        CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
+
+      {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
+
+      assert is_nil(modified["bcc"])
+    end
   end
 
   describe "user upgrade" do
diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
index a5b07c446..11f3c8357 100644
--- a/test/web/common_api/common_api_test.exs
+++ b/test/web/common_api/common_api_test.exs
@@ -87,6 +87,19 @@ test "it filters out obviously bad tags when accepting a post as Markdown" do
 
       assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
     end
+
+    test "it allows to address a list" do
+      user = insert(:user)
+      {:ok, list} = Pleroma.List.create("foo", user)
+
+      list_ap_id = Pleroma.List.ap_id(user, list.id)
+
+      {:ok, activity} =
+        CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
+
+      assert activity.data["bcc"] == [list_ap_id]
+      assert activity.recipients == [list_ap_id, user.ap_id]
+    end
   end
 
   describe "reactions" do

From 8feea72781e5813941d986effe785cae6a5dee90 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Tue, 14 May 2019 20:14:51 +0700
Subject: [PATCH 04/17] Update CHANGELOG

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5c0baa317..2fadb5f18 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -32,6 +32,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - OAuth: added support for refresh tokens
 - Emoji packs and emoji pack manager
 - AdminFE: initial release with basic user management accessible at /pleroma/admin/
+- Addressable lists
 
 ### Changed
 - **Breaking:** Configuration: move from Pleroma.Mailer to Pleroma.Emails.Mailer

From fc9b4410c4182747fbcbc2cbe2b94090c887b96f Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Tue, 14 May 2019 20:27:40 +0700
Subject: [PATCH 05/17] Add documentation

---
 docs/api/differences_in_mastoapi_responses.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/api/differences_in_mastoapi_responses.md b/docs/api/differences_in_mastoapi_responses.md
index 36b47608e..946e0e885 100644
--- a/docs/api/differences_in_mastoapi_responses.md
+++ b/docs/api/differences_in_mastoapi_responses.md
@@ -69,6 +69,7 @@ Additional parameters can be added to the JSON body/Form data:
 
 - `preview`: boolean, if set to `true` the post won't be actually posted, but the status entitiy would still be rendered back. This could be useful for previewing rich text/custom emoji, for example.
 - `content_type`: string, contain the MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint.
+- `visibility`: string, besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`.
 
 ## PATCH `/api/v1/update_credentials`
 

From f2936e0a0723956c167a06dc51518da172a508b2 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Fri, 17 May 2019 19:56:37 +0700
Subject: [PATCH 06/17] Add `ap_id` to List

---
 lib/pleroma/list.ex                           | 33 +++++++------------
 lib/pleroma/web/common_api/utils.ex           |  3 +-
 .../20190516112144_add_ap_id_to_lists.exs     | 26 +++++++++++++++
 test/list_test.exs                            | 18 ++--------
 test/web/common_api/common_api_test.exs       |  6 ++--
 5 files changed, 43 insertions(+), 43 deletions(-)
 create mode 100644 priv/repo/migrations/20190516112144_add_ap_id_to_lists.exs

diff --git a/lib/pleroma/list.ex b/lib/pleroma/list.ex
index 81b842e9c..16955b3b5 100644
--- a/lib/pleroma/list.ex
+++ b/lib/pleroma/list.ex
@@ -12,12 +12,11 @@ defmodule Pleroma.List do
   alias Pleroma.Repo
   alias Pleroma.User
 
-  @ap_id_regex ~r/^\/users\/(?<nickname>\w+)\/lists\/(?<list_id>\d+)/
-
   schema "lists" do
     belongs_to(:user, User, type: Pleroma.FlakeId)
     field(:title, :string)
     field(:following, {:array, :string}, default: [])
+    field(:ap_id, :string)
 
     timestamps()
   end
@@ -34,12 +33,6 @@ def follow_changeset(list, attrs \\ %{}) do
     |> validate_required([:following])
   end
 
-  def ap_id(%User{nickname: nickname}, list_id) do
-    Pleroma.Web.Endpoint.url() <> "/users/#{nickname}/lists/#{list_id}"
-  end
-
-  def ap_id({nickname, list_id}), do: ap_id(%User{nickname: nickname}, list_id)
-
   def for_user(user, _opts) do
     query =
       from(
@@ -64,16 +57,7 @@ def get(id, %{id: user_id} = _user) do
   end
 
   def get_by_ap_id(ap_id) do
-    host = Pleroma.Web.Endpoint.host()
-
-    with %{host: ^host, path: path} <- URI.parse(ap_id),
-         %{"list_id" => list_id, "nickname" => nickname} <-
-           Regex.named_captures(@ap_id_regex, path),
-         %User{} = user <- User.get_cached_by_nickname(nickname) do
-      get(list_id, user)
-    else
-      _ -> nil
-    end
+    Repo.get_by(__MODULE__, ap_id: ap_id)
   end
 
   def get_following(%Pleroma.List{following: following} = _list) do
@@ -126,7 +110,14 @@ def rename(%Pleroma.List{} = list, title) do
 
   def create(title, %User{} = creator) do
     list = %Pleroma.List{user_id: creator.id, title: title}
-    Repo.insert(list)
+
+    Repo.transaction(fn ->
+      list = Repo.insert!(list)
+
+      list
+      |> change(ap_id: "#{creator.ap_id}/lists/#{list.id}")
+      |> Repo.update!()
+    end)
   end
 
   def follow(%Pleroma.List{following: following} = list, %User{} = followed) do
@@ -150,10 +141,8 @@ def update_follows(%Pleroma.List{} = list, attrs) do
   def memberships(%User{follower_address: follower_address}) do
     Pleroma.List
     |> where([l], ^follower_address in l.following)
-    |> join(:inner, [l], u in User, on: l.user_id == u.id)
-    |> select([l, u], {u.nickname, l.id})
+    |> select([l], l.ap_id)
     |> Repo.all()
-    |> Enum.map(&ap_id/1)
   end
 
   def memberships(_), do: []
diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
index f082b77d8..ba6ed67ef 100644
--- a/lib/pleroma/web/common_api/utils.ex
+++ b/lib/pleroma/web/common_api/utils.ex
@@ -105,7 +105,8 @@ def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
   def to_for_user_and_mentions(_user, _mentions, _inReplyTo, _), do: {[], []}
 
   def bcc_for_list(user, {:list, list_id}) do
-    [Pleroma.List.ap_id(user, list_id)]
+    list = Pleroma.List.get(list_id, user)
+    [list.ap_id]
   end
 
   def bcc_for_list(_, _), do: []
diff --git a/priv/repo/migrations/20190516112144_add_ap_id_to_lists.exs b/priv/repo/migrations/20190516112144_add_ap_id_to_lists.exs
new file mode 100644
index 000000000..3c32bc355
--- /dev/null
+++ b/priv/repo/migrations/20190516112144_add_ap_id_to_lists.exs
@@ -0,0 +1,26 @@
+defmodule Pleroma.Repo.Migrations.AddApIdToLists do
+  use Ecto.Migration
+
+  def up do
+    alter table(:lists) do
+      add(:ap_id, :string)
+    end
+
+    execute("""
+    UPDATE lists
+    SET ap_id = u.ap_id || '/lists/' || lists.id
+    FROM users AS u
+    WHERE lists.user_id = u.id
+    """)
+
+    create(unique_index(:lists, :ap_id))
+  end
+
+  def down do
+    drop(index(:lists, [:ap_id]))
+
+    alter table(:lists) do
+      remove(:ap_id)
+    end
+  end
+end
diff --git a/test/list_test.exs b/test/list_test.exs
index 0e72b6660..6c5c6b197 100644
--- a/test/list_test.exs
+++ b/test/list_test.exs
@@ -114,22 +114,10 @@ test "getting own lists a given user belongs to" do
     refute not_owned_list in lists_2
   end
 
-  test "get ap_id by user nickname and list id" do
-    nickname = "foo"
-    list_id = 42
-
-    expected = Pleroma.Web.Endpoint.url() <> "/users/#{nickname}/lists/#{list_id}"
-
-    assert Pleroma.List.ap_id(%Pleroma.User{nickname: nickname}, list_id) == expected
-    assert Pleroma.List.ap_id({nickname, list_id}) == expected
-  end
-
   test "get by ap_id" do
     user = insert(:user)
     {:ok, list} = Pleroma.List.create("foo", user)
-    ap_id = Pleroma.List.ap_id(user, list.id)
-
-    assert Pleroma.List.get_by_ap_id(ap_id) == list
+    assert Pleroma.List.get_by_ap_id(list.ap_id) == list
   end
 
   test "memberships" do
@@ -138,8 +126,6 @@ test "memberships" do
     {:ok, list} = Pleroma.List.create("foo", user)
     {:ok, list} = Pleroma.List.follow(list, member)
 
-    list_ap_id = Pleroma.List.ap_id(user, list.id)
-
-    assert Pleroma.List.memberships(member) == [list_ap_id]
+    assert Pleroma.List.memberships(member) == [list.ap_id]
   end
 end
diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
index 23e89d685..84744e5af 100644
--- a/test/web/common_api/common_api_test.exs
+++ b/test/web/common_api/common_api_test.exs
@@ -114,13 +114,11 @@ test "it allows to address a list" do
       user = insert(:user)
       {:ok, list} = Pleroma.List.create("foo", user)
 
-      list_ap_id = Pleroma.List.ap_id(user, list.id)
-
       {:ok, activity} =
         CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
 
-      assert activity.data["bcc"] == [list_ap_id]
-      assert activity.recipients == [list_ap_id, user.ap_id]
+      assert activity.data["bcc"] == [list.ap_id]
+      assert activity.recipients == [list.ap_id, user.ap_id]
     end
   end
 

From 3b71612d3d8b5e2ad53bda4399eb7f687cd6c30e Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Sat, 18 May 2019 01:17:14 +0700
Subject: [PATCH 07/17] Improve
 Pleroma.Web.ActivityPub.ActivityPub.maybe_update_cc/3

---
 lib/pleroma/web/activity_pub/activity_pub.ex | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
index 048b9202b..8a5b3b8b4 100644
--- a/lib/pleroma/web/activity_pub/activity_pub.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
@@ -881,14 +881,12 @@ def fetch_activities(recipients, opts \\ %{}) do
     |> maybe_update_cc(list_memberships, opts["user"])
   end
 
-  defp maybe_update_cc(activities, [], _), do: activities
-  defp maybe_update_cc(activities, _, nil), do: activities
-
-  defp maybe_update_cc(activities, list_memberships, user) do
+  defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
+       when is_list(list_memberships) and length(list_memberships) > 0 do
     Enum.map(activities, fn
-      %{data: %{"bcc" => bcc}} = activity when is_list(bcc) ->
+      %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
         if Enum.any?(bcc, &(&1 in list_memberships)) do
-          update_in(activity.data["cc"], &[user.ap_id | &1])
+          update_in(activity.data["cc"], &[user_ap_id | &1])
         else
           activity
         end
@@ -898,6 +896,8 @@ defp maybe_update_cc(activities, list_memberships, user) do
     end)
   end
 
+  defp maybe_update_cc(activities, _, _), do: activities
+
   def fetch_activities_bounded(recipients_to, recipients_cc, opts \\ %{}) do
     fetch_activities_query([], opts)
     |> restrict_to_cc(recipients_to, recipients_cc)

From a7affbdd6d46caddea05ee6b34e0b2a24a62e721 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Fri, 24 May 2019 21:41:11 +0700
Subject: [PATCH 08/17] Fix tests

---
 test/web/activity_pub/activity_pub_test.exs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
index 5d0d5a40e..23b11d015 100644
--- a/test/web/activity_pub/activity_pub_test.exs
+++ b/test/web/activity_pub/activity_pub_test.exs
@@ -1193,6 +1193,7 @@ test "fetch_activities/2 returns activities addressed to a list " do
       CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
 
     activity = Repo.preload(activity, :bookmark)
+    activity = %Activity{activity | thread_muted?: !!activity.thread_muted?}
 
     assert ActivityPub.fetch_activities([], %{"user" => user}) == [activity]
   end

From ddd4a09b72ede65345ddf45a68eb239b54eda86c Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Wed, 5 Jun 2019 17:55:00 +0700
Subject: [PATCH 09/17] Fix merge conflict

---
 lib/pleroma/web/common_api/utils.ex | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
index 22ce1ea90..6c9e117ae 100644
--- a/lib/pleroma/web/common_api/utils.ex
+++ b/lib/pleroma/web/common_api/utils.ex
@@ -98,6 +98,8 @@ def get_to_and_cc(_user, mentioned_users, inReplyTo, "direct") do
     end
   end
 
+  def get_to_and_cc(_user, _mentions, _inReplyTo, _), do: {[], []}
+
   def get_addressed_users(_, to) when is_list(to) do
     User.get_ap_ids_by_nicknames(to)
   end

From 958fb9aa8082eabf63b106007b3bef09847cafc6 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Thu, 11 Jul 2019 16:36:08 +0700
Subject: [PATCH 10/17] Add "listMessage"

---
 lib/pleroma/web/activity_pub/publisher.ex |  1 -
 lib/pleroma/web/common_api/common_api.ex  | 26 +++++++++++++----------
 lib/pleroma/web/common_api/utils.ex       | 15 +++++++++----
 test/web/common_api/common_api_test.exs   |  1 +
 4 files changed, 27 insertions(+), 16 deletions(-)

diff --git a/lib/pleroma/web/activity_pub/publisher.ex b/lib/pleroma/web/activity_pub/publisher.ex
index b7dc90caa..ffdd33351 100644
--- a/lib/pleroma/web/activity_pub/publisher.ex
+++ b/lib/pleroma/web/activity_pub/publisher.ex
@@ -136,7 +136,6 @@ def publish(actor, %{data: %{"bcc" => bcc}} = activity) when is_list(bcc) and bc
       json =
         data
         |> Map.put("cc", cc)
-        |> Map.put("directMessage", true)
         |> Jason.encode!()
 
       Pleroma.Web.Federator.Publisher.enqueue_one(__MODULE__, %{
diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
index 8e3892bdf..1c47a31d7 100644
--- a/lib/pleroma/web/common_api/common_api.ex
+++ b/lib/pleroma/web/common_api/common_api.ex
@@ -215,7 +215,6 @@ def post(user, %{"status" => status} = data) do
          addressed_users <- get_addressed_users(mentioned_users, data["to"]),
          {poll, poll_emoji} <- make_poll_data(data),
          {to, cc} <- get_to_and_cc(user, addressed_users, in_reply_to, visibility),
-         bcc <- bcc_for_list(user, visibility),
          context <- make_context(in_reply_to),
          cw <- data["spoiler_text"] || "",
          sensitive <- data["sensitive"] || Enum.member?(tags, {"#nsfw", "nsfw"}),
@@ -241,16 +240,21 @@ def post(user, %{"status" => status} = data) do
              "emoji",
              Map.merge(Formatter.get_emoji_map(full_payload), poll_emoji)
            ) do
-      ActivityPub.create(
-        %{
-          to: to,
-          actor: user,
-          context: context,
-          object: object,
-          additional: %{"cc" => cc, "bcc" => bcc, "directMessage" => visibility == "direct"}
-        },
-        Pleroma.Web.ControllerHelper.truthy_param?(data["preview"]) || false
-      )
+      preview? = Pleroma.Web.ControllerHelper.truthy_param?(data["preview"]) || false
+      direct? = visibility == "direct"
+
+      additional_data =
+        %{"cc" => cc, "directMessage" => direct?} |> maybe_add_list_data(user, visibility)
+
+      params = %{
+        to: to,
+        actor: user,
+        context: context,
+        object: object,
+        additional: additional_data
+      }
+
+      ActivityPub.create(params, preview?)
     else
       {:private_to_public, true} ->
         {:error, dgettext("errors", "The message visibility must be direct")}
diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
index d4bfdd7e4..94b2c50fc 100644
--- a/lib/pleroma/web/common_api/utils.ex
+++ b/lib/pleroma/web/common_api/utils.ex
@@ -108,12 +108,19 @@ def get_addressed_users(_, to) when is_list(to) do
 
   def get_addressed_users(mentioned_users, _), do: mentioned_users
 
-  def bcc_for_list(user, {:list, list_id}) do
-    list = Pleroma.List.get(list_id, user)
-    [list.ap_id]
+  def maybe_add_list_data(additional_data, user, {:list, list_id}) do
+    case Pleroma.List.get(list_id, user) do
+      %Pleroma.List{} = list ->
+        additional_data
+        |> Map.put("listMessage", list.ap_id)
+        |> Map.put("bcc", [list.ap_id])
+
+      _ ->
+        additional_data
+    end
   end
 
-  def bcc_for_list(_, _), do: []
+  def maybe_add_list_data(additional_data, _, _), do: additional_data
 
   def make_poll_data(%{"poll" => %{"options" => options, "expires_in" => expires_in}} = data)
       when is_list(options) do
diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
index 694b52356..932c6877d 100644
--- a/test/web/common_api/common_api_test.exs
+++ b/test/web/common_api/common_api_test.exs
@@ -139,6 +139,7 @@ test "it allows to address a list" do
 
       assert activity.data["bcc"] == [list.ap_id]
       assert activity.recipients == [list.ap_id, user.ap_id]
+      assert activity.data["listMessage"] == list.ap_id
     end
   end
 

From 9e06873d58e031a0f90c6a4d436a6abb5f1ebbae Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Thu, 11 Jul 2019 19:29:24 +0700
Subject: [PATCH 11/17] Add `list` to Visibility

---
 lib/pleroma/list.ex                        |  6 ++
 lib/pleroma/web/activity_pub/visibility.ex | 16 +++++
 test/list_test.exs                         | 11 ++++
 test/web/activity_pub/visibilty_test.exs   | 72 +++++++++++++++++++---
 4 files changed, 98 insertions(+), 7 deletions(-)

diff --git a/lib/pleroma/list.ex b/lib/pleroma/list.ex
index 16955b3b5..1d320206e 100644
--- a/lib/pleroma/list.ex
+++ b/lib/pleroma/list.ex
@@ -146,4 +146,10 @@ def memberships(%User{follower_address: follower_address}) do
   end
 
   def memberships(_), do: []
+
+  def member?(%Pleroma.List{following: following}, %User{follower_address: follower_address}) do
+    Enum.member?(following, follower_address)
+  end
+
+  def member?(_, _), do: false
 end
diff --git a/lib/pleroma/web/activity_pub/visibility.ex b/lib/pleroma/web/activity_pub/visibility.ex
index 9908a2e75..e0282d758 100644
--- a/lib/pleroma/web/activity_pub/visibility.ex
+++ b/lib/pleroma/web/activity_pub/visibility.ex
@@ -34,6 +34,19 @@ def is_direct?(activity) do
     !is_public?(activity) && !is_private?(activity)
   end
 
+  def is_list?(%{data: %{"listMessage" => _}}), do: true
+  def is_list?(_), do: false
+
+  def visible_for_user?(%{actor: ap_id}, %User{ap_id: ap_id}), do: true
+
+  def visible_for_user?(%{data: %{"listMessage" => list_ap_id}}, %User{} = user) do
+    list_ap_id
+    |> Pleroma.List.get_by_ap_id()
+    |> Pleroma.List.member?(user)
+  end
+
+  def visible_for_user?(%{data: %{"listMessage" => _}}, nil), do: false
+
   def visible_for_user?(activity, nil) do
     is_public?(activity)
   end
@@ -73,6 +86,9 @@ def get_visibility(object) do
       object.data["directMessage"] == true ->
         "direct"
 
+      is_binary(object.data["listMessage"]) ->
+        "list"
+
       length(cc) > 0 ->
         "private"
 
diff --git a/test/list_test.exs b/test/list_test.exs
index 6c5c6b197..f39033d02 100644
--- a/test/list_test.exs
+++ b/test/list_test.exs
@@ -128,4 +128,15 @@ test "memberships" do
 
     assert Pleroma.List.memberships(member) == [list.ap_id]
   end
+
+  test "member?" do
+    user = insert(:user)
+    member = insert(:user)
+
+    {:ok, list} = Pleroma.List.create("foo", user)
+    {:ok, list} = Pleroma.List.follow(list, member)
+
+    assert Pleroma.List.member?(list, member)
+    refute Pleroma.List.member?(list, user)
+  end
 end
diff --git a/test/web/activity_pub/visibilty_test.exs b/test/web/activity_pub/visibilty_test.exs
index 4d5c07da4..2ce6928c4 100644
--- a/test/web/activity_pub/visibilty_test.exs
+++ b/test/web/activity_pub/visibilty_test.exs
@@ -16,6 +16,9 @@ defmodule Pleroma.Web.ActivityPub.VisibilityTest do
     following = insert(:user)
     unrelated = insert(:user)
     {:ok, following} = Pleroma.User.follow(following, user)
+    {:ok, list} = Pleroma.List.create("foo", user)
+
+    Pleroma.List.follow(list, unrelated)
 
     {:ok, public} =
       CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "public"})
@@ -29,6 +32,12 @@ defmodule Pleroma.Web.ActivityPub.VisibilityTest do
     {:ok, unlisted} =
       CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "unlisted"})
 
+    {:ok, list} =
+      CommonAPI.post(user, %{
+        "status" => "@#{mentioned.nickname}",
+        "visibility" => "list:#{list.id}"
+      })
+
     %{
       public: public,
       private: private,
@@ -37,29 +46,65 @@ defmodule Pleroma.Web.ActivityPub.VisibilityTest do
       user: user,
       mentioned: mentioned,
       following: following,
-      unrelated: unrelated
+      unrelated: unrelated,
+      list: list
     }
   end
 
-  test "is_direct?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
+  test "is_direct?", %{
+    public: public,
+    private: private,
+    direct: direct,
+    unlisted: unlisted,
+    list: list
+  } do
     assert Visibility.is_direct?(direct)
     refute Visibility.is_direct?(public)
     refute Visibility.is_direct?(private)
     refute Visibility.is_direct?(unlisted)
+    assert Visibility.is_direct?(list)
   end
 
-  test "is_public?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
+  test "is_public?", %{
+    public: public,
+    private: private,
+    direct: direct,
+    unlisted: unlisted,
+    list: list
+  } do
     refute Visibility.is_public?(direct)
     assert Visibility.is_public?(public)
     refute Visibility.is_public?(private)
     assert Visibility.is_public?(unlisted)
+    refute Visibility.is_public?(list)
   end
 
-  test "is_private?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
+  test "is_private?", %{
+    public: public,
+    private: private,
+    direct: direct,
+    unlisted: unlisted,
+    list: list
+  } do
     refute Visibility.is_private?(direct)
     refute Visibility.is_private?(public)
     assert Visibility.is_private?(private)
     refute Visibility.is_private?(unlisted)
+    refute Visibility.is_private?(list)
+  end
+
+  test "is_list?", %{
+    public: public,
+    private: private,
+    direct: direct,
+    unlisted: unlisted,
+    list: list
+  } do
+    refute Visibility.is_list?(direct)
+    refute Visibility.is_list?(public)
+    refute Visibility.is_list?(private)
+    refute Visibility.is_list?(unlisted)
+    assert Visibility.is_list?(list)
   end
 
   test "visible_for_user?", %{
@@ -70,7 +115,8 @@ test "visible_for_user?", %{
     user: user,
     mentioned: mentioned,
     following: following,
-    unrelated: unrelated
+    unrelated: unrelated,
+    list: list
   } do
     # All visible to author
 
@@ -78,13 +124,15 @@ test "visible_for_user?", %{
     assert Visibility.visible_for_user?(private, user)
     assert Visibility.visible_for_user?(unlisted, user)
     assert Visibility.visible_for_user?(direct, user)
+    assert Visibility.visible_for_user?(list, user)
 
-    # All visible to a mentioned user
+    # All visible to a mentioned user, except when it's a list activity
 
     assert Visibility.visible_for_user?(public, mentioned)
     assert Visibility.visible_for_user?(private, mentioned)
     assert Visibility.visible_for_user?(unlisted, mentioned)
     assert Visibility.visible_for_user?(direct, mentioned)
+    refute(Visibility.visible_for_user?(list, mentioned))
 
     # DM not visible for just follower
 
@@ -92,6 +140,7 @@ test "visible_for_user?", %{
     assert Visibility.visible_for_user?(private, following)
     assert Visibility.visible_for_user?(unlisted, following)
     refute Visibility.visible_for_user?(direct, following)
+    refute Visibility.visible_for_user?(list, following)
 
     # Public and unlisted visible for unrelated user
 
@@ -99,6 +148,9 @@ test "visible_for_user?", %{
     assert Visibility.visible_for_user?(unlisted, unrelated)
     refute Visibility.visible_for_user?(private, unrelated)
     refute Visibility.visible_for_user?(direct, unrelated)
+
+    # Visible for a list member
+    assert Visibility.visible_for_user?(list, unrelated)
   end
 
   test "doesn't die when the user doesn't exist",
@@ -115,18 +167,24 @@ test "get_visibility", %{
     public: public,
     private: private,
     direct: direct,
-    unlisted: unlisted
+    unlisted: unlisted,
+    list: list
   } do
     assert Visibility.get_visibility(public) == "public"
     assert Visibility.get_visibility(private) == "private"
     assert Visibility.get_visibility(direct) == "direct"
     assert Visibility.get_visibility(unlisted) == "unlisted"
+    assert Visibility.get_visibility(list) == "list"
   end
 
   test "get_visibility with directMessage flag" do
     assert Visibility.get_visibility(%{data: %{"directMessage" => true}}) == "direct"
   end
 
+  test "get_visibility with listMessage flag" do
+    assert Visibility.get_visibility(%{data: %{"listMessage" => ""}}) == "list"
+  end
+
   describe "entire_thread_visible_for_user?/2" do
     test "returns false if not found activity", %{user: user} do
       refute Visibility.entire_thread_visible_for_user?(%Activity{}, user)

From 9991254c064c63e3d45786379953414c8a26073a Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Thu, 11 Jul 2019 20:17:03 +0700
Subject: [PATCH 12/17] Update CHANGELOG

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ff0cb8740..3403ce64e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -28,6 +28,7 @@ Configuration: `federation_incoming_replies_max_depth` option
 - Added synchronization of following/followers counters for external users
 - Configuration: `enabled` option for `Pleroma.Emails.Mailer`, defaulting to `false`.
 - Mastodon API: Add support for categories for custom emojis by reusing the group feature. <https://github.com/tootsuite/mastodon/pull/11196>
+- Addressable lists
 
 ## [1.0.0] - 2019-06-29
 ### Security
@@ -89,7 +90,6 @@ Configuration: `federation_incoming_replies_max_depth` option
 - MRF: Support for rejecting reports from specific instances (`mrf_simple`)
 - MRF: Support for stripping avatars and banner images from specific instances (`mrf_simple`)
 - MRF: Support for running subchains.
-- Addressable lists
 - Configuration: `skip_thread_containment` option
 - Configuration: `rate_limit` option. See `Pleroma.Plugs.RateLimiter` documentation for details.
 - MRF: Support for filtering out likely spam messages by rejecting posts from new users that contain links.

From a87c313309b73ced5970c59d00117c357f51fecb Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 15 Jul 2019 14:00:29 +0700
Subject: [PATCH 13/17] Support `list` visibility in StatusView

---
 lib/pleroma/web/common_api/common_api.ex   | 11 ++++-------
 lib/pleroma/web/common_api/utils.ex        | 13 +++++++------
 test/web/mastodon_api/status_view_test.exs | 13 +++++++++++++
 3 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
index 1c47a31d7..f764e87af 100644
--- a/lib/pleroma/web/common_api/common_api.ex
+++ b/lib/pleroma/web/common_api/common_api.ex
@@ -243,18 +243,15 @@ def post(user, %{"status" => status} = data) do
       preview? = Pleroma.Web.ControllerHelper.truthy_param?(data["preview"]) || false
       direct? = visibility == "direct"
 
-      additional_data =
-        %{"cc" => cc, "directMessage" => direct?} |> maybe_add_list_data(user, visibility)
-
-      params = %{
+      %{
         to: to,
         actor: user,
         context: context,
         object: object,
-        additional: additional_data
+        additional: %{"cc" => cc, "directMessage" => direct?}
       }
-
-      ActivityPub.create(params, preview?)
+      |> maybe_add_list_data(user, visibility)
+      |> ActivityPub.create(preview?)
     else
       {:private_to_public, true} ->
         {:error, dgettext("errors", "The message visibility must be direct")}
diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
index 94b2c50fc..fed5f9de7 100644
--- a/lib/pleroma/web/common_api/utils.ex
+++ b/lib/pleroma/web/common_api/utils.ex
@@ -108,19 +108,20 @@ def get_addressed_users(_, to) when is_list(to) do
 
   def get_addressed_users(mentioned_users, _), do: mentioned_users
 
-  def maybe_add_list_data(additional_data, user, {:list, list_id}) do
+  def maybe_add_list_data(activity_params, user, {:list, list_id}) do
     case Pleroma.List.get(list_id, user) do
       %Pleroma.List{} = list ->
-        additional_data
-        |> Map.put("listMessage", list.ap_id)
-        |> Map.put("bcc", [list.ap_id])
+        activity_params
+        |> put_in([:additional, "bcc"], [list.ap_id])
+        |> put_in([:additional, "listMessage"], list.ap_id)
+        |> put_in([:object, "listMessage"], list.ap_id)
 
       _ ->
-        additional_data
+        activity_params
     end
   end
 
-  def maybe_add_list_data(additional_data, _, _), do: additional_data
+  def maybe_add_list_data(activity_params, _, _), do: activity_params
 
   def make_poll_data(%{"poll" => %{"options" => options, "expires_in" => expires_in}} = data)
       when is_list(options) do
diff --git a/test/web/mastodon_api/status_view_test.exs b/test/web/mastodon_api/status_view_test.exs
index ac42819d8..995bd52c8 100644
--- a/test/web/mastodon_api/status_view_test.exs
+++ b/test/web/mastodon_api/status_view_test.exs
@@ -541,4 +541,17 @@ test "embeds a relationship in the account in reposts" do
     assert result[:reblog][:account][:pleroma][:relationship] ==
              AccountView.render("relationship.json", %{user: user, target: user})
   end
+
+  test "visibility/list" do
+    user = insert(:user)
+
+    {:ok, list} = Pleroma.List.create("foo", user)
+
+    {:ok, activity} =
+      CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
+
+    status = StatusView.render("status.json", activity: activity)
+
+    assert status.visibility == "list"
+  end
 end

From d86a97abfb1ef32fbe76f455e8dce4ec429696b6 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 15 Jul 2019 14:20:31 +0700
Subject: [PATCH 14/17] Add an explanation comment to Publisher.publish/2

---
 lib/pleroma/web/activity_pub/publisher.ex | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/pleroma/web/activity_pub/publisher.ex b/lib/pleroma/web/activity_pub/publisher.ex
index ffdd33351..18145e45f 100644
--- a/lib/pleroma/web/activity_pub/publisher.ex
+++ b/lib/pleroma/web/activity_pub/publisher.ex
@@ -131,6 +131,8 @@ def publish(actor, %{data: %{"bcc" => bcc}} = activity) when is_list(bcc) and bc
       %User{ap_id: ap_id} =
         Enum.find(recipients, fn %{info: %{source_data: data}} -> data["inbox"] == inbox end)
 
+      # Get all the recipients on the same host and add them to cc. Otherwise it a remote
+      # instance would only accept a first message for the first recipient and ignore the rest.
       cc = get_cc_ap_ids(ap_id, recipients)
 
       json =

From 0c66bb5857ca5c67630f07ff25878aaa70f3ce4b Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 15 Jul 2019 14:27:56 +0700
Subject: [PATCH 15/17] Update documentation

---
 docs/api/differences_in_mastoapi_responses.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/docs/api/differences_in_mastoapi_responses.md b/docs/api/differences_in_mastoapi_responses.md
index 03917fffc..d2e9bcc4b 100644
--- a/docs/api/differences_in_mastoapi_responses.md
+++ b/docs/api/differences_in_mastoapi_responses.md
@@ -16,9 +16,11 @@ Adding the parameter `with_muted=true` to the timeline queries will also return
 
 ## Statuses
 
+- `visibility`: has an additional possible value `list`
+
 Has these additional fields under the `pleroma` object:
 
-- `local`: true if the post was made on the local instance.
+- `local`: true if the post was made on the local instance
 - `conversation_id`: the ID of the conversation the status is associated with (if any)
 - `in_reply_to_account_acct`: the `acct` property of User entity for replied user (if any)
 - `content`: a map consisting of alternate representations of the `content` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`

From 04f18a144bdbb58f0fc774ea5530029f166b6821 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 15 Jul 2019 14:29:13 +0700
Subject: [PATCH 16/17] Add `listMessage` to to the JSON-LD context

---
 priv/static/schemas/litepub-0.1.jsonld | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/priv/static/schemas/litepub-0.1.jsonld b/priv/static/schemas/litepub-0.1.jsonld
index f36b231c5..57ed05eba 100644
--- a/priv/static/schemas/litepub-0.1.jsonld
+++ b/priv/static/schemas/litepub-0.1.jsonld
@@ -20,6 +20,10 @@
             "sensitive": "as:sensitive",
             "litepub": "http://litepub.social/ns#",
             "directMessage": "litepub:directMessage",
+            "listMessage": {
+                "@id": "litepub:listMessage",
+                "@type": "@id"
+            },
             "oauthRegistrationEndpoint": {
                 "@id": "litepub:oauthRegistrationEndpoint",
                 "@type": "@id"

From de13c9bb8fc08b12d9694f63f92935ba39a51118 Mon Sep 17 00:00:00 2001
From: Egor Kislitsyn <egor@kislitsyn.com>
Date: Mon, 15 Jul 2019 14:54:40 +0700
Subject: [PATCH 17/17] List messages must be visible for mentioned users

---
 lib/pleroma/web/activity_pub/visibility.ex | 9 +++++----
 lib/pleroma/web/common_api/utils.ex        | 2 +-
 test/web/activity_pub/visibilty_test.exs   | 4 ++--
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/lib/pleroma/web/activity_pub/visibility.ex b/lib/pleroma/web/activity_pub/visibility.ex
index e0282d758..2666edc7c 100644
--- a/lib/pleroma/web/activity_pub/visibility.ex
+++ b/lib/pleroma/web/activity_pub/visibility.ex
@@ -39,10 +39,11 @@ def is_list?(_), do: false
 
   def visible_for_user?(%{actor: ap_id}, %User{ap_id: ap_id}), do: true
 
-  def visible_for_user?(%{data: %{"listMessage" => list_ap_id}}, %User{} = user) do
-    list_ap_id
-    |> Pleroma.List.get_by_ap_id()
-    |> Pleroma.List.member?(user)
+  def visible_for_user?(%{data: %{"listMessage" => list_ap_id}} = activity, %User{} = user) do
+    user.ap_id in activity.data["to"] ||
+      list_ap_id
+      |> Pleroma.List.get_by_ap_id()
+      |> Pleroma.List.member?(user)
   end
 
   def visible_for_user?(%{data: %{"listMessage" => _}}, nil), do: false
diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
index fed5f9de7..f28a96320 100644
--- a/lib/pleroma/web/common_api/utils.ex
+++ b/lib/pleroma/web/common_api/utils.ex
@@ -100,7 +100,7 @@ def get_to_and_cc(_user, mentioned_users, inReplyTo, "direct") do
     end
   end
 
-  def get_to_and_cc(_user, _mentions, _inReplyTo, _), do: {[], []}
+  def get_to_and_cc(_user, mentions, _inReplyTo, {:list, _}), do: {mentions, []}
 
   def get_addressed_users(_, to) when is_list(to) do
     User.get_ap_ids_by_nicknames(to)
diff --git a/test/web/activity_pub/visibilty_test.exs b/test/web/activity_pub/visibilty_test.exs
index 2ce6928c4..b62a89e68 100644
--- a/test/web/activity_pub/visibilty_test.exs
+++ b/test/web/activity_pub/visibilty_test.exs
@@ -126,13 +126,13 @@ test "visible_for_user?", %{
     assert Visibility.visible_for_user?(direct, user)
     assert Visibility.visible_for_user?(list, user)
 
-    # All visible to a mentioned user, except when it's a list activity
+    # All visible to a mentioned user
 
     assert Visibility.visible_for_user?(public, mentioned)
     assert Visibility.visible_for_user?(private, mentioned)
     assert Visibility.visible_for_user?(unlisted, mentioned)
     assert Visibility.visible_for_user?(direct, mentioned)
-    refute(Visibility.visible_for_user?(list, mentioned))
+    assert Visibility.visible_for_user?(list, mentioned)
 
     # DM not visible for just follower