Merge pull request #4 from RooSoft/nostr_basics

Now using NostrBasics

Author: RooSoft

lib/examples/nostr_app/console_handler.ex

@@ -46,4 +46,20 @@ defmodule NostrApp.ConsoleHandler do
   def handle(:transport_error, %{url: url, message: message}) do
     Logger.warning("transport error from #{url}: #{message}")
   end
+
+  def handle(:unknown_relay_message, %{url: url, message: message}) do
+    Logger.warning("unknown relay message from #{url}: #{message}")
+  end
+
+  def handle(:malformed_json_relay_message, %{url: url, message: message}) do
+    Logger.warning("malformed JSON relay message from #{url}: #{message}")
+  end
+
+  def handle(:ok, %{event_id: event_id, message: _message, success?: success?, url: url}) do
+    Logger.info("#{url} sent #{event_id}: #{success?}")
+  end
+
+  def handle(unknown_atom, data) do
+    Logger.warning("got a #{unknown_atom}: #{inspect(data)}")
+  end
 end

lib/examples/nostr_app/server.ex

@@ -9,10 +9,10 @@ defmodule NostrApp.Server do
 
   alias NostrApp.{ConsoleHandler, Subscribe}
 
+  alias NostrBasics.Keys.{PrivateKey, PublicKey}
+
   alias Nostr.Client
-  alias Nostr.Event.Types.{MetadataEvent, RecommendedServerEvent}
   alias Nostr.Models.{Profile}
-  alias Nostr.Keys.{PrivateKey, PublicKey}
 
   @impl true
   def init(%{relays: relays, private_key: private_key} = args) do
@@ -124,7 +124,7 @@ defmodule NostrApp.Server do
   @impl true
   def handle_cast({:delete, event_ids, note}, %{private_key: private_key} = socket) do
     case Client.delete_events(event_ids, note, private_key) do
-      {:ok, _} -> Logger.info("sent a deletion command for #{event_ids}")
+      {:ok, _} -> Logger.info("sent a deletion command for #{inspect(event_ids)}")
       {:error, message} -> Logger.error(message)
     end
 
@@ -277,13 +277,6 @@ defmodule NostrApp.Server do
     {:noreply, socket}
   end
 
-  @impl true
-  def handle_info({relay, %MetadataEvent{} = event}, socket) do
-    Logger.info("From #{relay}, got a profile: #{inspect(event)}")
-
-    {:noreply, socket}
-  end
-
   @impl true
   def handle_info({relay, event}, socket) do
     # credo:disable-for-next-line
@@ -294,13 +287,6 @@ defmodule NostrApp.Server do
     {:noreply, socket}
   end
 
-  @impl true
-  def handle_info(%RecommendedServerEvent{relay: relay, event: event}, socket) do
-    IO.puts("#{relay} is recommended by #{event.pubkey |> PublicKey.to_npub()}")
-
-    {:noreply, socket}
-  end
-
   @impl true
   def handle_info(event, socket) do
     # credo:disable-for-next-line

lib/nostr/client.ex

@@ -7,12 +7,12 @@ defmodule Nostr.Client do
 
   require Logger
 
-  alias Nostr.Event
-  alias Nostr.Keys.{PublicKey, PrivateKey}
-  alias Nostr.Event.{Signer, Validator}
-  alias Nostr.Event.Types.{EncryptedDirectMessageEvent, TextEvent}
+  alias NostrBasics.{Event}
+  alias NostrBasics.Keys.{PublicKey, PrivateKey}
+
   alias Nostr.Models.{Profile, Note}
   alias Nostr.Client.Relays.RelayManager
+  alias Nostr.Client.Tasks
 
   alias Nostr.Client.Subscriptions.{
     ProfileSubscription,
@@ -36,9 +36,6 @@ defmodule Nostr.Client do
     UpdateProfile
   }
 
-  alias Nostr.Crypto.AES256CBC
-  alias Nostr.Client.Relays.RelaySocket
-
   @default_config {}
 
   @doc """
@@ -184,29 +181,11 @@ defmodule Nostr.Client do
   Sends an encrypted direct message
   """
   @spec send_encrypted_direct_messages(PublicKey.id(), String.t(), PrivateKey.id()) ::
-          :ok | {:error, binary()}
+          :ok | {:error, String.t()}
   def send_encrypted_direct_messages(remote_pubkey, message, private_key) do
-    with {:ok, binary_remote_pubkey} <- PublicKey.to_binary(remote_pubkey),
-         {:ok, binary_private_key} <- PrivateKey.to_binary(private_key),
-         {:ok, binary_local_pubkey} <- PublicKey.from_private_key(binary_private_key),
-         encrypted_message = AES256CBC.encrypt(message, binary_private_key, binary_remote_pubkey),
-         dm_event =
-           EncryptedDirectMessageEvent.create(
-             encrypted_message,
-             binary_local_pubkey,
-             binary_remote_pubkey
-           ),
-         {:ok, signed_event} <- Signer.sign_event(dm_event.event, private_key),
-         :ok <- Validator.validate_event(signed_event) do
-      for relay_pid <- RelayManager.active_pids() do
-        RelaySocket.send_event(relay_pid, signed_event)
-      end
-
-      :ok
-    else
-      {:error, message} when is_atom(message) -> Atom.to_string(message)
-      {:error, message} -> {:error, message}
-    end
+    relay_pids = RelayManager.active_pids()
+
+    Tasks.SendEncryptedDirectMessage.execute(message, remote_pubkey, private_key, relay_pids)
   end
 
   @doc """
@@ -215,7 +194,7 @@ defmodule Nostr.Client do
   @spec subscribe_note(Note.id()) :: DynamicSupervisor.on_start_child()
   def subscribe_note(note_id) do
     case Event.Id.to_binary(note_id) do
-      {:ok, "note", binary_note_id} ->
+      {:ok, binary_note_id} ->
         DynamicSupervisor.start_child(
           Nostr.Subscriptions,
           {NoteSubscription, [RelayManager.active_pids(), binary_note_id, self()]}
@@ -227,9 +206,9 @@ defmodule Nostr.Client do
   end
 
   @doc """
-  Get an author's notes
+  Get a list of author's notes
   """
-  @spec subscribe_notes(list(Note.id())) ::
+  @spec subscribe_notes(list(Note.id()) | Note.id()) ::
           {:ok, DynamicSupervisor.on_start_child()} | {:error, String.t()}
   def subscribe_notes(pubkeys) when is_list(pubkeys) do
     case PublicKey.to_binary(pubkeys) do
@@ -247,14 +226,18 @@ defmodule Nostr.Client do
     end
   end
 
+  def subscribe_notes(pubkey) do
+    subscribe_notes([pubkey])
+  end
+
   @doc """
   Deletes events
   """
   @spec delete_events(list(Note.id()), String.t(), PrivateKey.id()) ::
           {:ok, GenServer.on_start()} | {:error, String.t()}
   def delete_events(note_ids, note, privkey) do
     with {:ok, binary_privkey} <- PrivateKey.to_binary(privkey),
-         {:ok, "note", binary_note_ids} <- Event.Id.to_binary(note_ids) do
+         {:ok, binary_note_ids} <- Event.Id.to_binary(note_ids) do
       {:ok,
        DeleteEvents.start_link(RelayManager.active_pids(), binary_note_ids, note, binary_privkey)}
     else
@@ -285,7 +268,7 @@ defmodule Nostr.Client do
   @spec repost(Note.id(), PrivateKey.id()) :: {:ok, GenServer.on_start()} | {:error, String.t()}
   def repost(note_id, privkey) do
     with {:ok, binary_privkey} <- PrivateKey.to_binary(privkey),
-         {:ok, "note", binary_note_id} <- Event.Id.to_binary(note_id) do
+         {:ok, binary_note_id} <- Event.Id.to_binary(note_id) do
       {:ok, SendRepost.start_link(RelayManager.active_pids(), binary_note_id, binary_privkey)}
     else
       {:error, message} -> {:error, message}
@@ -352,27 +335,16 @@ defmodule Nostr.Client do
   """
   @spec send_note(String.t(), PrivateKey.id()) :: :ok | {:error, String.t()}
   def send_note(note, privkey) do
-    with {:ok, binary_privkey} <- PrivateKey.to_binary(privkey),
-         {:ok, pubkey} <- PublicKey.from_private_key(privkey),
-         text_event = TextEvent.create(note, pubkey),
-         {:ok, signed_event} <- Signer.sign_event(text_event.event, binary_privkey),
-         :ok <- Validator.validate_event(signed_event) do
-      for relay_pid <- RelayManager.active_pids() do
-        RelaySocket.send_event(relay_pid, signed_event)
-      end
-
-      :ok
-    else
-      {:error, message} when is_atom(message) -> {:error, Atom.to_string(message)}
-      {:error, message} -> {:error, message}
-    end
+    relay_pids = RelayManager.active_pids()
+
+    Tasks.SendNote.execute(note, privkey, relay_pids)
   end
 
   @spec react(Note.id(), PrivateKey.id(), String.t()) ::
           {:ok, GenServer.on_start()} | {:error, String.t()}
   def react(note_id, privkey, content \\ "+") do
     with {:ok, binary_privkey} <- PrivateKey.to_binary(privkey),
-         {:ok, "note", binary_note_id} <- Event.Id.to_binary(note_id) do
+         {:ok, binary_note_id} <- Event.Id.to_binary(note_id) do
       {
         :ok,
         SendReaction.start_link(

lib/nostr/client/frame_dispatcher.ex

@@ -3,39 +3,49 @@ defmodule Nostr.Client.Relays.RelaySocket.FrameHandler do
   Websocket frames are first sent here to be decoded and then sent to the frame dispatcher
   """
 
-  alias Nostr.Frames.Notice
+  alias NostrBasics.RelayMessage
 
   @spec handle_text_frame(list(), list(), map(), pid()) :: :ok
   def handle_text_frame(frame, subscriptions, relay_url, owner_pid) do
-    with {:ok, data} <- Jason.decode(frame),
-         {:ok, item} <- Nostr.Client.FrameDispatcher.dispatch(data) do
-      case get_atom_id(item) do
-        nil ->
-          %Notice{message: message} = get_event(item)
-          send(owner_pid, {:console, :notice, %{url: relay_url, message: message}})
-
-        atom_id ->
-          case Keyword.get(subscriptions, atom_id) do
-            nil ->
-              :ok
-
-            subscriber ->
-              {_id, event} = item
-
-              send(subscriber, {relay_url, event})
-          end
-      end
-
-      :ok
-    else
-      {:error, _} ->
-        send(owner_pid, {:console, :parsing_error, %{url: relay_url, frame: frame}})
-        :ok
+    RelayMessage.parse(frame)
+    |> handle_message(subscriptions, relay_url, owner_pid)
+  end
+
+  defp handle_message({:event, subscription_id, event}, subscriptions, relay_url, _owner_pid) do
+    case Keyword.get(subscriptions, String.to_atom(subscription_id)) do
+      nil -> {relay_url, event}
+      subscriber -> send(subscriber, {relay_url, subscription_id, event})
     end
   end
 
-  defp get_atom_id({nil, _}), do: nil
-  defp get_atom_id({id, _}), do: String.to_atom(id)
+  defp handle_message({:notice, message}, _subscriptions, relay_url, owner_pid) do
+    send(owner_pid, {:console, :notice, %{url: relay_url, message: message}})
+  end
+
+  defp handle_message(
+         {:end_of_stored_events, subscription_id},
+         subscriptions,
+         relay_url,
+         _owner_pid
+       ) do
+    message = {:end_of_stored_events, relay_url, subscription_id}
+
+    case Keyword.get(subscriptions, String.to_atom(subscription_id)) do
+      nil -> message
+      subscriber -> send(subscriber, message)
+    end
+  end
 
-  defp get_event({_, event}), do: event
+  defp handle_message({:ok, event_id, success?, message}, _subscriptions, relay_url, owner_pid) do
+    info = %{url: relay_url, event_id: event_id, success?: success?, message: message}
+    send(owner_pid, {:console, :ok, info})
+  end
+
+  defp handle_message({:unknown, message}, _subscriptions, relay_url, owner_pid) do
+    send(owner_pid, {:console, :unknown_relay_message, url: relay_url, message: message})
+  end
+
+  defp handle_message({:json_error, message}, _subscriptions, relay_url, owner_pid) do
+    send(owner_pid, {:console, :malformed_json_relay_message, url: relay_url, message: message})
+  end
 end

lib/nostr/client/relays/relay_socket/frame_handler.ex

@@ -39,6 +39,10 @@ defmodule Nostr.Client.Relays.RelaySocket.Publisher do
     send(pid, {:console, :unexpected, %{url: relay_url, frame: frame}})
   end
 
+  def workflow_error(pid, relay_url, message) do
+    send(pid, {:console, :workflow_error, %{url: relay_url, message: message}})
+  end
+
   defp stringify(message) when is_atom(message), do: Atom.to_string(message)
   defp stringify(message) when is_binary(message), do: message
 end