xrbp 0.2.1 → 0.2.2

data/lib/xrbp/nodestore/fees.rb

@@ -0,0 +1,19 @@
+module XRBP
+  module NodeStore
+    class Fees
+      # FIXME where do these get updated in rippled?
+      attr_reader :base, :units, :reserve, :increment
+
+      def initialize
+        @base      = 0
+        @units     = 0
+        @reserve   = 0
+        @increment = 0
+      end
+
+      def account_reserve(owner_count)
+        STAmount.new :mantissa => reserve + owner_count + increment
+      end
+    end # class Fees
+  end # module NodeStore
+end # module XRBP

data/lib/xrbp/nodestore/format.rb

@@ -13,7 +13,7 @@ module XRBP
 
       NODE_TYPE_CODES = NODE_TYPES.invert
 
-      HASH_PREFIXES = {               # ASCII value:
+      HASH_PREFIX_CODES = {           # ASCII value:
         "54584E00" => :tx_id,         # TXN
         "534E4400" => :tx_node,       # SND
         "4D4C4E00" => :leaf_node,     # MLN
@@ -29,6 +29,8 @@ module XRBP
         #             :paychan_claim  # CLM
       }
 
+      HASH_PREFIXES = HASH_PREFIX_CODES.invert
+
       ###
 
       SERIALIZED_TYPES = {
@@ -48,6 +50,38 @@ module XRBP
         19 => :vector256
       }
 
+      SERIALIZED_FLAGS = {
+        # ltACCOUNT_ROOT
+        :password_spent    => 0x00010000,   # True, if password set fee is spent.
+        :require_dest_tag  => 0x00020000,   # True, to require a DestinationTag for payments.
+        :require_auth      => 0x00040000,   # True, to require a authorization to hold IOUs.
+        :disallow_xrp      => 0x00080000,   # True, to disallow sending XRP.
+        :disable_master    => 0x00100000,   # True, force regular key
+        :no_freeze         => 0x00200000,   # True, cannot freeze ripple states
+        :global_freeze     => 0x00400000,   # True, all assets frozen
+        :default_ripple    => 0x00800000,   # True, trust lines allow rippling by default
+        :deposit_auth      => 0x01000000,   # True, all deposits require authorization
+
+        # ltOFFER
+        :passive           => 0x00010000,
+        :sell              => 0x00020000,   # True, offer was placed as a sell.
+
+        # ltRIPPLE_STATE
+        :low_reserve       => 0x00010000,   # True, if entry counts toward reserve.
+        :high_reserve      => 0x00020000,
+        :low_auth          => 0x00040000,
+        :high_auth         => 0x00080000,
+        :low_no_ripple     => 0x00100000,
+        :high_no_ripple    => 0x00200000,
+        :low_freeze        => 0x00400000,   # True, low side has set freeze flag
+        :high_freeze       => 0x00800000,   # True, high side has set freeze flag
+
+        # ltSIGNER_LIST
+        :one_owner_count   => 0x00010000,   # True, uses only one OwnerCount
+      }
+
+      ###
+
       ENCODINGS = {
         # 16-bit unsigned integers (common)
         [:uint16,  1] => :ledger_entry_type,
@@ -232,6 +266,8 @@ module XRBP
         [:vector256, 3] => :amendments,
       }
 
+      ENCODING_TYPES = ENCODINGS.invert
+
       ###
 
       TYPE_INFER = Bistro.new([
@@ -319,6 +355,33 @@ module XRBP
 
       ###
 
+      LEDGER_NAMESPACE = {
+        :account         => 'a',
+        :dir_node        => 'd',
+        :generator       => 'g',
+        :ripple          => 'r',
+        :offer           => 'o',
+        :owner_dir       => 'O',
+        :book_dir        => 'B',
+        :contract        => 'c',
+        :skip_list       => 's',
+        :escrow          => 'u',
+        :amendment       => 'f',
+        :fee             => 'e',
+        :ticket          => 'T',
+        :signer_list     => 'S',
+        :xrp_uchannel    => 'x',
+        :check           => 'C',
+        :deposit_preauth => 'p',
+
+        # usused (according to rippled docs)
+        :nickname        => 'n'
+      }
+
+      LEDGER_NAMESPACE_CODES = LEDGER_NAMESPACE.invert
+
+      ###
+
       TX_TYPES = {
          -1 => :invalid,
           0 => :payment,
@@ -356,6 +419,14 @@ module XRBP
         'C3',  'iso_code',
         'C5',  'reserved2'
       ])
+
+      def self.encode_currency(iso_code)
+        return ([0] * 20).pack("C*") if iso_code == 'XRP'
+
+        ([0] * 12).pack("C*") +
+              iso_code.upcase +
+        ([0] *  5).pack("C*")
+      end
     end # module Format
   end # module NodeStore
 end # module XRBP

data/lib/xrbp/nodestore/ledger.rb

@@ -0,0 +1,272 @@
+require_relative './amendments'
+require_relative './fees'
+require_relative './parser'
+
+
+module XRBP
+  module NodeStore
+    class Ledger
+      include Amendments
+      include Parser
+
+      def initialize(args={})
+        @db = args[:db]
+        @hash = args[:hash]
+
+        if @hash
+          state_map.fetch_root [info["account_hash"]].pack("H*")
+             tx_map.fetch_root [info["tx_hash"]].pack("H*")
+        end
+      end
+
+      def txs
+        @txs ||= tx_map.collect { |tx| parse_tx_inner(tx.data) }
+      end
+
+      private
+
+      attr_reader :db, :hash
+
+      def state_map
+        @state_map ||= SHAMap.new :db => db
+      end
+
+      def tx_map
+        @tx_map ||= SHAMap.new :db => db
+      end
+
+      def info
+        @info ||= db.ledger(hash)
+      end
+
+      def fees
+        @fees ||= Fees.new
+      end
+
+      def global_frozen?(account)
+        return false if account == Crypto.xrp_account
+        sle = state_map.read(Indexes::account(account))
+        return sle && sle.flag?(:global_freeze)
+      end
+
+      def frozen?(account, iou)
+        return false if iou[:currency] == 'XRP'
+
+        sle = state_map.read(Indexes::account(iou[:account]))
+        return true if sle && sle.flag?(:global_freeze)
+
+        return false if iou[:account] == account
+
+        sle = state_map.read(Indexes::line(account, iou))
+        sle && sle.flag?(iou[:account] > account ? :high_freeze :
+                                                   :low_freeze)
+      end
+
+      def account_holds(owner_id, iou)
+        return xrp_liquid(owner_id, 0) if iou[:currency] == 'XRP'
+        sle = state_map.read(Indexes::line(owner_id, iou))
+        return STAmount.zero if !sle || frozen?(owner_id, iou)
+
+        amount = sle.amount(:balance)
+        amount.negate! if owner_id > iou[:account]
+        balance_hook(amount)
+      end
+
+      def xrp_liquid(account, owner_count_adj)
+        sle = state_map.read(Indexes::account(account))
+        return STAmount.zero unless sle
+
+        if fix1141? info['parent_close_time']
+          owner_count = confine_owner_account(owner_count_hook(
+                                      sle.field(:uint32, :owner_count)),
+                                                       owner_count_adj)
+
+          reserve = fees.account_reserve(owner_count)
+          full_balance = sle.amount(:balance)
+          balance = balance_hook(full_balance)
+          amount = balance - reserve
+          return STAmount.zero if balance < reserve
+          return amount
+
+        else
+          owner_count = confine_owner_account(sle.field(:uint32, :owner_count),
+                                                              owner_count_adj)
+          reserve = fees.account_reserve(sle.field(:uint32, :owner_count))
+          full_balance = sle.amount(:balance)
+          amount = balance - reserve
+          return STAmount.zero if balance < reserve
+          return balance_hook(amount)
+        end
+      end
+
+      def confine_owner_account(current, adjustment)
+        adjusted = current + adjustment
+        if adjustment > 0
+          # XXX: std::numeric_limits<std::uint32_t>::max
+          adjusted = 2**32-1 if adjusted < current
+        else
+          adjusted = 0 if adjusted > current
+        end
+
+        adjusted
+      end
+
+      def balance_hook(amount)
+        # TODO currently implementing ReadView::balanceHook,
+        #                   implement PaymentSandbox::balanceHook?
+        amount
+      end
+
+      def owner_count_hook(count)
+        # Same PaymentSandbox TODO as in balance_hook above
+        count
+      end
+
+      def transfer_rate(issuer)
+        sle = state_map.read(Indexes::account(issuer))
+        return Rate.new sle.field(:uint32,
+                                  :transfer_rate) if sle &&
+                                                     sle.field?(:transfer_rate)
+        Rate.parity
+      end
+
+      ###
+
+      public
+
+      def order_book(input, output)
+        offers = []
+
+        # Start at order book index
+        # Stop after max order book quality
+        tip_index = Indexes::order_book(input, output)
+         book_end = Indexes::get_quality_next(tip_index)
+
+        global_freeze = global_frozen?(output[:account]) ||
+                        global_frozen?(input[:account])
+
+        rate = transfer_rate(output[:account])
+
+           balances = {}
+               done = false # set true when we cannot traverse anymore
+             direct = true  # set true when we need to find next dir
+          offer_dir = nil   # current directory being travred
+           dir_rate = nil   # current directory quality
+        offer_index = nil   # index of current offer being processed
+         book_entry = nil   # index of next offer directory record
+        until done
+          if direct
+            direct = false
+            # Return first index after tip
+            ledger_index = state_map.succ(tip_index, book_end)
+            if ledger_index
+              # retrieve offer_dir SLE from db
+              offer_dir = state_map.read(ledger_index)
+            else
+              offer_dir = nil
+            end
+
+            if !offer_dir
+              done = true
+            else
+              # Set new tip, get first offer at new tip
+              tip_index = offer_dir.key
+              dir_rate = STAmount.from_quality(Indexes::get_quality(tip_index))
+              offer_index, offer_dir, book_entry = state_map.cdir_first(tip_index)
+            end
+          end
+
+          if !done
+            # Read offer from db and process
+            sle_offer = state_map.read(offer_index)
+            if sle_offer
+                owner_id = sle_offer.account_id(:account)
+              taker_gets = sle_offer.amount(:taker_gets)
+              taker_pays = sle_offer.amount(:taker_pays)
+
+                    owner_funds = nil
+              first_owner_offer = true
+
+              if output[:account] == owner_id
+                # issuer is offering it's own IOU, fully funded
+                owner_funds = taker_gets
+
+              elsif global_freeze
+                # all offers not ours are unfunded
+                owner_funds.clear(output)
+
+              else
+                if balances[owner_id]
+                  owner_funds = balances[owner_id]
+                  first_owner_offer = false
+
+                else
+                  # did not find balance in table
+                  owner_funds = account_holds(owner_id, output)
+
+                  # treat negative funds as zero
+                  owner_funds.clear if owner_funds < STAmount.zero
+                end
+              end
+
+              offer = Hash[sle_offer.fields]
+              taker_gets_funded = nil
+              owner_funds_limit = owner_funds
+              offer_rate = Rate.parity
+
+              if            rate != Rate.parity      && # transfer fee
+                       # TODO: provide support for 'taker_id' rpc param:
+                       #taker_id != output[:account] && # not taking offers of own IOUs
+                output[:account] != owner_id            # offer owner not issuing own funds
+                  # Need to charge a transfer fee to offer owner.
+                  offer_rate = rate
+                  owner_funds_limit = owner_funds / offer_rate.rate
+              end
+
+
+              if owner_funds_limit >= taker_gets
+                # Sufficient funds no shenanigans.
+                taker_gets_funded = taker_gets
+
+              else
+                # Only provide, if not fully funded.
+                taker_gets_funded = owner_funds_limit
+                offer[:taker_gets_funded] = taker_gets_funded
+                offer[:taker_pays_funded] = [taker_pays,
+                                             taker_gets_funded *
+                                                      dir_rate].min
+
+                # XXX: done in multiply operation in rippled
+                offer[:taker_pays_funded].issue = taker_pays.issue
+              end
+
+              owner_pays = (Rate.parity == offer_rate) ?
+                                     taker_gets_funded :
+                                           [owner_funds,
+                         taker_gets_funded * offer_rate].min
+
+              balances[owner_id] = owner_funds - owner_pays
+
+              # include all offers funded and unfunded
+              offer[:quality] = dir_rate
+              offer[:owner_funds] = owner_funds if first_owner_offer
+              offers << offer
+
+            else
+              puts "missing offer"
+            end
+
+            # Retrieve next offer in offer_dir,
+            # updating offer_index, offer_dir, book_entry appropriately
+            offer_index, offer_dir, book_entry = *state_map.cdir_next(tip_index, offer_dir, book_entry)
+
+            # if next offer not retrieved find next record after tip
+            direct = true if !offer_index
+          end
+        end
+
+        return offers
+      end
+    end # class Ledger
+  end # module NodeStore
+end # module XRBP

data/lib/xrbp/nodestore/parser.rb

@@ -0,0 +1,407 @@
+module XRBP
+  module NodeStore
+    module Parser
+      protected
+
+      # Parsers binary ledger representation into structured ledger.
+      #
+      # @protected
+      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
+      #
+      # @protected
+      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.
+      #
+      # @protected
+      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_PREFIX_CODES[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 return STLedgerEntry object
+
+        { :type   => Format::LEDGER_ENTRY_TYPE_CODES[prefix[1]],
+          :index  => index,
+          :fields => fields }
+      end
+
+      ###
+
+      # Parse and return series of fields from binary data.
+      #
+      # @protected
+      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.
+      #
+      # @protected
+      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)
+
+          # split into array of 256-bit (= 32 byte = 4 chars) strings
+          return data[offset..vl+offset-1].chunk(32),
+                 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.
+      #
+      # @protected
+      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
+      #
+      # @protected
+      def parse_amount(data)
+        amount = data[0..7].unpack("Q>").first
+           xrp = amount < 0x8000000000000000
+
+        # FIXME : is sign/neg right (?)
+
+        return STAmount.new(:issue    => NodeStore.xrp_issue,
+                            :mantissa => amount & 0x3FFFFFFFFFFFFFFF), data[8..-1] if xrp
+
+        sign = (amount & 0x4000000000000000) >> 62 # 0 = neg / 1 = pos
+         neg = (sign == 0)
+         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)
+
+        sle = STAmount.new(:issue    => Issue.new(currency, issuer),
+                           :neg      => neg,
+                           :mantissa => mant,
+                           :exponent => exp)
+
+        return sle, data
+      end
+
+      # Parse 'Account' data type from binary data.
+      #
+      # @protected
+      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
+
+        # TODO return STAccount
+        return Base58.binary_to_base58(acct, :ripple), data[vl..-1]
+      end
+
+      # Parse array of fields from binary data.
+      #
+      # @protected
+      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.
+      #
+      # @protected
+      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 return STObject
+          return parse_fields(data)
+
+        #else:
+        end
+
+        raise "unknown object type: #{e}"
+      end
+
+      # Parse PathSet from binary data.
+      #
+      # @protected
+      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
+
+        # TODO return STPathSet
+        return pathset, data
+      end
+
+      ###
+
+      # Parse Transaction from binary data
+      #
+      # @protected
+      def parse_tx(tx)
+                obj = Format::TYPE_INFER.decode(tx)
+          node_type = Format::NODE_TYPE_CODES[obj["node_type"]]
+        hash_prefix = Format::HASH_PREFIX_CODES[obj["hash_prefix"].upcase]
+        raise unless   node_type == :tx_node &&
+                     hash_prefix == :tx_node
+
+        # discard node type, and hash prefix
+        tx = tx[13..-1]
+
+        parse_tx_inner(tx)
+      end
+
+      # Parse Inner Transaction from binary data
+      #
+      # @protected
+      def parse_tx_inner(tx)
+        # 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*"))
+
+        # TODO return STTx
+        {  :node =>  node,
+           :meta =>  meta,
+          :index => index.pack("C*").unpack("H*").first.upcase }
+      end
+
+      # Parse InnerNode from binary data.
+      #
+      # @protected
+      def parse_inner_node(node)
+        # verify parsability
+                obj = Format::TYPE_INFER.decode(node)
+        hash_prefix = Format::HASH_PREFIX_CODES[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
+
+      # Return type and extracted structure from binary data.
+      #
+      # @protected
+      def infer_type(value)
+                obj = Format::TYPE_INFER.decode(value)
+          node_type = Format::NODE_TYPE_CODES[obj["node_type"]]
+        hash_prefix = Format::HASH_PREFIX_CODES[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 # module Parser
+  end # module NodeStore
+end # module XRBP