nostrb 0.1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f6159cbd2c246ae573103bd68e56e7cd97b0d3d81d36d8e0816abc5bd23c3c1
+  data.tar.gz: 8bcf8fe77b3baa61882ea849df549b2800ebbf5e788d55c2c1c00efddc99e1f8
+SHA512:
+  metadata.gz: 369121a3fa1b9ead9bc245a3bd5f18ce6a6e2cc3571e1c91019afb4752845de7edbef086b755ad3b90d4b1a072997b2cce8047e19c4db293cc14328332febb56
+  data.tar.gz: 8b19fa2c2b738e53711fdb4bbdac6a196ce8499b8a212b742be734318a526bd495bed6ddfd97f771c005323ee2583f6207feea8f79850b95e7c3aced24ac3cec

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake/testtask'
+
+Rake::TestTask.new :test do |t|
+  t.pattern = "test/*.rb"
+  t.warning = true
+end
+
+task :relay do |t|
+  sh "ruby -I lib examples/relay.rb"
+end
+
+task default: [:test, :relay]
+
+begin
+  require 'buildar'
+
+  Buildar.new do |b|
+    b.gemspec_file = 'nostrb.gemspec'
+    b.version_file = 'VERSION'
+    b.use_git = true
+  end
+rescue LoadError
+  warn "buildar tasks unavailable"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0.1

data/lib/nostrb/event.rb

@@ -0,0 +1,154 @@
+require 'nostrb'
+
+module Nostrb
+  class Event
+
+    # Event
+    #   content: any string
+    #   kind: 0..65535
+    #   tags: Array[Array[string]]
+    #   pubkey: 64 hex chars (32B binary)
+
+    def self.digest(ary) = Nostrb.digest(Nostrb.json(Nostrb.ary!(ary)))
+
+    def self.tag_values(tag, tags)
+      tags.select { |a| a[0] == tag }.map { |a| a[1] }
+    end
+
+    def self.d_tag(tags)
+      tag_values('d', tags).first
+    end
+
+    attr_reader :content, :kind, :tags, :pk
+
+    def initialize(content = '', kind: 1, tags: [], pk:)
+      @content = Nostrb.txt!(content)
+      @kind    = Nostrb.kind!(kind)
+      @tags    = Nostrb.tags!(tags)
+      @pk      = Nostrb.key!(pk)
+    end
+
+    alias_method :to_s, :content
+
+    def serialize(created_at)
+      [0, self.pubkey, Nostrb.int!(created_at), @kind, @tags, @content]
+    end
+
+    def to_a = serialize(Time.now.to_i)
+    def pubkey = SchnorrSig.bin2hex(@pk)
+    def digest(created_at) = Event.digest(serialize(created_at))
+    def sign(sk) = SignedEvent.new(self, sk)
+
+    #
+    # Tags
+    #
+
+    # add an array of 2+ strings to @tags
+    def add_tag(tag, value, *rest)
+      @tags.push([Nostrb.txt!(tag), Nostrb.txt!(value)] +
+                 rest.each { |s| Nostrb.txt!(s) })
+    end
+
+    # add an event tag based on event id, hex encoded
+    def ref_event(eid_hex, *rest)
+      add_tag('e', Nostrb.id!(eid_hex), *rest)
+    end
+
+    # add a pubkey tag based on pubkey, 64 bytes hex encoded
+    def ref_pubkey(pubkey, *rest)
+      add_tag('p', Nostrb.pubkey!(pubkey), *rest)
+    end
+
+    # kind: and pubkey: required
+    def ref_replace(*rest, kind:, pubkey:, d_tag: '')
+      val = [Nostrb.kind!(kind), Nostrb.pubkey!(pubkey), d_tag].join(':')
+      add_tag('a', val, *rest)
+    end
+  end
+
+  # SignedEvent
+  # id: 64 hex chars (32B binary)
+  # created_at: unix seconds, integer
+  # sig: 128 hex chars (64B binary)
+
+  class SignedEvent
+    class Error < RuntimeError; end
+    class IdCheck < Error; end
+    class SignatureCheck < Error; end
+
+    def self.validate!(parsed)
+      Nostrb.check!(parsed, Hash)
+      Nostrb.txt!(parsed.fetch("content"))
+      Nostrb.pubkey!(parsed.fetch("pubkey"))
+      Nostrb.kind!(parsed.fetch("kind"))
+      Nostrb.tags!(parsed.fetch("tags"))
+      Nostrb.int!(parsed.fetch("created_at"))
+      Nostrb.id!(parsed.fetch("id"))
+      Nostrb.sig!(parsed.fetch("sig"))
+      parsed
+    end
+
+    def self.digest(valid) = Nostrb.digest(Nostrb.json(serialize(valid)))
+
+    def self.serialize(valid)
+      Array[ 0,
+             valid["pubkey"],
+             valid["created_at"],
+             valid["kind"],
+             valid["tags"],
+             valid["content"], ]
+    end
+
+    # Validate the id (optional) and signature
+    # May raise explicitly: IdCheck, SignatureCheck
+    # May raise implicitly: Nostrb::SizeError, EncodingError, TypeError,
+    #                       SchnorrSig::Error
+    # Return a _completely validated_ hash
+    def self.verify(valid, check_id: true)
+      id, pubkey, sig = valid["id"], valid["pubkey"], valid["sig"]
+
+      # extract binary values for signature verification
+      digest = SchnorrSig.hex2bin id
+      pk = SchnorrSig.hex2bin pubkey
+      signature = SchnorrSig.hex2bin sig
+
+      # verify the signature
+      unless SchnorrSig.verify?(pk, digest, signature)
+        raise(SignatureCheck, sig)
+      end
+      # (optional) verify the id / digest
+      raise(IdCheck, id) if check_id and digest != SignedEvent.digest(valid)
+      valid
+    end
+
+    attr_reader :event, :created_at, :digest, :signature
+
+    # sk is used to generate @signature and then discarded
+    def initialize(event, sk)
+      @event = Nostrb.check!(event, Event)
+      @created_at = Time.now.to_i
+      @digest = @event.digest(@created_at)
+      @signature = SchnorrSig.sign(Nostrb.key!(sk), @digest)
+    end
+
+    def content = @event.content
+    def kind = @event.kind
+    def tags = @event.tags
+    def pubkey = @event.pubkey
+    def to_s = @event.to_s
+    def serialize = @event.serialize(@created_at)
+
+    def id = SchnorrSig.bin2hex(@digest)
+    def sig = SchnorrSig.bin2hex(@signature)
+
+    def to_h
+      Hash[ "content" => @event.content,
+            "kind" => @event.kind,
+            "tags" => @event.tags,
+            "pubkey" => @event.pubkey,
+            "created_at" => @created_at,
+            "id" => self.id,
+            "sig" => self.sig ]
+    end
+  end
+end

data/lib/nostrb/filter.rb

@@ -0,0 +1,144 @@
+module Nostrb
+  module Seconds
+    def milliseconds(i) = i / 1000r
+    def seconds(i) = i
+    def minutes(i) = 60 * i
+    def hours(i)   = 60 * minutes(i)
+    def days(i)    = 24 * hours(i)
+    def weeks(i)   =  7 * days(i)
+    def months(i)  = years(i) / 12
+    def years(i)   = 365 * days(i)
+
+    def process(hsh)
+      seconds = 0
+      [:seconds, :minutes, :hours, :days, :weeks, :months, :years].each { |p|
+        seconds += send(p, hsh[p]) if hsh.key?(p)
+      }
+      seconds
+    end
+  end
+  Seconds.extend(Seconds)
+
+  class Filter
+    TAG = /\A#([a-zA-Z])\z/
+
+    def self.ago(hsh)
+      Time.now.to_i - Seconds.process(hsh)
+    end
+
+    def self.ingest(hash)
+      f = Filter.new
+
+      if ids = hash.delete("ids")
+        f.add_ids(*ids)
+      end
+      if authors = hash.delete("authors")
+        f.add_authors(*authors)
+      end
+      if kinds = hash.delete("kinds")
+        f.add_kinds(*kinds)
+      end
+      if since = hash.delete("since")
+        f.since = since
+      end
+      if _until = hash.delete("until")
+        f.until = _until
+      end
+      if limit = hash.delete("limit")
+        f.limit = limit
+      end
+
+      # anything left in hash should only be single letter tags
+      hash.each { |tag, ary|
+        if matches = tag.match(TAG)
+          f.add_tag(matches[1], ary)
+        else
+          warn "unmatched tag: #{tag}"
+        end
+      }
+      f
+    end
+
+    attr_reader :ids, :authors, :kinds, :tags, :limit
+
+    def initialize
+      @ids = []
+      @authors = []
+      @kinds = []
+      @tags = {}
+      @since = nil
+      @until = nil
+      @limit = nil
+    end
+
+    def add_ids(*event_ids)
+      @ids += event_ids.each { |id| Nostrb.id!(id) }
+    end
+
+    def add_authors(*pubkeys)
+      @authors += pubkeys.each { |pubkey| Nostrb.pubkey!(pubkey) }
+    end
+
+    def add_kinds(*kinds)
+      @kinds += kinds.each { |k| Nostrb.kind!(k) }
+    end
+
+    def add_tag(letter, list)
+      @tags[Nostrb.txt!(letter, length: 1)] =
+        Nostrb.ary!(list, max: 99).each { |s| Nostrb.txt!(s) }
+    end
+
+    def since(hsh = nil) = hsh.nil? ? @since : (@since = Filter.ago(hsh))
+    def since=(int)
+      @since = int.nil? ? nil : Nostrb.int!(int)
+    end
+
+    def until(hsh = nil) = hsh.nil? ? @until : (@until = Filter.ago(hsh))
+    def until=(int)
+      @until = int.nil? ? nil : Nostrb.int!(int)
+    end
+
+    def limit=(int)
+      @limit = int.nil? ? nil : Nostrb.int!(int)
+    end
+
+    # Input
+    #   Ruby hash as returned from SignedEvent.validate!
+    def match?(valid)
+      return false if !@ids.empty?     and !@ids.include?(valid["id"])
+      return false if !@authors.empty? and !@authors.include?(valid["pubkey"])
+      return false if !@kinds.empty?   and !@kinds.include?(valid["kind"])
+      return false if !@since.nil?     and @since > valid["created_at"]
+      return false if !@until.nil?     and @until < valid["created_at"]
+      if !@tags.empty?
+        tags = valid["tags"]
+        @tags.each { |letter, ary|
+          tag_match = false
+          tags.each { |(tag, val)|
+            next if tag_match
+            if tag == letter
+              return false if !ary.include?(val)
+              tag_match = true
+            end
+          }
+          return false unless tag_match
+        }
+      end
+      true
+    end
+
+    def to_h
+      h = Hash.new
+      h["ids"] = @ids if !@ids.empty?
+      h["authors"] = @authors if !@authors.empty?
+      h["kinds"] = @kinds if !@kinds.empty?
+      @tags.each { |letter, ary|
+        h['#' + letter.to_s] = ary if !ary.empty?
+      }
+      h["since"] = @since unless @since.nil?
+      h["until"] = @until unless @until.nil?
+      h["limit"] = @limit unless @limit.nil?
+      h
+    end
+  end
+end

data/lib/nostrb/json.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+module Nostrb
+  # per NIP-01
+  JSON_OPTIONS = {
+    allow_nan: false,
+    max_nesting: 4,     # event is 3 deep, wire format is 4 deep
+    script_safe: false,
+    ascii_only: false,
+    array_nl: '',
+    object_nl: '',
+    indent: '',
+    space: '',
+    space_before: '',
+  }
+
+  def self.parse(json) = JSON.parse(json, **JSON_OPTIONS)
+  def self.json(object) = JSON.generate(object, **JSON_OPTIONS)
+end

data/lib/nostrb/names.rb

@@ -0,0 +1,71 @@
+require 'nostrb'
+
+module Nostrb
+  # NIP-05
+  module Names
+    LOCAL = /\A[_a-z0-0\-.]+\z/i
+    DOMAIN = /\A[a-z0-9\-.]+\z/i
+
+    # given bob@example.com, return [bob, example.com]
+    def self.identifier(str)
+      a = str.split('@')
+      raise "unexpected #{a.inspect}" unless a.length == 2
+      raise "bad local: #{a[0]}" unless LOCAL.match a[0]
+      raise "bad domain #{a[1]}" unless DOMAIN.match a[1]
+      a
+    end
+
+    # content: <JSON>
+    # kind: 0 (set_metadata)
+    # JSON:
+    #   name:
+    #   about:
+    #   picture:
+    #   nip05: bob@example.com
+    def self.extract_nip05(json)
+      addr = Nostrb.parse(json)['nip05']
+      identifier(addr) if addr
+    end
+
+    # when we get bob's profile back,
+    # if it has a nip05 field
+    # visit: https://example.com/.well-known/nostr.json?name=bob
+    def self.well_known_url(local, domain)
+      format("https://%s/.well-known/nostr.json?name=%s", domain, local)
+    end
+
+    # look for a pubkey:
+    # {"names":{"bob":"b0b0...b0"}}
+    # the pubkey at the URL should match the pubkey from the profile event
+    def self.extract_names(json)
+      hsh = Nostrb.parse(json).fetch("names")
+      hsh.each { |name, pubkey|
+        Nostrb.txt!(name)
+        Nostrb.pubkey!(pubkey)
+      }
+      hsh
+    end
+
+    # or even relays too:
+    # {"names":{"bob":"b0b0...b0"}
+    #  "relays":{
+    #    "b0b0...b0":["wss://relay.example.com/","wss://relay2.example.com/"]
+    #  }
+    # }
+    def self.extract_relays(json)
+      hsh = Nostrb.parse(json).fetch("relays")
+      hsh.each { |pubkey, urls|
+        Nostrb.pubkey!(pubkey)
+        Nostrb.ary!(urls)
+        urls.each { |u| Nostrb.txt!(u) }
+      }
+      hsh
+    end
+
+    # or, if we see bob@example.com
+    # visit: https://example.com/.well-known/nostr.json?name=bob
+    # get the pubkey
+    # subscribe to that user's profile events
+    # check if that user has nip05 and it matches bob@example.com
+  end
+end

data/lib/nostrb/oj.rb

@@ -0,0 +1,6 @@
+require 'oj'
+
+module Nostrb
+  def self.parse(json)  = Oj.load(json, mode: :strict)
+  def self.json(object) = Oj.dump(object, mode: :strict)
+end

data/lib/nostrb/relay.rb

@@ -0,0 +1,142 @@
+require 'nostrb/event'
+require 'nostrb/filter'
+require 'nostrb/sqlite'
+require 'set' # jruby wants this
+
+# Kind:
+#   1,4..44,1000..9999: regular -- relay stores all
+#   0,3: replaceable -- relay stores only the last message from pubkey
+#   2: deprecated
+#   10_000..19_999: replaceable -- relay stores latest(pubkey, kind)
+#   20_000..29_999: ephemeral -- relay doesn't store
+#   30_000..39_999: parameterized replaceable -- latest(pubkey, kind, dtag)
+
+# for replaceable events with same timestamp, lowest id wins
+
+module Nostrb
+  class Server
+    def self.event(sid, event) = ["EVENT", Nostrb.sid!(sid), event.to_h]
+    def self.ok(eid, msg = "", ok: true)
+      ["OK", Nostrb.id!(eid), !!ok, ok ? Nostrb.txt!(msg) : Nostrb.help!(msg)]
+    end
+    def self.eose(sid) = ["EOSE", Nostrb.sid!(sid)]
+    def self.closed(sid, msg) = ["CLOSED", Nostrb.sid!(sid), Nostrb.help!(msg)]
+    def self.notice(msg) = ["NOTICE", Nostrb.txt!(msg)]
+    def self.error(e) = notice(message(e))
+
+    def self.message(excp)
+      format("%s: %s", excp.class.name.split('::').last, excp.message)
+    end
+
+    def initialize(db_filename = nil, storage: :sqlite)
+      case storage
+      when :sqlite
+        mod = Nostrb::SQLite
+      when :sequel
+        require 'nostrb/sequel'
+        mod = Nostrb::Sequel
+      else
+        raise "unexpected: #{storage.inspect}"
+      end
+      db_filename ||= mod::Storage::FILENAME
+      @reader = mod::Reader.new(db_filename)
+      @writer = mod::Writer.new(db_filename)
+    end
+
+    # accepts a single json array
+    # returns a ruby array of response strings (json array)
+    def ingest(json)
+      begin
+        a = Nostrb.ary!(Nostrb.parse(json))
+        case a[0]
+        when 'EVENT'
+          [handle_event(Nostrb.check!(a[1], Hash))]
+        when 'REQ'
+          sid = Nostrb.sid!(a[1])
+          filters = a[2..-1].map { |f| Filter.ingest(f) }
+          handle_req(sid, *filters)
+        when 'CLOSE'
+          [handle_close(Nostrb.sid!(a[1]))]
+        else
+          [Server.notice("unexpected: #{a[0].inspect}")]
+        end
+      rescue StandardError => e
+        [Server.error(e)]
+      end
+    end
+
+    # return a single response
+    def handle_event(hsh)
+      begin
+        hsh = SignedEvent.validate!(hsh)
+      rescue Nostrb::Error, KeyError, RuntimeError => e
+        return Server.error(e)
+      end
+
+      eid = hsh.fetch('id')
+
+      begin
+        hsh = SignedEvent.verify(hsh)
+        case hsh['kind']
+        when 1, (4..44), (1000..9999)
+          # regular, store all
+          @writer.add_event(hsh)
+        when 0, 3, (10_000..19_999)
+          # replaceable, store latest (pubkey, kind)
+          @writer.add_r_event(hsh)
+        when 20_000..29_999
+          # ephemeral, don't store
+        when 30_000..30_999
+          # parameterized replaceable, store latest (pubkey, kind, dtag)
+          # TODO: implement dtag stuff
+          @writer.add_r_event(hsh)
+        else
+          raise(SignedEvent::Error, "kind: #{hsh['kind']}")
+        end
+
+        Server.ok(eid)
+      rescue SignedEvent::Error => e
+        Server.ok(eid, Server.message(e), ok: false)
+      rescue Nostrb::Error, KeyError, RuntimeError => e
+        Server.error(e)
+      end
+    end
+
+    # return an array of response
+    # filter1:
+    #   ids: [id1, id2]
+    #   authors: [pubkey1]
+    # filter2:
+    #   ids: [id3, id4]
+    #   authors: [pubkey2]
+
+    # run filter1
+    #   for any fields specified (ids, authors)
+    #     if any values match, the event is a match
+    #   all fields provided must match for the event to match
+    #     ids must have a match and authors must have a match
+
+    # run filter2 just like filter1
+    # the result set is the union of filter1 and filter2
+
+    def handle_req(sid, *filters)
+      responses = Set.new
+
+      filters.each { |f|
+        @reader.process_events(f).each { |h|
+          responses << Server.event(sid, h) if f.match? h
+        }
+        @reader.process_r_events(f).each { |h|
+          responses << Server.event(sid, h) if f.match? h
+        }
+      }
+      responses = responses.to_a
+      responses << Server.eose(sid)
+    end
+
+    # single response
+    def handle_close(sid)
+      Server.closed(sid, "reason: CLOSE requested")
+    end
+  end
+end