nostrb 0.1.0.1

data/test/event.rb

@@ -0,0 +1,193 @@
+require 'nostrb/event'
+require_relative 'common.rb'
+require 'minitest/autorun'
+
+include Nostrb
+
+describe Event do
+  def text_note(content = '')
+    Event.new(content, kind: 1, pk: Test::PK)
+  end
+
+  describe "class functions" do
+    it "computes a 32 byte digest of a JSON serialization" do
+      a = SignedEvent.serialize(Test::STATIC_HASH)
+      d = Event.digest(a)
+      expect(d).must_be_kind_of String
+      expect(d.length).must_equal 32
+      expect(d.encoding).must_equal Encoding::BINARY
+    end
+  end
+
+  describe "initialization" do
+    it "wraps a string of content" do
+      content = 'hello world'
+      expect(text_note(content).content).must_equal content
+    end
+
+    it "requires a _kind_ integer, defaulting to 1" do
+      expect(Event.new(kind: 0, pk: Test::PK).kind).must_equal 0
+      expect(Event.new(pk: Test::PK).kind).must_equal 1
+    end
+
+    it "requires a public key in binary format" do
+      expect(Test::EVENT.pk).must_equal Test::PK
+      expect {
+        Event.new(kind: 1, pk: SchnorrSig.bin2hex(Test::PK))
+      }.must_raise EncodingError
+      expect {
+        Event.new(kind: 1, pk: "0123456789abcdef".b)
+      }.must_raise SizeError
+      expect { Event.new }.must_raise
+    end
+  end
+
+  it "provides its content in a string context" do
+    s = text_note('hello').to_s
+    expect(s).must_equal 'hello'
+  end
+
+  it "serializes to an array starting with 0, length 6" do
+    a = text_note('hello').to_a
+    expect(a).must_be_kind_of Array
+    expect(a[0]).must_equal 0
+    expect(a.length).must_equal 6
+    expect(a[5]).must_equal 'hello'
+  end
+
+  it "has a pubkey in hex format" do
+    pubkey = Test::EVENT.pubkey
+    expect(pubkey).must_be_kind_of String
+    expect(pubkey.length).must_equal 64
+  end
+
+  it "requires a timestamp to create a SHA256 digest" do
+    e = Test::EVENT
+    d = e.digest(Time.now.to_i)
+    expect(d).must_be_kind_of String
+    expect(d.length).must_equal 32
+    expect(d.encoding).must_equal Encoding::BINARY
+  end
+
+  it "provides a SignedEvent when signed with a secret key" do
+    expect(Test::EVENT.sign(Test::SK)).must_be_kind_of SignedEvent
+  end
+
+  describe "event tags" do
+    it "supports tags in the form of Array[Array[String]]" do
+      e = text_note()
+      expect(e.tags).must_be_kind_of Array
+      expect(e.tags).must_be_empty
+
+      e.add_tag('tag', 'value')
+      expect(e.tags).wont_be_empty
+      expect(e.tags.length).must_equal 1
+
+      tags0 = e.tags[0]
+      expect(tags0.length).must_equal 2
+      expect(tags0[0]).must_equal 'tag'
+      expect(tags0[1]).must_equal 'value'
+
+      e.add_tag('foo', 'bar', 'baz')
+      expect(e.tags.length).must_equal 2
+
+      tags1 = e.tags[1]
+      expect(tags1.length).must_equal 3
+      expect(tags1[2]).must_equal 'baz'
+    end
+
+    it "references prior events" do
+      p = text_note()
+      s = p.sign(Test::SK)
+
+      e = text_note()
+      e.ref_event(s.id)
+      expect(e.tags).wont_be_empty
+      expect(e.tags.length).must_equal 1
+      expect(e.tags[0][0]).must_equal 'e'
+      expect(e.tags[0][1]).must_equal s.id
+    end
+
+    it "references known public keys" do
+      e = text_note()
+      pubkey = SchnorrSig.bin2hex Test::PK
+      e.ref_pubkey(pubkey)
+      expect(e.tags).wont_be_empty
+      expect(e.tags.length).must_equal 1
+      expect(e.tags[0][0]).must_equal 'p'
+      expect(e.tags[0][1]).must_equal pubkey
+    end
+  end
+end
+
+describe SignedEvent do
+  def signed_note(content = '')
+    Event.new(content, kind: 1, pk: Test::PK).sign(Test::SK)
+  end
+
+  describe "class functions" do
+    it "validates a JSON parsed hash" do
+      h = SignedEvent.validate!(Test::STATIC_HASH)
+      expect(h).must_be_kind_of Hash
+      %w[id pubkey kind content tags created_at sig].each { |k|
+        expect(h.key?(k)).must_equal true
+      }
+    end
+
+    it "verifies a JSON parsed hash" do
+      h = SignedEvent.verify(Test::STATIC_HASH)
+      expect(h).must_be_kind_of Hash
+    end
+
+    it "serializes a JSON parsed hash" do
+      a = SignedEvent.serialize(Test::STATIC_HASH)
+      expect(a).must_be_kind_of Array
+      expect(a.length).must_equal 6
+    end
+
+    it "digests a hash JSON parsed hash, which it will serialize" do
+      a = SignedEvent.serialize(Test::STATIC_HASH)
+      d = Event.digest(a)
+      d2 = SignedEvent.digest(Test::STATIC_HASH)
+      expect(d2).must_equal d
+    end
+  end
+
+  it "generates a timestamp at creation time" do
+    expect(signed_note().created_at).must_be_kind_of Integer
+  end
+
+  it "signs the event, given a private key in binary format" do
+    signed = signed_note()
+    expect(signed).must_be_kind_of SignedEvent
+    expect(signed.id).must_be_kind_of String
+    expect(signed.created_at).must_be_kind_of Integer
+
+    # check signature
+    signature = signed.signature
+    expect(signature).must_be_kind_of String
+    expect(signature.encoding).must_equal Encoding::BINARY
+    expect(signature.length).must_equal 64
+
+    # check sig hex
+    sig = signed.sig
+    expect(sig).must_be_kind_of String
+    expect(sig.encoding).wont_equal Encoding::BINARY
+    expect(sig.length).must_equal 128
+  end
+
+  it "has a formalized Key-Value format" do
+    h = signed_note().to_h
+    expect(h).must_be_kind_of Hash
+    expect(h.fetch "content").must_be_kind_of String
+    expect(h.fetch "pubkey").must_be_kind_of String
+    expect(h["pubkey"]).wont_be_empty
+    expect(h.fetch "kind").must_be_kind_of Integer
+    expect(h.fetch "tags").must_be_kind_of Array
+    expect(h.fetch "created_at").must_be_kind_of Integer
+    expect(h.fetch "id").must_be_kind_of String
+    expect(h["id"]).wont_be_empty
+    expect(h.fetch "sig").must_be_kind_of String
+    expect(h["sig"]).wont_be_empty
+  end
+end

data/test/nostrb.rb

@@ -0,0 +1,87 @@
+require 'nostrb'
+require 'minitest/autorun'
+
+describe Nostrb do
+  describe "module functions" do
+    describe "type enforcement" do
+      it "can check any class" do
+        str = 'asdf'
+        expect(Nostrb.check!(str, String)).must_equal str
+        expect { Nostrb.check!(str, Range) }.must_raise TypeError
+
+        range = (0..10)
+        expect(Nostrb.check!(range, Range)).must_equal range
+        expect { Nostrb.check!(range, Symbol) }.must_raise TypeError
+
+        sym = :symbol
+        expect(Nostrb.check!(sym, Symbol)).must_equal sym
+        expect { Nostrb.check!(sym, String) }.must_raise TypeError
+      end
+
+      it "validates a text (possibly hex) string" do
+        hex = "0123456789abcdef"
+
+        expect(Nostrb.txt!(hex)).must_equal hex
+        expect(Nostrb.txt!(hex, length: 16)).must_equal hex
+        expect { Nostrb.txt!(hex, length: 8) }.must_raise Nostrb::SizeError
+        expect { Nostrb.txt!("0123".b) }.must_raise EncodingError
+      end
+
+      it "enforces Integer class where expected" do
+        int = 1234
+        expect(Nostrb.int!(int)).must_equal int
+        expect { Nostrb.int!('1234') }.must_raise TypeError
+      end
+
+      it "enforces a particular tag structure where expected" do
+        # Array[Array[String]]
+        tags = [['a', 'b', 'c'], ['1', '2', '3', '4']]
+        expect(Nostrb.tags!(tags)).must_equal tags
+
+        [
+          ['a', 'b', 'c', '1' , '2', '3', '4'],  # Array[String]
+          [['a', 'b', 'c'], [1, 2, 3, 4]],       # Array[Array[String|Integer]]
+          ['a', 'b', 'c', ['1' , '2', '3', '4']],# Array[Array | String]
+          'a',                                   # String
+          [[:a, :b, :c], [1, 2, 3, 4]],          # Array[Array[Symbol|String]]
+        ].each { |bad|
+          expect { Nostrb.tags!(bad) }.must_raise TypeError
+        }
+      end
+    end
+
+    describe "JSON I/O" do
+      it "parses a JSON string to a Ruby object" do
+        expect(Nostrb.parse('{}')).must_equal Hash.new
+        expect(Nostrb.parse('[]')).must_equal Array.new
+      end
+
+      it "generates JSON from a Ruby hash or array" do
+        expect(Nostrb.json({})).must_equal '{}'
+        expect(Nostrb.json([])).must_equal '[]'
+      end
+    end
+
+    describe "SHA256 digest" do
+      it "generates 32 bytes binary, given any string" do
+        strings = ["\x01\x02".b, '1234', 'asdf', '']
+        digests = strings.map { |s| Nostrb.digest(s) }
+
+        digests.each { |d|
+          expect(d).must_be_kind_of String
+          expect(d.encoding).must_equal Encoding::BINARY
+          expect(d.length).must_equal 32
+        }
+      end
+
+      it "generates the same output for the same input" do
+        strings = ["\x01\x02".b, '1234', 'asdf', '']
+        digests = strings.map { |s| Nostrb.digest(s) }
+
+        strings.each.with_index { |s, i|
+          expect(Nostrb.digest(s)).must_equal digests[i]
+        }
+      end
+    end
+  end
+end

data/test/relay.rb

@@ -0,0 +1,360 @@
+require 'nostrb/relay'
+require 'nostrb/source'
+require_relative 'common'
+require 'minitest/autorun'
+
+include Nostrb
+
+
+# this can be set by GitHubActions
+DB_FILE = ENV['INPUT_DB_FILE'] || 'testing.db'
+
+# use SQLite backing
+SQLite::Setup.new(DB_FILE).setup
+
+describe Server do
+  def valid_response!(resp)
+    types = ["EVENT", "OK", "EOSE", "CLOSED", "NOTICE"]
+    expect(resp).must_be_kind_of Array
+    expect(resp.length).must_be :>=, 2
+    expect(resp.length).must_be :<=, 4
+    resp[0..1].each { |s| expect(s).must_be_kind_of String }
+    expect(resp[0].upcase).must_equal resp[0]
+    expect(types.include?(resp[0])).must_equal true
+  end
+
+  describe "class functions" do
+    it "has an EVENT response, given subscriber_id and requested event" do
+      sid = '1234'
+      resp = Server.event(sid, Test::SIGNED)
+      valid_response!(resp)
+      expect(resp[0]).must_equal "EVENT"
+      expect(resp[1]).must_equal sid
+      expect(resp[2]).must_be_kind_of Hash
+      expect(resp[2]).wont_be_empty
+    end
+
+    it "has an OK response, given an event_id" do
+      # positive ok
+      resp = Server.ok(Test::SIGNED.id)
+      valid_response!(resp)
+      expect(resp[0]).must_equal "OK"
+      expect(resp[1]).must_equal Test::SIGNED.id
+      expect(resp[2]).must_equal true
+      expect(resp[3]).must_be_kind_of String # empty by default
+
+      # negative ok
+      resp = Server.ok(Test::SIGNED.id, "error: testing", ok: false)
+      valid_response!(resp)
+      expect(resp[0]).must_equal "OK"
+      expect(resp[1]).must_equal Test::SIGNED.id
+      expect(resp[2]).must_equal false
+      expect(resp[3]).must_be_kind_of String
+      expect(resp[3]).wont_be_empty
+
+      # ok:false requires nonempty message
+      expect {
+        Server.ok(Test::SIGNED.id, "", ok: false)
+      }.must_raise FormatError
+      expect { Server.ok(Test::SIGNED.id, ok: false) }.must_raise FormatError
+    end
+
+    it "has an EOSE response to conclude a series of EVENT responses" do
+      sid = '1234'
+      resp = Server.eose(sid)
+      valid_response!(resp)
+      expect(resp[0]).must_equal "EOSE"
+      expect(resp[1]).must_equal sid
+    end
+
+    it "has a CLOSED response to shut down a subscriber" do
+      sid = '1234'
+      msg = "closed: bye"
+      resp = Server.closed(sid, msg)
+      valid_response!(resp)
+      expect(resp[0]).must_equal "CLOSED"
+      expect(resp[1]).must_equal sid
+      expect(resp[2]).must_equal msg
+    end
+
+    it "has a NOTICE response to provide any message to the user" do
+      msg = "all i ever really wanna do is get nice, " +
+            "get loose and goof this little slice of life"
+      resp = Server.notice(msg)
+      valid_response!(resp)
+      expect(resp[0]).must_equal "NOTICE"
+      expect(resp[1]).must_equal msg
+    end
+
+    it "formats Exceptions to a common string representation" do
+      r = RuntimeError.new("stuff")
+      expect(r).must_be_kind_of Exception
+      expect(Server.message(r)).must_equal "RuntimeError: stuff"
+
+      e = Nostrb::Error.new("things")
+      expect(e).must_be_kind_of Exception
+      expect(Server.message(e)).must_equal "Error: things"
+    end
+
+    it "uses NOTICE to return errors" do
+      e = RuntimeError.new "stuff"
+      resp = Server.error(e)
+      valid_response!(resp)
+      expect(resp[0]).must_equal "NOTICE"
+      expect(resp[1]).must_equal "RuntimeError: stuff"
+    end
+  end
+
+  it "has no initialization parameters" do
+    s = Server.new(DB_FILE)
+    expect(s).must_be_kind_of Server
+  end
+
+  # respond OK: true
+  it "has a single response to EVENT requests" do
+    json = Nostrb.json(Source.publish(Test::SIGNED))
+    responses = Server.new(DB_FILE).ingest(json)
+    expect(responses).must_be_kind_of Array
+    expect(responses.length).must_equal 1
+
+    resp = responses[0]
+    expect(resp).must_be_kind_of Array
+    expect(resp[0]).must_equal "OK"
+    expect(resp[1]).must_equal Test::SIGNED.id
+    expect(resp[2]).must_equal true
+  end
+
+  # store and retrieve with a subscription filter
+  it "stores inbound events" do
+    s = Server.new(DB_FILE)
+    sk, pk = SchnorrSig.keypair
+    e = Event.new('sqlite', pk: pk).sign(sk)
+    resp = s.ingest Nostrb.json(Source.publish(e))
+    expect(resp).must_be_kind_of Array
+    expect(resp[0]).must_be_kind_of Array
+    expect(resp[0][0]).must_equal "OK"
+
+    pubkey = SchnorrSig.bin2hex(pk)
+
+    f = Filter.new
+    f.add_authors pubkey
+    f.add_ids e.id
+
+    resp = s.ingest Nostrb.json(Source.subscribe(pubkey, f))
+    expect(resp).must_be_kind_of Array
+    expect(resp.length).must_equal 2
+    event, eose = *resp
+    expect(event[0]).must_equal 'EVENT'
+    expect(event[1]).must_equal pubkey
+    expect(event[2]).must_be_kind_of Hash
+    expect(event[2]['id']).must_equal e.id
+    expect(eose[0]).must_equal 'EOSE'
+  end
+
+  it "has multiple responses to REQ requets" do
+    s = Server.new(DB_FILE)
+    sk, pk = SchnorrSig.keypair
+    e = Event.new('first', pk: pk).sign(sk)
+    resp = s.ingest Nostrb.json(Source.publish(e))
+    expect(resp).must_be_kind_of Array
+    expect(resp[0]).must_be_kind_of Array
+    expect(resp[0][0]).must_equal "OK"
+
+    e2 = Event.new('second', pk: pk).sign(sk)
+    resp = s.ingest Nostrb.json(Source.publish(e2))
+    expect(resp).must_be_kind_of Array
+    expect(resp[0]).must_be_kind_of Array
+    expect(resp[0][0]).must_equal "OK"
+
+    # with no filters, nothing will match
+    sid = e.pubkey
+    responses = s.ingest(Nostrb.json(Source.subscribe(sid)))
+    expect(responses).must_be_kind_of Array
+    expect(responses.length).must_equal 1
+    resp = responses[0]
+    expect(resp).must_be_kind_of Array
+    expect(resp[0]).must_equal "EOSE"
+    expect(resp[1]).must_equal sid
+
+    # now add a filter based on pubkey
+    f = Filter.new
+    f.add_authors e.pubkey
+    f.add_ids e.id, e2.id
+
+    resp = s.ingest Nostrb.json(Source.subscribe(sid, f))
+    expect(resp).must_be_kind_of Array
+    expect(resp.length).must_equal 3
+
+    # remove EOSE and validate
+    eose = resp.pop
+    expect(eose).must_be_kind_of Array
+    expect(eose[0]).must_equal "EOSE"
+    expect(eose[1]).must_equal sid
+
+    # verify the response event ids
+    resp.each { |event|
+      expect(event).must_be_kind_of Array
+      expect(event[0]).must_equal "EVENT"
+      expect(event[1]).must_equal sid
+      hsh = event[2]
+      expect(hsh).must_be_kind_of Hash
+      expect(SignedEvent.validate!(hsh)).must_equal hsh
+      expect([e.id, e2.id]).must_include hsh["id"]
+    }
+  end
+
+  it "has a single response to CLOSE requests" do
+    s = Server.new(DB_FILE)
+    sid = Test::EVENT.pubkey
+    responses = s.ingest(Nostrb.json(Source.close(sid)))
+
+    # respond CLOSED
+    expect(responses).must_be_kind_of Array
+    expect(responses.length).must_equal 1
+
+    resp = responses[0]
+    expect(resp).must_be_kind_of Array
+    expect(resp[0]).must_equal "CLOSED"
+    expect(resp[1]).must_equal sid
+  end
+
+  describe "error handling" do
+    # invalid request type
+    it "handles unknown unknown request types with an error notice" do
+      a = Source.publish Test::SIGNED
+      a[0] = 'NONSENSE'
+      responses = Server.new(DB_FILE).ingest(Nostrb.json(a))
+      expect(responses).must_be_kind_of Array
+      expect(responses.length).must_equal 1
+
+      resp = responses[0]
+      expect(resp).must_be_kind_of Array
+      expect(resp[0]).must_equal "NOTICE"
+      expect(resp[1]).must_be_kind_of String
+      expect(resp[1]).wont_be_empty
+    end
+
+    # replace leading open brace with space
+    it "handles JSON parse errors with an error notice" do
+      j = Nostrb.json(Nostrb::Source.publish(Test::SIGNED))
+      expect(j[9]).must_equal '{'
+      j[9] = ' '
+      resp = Server.new(DB_FILE).ingest(j)
+      expect(resp).must_be_kind_of Array
+      expect(resp.length).must_equal 1
+
+      type, msg = *resp.first
+      expect(type).must_equal "NOTICE"
+      expect(msg).must_be_kind_of String
+      expect(msg).wont_be_empty
+    end
+
+    # add "stuff":"things"
+    it "handles unexpected fields with an error notice" do
+      a = Nostrb::Source.publish(Test::SIGNED)
+      expect(a[1]).must_be_kind_of Hash
+      a[1]["stuff"] = "things"
+
+      resp = Server.new(DB_FILE).ingest(Nostrb.json(a))
+      expect(resp).must_be_kind_of Array
+      expect(resp.length).must_equal 1
+
+      type, msg = *resp.first
+      expect(type).must_equal "NOTICE"
+      expect(msg).must_be_kind_of String
+      expect(msg).wont_be_empty
+    end
+
+    # remove "tags"
+    it "handles missing fields with an error notice" do
+      a = Nostrb::Source.publish(Test::SIGNED)
+      expect(a[1]).must_be_kind_of Hash
+      a[1].delete("tags")
+
+      resp = Server.new(DB_FILE).ingest(Nostrb.json(a))
+      expect(resp).must_be_kind_of Array
+      expect(resp.length).must_equal 1
+
+      type, msg = *resp.first
+      expect(type).must_equal "NOTICE"
+      expect(msg).must_be_kind_of String
+      expect(msg).wont_be_empty
+    end
+
+    # cut "id" in half
+    it "handles field format errors with an error notice" do
+      a = Nostrb::Source.publish(Test::SIGNED)
+      expect(a[1]).must_be_kind_of Hash
+      a[1]["id"] = a[1]["id"].slice(0, 32)
+
+      resp = Server.new(DB_FILE).ingest(Nostrb.json(a))
+      expect(resp).must_be_kind_of Array
+      expect(resp.length).must_equal 1
+
+      type, msg = *resp.first
+      expect(type).must_equal "NOTICE"
+      expect(msg).must_be_kind_of String
+      expect(msg).wont_be_empty
+    end
+
+    # random "sig"
+    it "handles invalid signature with OK:false" do
+      a = Nostrb::Source.publish(Test::SIGNED)
+      expect(a[1]).must_be_kind_of Hash
+      a[1]["sig"] = SchnorrSig.bin2hex(Random.bytes(64))
+
+      resp = Server.new(DB_FILE).ingest(Nostrb.json(a))
+      expect(resp).must_be_kind_of Array
+      expect(resp.length).must_equal 1
+
+      type, id, value, msg = *resp.first
+      expect(type).must_equal "OK"
+      expect(id).must_equal a[1]["id"]
+      expect(value).must_equal false
+      expect(msg).must_be_kind_of String
+      expect(msg).wont_be_empty
+      expect(msg).must_match(/SignatureCheck/)
+    end
+
+    # "id" and "sig" spoofed from another event
+    it "handles spoofed id with OK:false" do
+      orig = Source.publish(Test.new_event('orig'))
+      spoof = Source.publish(Test::SIGNED)
+
+      orig[1]["id"] = spoof[1]["id"]
+      orig[1]["sig"] = spoof[1]["sig"]
+
+      # now sig and id agree with each other, but not orig's content/metadata
+      # the signature should verify, but the id should not
+
+      resp = Server.new(DB_FILE).ingest(Nostrb.json(orig))
+      expect(resp).must_be_kind_of Array
+      expect(resp.length).must_equal 1
+
+      type, id, value, msg = *resp.first
+      expect(type).must_equal "OK"
+      expect(id).must_equal orig[1]["id"]
+      expect(value).must_equal false
+      expect(msg).must_be_kind_of String
+      expect(msg).wont_be_empty
+      expect(msg).must_match(/IdCheck/)
+    end
+
+    # random "id"
+    it "handles invalid id with OK:false" do
+      a = Source.publish(Test::SIGNED)
+      a[1]["id"] = SchnorrSig.bin2hex(Random.bytes(32))
+
+      resp = Server.new(DB_FILE).ingest(Nostrb.json(a))
+      expect(resp).must_be_kind_of Array
+      expect(resp.length).must_equal 1
+
+      type, id, value, msg = *resp.first
+      expect(type).must_equal "OK"
+      expect(id).must_equal a[1]["id"]
+      expect(value).must_equal false
+      expect(msg).must_be_kind_of String
+      expect(msg).wont_be_empty
+    end
+  end
+end