nostr_ruby 0.2.0 → 0.3.0

data/lib/client.rb

@@ -0,0 +1,184 @@
+require_relative 'event_wizard'
+require 'faye/websocket'
+
+module Nostr
+
+  class Client
+    include EventWizard
+
+    attr_reader :signer
+    attr_reader :relay
+    attr_reader :subscriptions
+
+
+    def initialize(signer: nil, private_key: nil, relay: nil, context: Context.new(timeout: 5))
+      initialize_event_emitter
+
+      if signer
+        @signer = signer
+      elsif private_key
+        @signer = Nostr::Signer.new(private_key: private_key)
+      end
+
+      @relay = relay
+      @context = context
+
+      @running = false
+      @expected_response_id = nil
+      @response_condition = ConditionVariable.new
+      @response_mutex = Mutex.new
+      @event_to_publish = nil
+
+      @subscriptions = {}
+      @outbound_channel = EventMachine::Channel.new
+      @inbound_channel = EventMachine::Channel.new
+
+      @inbound_channel.subscribe do |msg|
+        case msg[:type]
+        when :open
+          emit :connect, msg[:relay]
+        when :message
+          parsed_data = Nostr::MessageHandler.handle(msg[:data])
+          emit :message, parsed_data
+          emit :event, parsed_data if parsed_data.type == "EVENT"
+          emit :ok, parsed_data if parsed_data.type == "OK"
+          emit :eose, parsed_data if parsed_data.type == "EOSE"
+          emit :closed, parsed_data if parsed_data.type == "CLOSED"
+          emit :notice, parsed_data if parsed_data.type == "NOTICE"
+        when :error
+          emit :error, msg[:message]
+        when :close
+          emit :close, msg[:code], msg[:reason]
+        end
+      end
+    end
+
+    def nsec
+      signer.nsec
+    end
+
+    def private_key
+      signer.private_key
+    end
+
+    def npub
+      signer.npub
+    end
+
+    def public_key
+      signer.public_key
+    end
+
+    def sign(event)
+      signer.sign(event)
+    end
+
+    def decrypt(event)
+      signer.decrypt(event)
+    end
+
+    def generate_delegation_tag(to:, conditions:)
+      signer.generate_delegation_tag(to, conditions)
+    end
+
+    def connect(context: @context)
+      @thread = Thread.new do
+        EM.run do
+          @ws_client = Faye::WebSocket::Client.new(@relay)
+
+          @outbound_channel.subscribe { |msg| @ws_client.send(msg) && emit(:send, msg) }
+
+          @ws_client.on :open do
+            @running = true
+            @inbound_channel.push(type: :open, relay: @relay)
+          end
+
+          @ws_client.on :message do |event|
+            @inbound_channel.push(type: :message, data: event.data)
+          end
+
+          @ws_client.on :error do |event|
+            @inbound_channel.push(type: :error, message: event.message)
+          end
+
+          @ws_client.on :close do |event|
+            context.cancel
+            @inbound_channel.push(type: :close, code: event.code, reason: event.reason)
+          end
+
+        end
+      end
+
+      # Wait for the connection to be established or for the context to be canceled
+      if context
+        context.wait { @running }
+      end
+
+    end
+
+    def running?
+      @running
+    end
+
+    def close
+      @running = false
+      EM.next_tick do
+        @ws_client.close if @ws_client
+        EM.add_timer(0.1) do
+          EM.stop if EM.reactor_running?
+        end
+      end
+    end
+
+    def publish(event)
+      return false unless running?
+      @outbound_channel.push(['EVENT', event.to_json].to_json)
+      return true
+    end
+
+    def publish_and_wait(event, context: @context, close_on_finish: false)
+      return false unless running?
+
+      response = nil
+      @outbound_channel.push(['EVENT', event.to_json].to_json)
+
+      response_thread = Thread.new do
+        context.wait do
+          @response_mutex.synchronize do
+            @response_condition.wait(@response_mutex) # Wait for a response
+          end
+        end
+      end
+
+      @inbound_channel.subscribe do |message|
+        parsed_data = Nostr::MessageHandler.handle(message[:data])
+        if parsed_data.type == "OK" && parsed_data.event_id == event.id
+          response = parsed_data
+          @response_condition.signal
+        end
+      end
+
+      response_thread.join
+      close if close_on_finish
+
+      response
+    end
+
+    def subscribe(subscription_id: SecureRandom.hex, filter: Filter.new)
+      @subscriptions[subscription_id] = filter
+      @outbound_channel.push(["REQ", subscription_id, filter.to_h].to_json)
+      @subscriptions[subscription_id]
+      subscription_id
+    end
+
+    def unsubscribe(subscription_id)
+      @subscriptions.delete(subscription_id)
+      @outbound_channel.push(["CLOSE", subscription_id].to_json)
+    end
+
+    def unsubscribe_all
+      @subscriptions.each{|s| unsubscribe(s[0])}
+    end
+
+  end
+end

data/lib/context.rb

@@ -0,0 +1,48 @@
+class Context
+  attr_reader :canceled, :timeout
+
+  def initialize(timeout: nil)
+    @timeout = timeout
+    @canceled = false
+    @mutex = Mutex.new
+    @condition = ConditionVariable.new
+
+    # Start a timer if a timeout is specified
+    if @timeout
+      @start_time = Time.now
+    end
+  end
+
+  def cancel
+    @mutex.synchronize do
+      @canceled = true
+      @condition.broadcast
+    end
+  end
+
+  def timed_out?
+    return false unless @timeout
+
+    # Check the elapsed time without locking the mutex
+    Time.now - @start_time > @timeout
+  end
+
+  def wait(&block)
+    reset # Reset the context state before waiting
+    loop do
+      break if block.call
+      if timed_out?
+        raise StandardError.new("Operation timed out after #{timeout} seconds")
+      end
+      sleep(0.1) # Sleep briefly to avoid busy-waiting
+    end
+  end
+
+  def reset
+    @mutex.synchronize do
+      @canceled = false
+      @start_time = Time.now if @timeout
+    end
+  end
+
+end

data/lib/event.rb

@@ -0,0 +1,188 @@
+module Nostr
+  class Event
+    include CryptoTools
+
+    ATTRIBUTES = [:kind, :pubkey, :created_at, :tags, :content, :id, :sig, :pow, :delegation, :recipient]
+
+    # Create attr_reader for each attribute name
+    ATTRIBUTES.each do |attribute|
+      attr_reader attribute
+    end
+
+    attr_reader :errors
+
+    class ValidationError < StandardError; end
+
+    def initialize(
+      kind:,
+      pubkey: nil,
+      created_at: nil,
+      tags: [],
+      content: nil,
+      id: nil,
+      sig: nil,
+      pow: nil,
+      delegation: nil,
+      subscription_id: nil
+    )
+      @pubkey = pubkey
+      @created_at = created_at ? created_at : Time.now.utc.to_i
+      @kind = kind
+      @tags = tags
+      @content = content
+      @id = id
+      @sig = sig
+
+      @pow = pow
+      @delegation = delegation
+
+    end
+
+    # Create setter methods for each attribute name
+    ATTRIBUTES.each do |attribute|
+      define_method("#{attribute}=") do |value|
+        return if instance_variable_get("@#{attribute}") == value
+        instance_variable_set("@#{attribute}", value)
+        reset! unless attribute == :id || attribute == :sig
+      end
+    end
+
+    def type
+      "EVENT"
+    end
+
+    def content=(content)
+      return if @content == content
+      @content = content
+      reset!
+    end
+
+    def has_tag?(tag)
+      @tags.each_slice(2).any? { |e| e.first == tag }
+    end
+
+    def to_json
+      {
+        'kind': @kind,
+        'pubkey': @pubkey,
+        'created_at': @created_at,
+        'tags': @tags,
+        'content': @content,
+        'id': @id,
+        'sig': @sig,
+      }
+    end
+
+    def match_pow_difficulty?
+      self.match_pow_difficulty?(@id, pow)
+    end
+
+    def self.match_pow_difficulty?(event_id, pow)
+      pow.nil? || pow == [event_id].pack("H*").unpack("B*")[0].index('1')
+    end
+
+    def serialize
+      [
+        0,
+        @pubkey,
+        @created_at,
+        @kind,
+        @tags,
+        @content
+      ]
+    end
+
+    def signable?
+      @errors = []
+
+      # Check mandatory fields
+      @errors << "Kind is missing" if @kind.nil?
+      @errors << "Created at is missing" if @created_at.nil?
+
+      # Type validations
+      @errors << "Pubkey must be a string" if @pubkey && !@pubkey.is_a?(String)
+      @errors << "Kind must be an integer" unless @kind.is_a?(Integer)
+      if @created_at
+        # Check if it's a valid Unix timestamp or can be converted to one
+        begin
+          timestamp = if @created_at.is_a?(Time)
+            @created_at.to_i
+          elsif @created_at.is_a?(Integer)
+            @created_at
+          elsif @created_at.respond_to?(:to_time)
+            @created_at.to_time.to_i
+          else
+            raise ArgumentError
+          end
+
+          # Validate timestamp range
+          @errors << "Created at is not a valid timestamp" unless
+            timestamp.is_a?(Integer) &&
+            timestamp >= 0
+        rescue
+          @errors << "Created at must be a valid datetime or Unix timestamp"
+        end
+      end
+      @errors << "Tags must be an array" unless @tags.is_a?(Array)
+
+      @errors << "Content must be a string" if @content && !@content.is_a?(String)
+      @errors << "ID must be a string" if @id && !@id.is_a?(String)
+      @errors << "Signature must be a string" if @sig && !@sig.is_a?(String)
+      @errors << "POW must be an integer" if @pow && !@pow.is_a?(Integer)
+      @errors << "Delegation must be an array" if @delegation && !@delegation.is_a?(Array)
+
+      if @errors.any?
+        raise ValidationError, @errors.join(", ")
+      end
+
+      true
+    end
+
+    def valid?
+      begin
+        signable?
+      rescue ValidationError => e
+        return false
+      end
+
+      # Additional checks for a valid signed event
+      @errors = []
+      @errors << "ID is missing" if @id.nil?
+      @errors << "Signature is missing" if @sig.nil?
+      @errors << "Pubkey is missing" if @pubkey.nil?
+
+      if @errors.any?
+        raise ValidationError, @errors.join(", ")
+      end
+
+      true
+    end
+
+    def self.from_message(message)
+      subscription_id = message[1]
+      event_data = message[2]
+
+      event = new(
+        subscription_id: subscription_id,
+        kind: event_data["kind"],
+        pubkey: event_data["pubkey"],
+        created_at: event_data["created_at"],
+        tags: event_data["tags"],
+        content: event_data["content"],
+        id: event_data["id"],
+        sig: event_data["sig"],
+        pow: event_data["nonce"]&.last&.to_i
+      )
+      raise ArgumentError, "Event is not valid" unless event.valid?
+      return event
+    end
+
+  private
+
+    def reset!
+      @id = nil
+      @sign = nil
+    end
+
+  end
+end

data/lib/event_wizard.rb

@@ -0,0 +1,31 @@
+module EventWizard
+  def initialize_event_emitter
+    @listeners = Hash.new { |hash, key| hash[key] = [] }
+  end
+
+  def on(event, &callback)
+    # Prevent adding the same callback multiple times
+    unless @listeners[event].include?(callback)
+      @listeners[event] << callback
+    end
+  end
+
+  def emit(event, *args)
+    @listeners[event].each { |callback| callback.call(*args) }
+  end
+
+  def off(event, callback)
+    return unless @listeners[event]
+    @listeners[event].delete(callback)
+  end
+
+  def replace(event, old_callback, new_callback)
+    return unless @listeners[event]
+    index = @listeners[event].index(old_callback)
+    @listeners[event][index] = new_callback if index
+  end
+
+  def clear(event)
+    @listeners.delete(event)
+  end
+end

data/lib/filter.rb

@@ -0,0 +1,57 @@
+module Nostr
+  class Filter
+
+    attr_reader :id
+    attr_reader :kinds
+    attr_reader :authors
+    attr_reader :tags
+    attr_reader :since
+    attr_reader :until
+    attr_reader :limit
+    attr_reader :search
+    ('a'..'z').each { |char| attr_reader char.to_sym }
+    ('A'..'Z').each { |char| attr_reader char.to_sym }
+
+    def initialize(ids: nil, kinds: nil, authors: nil, since: nil, limit: nil, search: nil, **params)
+      @id = id
+      @kinds = kinds
+      @authors = authors
+      @tags = tags
+      @since = since.nil? ? nil : since.to_i
+      @limit = limit
+      @search = search
+      @until = params[:until].nil? ? nil : params[:until].to_i # this is an hack to permit the use of the 'until' param, since it is a reserved word
+
+      # Handle additional parameters with a-zA-Z names
+      params.each do |key, value|
+        if key.to_s.match?(/\A[a-zA-Z]\z/)
+          instance_variable_set("@#{key}", value)
+        end
+      end
+    end
+
+    def to_h
+      result = {
+        id: @id,
+        authors: @authors,
+        kinds: @kinds,
+        since: @since,
+        until: @until,
+        limit: @limit,
+        search: @search
+      }.compact
+
+      ('a'..'z').each do |char|
+        var_value = instance_variable_get("@#{char}")
+        result["##{char}"] = var_value unless var_value.nil?
+      end
+      ('A'..'Z').each do |char|
+        var_value = instance_variable_get("@#{char}")
+        result["##{char}"] = var_value unless var_value.nil?
+      end
+
+      result
+    end
+
+  end
+end

data/lib/key.rb

@@ -0,0 +1,15 @@
+module Nostr
+  class Key
+
+    def self.generate_private_key
+      group = ECDSA::Group::Secp256k1
+      (1 + SecureRandom.random_number(group.order - 1)).to_s(16).rjust(64, '0')
+    end
+
+    def self.get_public_key(private_key)
+      group = ECDSA::Group::Secp256k1
+      group.generator.multiply_by_scalar(private_key.to_i(16)).x.to_s(16).rjust(64, '0')
+    end
+
+  end
+end

data/lib/kind.rb

@@ -0,0 +1,10 @@
+module Nostr
+  module Kind
+    METADATA = 0
+    SHORT_NOTE = 1
+    CONTACT_LIST = 3
+    DIRECT_MESSAGE = 4
+    DELETION = 5
+    REACTION = 7
+  end
+end

data/lib/message_handler.rb

@@ -0,0 +1,107 @@
+module Nostr
+  class MessageHandler
+    def self.handle(message)
+
+      message = JSON.parse(message) rescue ["?", message]
+      type = message[0]
+      strategy_class = case type
+        when 'EVENT' then EventMessageStrategy
+        when 'OK' then OkMessageStrategy
+        when 'EOSE' then EoseMessageStrategy
+        when 'CLOSED' then ClosedMessageStrategy
+        when 'NOTICE' then NoticeMessageStrategy
+        else UnknownMessageStrategy
+      end
+
+      processed_data = strategy_class.new(message).process
+      type == "EVENT" ? processed_data : ParsedData.new(processed_data)
+
+    end
+  end
+
+  class BaseMessageStrategy
+    def initialize(message)
+      @message = message
+    end
+
+    def process
+      raise NotImplementedError
+    end
+  end
+
+  class EventMessageStrategy < BaseMessageStrategy
+    def process
+      Event.from_message(@message)
+    end
+  end
+
+  class OkMessageStrategy < BaseMessageStrategy
+    def process
+      {
+        type: 'OK',
+        event_id: @message[1],
+        success: @message[2],
+        message: @message[3]
+      }
+    end
+  end
+
+  class EoseMessageStrategy < BaseMessageStrategy
+    def process
+      {
+        type: 'EOSE',
+        subscription_id: @message[1]
+      }
+    end
+  end
+
+  class ClosedMessageStrategy < BaseMessageStrategy
+    def process
+      {
+        type: 'CLOSED',
+        subscription_id: @message[1],
+        reason: @message[2]
+      }
+    end
+  end
+
+  class NoticeMessageStrategy < BaseMessageStrategy
+    def process
+      {
+        type: 'NOTICE',
+        message: @message[1]
+      }
+    end
+  end
+
+  class UnknownMessageStrategy < BaseMessageStrategy
+    def process
+      {
+        type: 'UNKNOWN',
+        raw_message: @message
+      }
+    end
+  end
+end
+
+class ParsedData
+  def initialize(data)
+    @data = data
+  end
+
+  def type
+    @data[:type]
+  end
+
+  def method_missing(method_name, *args, &block)
+    if @data.key?(method_name)
+      @data[method_name]
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @data.key?(method_name) || super
+  end
+end