xrbp 0.2.1 → 0.2.2

data/lib/xrbp/nodestore/shamap/errors.rb

@@ -0,0 +1,8 @@
+module XRBP
+  class SHAMap
+    module Errors
+      class MissingNode < StandardError
+      end # class MissingNode
+    end
+  end # class SHAMap
+end # module XRBP

data/lib/xrbp/nodestore/shamap/inner_node.rb

@@ -0,0 +1,98 @@
+module XRBP
+  class SHAMap
+    # A DB entry which may contain references of up to 16-child
+    # nodes, facilitating abstract tree-like traversal.
+    #
+    # This class simply encapsulates children w/ hashes
+    class InnerNode < Node
+      attr_accessor :depth, :common, :hashes, :is_branch
+
+      def initialize(args={})
+        @v2    = args[:v2]
+        @depth = args[:depth] || 0
+
+        @common    = {}
+        @hashes    = {}
+        @children  = []
+        @is_branch = 0
+      end
+
+      def v2?
+        @v2
+      end
+
+      def inner?
+        true
+      end
+
+      def common_prefix?(key)
+        hd = depth/2
+        0.upto(hd) do |d|
+          return false if common[d] != key[d]
+        end
+
+        return (common[hd] & 0xF0) &&
+               (key[hd]    & 0xF0) if depth & 1
+
+        return true
+      end
+
+      # Returns true if node has no children
+      def empty?
+        is_branch == 0
+      end
+
+      # Return true if specified branch is empty,
+      # else false
+      def empty_branch?(branch)
+        (is_branch & (1 << branch)) == 0
+      end
+
+      # Returns hash of child on given branch
+      def child_hash(branch)
+        raise ArgumentError unless branch >= 0 &&
+                                   branch < 16
+        hashes[branch]
+      end
+
+      # Returns child containing in given branch
+      def child(branch)
+        raise ArgumentError unless branch >= 0 &&
+                                   branch < 16
+        @children[branch]
+      end
+
+      # Canonicalize and store child node at branch
+      def canonicalize_child(branch, node)
+        raise ArgumentError unless branch >= 0 &&
+                                   branch < 16
+        raise unless node
+        raise unless node.hash == hashes[branch]
+
+        if @children[branch]
+          return @children[branch]
+        else
+          return @children[branch] = node
+        end
+      end
+
+      # Update this node's hash from child hashes
+      def update_hash
+        nh = nil
+
+        if is_branch != 0
+          sha512 = OpenSSL::Digest::SHA512.new
+          sha512 << HASH_+PREFIXES[:inner_node]
+          hashes.each { |k,h|
+            sha512 << v
+          }
+          nh = sha512.digest
+        end
+
+        return false if nh == self.hash
+        self.hash = nh
+        return true
+      end
+    end # class InnerNode
+  end # class SHAMap
+end # module XRBP

data/lib/xrbp/nodestore/shamap/item.rb

@@ -0,0 +1,14 @@
+module XRBP
+  class SHAMap
+    # Binary data blog stored in DB w/ key
+    class Item
+      attr_reader :key
+      attr_reader :data
+
+      def initialize(args = {})
+        @key  = args[:key]
+        @data = args[:data]
+      end
+    end # class Item
+  end # class SHAMap
+end # module XRBP

data/lib/xrbp/nodestore/shamap/node.rb

@@ -0,0 +1,49 @@
+require_relative './node_factory'
+
+module XRBP
+  class SHAMap
+    # Base Node class, all entries stored in tree structures
+    # in nodestore DB inherit from this class
+    class Node
+      extend NodeFactory
+
+      attr_accessor :hash
+
+      TYPES = {
+        :error          => 0,
+        :infer          => 1,
+        :transaction_nm => 2,
+        :transaction_md => 3,
+        :account_state  => 4
+      }
+
+      LEAF_TYPES = [
+        :transaction_nm,
+        :transaction_md,
+        :account_state
+      ]
+
+      def initialize(args={})
+        @hash = args[:hash]
+        @type = args[:type]
+        @seq  = args[:seq]
+      end
+
+      def leaf?
+        LEAF_TYPES.include?(@type)
+      end
+
+      def inner?
+        false
+      end
+
+      def tree_node?
+        false
+      end
+
+      def update_hash
+        raise "abstract: must be called on a subclass"
+      end
+    end # class Node
+  end # class SHAMap
+end # module XRBP

data/lib/xrbp/nodestore/shamap/node_factory.rb

@@ -0,0 +1,120 @@
+module XRBP
+  class SHAMap
+    module NodeFactory
+      # See rippled::SHAMapAbstractNode::make
+      def make(node, seq, format, hash, hash_valid)
+        node_id = NodeID.new
+
+        if format == :wire
+          # TODO
+
+        elsif format == :prefix
+          raise if node.size < 4
+
+          prefix   = node[0].ord
+          prefix <<= 8
+          prefix  |= node[1].ord
+          prefix <<= 8
+          prefix  |= node[2].ord
+          prefix <<= 8
+          prefix  |= node[3].ord
+          prefix = prefix.to_s(16).upcase
+
+          s = node[4..-1]
+
+          if prefix == NodeStore::Format::HASH_PREFIXES[:tx_id]
+            sha512  = OpenSSL::Digest::SHA512.new
+            sha512 <<  NodeStore::Format::HASH_PREFIXES[:tx_id]
+            sta512 << node
+               key  = sha512.digest[0..31]
+
+            item = Item.new(:key => key,
+                           :data => node)
+
+            tree_node = {:item => item,
+                         :seq  =>  seq,
+                         :type => :transaction_nm}
+              tree_node[:hash] = hash if hash_valid
+
+            return TreeNode.new(tree_node)
+
+          elsif prefix == NodeStore::Format::HASH_PREFIXES[:leaf_node]
+            raise "short PLN node" if s.size < 32
+
+            u = s[-32..-1]
+            s = s[0..-33]
+            raise "invalid PLN node" if u.zero?
+
+            item = Item.new(:key => u,
+                           :data => s)
+
+            tree_node = {:item => item,
+                         :seq  => seq,
+                         :type => :account_state}
+              tree_node[:hash] = hash if hash_valid
+
+            return TreeNode.new(tree_node)
+
+          elsif (prefix == NodeStore::Format::HASH_PREFIXES[:inner_node]) ||
+                (prefix == NodeStore::Format::HASH_PREFIXES[:inner_node_v2])
+            len = s.size
+            isv2 = prefix == NodeStore::Format::HASH_PREFIXES[:inner_node_v2]
+
+            raise "invalid PIN node" if len < 512    ||
+                             (!isv2 && (len != 512)) ||
+                             ( isv2 && (len == 512))
+
+            ret = InnerNode.new :v2 => isv2
+
+            0.upto(15)  { |i|
+              ret.hashes[i] = s[i*32...(i+1)*32]
+              ret.is_branch |= (1 << i) unless ret.hashes[i].zero?
+            }
+
+            if isv2
+              ret.depth = s[512]
+              n = (ret.depth + 1)/2
+              raise "invalid PIN node" if len != 512 + 1 + n
+
+              0.upto(n-1) { |i|
+                ret.common << s[512+1+i]
+              }
+            end
+
+            if hash_valid
+              ret.hash = hash
+            else
+              ret.update_hash
+            end
+
+            return ret
+
+          elsif prefix == NodeStore::Format::HASH_PREFIXES[:tx_node]
+            # transaction with metadata
+            raise "short TXN node" if s.size < 32
+
+            tx_id = s[-32..-1]
+                # XXX: tx_id is last field in binary transaction, keep so
+                # it can be parsed w/ other fields later:
+                #s = s[0..-33]
+
+            item = Item.new(:key => tx_id,
+                           :data => s)
+
+            tree_node = {:item => item,
+                         :seq  => seq,
+                         :type => :transaction_md}
+              tree_node[:hash] = hash if hash_valid
+
+            return TreeNode.new(tree_node)
+
+          else
+            raise "Unknown prefix #{prefix}"
+          end
+        end
+
+        raise "Unknown format"
+      end
+    end # module NodeFactory
+  end # class SHAMap
+end # module XRBP

data/lib/xrbp/nodestore/shamap/node_id.rb

@@ -0,0 +1,83 @@
+module XRBP
+  class SHAMap
+    # Encapsulates node key to allow for tree traversal.
+    #
+    # Provides branch extraction/generation logic.
+    # Since branch is between 0-15, only a nibble (4bits)
+    # are needed to store. Thus each char (8bits) can describe
+    # 2 tree branches
+    class NodeID
+      attr_reader :depth, :key
+
+      def initialize(args={})
+        @depth ||= args[:depth] || 0
+        @key   ||= args[:key]   || NodeStore.uint256
+      end
+
+      MASK_SIZE = 65
+
+      # Masks corresponding to each tree level.
+      # Used to calculate inner node hash for
+      # tree level:
+      #   inner node = lookup key & mask
+      def masks
+        @masks ||= begin
+          masks = Array.new(MASK_SIZE)
+
+          i = 0
+          selector = NodeStore.uint256
+          while(i < MASK_SIZE-1)
+            masks[i] = String.new(selector)
+            selector[i / 2] = 0xF0.chr
+            masks[i+1] = String.new(selector)
+            selector[i / 2] = 0xFF.chr
+            i += 2
+          end
+          masks[MASK_SIZE-1] = selector
+
+          masks
+        end
+      end
+
+      # Return mask for current tree depth
+      def mask
+        @mask ||= masks[depth]
+      end
+
+      # Return branch number of specified hash.
+      def select_branch(hash)
+        #if RIPPLE_VERIFY_NODEOBJECT_KEYS
+        raise if depth >= 64
+        raise if (hash.to_bn & mask.to_bn) != key.to_bn
+        #end
+
+        # Extract hash byte at local node depth
+        br = hash[depth / 2].ord
+
+        # Reduce to relevant nibble
+        if (depth & 1) == 1
+          br &= 0xf
+        else
+          br >>= 4
+        end
+
+        raise unless (br >= 0) && (br < 16)
+        br
+      end
+
+      # Return NodeID for specified branch under this one.
+      def child_node_id(branch)
+        raise unless branch >= 0 && branch < 16
+        raise unless depth < 64
+
+        # Copy local key and assign branch number to
+        # nibble in byte at local depth
+        child = key.unpack("C*")
+        child[depth/2] |= ((depth & 1) == 1) ? branch : (branch << 4)
+
+        NodeID.new :depth => (depth + 1),
+                   :key   => child.pack("C*")
+      end
+    end # class NodeID
+  end # class SHAMap
+end # module XRBP

data/lib/xrbp/nodestore/shamap/tagged_cache.rb

@@ -0,0 +1,20 @@
+module XRBP
+  class SHAMap
+    # Internal node caching mechanism.
+    #
+    # TODO timeout mechanism, metrics
+    class TaggedCache
+      def initialize
+        @cache = {}
+      end
+
+      def fetch(key)
+        @cache[key]
+      end
+
+      def canonicalize(key, node)
+        @cache[key] = node
+      end
+    end # class TaggedCache
+  end # class SHAMap
+end # module XRBP

data/lib/xrbp/nodestore/shamap/tree_node.rb

@@ -0,0 +1,21 @@
+module XRBP
+  class SHAMap
+    # Terminating tree node referencing concrete data
+    class TreeNode < Node
+      attr_reader :item
+
+      def initialize(args={})
+        super
+        @item = args[:item]
+      end
+
+      def tree_node?
+        true
+      end
+
+      def peek_item
+        item
+      end
+    end # class TreeNode
+  end # class SHAMap
+end # module XRBP

data/lib/xrbp/nodestore/sle.rb

@@ -0,0 +1,4 @@
+require_relative './sle/st_object'
+require_relative './sle/st_account'
+require_relative './sle/st_amount'
+require_relative './sle/st_ledger_entry'

data/lib/xrbp/nodestore/sle/st_account.rb

@@ -0,0 +1,8 @@
+module XRBP
+  module NodeStore
+    # Serialized Account Representation
+    class STAccount
+      # TODO
+    end # class STAccount
+  end # module NodeStore
+end # module XRBP

data/lib/xrbp/nodestore/sle/st_amount.rb

@@ -0,0 +1,226 @@
+module XRBP
+  module NodeStore
+    # Serialized Amount Representation
+    class STAmount
+      # see: https://github.com/ripple/rippled/blob/b53fda1e1a7f4d09b766724274329df1c29988ab/src/ripple/protocol/STAmount.h#L67
+      MIN_VAL = 1000000000000000
+
+      attr_reader :mantissa, :exponent, :neg
+      attr_accessor :issue
+
+      alias :value  :mantissa
+      alias :offset :exponent
+
+      def self.zero(args={})
+        STAmount.new args.merge({:mantissa => 0})
+      end
+
+      def self.from_quality(rate)
+        return STAmount.new(:issue => NodeStore.no_issue) if rate == 0
+
+        mantissa = rate & ~(255 << (64 - 8))
+        exponent = (rate >> (64 - 8)) - 100
+
+        return STAmount.new(:issue    => NodeStore.no_issue,
+                            :mantissa => mantissa,
+                            :exponent => exponent)
+      end
+
+      def initialize(args={})
+        @issue    = args[:issue]
+        @mantissa = args[:mantissa] || 0
+        @exponent = args[:exponent] || 0
+        @neg      = !!args[:neg]
+      end
+
+      def native?
+        @issue.xrp?
+      end
+
+      def zero?
+        @mantissa == 0
+      end
+
+      def clear
+        # see: https://github.com/ripple/rippled/blob/b53fda1e1a7f4d09b766724274329df1c29988ab/src/ripple/protocol/STAmount.h#L224
+        @exponent = native? ? 0 : -100
+
+        @neg = false
+        @mantissa = 0
+      end
+
+      def negate!
+        return if zero?
+        @neg = !@neg
+      end
+
+      def sn_value
+        neg ? (-mantissa) : mantissa
+      end
+
+      ###
+
+      # In drops!
+      def xrp_amount
+        neg ? (-value) : value
+      end
+
+      alias :drops :xrp_amount
+
+      def iou_amount
+        (neg ? -1 : 1) * mantissa * 10 ** (exponent-97)
+      end
+
+      ###
+
+      def +(v)
+        e1 = exponent
+        e2 = v.exponent
+
+        m1 = mantissa
+        m2 = v.mantissa
+
+        m1 *= -1 if   neg
+        m2 *= -1 if v.neg
+
+        while e1 < e2
+          m1 /= 10
+          e1 += 1
+        end
+
+        while e2 < e1
+          m2 /= 10
+          e2 += 1
+        end
+
+        m = m1 + m2
+        return STAmount.new :issue => issue if m >= -10 && m <= 10
+        return STAmount.new :mantissa => m,
+                            :exponent => e1,
+                            :issue    => issue if m >= 0
+        return STAmount.new :mantissa => -m,
+                            :exponent => e1,
+                            :issue    => issue
+      end
+
+      def -(v)
+        self + (-v)
+      end
+
+      def /(v)
+        if v.is_a?(Rate)
+          return self if v == Rate.parity
+          return self / v.to_amount
+        end
+
+        raise "divide by zero" if v.zero?
+        return STAmount.new :issue => issue
+
+        nm = mantissa
+        dm = v.mantissa
+
+        ne = exponent
+        de = v.exponent
+
+        if native?
+          while nm < MIN_VAL
+            nm *= 10
+            ne -= 1
+          end
+        end
+
+        if v.native?
+          while dm < MIN_VAL
+            dm *= 10
+            de -= 1
+          end
+        end
+
+        # see note: https://github.com/ripple/rippled/blob/b53fda1e1a7f4d09b766724274329df1c29988ab/src/ripple/protocol/impl/STAmount.cpp#L1075
+        STAmount.new :issue => issue,
+                     :mantissa => (nm * 10**17)/dm,
+                     :exponent => (ne - de - 17),
+                     :neg      => (neg != v.neg)
+      end
+
+      def *(o)
+        return STAmount.new :issue => issue if zero? || o.zero?
+
+        if native?
+          min = sn_value < o.sn_value ?   sn_value : o.sn_value
+          max = sn_value < o.sn_value ? o.sn_value :   sn_value
+
+          return STAmount.new :mantissa => min * max
+        end
+
+        m1 =   mantissa
+        m2 = o.mantissa
+        e1 =   exponent
+        e2 = o.exponent
+
+        if native?
+          while nm < MIN_VAL
+            m1 *= 10
+            e1 -= 1
+          end
+        end
+
+        if o.native?
+          while dm < MIN_VAL
+            m2 *= 10
+            e2 -= 1
+          end
+        end
+
+        # see note: https://github.com/ripple/rippled/blob/b53fda1e1a7f4d09b766724274329df1c29988ab/src/ripple/protocol/impl/STAmount.cpp#L1131
+        STAmount.new :issue => issue,
+                     :mantissa => (m1 * m2)/(10**14),
+                     :exponent => (e1 + e2 + 14),
+                     :neg      => (neg != o.neg)
+      end
+
+      def -@
+        STAmount.new(:mantissa => mantissa,
+                     :exponent => exponent,
+                     :issue    => issue,
+                     :neg      => !neg)
+      end
+
+      def <(o)
+        return neg if neg && !o.neg
+        if mantissa == 0
+          return false if o.neg
+          return o.mantissa != 0
+        end
+
+        return false if o.mantissa == 0
+        return  neg  if exponent > o.exponent
+        return !neg  if exponent < o.exponent
+        return  neg  if mantissa > o.mantissa
+        return !neg  if mantissa < o.mantissa
+
+        return false
+      end
+
+      def >=(o)
+        !(self < o)
+      end
+
+      def >(o)
+        self >= o && self != o
+      end
+
+      def ==(o)
+             neg == o.neg      &&
+        mantissa == o.mantissa &&
+        exponent == o.exponent
+      end
+
+      def <=>(o)
+        return  0 if self == o
+        return -1 if self  < o
+        return  1 if self  > o
+      end
+    end # class STAmount
+  end # module NodeStore
+end # module XRBP