xrbp 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80c7817a86dc903b6eb5725bb37ecd562fe6a73b1aef5ee81e2b27ff1aeb50a6
-  data.tar.gz: 7003cb99a4488aea91f41d4b8c6bf2fc3bdc577b980d251c858639508f6ae1f1
+  metadata.gz: e441fc01ed75b0df28778339ba809a235438773082f62f25e1dcac9fb04c3308
+  data.tar.gz: e303c49a8ae8f71d19f532b24f0120f1dd1201747e4d0d274655c44cd5634ba4
 SHA512:
-  metadata.gz: 9792f31b6e62658be6b94f32b3dae6a8fd99a395b5b513d7d6f1cf1e766a121bc074a043b8a1f884c516bda807e06243806f83f7ad2e397655d7ab69b09a5e51
-  data.tar.gz: 4e360f3e4464758f0b49158239d898b8b901d094ea5be52faadfaa29dccb4f12120c392bcce1d2c0a03a1058b8345bcce6016abce59ec9dd3524bb75142ec3a6
+  metadata.gz: 8dd5c9a48b69f732ebb11c72dba6b5345cedb6e89f52b0ca06f189bfd6592993425b4f2b2dfcd04b152a48c384b4e0b86248c30059adf7e5ae02018aaa9dc981
+  data.tar.gz: 261057099aeab635832d49bac987ad006fdb928a2b2507a8ec974cce1b4e2e59d9199aecc0f77412555b9fb5d33c4c77b47f6ff6ad489e40155ecc461f06f43d

data/lib/xrbp/crypto/account.rb

@@ -38,7 +38,12 @@ module XRBP
     # @return [String, nil] unique account id or nil if input
     #   if not an account
     def self.parse_account(account)
-      bin = Base58.base58_to_binary(account, :ripple)
+      begin
+        bin = Base58.base58_to_binary(account, :ripple)
+      rescue ArgumentError
+        return nil
+      end
+
       typ = bin[0]
       chk = bin[-4..-1]
       bin = bin[1...-4]

data/lib/xrbp/crypto/key.rb

@@ -60,14 +60,20 @@ module XRBP
       end
 
       # @return [Hash] new ed25519 key pair (both public and private components)
-      def self.ed25519
+      def self.ed25519(seed=nil)
         # XXX openssl 1.1.1 needed for EdDSA support:
         #     https://www.openssl.org/blog/blog/2018/09/11/release111/
         #     Until then use this:
         require "ed25519"
 
-        sd = Crypto.seed[:seed]
-        pk = Crypto.parse_seed(sd)
+        sd, pk = nil
+        if seed
+          sd,pk = seed,seed
+
+        else
+          sd = Crypto.seed[:seed]
+          pk = Crypto.parse_seed(sd)
+        end
 
         sha512 = OpenSSL::Digest::SHA512.new
         pk = sha512.digest(pk)[0..31]
@@ -90,19 +96,15 @@ module XRBP
         raise "unknown key" unless key.is_a?(Hash) && key[:type] && key[:private]
         raise "invalid data" unless data.length == 32
 
-
         if key[:type] == :secp256k1
-          # XXX: see note about this library above
           require 'secp256k1'
 
           pk = Secp256k1::PrivateKey.new
           pk.set_raw_privkey [key[:private]].pack("H*")
-          #pk.pubkey.deserialize [key[:public]].pack("H*")
           sig_raw = pk.ecdsa_sign data, raw: true
           return pk.ecdsa_serialize sig_raw
 
         elsif key[:type] == :ed25519
-          # XXX: see note about this library above
           require "ed25519"
 
           sd = key[:seed]
@@ -128,7 +130,6 @@ module XRBP
       #   original data
       def self.verify(key, data, expected)
         if key[:type] == :secp256k1
-          # XXX: see note about this library above
           require 'secp256k1'
 
           pb = Secp256k1::PublicKey.new :pubkey => [key[:public]].pack("H*"),
@@ -139,7 +140,6 @@ module XRBP
                  pv.ecdsa_deserialize(data), raw: true
 
         elsif key[:type] == :ed25519
-          # XXX: see note about this library above
           require "ed25519"
 
           pk = Ed25519::VerifyKey.new([key[:public]].pack("H*"))

data/lib/xrbp/crypto/node.rb

@@ -34,7 +34,12 @@ module XRBP
     # @return [String, nil] unique node id or nil if input
     #   if not an node
     def self.parse_node(node)
-      bin = Base58.base58_to_binary(node, :ripple)
+      begin
+        bin = Base58.base58_to_binary(node, :ripple)
+      rescue ArgumentError
+        return nil
+      end
+
       typ = bin[0]
       chk = bin[-4..-1]
       bin = bin[1...-4]

data/lib/xrbp/nodestore/backends/decompressor.rb

@@ -101,13 +101,13 @@ module XRBP
 
             out = [0, 0, 0, 0,
                    0, 0, 0, 0,
-                   Format::NODE_OBJ_TYPES[:unknown]] +
+                   Format::NODE_TYPES[:unknown]] +
                   [Format::HASH_PREFIXES.invert[:inner_node]].pack("H*")
                                                              .unpack("C*")
 
             # extract mask indicating which hashes are set
             bytes = data.bytes
-             mask = bytes[0..1].pack("C*").unpack("S").first
+             mask = bytes[0..1].pack("C*").unpack("S>").first
             bytes = bytes[2..-1]
 
             raise "nodeobject codec v1: empty inner node" if mask == 0
@@ -146,14 +146,14 @@ module XRBP
 
             out = [0, 0, 0, 0,
                    0, 0, 0, 0,
-                   Format::NODE_OBJ_TYPES[:unknown]] +
+                   Format::NODE_TYPES[:unknown]] +
                   [Format::HASH_PREFIXES.invert[:inner_node_v2]].pack("H*")
                                                                 .unpack("C*")
 
             # Same mask / hash extraction as V1
 
             bytes = data.bytes
-             mask = bytes[0..1].pack("C*").unpack("S").first
+             mask = bytes[0..1].pack("C*").unpack("S>").first
             bytes = bytes[2..-1]
 
             raise "nodeobject codec v2: empty inner node" if mask == 0
@@ -204,7 +204,7 @@ module XRBP
 
             out = [0, 0, 0, 0,
                    0, 0, 0, 0,
-                   Format::NODE_OBJ_TYPES[:unknown]] +
+                   Format::NODE_TYPES[:unknown]] +
                   [Format::HASH_PREFIXES.invert[:inner_node]].pack("H*").unpack("C*")
             (out + data[0...512].bytes).pack("C*")
           end
@@ -222,7 +222,7 @@ module XRBP
 
             out = [0, 0, 0, 0,
                    0, 0, 0, 0,
-                   Format::NODE_OBJ_TYPES[:unknown]] +
+                   Format::NODE_TYPES[:unknown]] +
                   [Format::HASH_PREFIXES.invert[:inner_node_v2]].pack("H*").unpack("C*")
 
              out += bytes[0..511]

data/lib/xrbp/nodestore/backends/nudb.rb

@@ -34,7 +34,9 @@ module XRBP
         # @param key [String] binary key to lookup
         # @return [String] binary value
         def [](key)
-          decompress(@store.fetch(key)[0])
+          fetched = @store.fetch(key)[0]
+          return nil if fetched.empty?
+          decompress(fetched)
         end
 
         # Iterate over each database key/value pair,

data/lib/xrbp/nodestore/backends/rocksdb.rb

@@ -13,7 +13,7 @@ module XRBP
       #   puts rocksdb.ledger('B506ADD630CB707044B4BFFCD943C1395966692A13DD618E5BD0978A006B43BD')
       class RocksDB < DB
         # cap max open files for performance
-        MAX_OPEN_FILES = 200
+        MAX_OPEN_FILES = 2000
 
         def initialize(path)
           @db = ::RocksDB::DB.new path,

data/lib/xrbp/nodestore/db.rb

@@ -24,26 +24,37 @@ module XRBP
       include Enumerable
       include EventEmitter
 
-      # TODO return nil if db lookup not found
-
       # Return the NodeStore Ledger for the given lookup hash
       def ledger(hash)
-        parse_ledger(self[hash])
+        val = self[hash]
+        return nil if val.nil?
+        parse_ledger(val)
       end
 
       # Return the NodeStore Account for the given lookup hash
       def account(hash)
-        parse_ledger_entry(self[hash])
+        ledger_entry(hash)
+      end
+
+      # Return the NodeStore Ledger Entry for the given lookup hash
+      def ledger_entry(hash)
+        val = self[hash]
+        return nil if val.nil?
+        parse_ledger_entry(val)
       end
 
       # Return the NodeStore Transaction for the given lookup hash
       def tx(hash)
-        parse_tx(self[hash])
+        val = self[hash]
+        return nil if val.nil?
+        parse_tx(val)
       end
 
       # Return the NodeStore InnerNode for the given lookup hash
       def inner_node(hash)
-        parse_inner_node(self[hash])
+        val = self[hash]
+        return nil if val.nil?
+        parse_inner_node(val)
       end
 
       ###
@@ -96,7 +107,7 @@ module XRBP
       def parse_ledger_entry(ledger_entry)
         # validate parsability
                 obj = Format::TYPE_INFER.decode(ledger_entry)
-          node_type = Format::NODE_TYPES[obj["node_type"]]
+          node_type = Format::NODE_TYPE_CODES[obj["node_type"]]
         hash_prefix = Format::HASH_PREFIXES[obj["hash_prefix"].upcase]
         raise unless   node_type == :account_node &&
                      hash_prefix == :leaf_node
@@ -119,12 +130,13 @@ module XRBP
                                       .upcase
 
         # remaining bytes are serialized object
-        fields = parse_fields(ledger_entry[2...-32].pack("C*"))
+        fields, remaining = parse_fields(ledger_entry[2...-32].pack("C*"))
+        raise unless remaining.empty?
 
-        # TODO instantiate class corresponding to prefix &
-        #      populate attributes w/ fields
+        # TODO instantiate class corresponding to type &
+        #      populate attributes w/ fields (?)
 
-        { :prefix => prefix,
+        { :type   => Format::LEDGER_ENTRY_TYPE_CODES[prefix[1]],
           :index  => index,
           :fields => fields }
       end
@@ -143,10 +155,10 @@ module XRBP
           e = Format::ENCODINGS[encoding]
           value, fields = parse_field(fields, encoding)
           break unless value
-          parsed[e] = value
+          parsed[e] = convert_field(encoding, value)
         end
 
-        return parsed
+        return parsed, fields
       end
 
       # Parse single field of specified encoding from data.
@@ -160,11 +172,11 @@ module XRBP
         when :uint8
           return data.unpack("C").first, data[1..-1]
         when :uint16
-          return data.unpack("S").first, data[2..-1]
+          return data.unpack("S>").first, data[2..-1]
         when :uint32
-          return data.unpack("L").first, data[4..-1]
+          return data.unpack("L>").first, data[4..-1]
         when :uint64
-          return data.unpack("Q").first, data[8..-1]
+          return data.unpack("Q>").first, data[8..-1]
         when :hash128
           return data.unpack("H32").first, data[16..-1]
         when :hash160
@@ -192,6 +204,22 @@ module XRBP
         raise
       end
 
+      def convert_field(encoding, value)
+        e = Format::ENCODINGS[encoding]
+
+        if encoding.first == :vl
+          return value.unpack("H*").first
+
+        elsif e == :transaction_type
+          return Format::TX_TYPES[value]
+
+        elsif e == :ledger_entry_type
+          return Format::LEDGER_ENTRY_TYPE_CODES[value.chr]
+        end
+
+        value
+      end
+
       # Parse variable length header from data buffer. Returns length
       # extracted from header and the number of bytes in header.
       #
@@ -217,6 +245,8 @@ module XRBP
 
       # Parse 'Amount' data type from binary data.
       #
+      # @see https://developers.ripple.com/currency-formats.html
+      #
       # @private
       def parse_amount(data)
         amount = data[0..7].unpack("Q>").first
@@ -229,16 +259,16 @@ module XRBP
 
         data = data[8..-1]
         currency = Format::CURRENCY_CODE.decode(data)
+        currency = currency["iso_code"].pack("C*")
 
         data = data[Format::CURRENCY_CODE.size..-1]
         issuer, data = parse_account(data, 20)
 
-        # TODO calculate value
-        return { :sign => sign,
-                  :exp => exp,
-             :mantissa => mant,
-             :currency => currency,
-               :issuer => issuer }, data
+        amount = (sign == 0 ? -1 : 1) * mant * 10 ** (exp-97)
+
+        return { :amount => amount,
+               :currency => currency,
+                 :issuer => issuer }, data
       end
 
       # Parse 'Account' data type from binary data.
@@ -294,13 +324,13 @@ module XRBP
              :majority, :memo,
              :modified_node, :created_node, :deleted_node,
              :previous_fields, :final_fields, :new_fields
-          # TODO instantiate corresponding classes
+          # TODO instantiate corresponding classes (?)
           return parse_fields(data)
 
         #else:
         end
 
-        raise "unknown object type"
+        raise "unknown object type: #{e}"
       end
 
       # Parse PathSet from binary data.
@@ -327,6 +357,7 @@ module XRBP
 
             if (segment & 0x10) != 0 # path currency
               currency = Format::CURRENCY_CODE.decode(data)
+              currency = currency["iso_code"].pack("C*")
               data = data[Format::CURRENCY_CODE.size..-1]
               path[:currency] = currency
             end
@@ -350,7 +381,7 @@ module XRBP
       # @private
       def parse_tx(tx)
                 obj = Format::TYPE_INFER.decode(tx)
-          node_type = Format::NODE_TYPES[obj["node_type"]]
+          node_type = Format::NODE_TYPE_CODES[obj["node_type"]]
         hash_prefix = Format::HASH_PREFIXES[obj["hash_prefix"].upcase]
         raise unless   node_type == :tx_node &&
                      hash_prefix == :tx_node
@@ -361,12 +392,12 @@ module XRBP
         # get node length
         vl, offset = parse_vl(tx)
         node, _tx = tx.bytes[offset..vl+offset-1], tx.bytes[vl+offset..-1]
-        node = parse_fields(node.pack("C*"))
+        node, _remaining = parse_fields(node.pack("C*"))
 
         # get meta length
         vl, offset = parse_vl(_tx.pack("C*"))
         meta, index = _tx[offset..vl+offset-1], _tx[vl+offset..-1]
-        meta = parse_fields(meta.pack("C*"))
+        meta, _remaining = parse_fields(meta.pack("C*"))
 
         {  :node =>  node,
            :meta =>  meta,
@@ -392,14 +423,14 @@ module XRBP
       # @private
       def infer_type(value)
                 obj = Format::TYPE_INFER.decode(value)
-          node_type = Format::NODE_TYPES[obj["node_type"]]
+          node_type = Format::NODE_TYPE_CODES[obj["node_type"]]
         hash_prefix = Format::HASH_PREFIXES[obj["hash_prefix"].upcase]
 
         if hash_prefix == :inner_node
           return :inner_node, parse_inner_node(value)
 
         elsif node_type == :account_node
-          return :account, parse_ledger_entry(value)
+          return :ledger_entry, parse_ledger_entry(value)
 
         elsif node_type == :tx_node
           return :tx, parse_tx(value)

data/lib/xrbp/nodestore/format.rb

@@ -3,20 +3,16 @@ require "bistro"
 module XRBP
   module NodeStore
     module Format
-      NODE_OBJ_TYPES = {
-        :unknown          => 0,
-        :ledger           => 1,
-        :account_node     => 2,
-        :transaction_node => 3
-      }
-
       NODE_TYPES = {
-        1 => :ledger,
-        2 => :tx,
-        3 => :account_node,
-        4 => :tx_node
+        :unknown       => 0,
+        :ledger        => 1,
+        #:tx           => 2, # unused
+        :account_node  => 3,
+        :tx_node       => 4
       }
 
+      NODE_TYPE_CODES = NODE_TYPES.invert
+
       HASH_PREFIXES = {               # ASCII value:
         "54584E00" => :tx_id,         # TXN
         "534E4400" => :tx_node,       # SND
@@ -298,6 +294,62 @@ module XRBP
            'C', 'close_flags',
       ])
 
+      ###
+
+      LEDGER_ENTRY_TYPES = {
+        :any             =>  -3,
+        :child           =>  -2,
+        :invalid         =>  -1,
+        :account_root    => 'a',
+        :dir_node        => 'd',
+        :ripple_state    => 'r',
+        :ticket          => 'T',
+        :signer_list     => 'S',
+        :offer           => 'o',
+        :ledger_hashes   => 'h',
+        :amendments      => 'f',
+        :fee_settings    => 's',
+        :escrow          => 'u',
+        :paychan         => 'x',
+        :check           => 'C',
+        :deposit_preauth => 'p'
+      }
+
+      LEDGER_ENTRY_TYPE_CODES = LEDGER_ENTRY_TYPES.invert
+
+      ###
+
+      TX_TYPES = {
+         -1 => :invalid,
+          0 => :payment,
+          1 => :escrow_create,
+          2 => :escrow_finish,
+          3 => :account_set,
+          4 => :escrow_cancel,
+          5 => :regular_key_set,
+          6 => :nickname_set,    #open
+          7 => :offer_create,
+          8 => :offer_cancel,
+
+          9 => :no_longer_used,
+
+         11 => :ticket_create,
+         12 => :ticket_cancel,
+         13 => :signer_list_set,
+         14 => :paychan_create,
+         15 => :paychan_fund,
+         16 => :paychan_claim,
+         17 => :check_create,
+         18 => :check_cash,
+         19 => :check_cancel,
+         20 => :deposit_preauth,
+
+        100 => :amendment,
+        101 => :fee
+      }
+
+      ###
+
       CURRENCY_CODE = Bistro.new([
         'C',   'type_code',
         'C11', 'reserved1',

data/lib/xrbp/overlay/connection.rb

@@ -77,6 +77,14 @@ module XRBP
         ssl_socket.puts(data)
       end
 
+      def write_frame(msg)
+        write(Frame.from_msg(msg))
+      end
+
+      def write_msg(data)
+        write_frame(Overlay.create_msg(data))
+      end
+
       # Read raw data from connection
       def read
         ssl_socket.gets

data/lib/xrbp/overlay/frame.rb

@@ -30,6 +30,10 @@ module XRBP
       attr_reader :type, :size
       attr_accessor :data
 
+      def self.from_msg(msg)
+        # ...
+      end
+
       def initialize(type, size)
         @type = type
         @size = size

data/lib/xrbp/overlay/messages.rb

@@ -23,5 +23,9 @@ module XRBP
       :MTVALIDATION           => Protocol::TMValidation,
       :MTGET_OBJECTS          => Protocol::TMGetObjectByHash
     }
+
+    def self.create_msg(hash)
+      # ...
+    end
   end # module Overlay
 end # module XRBP

data/lib/xrbp/version.rb

@@ -1,3 +1,3 @@
 module XRBP
-  VERSION = '0.1.9'
+  VERSION = '0.1.10'
 end # module XRBP

data/spec/spec_helper.rb

@@ -6,6 +6,8 @@ Camcorder.config.recordings_dir = 'spec/recordings'
 require 'xrbp'
 
 RSpec.configure do |config|
+  config.alias_it_should_behave_like_to :it_provides,  'provides:'
+
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end

data/spec/xrbp/crypto/account_spec.rb

@@ -1,6 +1,24 @@
 describe XRBP::Crypto do
+  let(:account) { "rDbWJ9C7uExThZYAwV8m6LsZ5YSX3sa6US" }
+  let(:expected) { [0x8a, 0x28, 0x1b, 0x5e, 0x46, 0xb0, 0x27, 0xc3, 0x70, 0x26, 0xe3, 0x8d, 0xbc, 0x5f, 0x9a, 0xa1, 0x4c, 0x37, 0x51, 0x45].pack("C*") }
+
   it "generates valid account" do
     acct = described_class.account
     expect(described_class.account?(acct[:account])).to be(true)
   end
+
+  it "parses account" do
+    a = described_class.parse_account(account)
+    expect(a).to_not be_nil
+    expect(a).to eq(expected)
+  end
+
+  it "does not parse invalid account" do
+    expect(described_class.parse_account("invalid")).to be_nil
+  end
+
+  it "verifies account" do
+    expect(described_class.account?(account)).to be(true)
+    expect(described_class.account?("invalid")).to be(false)
+  end
 end

data/spec/xrbp/crypto/key_spec.rb

@@ -2,10 +2,21 @@ describe XRBP::Crypto::Key do
   it "generates valid sec256k1 key"
   it "generates valid ed25519 key"
 
-  it "generates signs and verifies digest" do
-    key = described_class.secp256k1
-    dat = "ABCDEFGHIJLMNOPQRSTUVWYZ12345678"
-    signed = XRBP::Crypto::Key.sign_digest(key, dat)
-    expect(XRBP::Crypto::Key.verify(key, signed, dat))
-  end
+  [:secp256k1, :ed25519].each { |key_type|
+
+    let(:dat) { "ABCDEFGHIJLMNOPQRSTUVWYZ12345678" }
+
+    it "generates signs and verifies #{key_type} digest" do
+      key = described_class.send(key_type)
+      signed = XRBP::Crypto::Key.sign_digest(key, dat)
+      expect(XRBP::Crypto::Key.verify(key, signed, dat))
+    end
+
+    it "accepts #{key_type} seed" do
+      seed = XRBP::Crypto.seed[:seed]
+      key = described_class.send(key_type, seed)
+      signed = XRBP::Crypto::Key.sign_digest(key, dat)
+      expect(XRBP::Crypto::Key.verify(key, signed, dat))
+    end
+  }
 end

data/spec/xrbp/crypto/node_spec.rb

@@ -1,6 +1,24 @@
 describe XRBP::Crypto do
+  let(:node) { "n9Kgda1F7evck24hJUqFsn8m6pNERJd6UkjwLuNBSUJ6Ykm76NdJ" }
+  let(:expected) { [0x2, 0x96, 0x24, 0xe4, 0x37, 0x80, 0xeb, 0xcc, 0xf2, 0x77, 0x67, 0x48, 0x4d, 0x42, 0xc5, 0x54, 0xbe, 0x7b, 0xaa, 0x28, 0x78, 0x82, 0x7e, 0x91, 0x2f, 0x4e, 0x66, 0x94, 0xbf, 0x64, 0xa4, 0x55, 0x80].pack("C*") }
+
   it "generates valid node" do
     node = described_class.node
     expect(described_class.node?(node[:node])).to be(true)
   end
+
+  it "parses node" do
+    n = described_class.parse_node(node)
+    expect(n).to_not be_nil
+    expect(n).to eq(expected)
+  end
+
+  it "does not parse invalid node" do
+    expect(described_class.parse_node("invalid")).to be_nil
+  end
+
+  it "verifies node" do
+    expect(described_class.node?(node)).to be(true)
+    expect(described_class.node?("invalid")).to be(false)
+  end
 end

data/spec/xrbp/nodestore/backends/db_access.rb

@@ -0,0 +1,15 @@
+shared_examples "database access" do |opts={}|
+  let(:key) { ["516F940640172099A89F9733B8E69F2A56720E67C53EE7E0F3022BB6E55E6986"].pack("H*") }
+  let(:val) { "0000000000000000014c57520002d4ebd001633dd73a0b3efdc4fad6eb19f6a6089e7aebc73af596db471305bc0ebb99d9d1414bd4db8c9d43934a5e57c598f0505664f9349da87fd32afbe1c315a2cb6cfb5b690aecc6b1a3fea269daaa66c820978ac95f0399ecaca7a3abac91402c9fc7961a53d053332f247c5e24247c5e250a00" }
+
+  it "returns values for key" do
+    actual = db[key].unpack("H*").first
+    expect(actual).to eq(val)
+  end
+
+  context "key not found" do
+    it "returns nil" do
+      expect(db["key"]).to be_nil
+    end
+  end
+end

data/spec/xrbp/nodestore/backends/db_parser.rb

@@ -0,0 +1,39 @@
+shared_examples "a database parser" do |opts={}|
+  let(:ledger_key) { ["516F940640172099A89F9733B8E69F2A56720E67C53EE7E0F3022BB6E55E6986"].pack("H*") }
+  let(:ledger) { {"nt_ledger"=>1, "hp_ledger_master"=>"4c575200", "index"=>47508432, "total_coins"=>18248035087498961665, "parent_hash"=>"C4FAD6EB19F6A6089E7AEBC73AF596DB471305BC0EBB99D9D1414BD4DB8C9D43", "tx_hash"=>"934A5E57C598F0505664F9349DA87FD32AFBE1C315A2CB6CFB5B690AECC6B1A3", "account_hash"=>"FEA269DAAA66C820978AC95F0399ECACA7A3ABAC91402C9FC7961A53D053332F", "parent_close_time"=>Time.parse("2019-05-25T20:12:20Z").utc, "close_time"=>Time.parse("2019-05-25T20:12:21Z").utc, "close_time_resolution"=>10, "close_flags"=>0} }
+
+  let(:tx_key) { ["003b960d5e30ff91a91f7c900509a99a8a6b89441b76158e5ed295ad1d27b0e7"].pack("H*") }
+  let(:tx) { {:node=>{:transaction_type=>:payment, :flags=>2147942400, :sequence=>3366484, :last_ledger_sequence=>47713577, :amount=>{:amount=>(10000/1), :currency=>"XCN", :issuer=>"rPFLkxQk6xUGdGYEykqe7PR25Gr7mLHDc8"}, :fee=>11, :send_max=>10000000000, :signing_pub_key=>"030ac4f2ba6e1ff86beb234b639918dafdf0675032ae264d2b39641503822373fe", :txn_signature=>"304402207ac9c62a6e8a876e67945edebcd3f6c71c36c95fbbb0ce05a85871d0794b1b8c0220297fe7195beb083a78ff9de4d822b5e4cb42be7e5a8662bcbc2f42c737e264bf", :account=>"rKLpjpCoXgLQQYQyj13zgay73rsgmzNH13", :destination=>"rKLpjpCoXgLQQYQyj13zgay73rsgmzNH13", :paths=>[[{:currency=>"CNY", :issuer=>"rKiCet8SdvWxPXnAgYarFUXMh1zCPz432Y"}, {:currency=>"USD", :issuer=>"rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq"}, {:currency=>"\x00\x00\x00"}, {:currency=>"XCN", :issuer=>"rPFLkxQk6xUGdGYEykqe7PR25Gr7mLHDc8"}], [{:currency=>"USD", :issuer=>"rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq"}, {:currency=>"CNY", :issuer=>"rKiCet8SdvWxPXnAgYarFUXMh1zCPz432Y"}, {:currency=>"\x00\x00\x00"}, {:currency=>"XCN", :issuer=>"rPFLkxQk6xUGdGYEykqe7PR25Gr7mLHDc8"}], [{:currency=>"CNY", :issuer=>"rKiCet8SdvWxPXnAgYarFUXMh1zCPz432Y"}, {:currency=>"CNY", :issuer=>"razqQKzJRdB4UxFPWf5NEpEG3WMkmwgcXA"}, {:currency=>"\x00\x00\x00"}, {:currency=>"XCN", :issuer=>"rPFLkxQk6xUGdGYEykqe7PR25Gr7mLHDc8"}], [{:currency=>"CNY", :issuer=>"razqQKzJRdB4UxFPWf5NEpEG3WMkmwgcXA"}, {:currency=>"CNY", :issuer=>"rKiCet8SdvWxPXnAgYarFUXMh1zCPz432Y"}, {:currency=>"\x00\x00\x00"}, {:currency=>"XCN", :issuer=>"rPFLkxQk6xUGdGYEykqe7PR25Gr7mLHDc8"}], [{:currency=>"CNY", :issuer=>"rKiCet8SdvWxPXnAgYarFUXMh1zCPz432Y"}, {:currency=>"EUR", :issuer=>"rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq"}, {:currency=>"\x00\x00\x00"}, {:currency=>"XCN", :issuer=>"rPFLkxQk6xUGdGYEykqe7PR25Gr7mLHDc8"}], [{:currency=>"EUR", :issuer=>"rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq"}, {:currency=>"CNY", :issuer=>"rKiCet8SdvWxPXnAgYarFUXMh1zCPz432Y"}, {:currency=>"\x00\x00\x00"}, {:currency=>"XCN", :issuer=>"rPFLkxQk6xUGdGYEykqe7PR25Gr7mLHDc8"}]]}, :meta=>{:transaction_index=>30, :affected_nodes=>[{:ledger_entry_type=>:account_root, :previous_txn_lgr_seq=>47713575, :previous_txn_id=>"2e397e516ccde852e829d36eb7d0d195dd9a974a188e213ad256c3ae3c131e58", :ledger_index=>"792ba4e4659c27cf3b63f96b34f158748b081cf532f6746a1e3ebd07acba1a0e", :previous_fields=>{:sequence=>3366484, :balance=>1920887273}, :final_fields=>{:flags=>0, :sequence=>3366485, :owner_count=>5, :balance=>1920887262, :account=>"rKLpjpCoXgLQQYQyj13zgay73rsgmzNH13"}}], :transaction_result=>128}, :index=>"5C28E293E88CCEEFBBAB3EF58C1F8C1C02A5194F42A42349597DDCBC86BFEB0D"} }
+
+  let(:ledger_entry_key) { ["002989b414eff398027fce4045f643d68aca440aeea11518a950550ca02c18dd"].pack("H*") }
+  let(:ledger_entry) { {:type=>:account_root, :index=>"9A34C6D1C46168ECE90EB867C78AB2BECE80FAF5D86D09082017E2C89BD68E56", :fields=>{:flags=>0, :sequence=>2, :previous_txn_lgr_seq=>45017187, :owner_count=>0, :previous_txn_id=>"3133839f2401cc9a719778f53319486d11e7ad7ec7891ac083e2aa7eb924516a", :balance=>20000000, :account=>"r4HW4bomLvvzA22dACJwUq95ZRr8ZAcXXs"}} }
+
+  let(:inner_node_key) { ["001b46daaea7a40d9dcdc30f83918db8c8f9110c22e1207bcd8f9145dbe032dd"].pack("H*") }
+  # XXX - see: https://github.com/ripple/rippled/issues/2960
+  let(:inner_node_type) { described_class == XRBP::NodeStore::Backends::NuDB ? 0 : 3 }
+  let(:inner_node) { {"node_type"=>inner_node_type, "hp_inner_node"=>"4d494e00", "child0"=>"0000000000000000000000000000000000000000000000000000000000000000", "child1"=>"0000000000000000000000000000000000000000000000000000000000000000", "child2"=>"0000000000000000000000000000000000000000000000000000000000000000", "child3"=>"0000000000000000000000000000000000000000000000000000000000000000", "child4"=>"0000000000000000000000000000000000000000000000000000000000000000", "child5"=>"0000000000000000000000000000000000000000000000000000000000000000", "child6"=>"0000000000000000000000000000000000000000000000000000000000000000", "child7"=>"0000000000000000000000000000000000000000000000000000000000000000", "child8"=>"0000000000000000000000000000000000000000000000000000000000000000", "child9"=>"0000000000000000000000000000000000000000000000000000000000000000", "child10"=>"0000000000000000000000000000000000000000000000000000000000000000", "child11"=>"0000000000000000000000000000000000000000000000000000000000000000", "child12"=>"0000000000000000000000000000000000000000000000000000000000000000", "child13"=>"0000000000000000000000000000000000000000000000000000000000000000", "child14"=>"0000000000000000000000000000000000000000000000000000000000000000", "child15"=>"666a34c47ed2890eab999536b6c0f728b3b2d616080bd38837f7c9f509b55204", "child16"=>"", "child17"=>"", "child18"=>"", "child19"=>"", "child20"=>"", "child21"=>"", "child22"=>"", "child23"=>"", "child24"=>"", "child25"=>"", "child26"=>"", "child27"=>"", "child28"=>"", "child29"=>"", "child30"=>"", "child31"=>""} }
+
+  it "returns ledger" do
+    actual = db.ledger(ledger_key)
+    expect(actual).to eq(ledger)
+  end
+
+  it "returns transaction" do
+    actual = db.tx(tx_key)
+    expect(actual).to eq(tx)
+  end
+
+  # TODO test other transaction types
+
+  it "returns ledger entry" do
+    actual = db.ledger_entry(ledger_entry_key)
+    expect(actual).to eq(ledger_entry)
+  end
+
+  ## TODO test other ledger entry types
+
+  it "returns inner node" do
+    actual = db.inner_node(inner_node_key)
+    expect(actual).to eq(inner_node)
+  end
+end

data/spec/xrbp/nodestore/backends/nudb_spec.rb

@@ -0,0 +1,25 @@
+require 'xrbp/nodestore/backends/nudb'
+
+require_relative "./db_access"
+#require_relative "./db_iterator_access"
+#require_relative "./db_decompression"
+require_relative "./db_parser"
+
+describe XRBP::NodeStore::Backends::NuDB do
+  before(:each) do
+    Camcorder.intercept_constructor ::RuDB::Store
+  end
+
+  after(:each) do
+    Camcorder.deintercept_constructor ::RuDB::Store
+  end
+
+  let(:db) {
+    XRBP::NodeStore::Backends::NuDB.new("/var/lib/rippled/nudb")
+  }
+
+  it_provides "database access"
+#  it_provides "database iterator access"
+#  it_provides "database decompression"
+  it_provides "a database parser"
+end

data/spec/xrbp/nodestore/backends/rocksdb_spec.rb

@@ -0,0 +1,23 @@
+require 'xrbp/nodestore/backends/rocksdb'
+
+require_relative "./db_access"
+#require_relative "./db_iterator_access"
+#require_relative "./db_parser"
+
+describe XRBP::NodeStore::Backends::RocksDB do
+  before(:each) do
+    Camcorder.intercept_constructor ::RocksDB::DB
+  end
+
+  after(:each) do
+    Camcorder.deintercept_constructor ::RocksDB::DB
+  end
+
+  let(:db) {
+    XRBP::NodeStore::Backends::RocksDB.new("/var/lib/rippled/rocksdb/")
+  }
+
+  it_provides "database access"
+  #it_provides "database iterator access"
+  #it_provides "a database parser"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xrbp
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Dev Null Productions
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-24 00:00:00.000000000 Z
+date: 2019-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -292,6 +292,10 @@ files:
 - spec/xrbp/crypto/key_spec.rb
 - spec/xrbp/crypto/node_spec.rb
 - spec/xrbp/crypto/seed_spec.rb
+- spec/xrbp/nodestore/backends/db_access.rb
+- spec/xrbp/nodestore/backends/db_parser.rb
+- spec/xrbp/nodestore/backends/nudb_spec.rb
+- spec/xrbp/nodestore/backends/rocksdb_spec.rb
 - spec/xrbp/websocket/client_spec.rb
 - spec/xrbp/websocket/command_spec.rb
 - spec/xrbp/websocket/connection_spec.rb
@@ -316,8 +320,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Helper module to read and write data from the XRP Ledger and related resources!