xrbp 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6390bfb57eaa26b5285cb3f3c3fb10d85d0a3a81e09e3c3b1e52eff6d4a00514
-  data.tar.gz: b616a6a4324fbd34ec8e77529c2827fca77949f635a0785ab33d8ca867baccc2
+  metadata.gz: cdd7b83c144366a77c0a68287e2ae511fa2878ef5b3be0e0f24b0b4d9e6a1be5
+  data.tar.gz: 1db244c92cefaca23244dd7a20cbb89c0d9e2fc25ab10659483aaa8187f0f117
 SHA512:
-  metadata.gz: 6b96064684b5ef84f089808649e4b281e9f055610543deec66b8d09122c7a7b545da95f44b55e60a8e73e6402ec3d03f52cfc79ea9ee85bacc9e66003dbf0b01
-  data.tar.gz: 1f9f959987d864d4500ffc5ba2172c5341a9705a3eec9e3af09de88bfa9bf5f8feabbae0a7030db3437af75348a924b2535abb0b4661192aa44b3d5e300715df
+  metadata.gz: 42cdd0d6b998b3550a89233b90c86676fe9e56f7a4981cfad96f209fb3272ae2f669f5b16de399318596d13fb9c0fc2b087fa968155a4f30f211fed46cce74c4
+  data.tar.gz: ee8e543e9e04557f8e8355dbd4f56a19f9176ba8e3f24c87db128298f38caa0386bf3763180bee734c94f7e91aaba3341c4689b4f7d4a53b3d4d0fa49d22b6d9

data/examples/nodestore1.rb

@@ -9,11 +9,16 @@ db = XRBP::NodeStore::Backends::RocksDB.new "/var/lib/rippled/rocksdb/rippledb.0
 #require 'xrbp/nodestore/backends/nudb'
 #db = XRBP::NodeStore::Backends::NuDB.new "/var/lib/rippled/nudb/"
 
-#ledger = "B506ADD630CB707044B4BFFCD943C1395966692A13DD618E5BD0978A006B43BD"
-#ledger = [ledger].pack("H*")
-#puts db.ledger(ledger)
+ledger = "32E073D7E4D722D956F7FDE095F756FBB86DC9CA487EB0D9ABF5151A8D88F912"
+ledger = [ledger].pack("H*")
+puts db.ledger(ledger)
 
-#account = "0001bf7468341666f1f47a95e0f4d88e68b5fc7d20d77437cb22954fbbfe6127"
-account = "02c46b3a4130d0a329c47f0da61b829aa5d1ae53c5817e475bcd794e5107be44"
-account = [account].pack("H*")
-puts db.account(account)
+gw1 = 'razqQKzJRdB4UxFPWf5NEpEG3WMkmwgcXA'
+iou1 = {:currency => 'XRP', :account => XRBP::Crypto.xrp_account}
+iou2 = {:currency => 'CNY', :account => gw1}
+nledger = XRBP::NodeStore::Ledger.new(:db => db, :hash => ledger)
+puts nledger.order_book iou1, iou2
+puts nledger.txs
+
+require 'xrbp/nodestore/sqldb'
+puts XRBP::NodeStore::SQLDB.new("/var/lib/rippled/").ledger_hash_for_seq(49340234)

data/lib/xrbp/core_ext.rb

@@ -29,6 +29,22 @@ class String
   def to_bn
     bytes.inject(0) { |bn, b| (bn << 8) | b }
   end
+
+  def all?(&bl)
+    each_char { |c| return false unless bl.call(c) }
+    return true
+  end
+
+  def zero?
+    return self == "\0" if size == 1
+    all? { |c| c.zero? }
+  end
+
+  # scan(regex) will not work as we need to process
+  # binary strings (\n's seem to trip scan up)
+  def chunk(size)
+    ((self.length + size - 1) / size).times.collect { |i| self[i * size, size] }
+  end
 end
 
 # @private
@@ -44,3 +60,14 @@ class Integer
     b
   end
 end
+
+# @private
+class Array
+  def rjust!(n, x)
+    insert(0, *Array.new([0, n-length].max, x))
+  end
+
+  def ljust!(n, x)
+    fill(x, length...n)
+  end
+end

data/lib/xrbp/crypto/account.rb

@@ -2,12 +2,13 @@ require 'base58'
 
 module XRBP
   module Crypto
-    # Generate and new XRPL account.
+    # Generate a new XRPL account.
     #
     # @param key [Symbol, Hash] key type to generate or key itself (optional)
     # @return [Hash] account details containing id and pub/priv key pair
     def self.account(key=nil)
       pub = nil
+      account_id = nil
       if key == :secp256k1 || key.nil?
         key = Key::secp256k1
         pub = key[:public]
@@ -17,21 +18,45 @@ module XRBP
         pub = "\xED" + key[:public]
 
       elsif key.is_a?(Hash)
-        pub = key[:public]
+        if key[:account_id]
+          account_id = key[:account_id]
+        elsif key[:public]
+          pub = key[:public]
+        end
 
       else
         pub = key
         key = {:public => pub}
       end
 
+      raise "must specify pub or account_id" unless pub || account_id
+
           sha256 = OpenSSL::Digest::SHA256.new
        ripemd160 = OpenSSL::Digest::RIPEMD160.new
-      account_id = [Key::TOKEN_TYPES[:account_id]].pack("C") + ripemd160.digest(sha256.digest([pub].pack("H*")))
+      account_id = [Key::TOKEN_TYPES[:account_id]].pack("C") + ripemd160.digest(sha256.digest([pub].pack("H*"))) unless account_id
           chksum = sha256.digest(sha256.digest(account_id))[0..3]
 
       { :account => Base58.binary_to_base58(account_id  + chksum, :ripple) }.merge(key)
     end
 
+    # Account Zero: https://xrpl.org/accounts.html#special-addresses
+    def self.xrp_account
+      @xrp_account ||= account(:account_id => ([0] * 21).pack("C*"))[:account]
+    end
+
+    # Account One: https://xrpl.org/accounts.html#special-addresses
+    def self.no_account
+      @no_account ||= account(:account_id => ([0] * 20 + [1]).pack("C*"))[:account]
+    end
+
+    # Return the account id for the specified XRP account.
+    # This is a simpler version of {parse_account} that just
+    # returns the binary account, _skipping_ the token and
+    # checksum verifications.
+    def self.account_id(account)
+      Base58.base58_to_binary(account, :ripple)[1..-5]
+    end
+
     # Extract Account ID from Address.
     #
     # @param account [String] Base58 encoded account address

data/lib/xrbp/nodestore.rb

@@ -1,4 +1,10 @@
+require_relative './nodestore/uint'
 require_relative './nodestore/format'
+require_relative './nodestore/sle'
+require_relative './nodestore/shamap'
+require_relative './nodestore/ledger'
+
+require_relative './nodestore/protocol'
 
 require_relative './nodestore/db'
 

data/lib/xrbp/nodestore/amendments.rb

@@ -0,0 +1,13 @@
+module XRBP
+  module NodeStore
+    module Amendments
+      def fix1141_time
+        @fix1141_time ||= Time.new(2016, 6, 1, 17, 0, 0, 0)
+      end
+
+      def fix1141?(time)
+        time > fix1141_time
+      end
+    end
+  end # module NodeStore
+end # module XRBP

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

@@ -102,8 +102,8 @@ module XRBP
             out = [0, 0, 0, 0,
                    0, 0, 0, 0,
                    Format::NODE_TYPES[:unknown]] +
-                  [Format::HASH_PREFIXES.invert[:inner_node]].pack("H*")
-                                                             .unpack("C*")
+                  [Format::HASH_PREFIXES[:inner_node]].pack("H*")
+                                                      .unpack("C*")
 
             # extract mask indicating which hashes are set
             bytes = data.bytes
@@ -147,8 +147,8 @@ module XRBP
             out = [0, 0, 0, 0,
                    0, 0, 0, 0,
                    Format::NODE_TYPES[:unknown]] +
-                  [Format::HASH_PREFIXES.invert[:inner_node_v2]].pack("H*")
-                                                                .unpack("C*")
+                  [Format::HASH_PREFIXES[:inner_node_v2]].pack("H*")
+                                                         .unpack("C*")
 
             # Same mask / hash extraction as V1
 
@@ -205,7 +205,8 @@ module XRBP
             out = [0, 0, 0, 0,
                    0, 0, 0, 0,
                    Format::NODE_TYPES[:unknown]] +
-                  [Format::HASH_PREFIXES.invert[:inner_node]].pack("H*").unpack("C*")
+                  [Format::HASH_PREFIXES[:inner_node]].pack("H*")
+                                                      .unpack("C*")
             (out + data[0...512].bytes).pack("C*")
           end
 
@@ -223,7 +224,8 @@ module XRBP
             out = [0, 0, 0, 0,
                    0, 0, 0, 0,
                    Format::NODE_TYPES[:unknown]] +
-                  [Format::HASH_PREFIXES.invert[:inner_node_v2]].pack("H*").unpack("C*")
+                  [Format::HASH_PREFIXES[:inner_node_v2]].pack("H*")
+                                                         .unpack("C*")
 
              out += bytes[0..511]
             bytes = bytes[512..-1]

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

@@ -76,6 +76,8 @@ module XRBP
                                       :value => val)
             yield iterator
           end
+
+          return self
         end
 
         private

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

@@ -67,6 +67,7 @@ module XRBP
           end
 
           iterator.close
+          return self
         end
       end # class RocksDB
     end # module Backends

data/lib/xrbp/nodestore/db.rb

@@ -1,6 +1,8 @@
 require 'base58'
 require 'openssl'
 
+require_relative './parser'
+
 module XRBP
   # The NodeStore is the Key/Value DB which rippled persistent stores
   # ledger data. Implemented via a backend configured at run time,
@@ -24,6 +26,9 @@ module XRBP
       include Enumerable
       include EventEmitter
 
+      # NodeStore Parser
+      include Parser
+
       # Return the NodeStore Ledger for the given lookup hash
       def ledger(hash)
         val = self[hash]
@@ -56,393 +61,6 @@ module XRBP
         return nil if val.nil?
         parse_inner_node(val)
       end
-
-      ###
-
-      private
-
-      # Parsers binary ledger representation into structured ledger.
-      #
-      # @private
-      def parse_ledger(ledger)
-        obj = Format::LEDGER.decode(ledger)
-               obj['close_time'] = XRBP::from_xrp_time(obj['close_time']).utc
-        obj['parent_close_time'] = XRBP::from_xrp_time(obj['parent_close_time']).utc
-        obj['parent_hash'].upcase!
-        obj['tx_hash'].upcase!
-        obj['account_hash'].upcase!
-        obj
-      end
-
-      # Certain data types are prefixed with an 'encoding' header
-      # consisting of a field and/or type. Field, type, and remaining
-      # bytes are returned
-      #
-      # @private
-      def parse_encoding(encoding)
-             enc = encoding.unpack("C").first
-            type = enc >> 4
-           field = enc  & 0xF
-        encoding = encoding[1..-1]
-
-        if type == 0
-          type = encoding.unpack("C").first
-          encoding = encoding[1..-1]
-        end
-
-        if field == 0
-          field = encoding.unpack("C").first
-          encoding = encoding[1..-1]
-        end
-
-        type = Format::SERIALIZED_TYPES[type]
-        [[type, field], encoding]
-      end
-
-      # Parses binary ledger entry into hash. Data returned
-      # in hash includes ledger entry type prefix, index,
-      # and array of parsed fields.
-      #
-      # @private
-      def parse_ledger_entry(ledger_entry)
-        # validate parsability
-                obj = Format::TYPE_INFER.decode(ledger_entry)
-          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
-
-        # discard node type, and hash prefix
-        ledger_entry = ledger_entry[13..-1]
-
-        # verify encoding
-        encoding, ledger_entry = parse_encoding(ledger_entry)
-        raise "Invalid Ledger Entry" unless Format::ENCODINGS[encoding] == :ledger_entry_type
-        ledger_entry = ledger_entry.bytes
-
-        # first byte after encoding is ledger entry type prefix
-        prefix = ledger_entry[0..1].pack("C*")
-
-        # last 32 bytes is entry index
-        index  = ledger_entry[-32..-1].pack("C*")
-                                      .unpack("H*")
-                                      .first
-                                      .upcase
-
-        # remaining bytes are serialized object
-        fields, remaining = parse_fields(ledger_entry[2...-32].pack("C*"))
-        raise unless remaining.empty?
-
-        # TODO instantiate class corresponding to type &
-        #      populate attributes w/ fields (?)
-
-        { :type   => Format::LEDGER_ENTRY_TYPE_CODES[prefix[1]],
-          :index  => index,
-          :fields => fields }
-      end
-
-      ###
-
-      # Parse and return series of fields from binary data.
-      #
-      # @private
-      def parse_fields(fields)
-        parsed = {}
-        until fields == "" || fields == "\0" || fields.nil?
-          encoding, fields = parse_encoding(fields)
-          return parsed if encoding.first.nil?
-
-          e = Format::ENCODINGS[encoding]
-          value, fields = parse_field(fields, encoding)
-          break unless value
-          parsed[e] = convert_field(encoding, value)
-        end
-
-        return parsed, fields
-      end
-
-      # Parse single field of specified encoding from data.
-      # Dispatches to corresponding parsing method when appropriate.
-      #
-      # @private
-      def parse_field(data, encoding)
-        length = encoding.first
-
-        case length
-        when :uint8
-          return data.unpack("C").first, data[1..-1]
-        when :uint16
-          return data.unpack("S>").first, data[2..-1]
-        when :uint32
-          return data.unpack("L>").first, data[4..-1]
-        when :uint64
-          return data.unpack("Q>").first, data[8..-1]
-        when :hash128
-          return data.unpack("H32").first, data[16..-1]
-        when :hash160
-          return data.unpack("H40").first, data[20..-1]
-        when :hash256
-          return data.unpack("H64").first, data[32..-1]
-        when :amount
-          return parse_amount(data)
-        when :vl
-          vl, offset = parse_vl(data)
-          return data[offset..vl+offset-1], data[vl+offset..-1]
-        when :account
-          return parse_account(data)
-        when :array
-          return parse_array(data, encoding)
-        when :object
-          return parse_object(data, encoding)
-        when :pathset
-          return parse_pathset(data)
-        when :vector256
-          vl, offset = parse_vl(data)
-          return data[offset..vl+offset-1], data[vl+offset..-1]
-        end
-
-        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.
-      #
-      # @private
-      def parse_vl(data)
-         data = data.bytes
-        first = data.first.to_i
-        return first, 1 if first <= 192
-
-        data = data[1..-1]
-        second = data.first.to_i
-        if first <= 240
-          return (193+(first-193)*256+second), 2
-
-        elsif first <= 254
-          data = data[1..-1]
-          third = data.first.to_i
-          return (12481 + (first-241)*65536 + second*256 + third), 3
-        end
-
-        raise
-      end
-
-      # 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
-           xrp = amount < 0x8000000000000000
-        return  (amount & 0x3FFFFFFFFFFFFFFF), data[8..-1] if xrp
-
-        sign = (amount & 0x4000000000000000) >> 62 # 0 = neg / 1 = pos
-         exp = (amount & 0x3FC0000000000000) >> 54
-        mant = (amount & 0x003FFFFFFFFFFFFF)
-
-        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)
-
-        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.
-      #
-      # @private
-      def parse_account(data, vl=nil)
-        unless vl
-          vl,offset = parse_vl(data)
-          data = data[offset..-1]
-        end
-
-          acct = "\0" + data[0..vl-1]
-        sha256 = OpenSSL::Digest::SHA256.new
-        digest = sha256.digest(sha256.digest(acct))[0..3]
-        acct  += digest
-        acct.force_encoding(Encoding::BINARY) # required for Base58 gem
-        return Base58.binary_to_base58(acct, :ripple), data[vl..-1]
-      end
-
-      # Parse array of fields from binary data.
-      #
-      # @private
-      def parse_array(data, encoding)
-        e = Format::ENCODINGS[encoding]
-        return nil, data if e == :end_of_array
-
-        array = []
-        until data == "" || data.nil?
-          aencoding, data = parse_encoding(data)
-          break if aencoding.first.nil?
-
-          e = Format::ENCODINGS[aencoding]
-          break if e == :end_of_array
-
-          value, data = parse_field(data, aencoding)
-          break unless value
-          array << value
-        end
-
-        return array, data
-      end
-
-      # Parse Object consisting of multiple fields from binary data.
-      #
-      # @private
-      def parse_object(data, encoding)
-        e = Format::ENCODINGS[encoding]
-        case e
-        when :end_of_object
-          return nil, data
-
-        when :signer,   :signer_entry,
-             :majority, :memo,
-             :modified_node, :created_node, :deleted_node,
-             :previous_fields, :final_fields, :new_fields
-          # TODO instantiate corresponding classes (?)
-          return parse_fields(data)
-
-        #else:
-        end
-
-        raise "unknown object type: #{e}"
-      end
-
-      # Parse PathSet from binary data.
-      #
-      # @private
-      def parse_pathset(data)
-        pathset = [[]]
-        until data == "" || data.nil?
-          segment = data.unpack("C").first
-          data = data[1..-1]
-          return pathset, data if segment == 0x00 # end of path
-
-          if segment == 0xFF # path boundry
-            pathset << []
-          else
-            account, current, issuer = nil
-
-            path = {}
-
-            if (segment & 0x01) != 0 # path account
-              account, data = parse_account(data, 20)
-              path[:account] = account
-            end
-
-            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
-
-            if (segment & 0x20) != 0 # path issuer
-              issuer, data = parse_account(data, 20)
-              path[:issuer] = issuer
-            end
-
-            pathset.last << path
-          end
-        end
-
-        return pathset, data
-      end
-
-      ###
-
-      # Parse Transaction from binary data
-      #
-      # @private
-      def parse_tx(tx)
-                obj = Format::TYPE_INFER.decode(tx)
-          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
-
-        # discard node type, and hash prefix
-        tx = tx[13..-1]
-
-        # get node length
-        vl, offset = parse_vl(tx)
-        node, _tx = tx.bytes[offset..vl+offset-1], tx.bytes[vl+offset..-1]
-        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, _remaining = parse_fields(meta.pack("C*"))
-
-        {  :node =>  node,
-           :meta =>  meta,
-          :index => index.pack("C*").unpack("H*").first.upcase }
-      end
-
-      # Parse InnerNode from binary data.
-      #
-      # @private
-      def parse_inner_node(node)
-        # verify parsability
-                obj = Format::TYPE_INFER.decode(node)
-        hash_prefix = Format::HASH_PREFIXES[obj["hash_prefix"].upcase]
-        raise unless hash_prefix == :inner_node
-
-        node = Format::INNER_NODE.decode(node)
-        node['node_type'] = Format::NODE_TYPE_CODES[node['node_type']]
-        node
-      end
-
-      protected
-
-      # Return type and extracted structure from binary data.
-      #
-      # @private
-      def infer_type(value)
-                obj = Format::TYPE_INFER.decode(value)
-          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 :ledger_entry, parse_ledger_entry(value)
-
-        elsif node_type == :tx_node
-          return :tx, parse_tx(value)
-
-        elsif node_type == :ledger
-          return :ledger, parse_ledger(value)
-        end
-
-        return nil
-      end
     end # class DB
   end # module NodeStore
 end # module XRBP