nostr_ruby 0.1.3 → 0.3.0

data/lib/nostr_ruby.rb

@@ -1,4 +1,6 @@
-require 'custom_addr'
+require_relative 'version'
+require_relative 'crypto_tools'
+
 require 'ecdsa'
 require 'schnorr'
 require 'json'
@@ -7,274 +9,16 @@ require 'bech32'
 require 'unicode/emoji'
 require 'websocket-client-simple'
 
-# * Ruby library to interact with the Nostr protocol
-
-class Nostr
-  attr_reader :private_key, :public_key, :pow_difficulty_target
-
-  def initialize(key)
-    hex_private_key =  if key[:private_key]&.include?('nsec')
-      Nostr.to_hex(key[:private_key])
-    else
-      key[:private_key]
-    end
-
-    hex_public_key = if key[:public_key]&.include?('npub')
-      Nostr.to_hex(key[:public_key])
-    else
-      key[:public_key]
-    end
-
-    if hex_private_key
-      @private_key = hex_private_key
-      group = ECDSA::Group::Secp256k1
-      @public_key = group.generator.multiply_by_scalar(private_key.to_i(16)).x.to_s(16).rjust(64, '0')
-    elsif hex_public_key
-      @public_key = hex_public_key
-    else
-      raise 'Missing private or public key'
-    end
-  end
-
-  def keys
-    keys = { public_key: @public_key }
-    keys[:private_key] = @private_key if @private_key
-    keys
-  end
-
-  def bech32_keys
-    bech32_keys = { public_key: Nostr.to_bech32(@public_key, 'npub') }
-    bech32_keys[:private_key] = Nostr.to_bech32(@private_key, 'nsec') if @private_key
-    bech32_keys
-  end
-
-  def self.to_hex(bech32_key)
-    public_addr = CustomAddr.new(bech32_key)
-    public_addr.to_scriptpubkey
-  end
-
-  def self.to_bech32(hex_key, hrp)
-    custom_addr = CustomAddr.new
-    custom_addr.scriptpubkey = hex_key
-    custom_addr.hrp = hrp
-    custom_addr.addr
-  end
-
-  def calculate_shared_key(other_public_key)
-    ec = OpenSSL::PKey::EC.new('secp256k1')
-    ec.private_key = OpenSSL::BN.new(@private_key, 16)
-    recipient_key_hex = "02#{other_public_key}"
-    recipient_pub_bn = OpenSSL::BN.new(recipient_key_hex, 16)
-    secret_point = OpenSSL::PKey::EC::Point.new(ec.group, recipient_pub_bn)
-    ec.dh_compute_key(secret_point)
-  end
-
-  def sign_event(event)
-    raise 'Invalid pubkey' unless event[:pubkey].is_a?(String) && event[:pubkey].size == 64
-    raise 'Invalid created_at' unless event[:created_at].is_a?(Integer)
-    raise 'Invalid kind' unless (0..29_999).include?(event[:kind])
-    raise 'Invalid tags' unless event[:tags].is_a?(Array)
-    raise 'Invalid content' unless event[:content].is_a?(String)
-
-    serialized_event = [
-      0,
-      event[:pubkey],
-      event[:created_at],
-      event[:kind],
-      event[:tags],
-      event[:content]
-    ]
-
-    serialized_event_sha256 = nil
-    if @pow_difficulty_target
-      nonce = 1
-      loop do
-        nonce_tag = ['nonce', nonce.to_s, @pow_difficulty_target.to_s]
-        nonced_serialized_event = serialized_event.clone
-        nonced_serialized_event[4] = nonced_serialized_event[4] + [nonce_tag]
-        serialized_event_sha256 = Digest::SHA256.hexdigest(JSON.dump(nonced_serialized_event))
-        if match_pow_difficulty?(serialized_event_sha256)
-          event[:tags] << nonce_tag
-          break
-        end
-        nonce += 1
-      end
-    else
-      serialized_event_sha256 = Digest::SHA256.hexdigest(JSON.dump(serialized_event))
-    end
-
-    private_key = Array(@private_key).pack('H*')
-    message = Array(serialized_event_sha256).pack('H*')
-    event_signature = Schnorr.sign(message, private_key).encode.unpack('H*')[0]
-
-    event['id'] = serialized_event_sha256
-    event['sig'] = event_signature
-    event
-  end
-
-  def build_event(payload)
-    event = sign_event(payload)
-    ['EVENT', event]
-  end
-
-  def build_metadata_event(name, about, picture, nip05)
-    data = {}
-    data[:name] = name if name
-    data[:about] = about if about
-    data[:picture] = picture if picture
-    data[:nip05] = nip05 if nip05
-    event = {
-      "pubkey": @public_key,
-      "created_at": Time.now.utc.to_i,
-      "kind": 0,
-      "tags": [],
-      "content": data.to_json
-    }
-
-    event = sign_event(event)
-    ['EVENT', event]
-  end
-
-  def build_note_event(text, channel_key = nil)
-    event = {
-      "pubkey": @public_key,
-      "created_at": Time.now.utc.to_i,
-      "kind": channel_key ? 42 : 1,
-      "tags": channel_key ? [['e', channel_key]] : [],
-      "content": text
-    }
-
-    event = sign_event(event)
-    ['EVENT', event]
-  end
-
-  def build_recommended_relay_event(relay)
-    raise 'Invalid relay' unless relay.start_with?('wss://') || relay.start_with?('ws://')
-
-    event = {
-      "pubkey": @public_key,
-      "created_at": Time.now.utc.to_i,
-      "kind": 2,
-      "tags": [],
-      "content": relay
-    }
-
-    event = sign_event(event)
-    ['EVENT', event]
-  end
-
-  def build_contact_list_event(contacts)
-    event = {
-      "pubkey": @public_key,
-      "created_at": Time.now.utc.to_i,
-      "kind": 3,
-      "tags": contacts.map { |c| ['p'] + c },
-      "content": ''
-    }
-
-    event = sign_event(event)
-    ['EVENT', event]
-  end
-
-  def build_dm_event(text, recipient_public_key)
-    cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
-    cipher.encrypt
-    cipher.iv = iv = cipher.random_iv
-    cipher.key = calculate_shared_key(recipient_public_key)
-    encrypted_text = cipher.update(text)
-    encrypted_text << cipher.final
-    encrypted_text = "#{Base64.encode64(encrypted_text)}?iv=#{Base64.encode64(iv)}"
-    encrypted_text = encrypted_text.gsub("\n", '')
-
-    event = {
-      "pubkey": @public_key,
-      "created_at": Time.now.utc.to_i,
-      "kind": 4,
-      "tags": [['p', recipient_public_key]],
-      "content": encrypted_text
-    }
-
-    event = sign_event(event)
-    ['EVENT', event]
-  end
-
-  def build_deletion_event(events, reason = '')
-    event = {
-      "pubkey": @public_key,
-      "created_at": Time.now.utc.to_i,
-      "kind": 5,
-      "tags": events.map{ |e| ['e', e] },
-      "content": reason
-    }
-
-    event = sign_event(event)
-    ['EVENT', event]
-  end
-
-  def build_reaction_event(reaction, event, author)
-    raise 'Invalid reaction' unless ['+', '-'].include?(reaction) || reaction.match?(Unicode::Emoji::REGEX)
-    raise 'Invalid author' unless event.is_a?(String) && event.size == 64
-    raise 'Invalid event' unless author.is_a?(String) && author.size == 64
-
-    event = {
-      "pubkey": @public_key,
-      "created_at": Time.now.utc.to_i,
-      "kind": 7,
-      "tags": [['e', event], ['p', author]],
-      "content": reaction
-    }
-
-    event = sign_event(event)
-    ['EVENT', event]
-  end
-
-  def decrypt_dm(event)
-    data = event[1]
-    sender_public_key = data[:pubkey] != @public_key ? data[:pubkey] : data[:tags][0][1]
-    encrypted = data[:content].split('?iv=')[0]
-    iv = data[:content].split('?iv=')[1]
-    cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
-    cipher.decrypt
-    cipher.iv = Base64.decode64(iv)
-    cipher.key = calculate_shared_key(sender_public_key)
-    (cipher.update(Base64.decode64(encrypted)) + cipher.final).force_encoding('UTF-8')
-  end
-
-  def build_req_event(filters)
-    ['REQ', SecureRandom.random_number.to_s, filters]
-  end
-
-  def build_close_event(subscription_id)
-    ['CLOSE', subscription_id]
-  end
-
-  def build_notice_event(message)
-    ['NOTICE', message]
-  end
-
-  def match_pow_difficulty?(event_id)
-    @pow_difficulty_target.nil? || @pow_difficulty_target == [event_id].pack("H*").unpack("B*")[0].index('1')
-  end
-
-  def set_pow_difficulty_target(n)
-    @pow_difficulty_target = n
-  end
-
-  def test_post_event(event, relay)
-    response = nil
-    ws = WebSocket::Client::Simple.connect relay
-    ws.on :message do |msg|
-      puts msg
-      response = JSON.parse(msg.data)
-      ws.close
-    end
-    ws.on :open do
-      ws.send event.to_json
-    end
-    while response.nil? do
-      sleep 0.1
-    end
-    response[0] == 'OK'
-  end
+require_relative 'bech32'
+require_relative 'context'
+require_relative 'kind'
+require_relative 'key'
+require_relative 'event'
+require_relative 'filter'
+require_relative 'signer'
+require_relative 'client'
+require_relative 'message_handler'
+
+module Nostr
 
 end

data/lib/signer.rb

@@ -0,0 +1,89 @@
+module Nostr
+  class Signer
+
+    attr_reader :private_key
+    attr_reader :public_key
+
+    def initialize(private_key:)
+      @private_key = private_key
+      unless @public_key
+        @public_key = Nostr::Key::get_public_key(@private_key)
+      end
+    end
+
+    def nsec
+      Nostr::Bech32.encode_nsec(@private_key)
+    end
+
+    def npub
+      Nostr::Bech32.encode_npub(@public_key)
+    end
+
+    def sign(event)
+
+      raise ArgumentError, "Event is not signable" unless event.signable?
+
+      event.pubkey = @public_key if event.pubkey.nil? || event.pubkey.empty?
+
+      raise ArgumentError, "Pubkey doesn't match the private key" unless event.pubkey == @public_key
+
+      if event.kind == Nostr::Kind::DIRECT_MESSAGE
+        dm_recipient = event.tags.select{|t| t[0] == "p"}.first[1]
+        event.content = CryptoTools.aes_256_cbc_encrypt(@private_key, dm_recipient, event.content)
+      end
+
+      if event.delegation
+        event.tags << event.delegation
+      end
+
+      event_sha256_digest = nil
+      if event.pow
+        nonce = 1
+        loop do
+          nonce_tag = ['nonce', nonce.to_s, event.pow.to_s]
+          nonced_serialized_event = event.serialize.clone
+          nonced_serialized_event[4] = nonced_serialized_event[4] + [nonce_tag]
+          event_sha256_digest = Digest::SHA256.hexdigest(JSON.dump(nonced_serialized_event))
+          if Nostr::Event.match_pow_difficulty?(event_sha256_digest, event.pow)
+            event.tags << nonce_tag
+            break
+          end
+          nonce += 1
+        end
+      else
+        event_sha256_digest = Digest::SHA256.hexdigest(JSON.dump(event.serialize))
+      end
+
+      event.id = event_sha256_digest
+      binary_private_key = Array(@private_key).pack('H*')
+      binary_message = Array(event.id).pack('H*')
+      event.sig = Schnorr.sign(binary_message, binary_private_key).encode.unpack('H*')[0]
+      event
+    end
+
+    def decrypt(event)
+      case event.kind
+      when Nostr::Kind::DIRECT_MESSAGE
+        data = event.content.split('?iv=')[0]
+        iv = event.content.split('?iv=')[1]
+        dm_recipient = event.tags.select{|t| t[0] == "p"}.first[1]
+        event.content = CryptoTools.aes_256_cbc_decrypt(@private_key, dm_recipient, data, iv)
+        event
+      else
+        raise "Unable to decrypt a kind #{event.kind} event"
+      end
+    end
+
+    def generate_delegation_tag(to:, conditions:)
+      delegation_message_sha256 = Digest::SHA256.hexdigest("nostr:delegation:#{to}:#{conditions}")
+      signature = Schnorr.sign(Array(delegation_message_sha256).pack('H*'), Array(@private_key).pack('H*')).encode.unpack('H*')[0]
+      [
+        "delegation",
+        @public_key,
+        conditions,
+        signature
+      ]
+    end
+
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Nostr
+  VERSION = '0.3.0'
+end

data/nostr_ruby.gemspec

@@ -1,9 +1,9 @@
 $:.unshift File.expand_path('../lib', __FILE__)
-require 'nostr_ruby/version'
+require 'version'
 
 Gem::Specification.new do |s|
   s.name          = 'nostr_ruby'
-  s.version       = NostrRuby::VERSION
+  s.version       = Nostr::VERSION
   s.summary       = 'A Ruby library to interact with the Nostr protocol'
   s.description   = 'NostrRuby is a Ruby library to interact with the Nostr protocol. At this stage the focus is the creation of public events and private encrypted messages.'
   s.authors       = ['Daniele Tonon']
@@ -14,9 +14,9 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
   s.add_dependency 'base64', '~> 0.1.1'
-  s.add_dependency 'bech32', '~> 1.3.0'
+  s.add_dependency 'bech32', '~> 1.4.0'
   s.add_dependency 'bip-schnorr', '~> 0.4.0'
   s.add_dependency 'json', '~> 2.6.2'
   s.add_dependency 'unicode-emoji', '~> 3.3.1'
-  s.add_dependency 'websocket-client-simple', '~> 0.6.0'
+  s.add_dependency 'faye-websocket', '~> 0.11'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nostr_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniele Tonon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-10 00:00:00.000000000 Z
+date: 2025-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: bip-schnorr
   requirement: !ruby/object:Gem::Requirement
@@ -81,19 +81,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.3.1
 - !ruby/object:Gem::Dependency
-  name: websocket-client-simple
+  name: faye-websocket
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: '0.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: '0.11'
 description: NostrRuby is a Ruby library to interact with the Nostr protocol. At this
   stage the focus is the creation of public events and private encrypted messages.
 email:
@@ -105,9 +105,20 @@ files:
 - Gemfile.lock
 - LICENSE.md
 - README.md
-- lib/custom_addr.rb
+- lib/bech32.rb
+- lib/client.rb
+- lib/context.rb
+- lib/crypto_tools.rb
+- lib/event.rb
+- lib/event_wizard.rb
+- lib/filter.rb
+- lib/key.rb
+- lib/kind.rb
+- lib/message_handler.rb
 - lib/nostr_ruby.rb
-- lib/nostr_ruby/version.rb
+- lib/signer.rb
+- lib/version.rb
+- nostr_ruby-0.2.0.gem
 - nostr_ruby.gemspec
 homepage: https://github.com/dtonon/nostr-ruby
 licenses:

data/lib/custom_addr.rb

@@ -1,59 +0,0 @@
-class CustomAddr
-
-  attr_accessor :hrp # human-readable part
-  attr_accessor :prog # witness program
-
-  def initialize(addr = nil)
-    @hrp, @prog = parse_addr(addr) if addr
-  end
-
-  def to_scriptpubkey
-    prog.map{|p|[p].pack("C")}.join.unpack('H*').first
-  end
-
-  def scriptpubkey=(script)
-    values = [script].pack('H*').unpack("C*")
-    @prog = values
-  end
-
-  def addr
-    spec = Bech32::Encoding::BECH32
-    Bech32.encode(hrp, convert_bits(prog, 8, 5), spec)
-  end
-
-  private
-
-  def parse_addr(addr)
-    hrp, data, spec = Bech32.decode(addr)
-    raise 'Invalid address.' if hrp.nil? || data[0].nil?
-    # raise 'Invalid witness version' if ver > 16
-    prog = convert_bits(data, 5, 8, false)
-    # raise 'Invalid witness program' if prog.nil? || prog.length < 2 || prog.length > 40
-    # raise 'Invalid witness program with version 0' if ver == 0 && (prog.length != 20 && prog.length != 32)
-    [hrp, prog]
-  end
-
-  def convert_bits(data, from, to, padding=true)
-    acc = 0
-    bits = 0
-    ret = []
-    maxv = (1 << to) - 1
-    max_acc = (1 << (from + to - 1)) - 1
-    data.each do |v|
-      return nil if v < 0 || (v >> from) != 0
-      acc = ((acc << from) | v) & max_acc
-      bits += from
-      while bits >= to
-        bits -= to
-        ret << ((acc >> bits) & maxv)
-      end
-    end
-    if padding
-      ret << ((acc << (to - bits)) & maxv) unless bits == 0
-    elsif bits >= from || ((acc << (to - bits)) & maxv) != 0
-      return nil
-    end
-    ret
-  end
-
-end

data/lib/nostr_ruby/version.rb

@@ -1,3 +0,0 @@
-module NostrRuby
-  VERSION = '0.1.3'
-end