dcha 0.1.0

data/lib/dcha/mpt/node.rb

@@ -0,0 +1,64 @@
+module Dcha
+  module MPT
+    # :nodoc:
+    class Node < Array
+      autoload :Findable, 'dcha/mpt/node/findable'
+      autoload :Editable, 'dcha/mpt/node/editable'
+      autoload :Deletable, 'dcha/mpt/node/deletable'
+      autoload :ToHashable, 'dcha/mpt/node/to_hashable'
+
+      class << self
+        def decode(encoded)
+          return BLANK if encoded == BLANK.first
+          return encoded if encoded.is_a?(Node)
+          return new encoded if encoded.is_a?(Array)
+          new RLP.decode(Config.store[encoded])
+        end
+      end
+
+      BLANK = new(['']).freeze
+
+      BRANCH_CARDINAL = 16
+      BRANCH_WIDTH = BRANCH_CARDINAL + 1
+      KV_WIDTH = 2
+
+      include Node::Findable
+      include Node::Editable
+      include Node::Deletable
+      include Node::ToHashable
+
+      def type
+        return :blank if size == 1 && first.empty?
+
+        case size
+        when KV_WIDTH
+          NibbleKey.decode(first).terminate? ? :leaf : :extension
+        when BRANCH_WIDTH
+          :branch
+        end
+      end
+
+      def tree_size
+        case type
+        when :branch
+          children = take(BRANCH_CARDINAL).map(&:tree_size)
+          children.push(last != BLANK ? 0 : 1)
+          size.reduce(0, &:+)
+        when :extension then Node.decode(self[1]).tree_size
+        when :leaf then 1
+        when :blank then 0
+        end
+      end
+
+      def save(force = false)
+        value = RLP.encode self
+        return self if value.size < 32 && !force
+        key = Config.digest.hexdigest(value)
+
+        Config.store[key] = value
+
+        key
+      end
+    end
+  end
+end

data/lib/dcha/mpt/node/deletable.rb

@@ -0,0 +1,83 @@
+module Dcha
+  module MPT
+    class Node < Array
+      # :nodoc:
+      module Deletable
+        def delete(key)
+          case type
+          when :blank then Node::BLANK
+          when :branch then delete_branch_node(key)
+          else
+            delete_kv_node(key)
+          end
+        end
+
+        private
+
+        def delete_branch_node(key)
+          if key.empty?
+            self[-1] = Node::BLANK
+            return normalize
+          end
+
+          new_sub_node = Node.decode(self[key[0]]).delete(key[1..-1])
+          encoded_new_sub_node = new_sub_node.save
+          return self if encoded_new_sub_node == self[key[0]]
+
+          self[key[0]] = encoded_new_sub_node
+          return normalize if encoded_new_sub_node == Node::BLANK
+
+          self
+        end
+
+        def delete_kv_node(key)
+          node_key = NibbleKey.decode(first).terminate(false)
+          return self unless node_key.prefix?(key)
+          return key == node_key ? Node::BLANK : self if type == :leaf
+
+          new_sub_node = Node.decode(self[1]).delete(key[node_key.size..-1])
+
+          replace_with_new_sub_node(node_key, new_sub_node)
+        end
+
+        def replace_with_new_sub_node(node_key, new_sub_node)
+          return self if new_sub_node.save == self[1]
+          return Node::BLANK if new_sub_node == Node::BLANK
+
+          case new_sub_node.type
+          when :branch
+            Node.new([node_key.encode, new_sub_node.save])
+          when :leaf, :extension
+            new_key = node_key + NibbleKey.decode(new_sub_node[0])
+            Node.new([new_key.encode, new_sub_node[1]])
+          end
+        end
+
+        def normalize
+          return self if non_blank_items.size > 1
+
+          non_blank_index = non_blank_items[0][1]
+          new_node = Node.new([NibbleKey.new([]).terminate(true).encode, last])
+          return new_node if non_blank_index == NibbleKey::TERMINATOR
+
+          replace_with_sub_node(non_blank_index)
+        end
+
+        def replace_with_sub_node(non_blank_index)
+          sub_node = Node.decode(self[non_blank_index])
+          case sub_node.type
+          when :branch
+            Node.new([NibbleKey.new([non_blank_index]).encode, sub_node.save])
+          when :leaf, :extension
+            new_key = NibbleKey.decode(sub_node[0]).unshift(non_blank_index)
+            Node.new(new_key.encode, sub_node[1])
+          end
+        end
+
+        def non_blank_items
+          each_with_index.reject { |(x, _)| x == Node::BLANK }
+        end
+      end
+    end
+  end
+end

data/lib/dcha/mpt/node/editable.rb

@@ -0,0 +1,135 @@
+# rubocop:disable Metrics/LineLength
+module Dcha
+  module MPT
+    class Node < Array
+      # :nodoc:
+      module Editable
+        def update(key, value)
+          case type
+          when :blank then
+            dup.clear.push key.terminate(true).encode, value
+          when :branch then update_branch(key, value)
+          when :leaf then update_leaf(key, value)
+          else update_extension(key, value)
+          end
+        end
+
+        private
+
+        def update_branch(key, value)
+          return dup.tap { |copy| copy[-1] = value } if key.empty?
+
+          new_node = Node.decode(self[key[0]])
+                         .update(key[1..-1], value)
+          dup.tap do |copy|
+            copy[key[0]] = new_node
+          end
+        end
+
+        def update_leaf(key, value)
+          node_key, common_key, remain_key, remain_node_key = common_key_pairs(key)
+
+          no_remain_key = remain_key.empty? && remain_node_key.empty?
+          return dup.clear.push first, value if no_remain_key
+
+          new_node = if remain_node_key.empty?
+                       convert_leaf_to_branch_node(remain_key, value)
+                     else
+                       expand_leaf_to_branch_node(remain_key, remain_node_key, value)
+                     end
+
+          apply_node(common_key, node_key, new_node)
+        end
+
+        def apply_node(common_key, node_key, new_node)
+          if common_key.empty?
+            dup.clear.concat new_node
+          else
+            dup.clear.push node_key[0, common_key.size].encode,
+                           Node.new(new_node).save
+          end
+        end
+
+        def convert_leaf_to_branch_node(key, value)
+          new_node = Node::BLANK * Node::BRANCH_WIDTH
+          new_node[-1] = self[1]
+
+          new_node[key[0]] = Node.new(
+            [
+              key[1..-1].terminate(true).encode,
+              value
+            ]
+          ).save
+          new_node
+        end
+
+        def expand_leaf_to_branch_node(key, node_key, value)
+          new_node = convert_leaf_to_branch_node(node_key, self[1])
+
+          if key.empty?
+            new_node[-1] = value
+          else
+            new_node[key[0]] = Node.new(
+              [key[1..-1].terminate(true).encode, value]
+            ).save
+          end
+
+          new_node
+        end
+
+        def update_extension(key, value)
+          node_key, common_key, remain_key, remain_node_key = common_key_pairs(key)
+
+          new_node = if remain_node_key.empty?
+                       Node.decode(self[1]).update(remain_key, value)
+                     else
+                       expand_extension_to_branch_node(
+                         remain_key, remain_node_key, value
+                       )
+                     end
+          apply_node(common_key, node_key, new_node)
+        end
+
+        def convert_extension_to_branch_node(key, value)
+          new_node = Node::BLANK * Node::BRANCH_WIDTH
+
+          if key.size == 1
+            new_node[key[0]] = value
+            return new_node
+          end
+
+          new_node[key[0]] = Node.new(
+            [key[1..-1].terminate(false).encode, value]
+          ).save
+
+          new_node
+        end
+
+        def expand_extension_to_branch_node(key, node_key, value)
+          new_node = convert_extension_to_branch_node(node_key, self[1])
+
+          if key.empty?
+            new_node[-1] = value
+            return new_node
+          end
+
+          new_node[key[0]] = Node.new(
+            [key[1..-1].terminate(true).encode, value]
+          ).save
+
+          new_node
+        end
+
+        def common_key_pairs(key)
+          node_key = NibbleKey.decode(first).terminate(false)
+
+          common = node_key.common_prefix(key)
+          remain = key[common.size..-1]
+          remain_node = node_key[common.size..-1]
+
+          [node_key, common, remain, remain_node]
+        end
+      end
+    end
+  end
+end

data/lib/dcha/mpt/node/findable.rb

@@ -0,0 +1,37 @@
+module Dcha
+  module MPT
+    class Node < Array
+      # :nodoc:
+      module Findable
+        def find(nbk)
+          case type
+          when :blank then Node::BLANK.first
+          when :branch then find_branch(nbk)
+          when :leaf then find_leaf(nbk)
+          when :extension then find_extension(nbk)
+          end
+        end
+
+        private
+
+        def find_branch(nbk)
+          return last if nbk.empty?
+          node = Node.decode(self[nbk[0]])
+          node.find(nbk[1..-1])
+        end
+
+        def find_leaf(nbk)
+          key = NibbleKey.decode(first).terminate(false)
+          nbk == key ? self[1] : Node::BLANK.first
+        end
+
+        def find_extension(nbk)
+          key = NibbleKey.decode(first).terminate(false)
+          return Node::BLANK.first unless key.prefix?(nbk)
+          node = Node.decode(self[1])
+          node.find nbk[key.size..-1]
+        end
+      end
+    end
+  end
+end

data/lib/dcha/mpt/node/to_hashable.rb

@@ -0,0 +1,42 @@
+module Dcha
+  module MPT
+    class Node < Array
+      # :nodoc:
+      module ToHashable
+        def to_h
+          case type
+          when :blank then {}
+          when :branch then branch_to_h
+          when :leaf, :extension
+            kv_to_h
+          end
+        end
+
+        private
+
+        def branch_to_h
+          hash = {}
+          16.times do |i|
+            sub_hash = Node.decode(self[i]).to_h
+            sub_hash.each { |k, v| hash[NibbleKey.new([i]) + k] = v }
+          end
+          hash[NibbleKey.terminator] = last if last
+          hash
+        end
+
+        def kv_to_h
+          nibbles = NibbleKey.decode(first).terminate(false)
+          sub_hash = if type == :extension
+                       Node.decode(self[1]).to_h
+                     else
+                       { NibbleKey.terminator => self[1] }
+                     end
+
+          {}.tap do |h|
+            sub_hash.each { |k, v| h[nibbles + k] = v }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dcha/mpt/trie.rb

@@ -0,0 +1,73 @@
+module Dcha
+  module MPT
+    # :nodoc:
+    class Trie
+      include Enumerable
+
+      def initialize(hash = nil)
+        @root = if hash.nil?
+                  Node::BLANK
+                else
+                  Node.decode(hash)
+                end
+      end
+
+      def root_hash
+        return blank_root if @root == Node::BLANK
+        @root.save(true)
+      end
+      alias update_root_hash root_hash
+
+      def get(key)
+        @root.find NibbleKey.from_string(key)
+      end
+      alias [] get
+
+      def set(key, value)
+        @root = @root.update(
+          NibbleKey.from_string(key),
+          value
+        )
+
+        update_root_hash
+      end
+      alias []= set
+
+      def delete(key)
+        @root = @root.delete(NibbleKey.from_string(key))
+
+        update_root_hash
+      end
+
+      def to_h
+        Hash[
+          @root.to_h.map do |key, value|
+            [
+              key.terminate(false).to_s,
+              value
+            ]
+          end
+        ]
+      end
+
+      def each(&block)
+        to_h.each(&block)
+      end
+
+      def key?(key)
+        self[key] != Node::BLANK.first
+      end
+      alias include? key?
+
+      def size
+        @root.tree_size
+      end
+
+      private
+
+      def blank_root
+        @blank_root ||= Config.digest.hexdigest(RLP.encode('')).freeze
+      end
+    end
+  end
+end

data/lib/dcha/packet_manager.rb

@@ -0,0 +1,28 @@
+module Dcha
+  # :nodoc:
+  class PacketManager < Hash
+    attr_reader :todo
+
+    def initialize
+      @todo = Queue.new
+    end
+
+    def <<(chunk)
+      self[chunk.tag] ||= []
+      self[chunk.tag] << chunk
+      self[chunk.tag].uniq!
+
+      check(chunk)
+    end
+
+    private
+
+    def check(chunk)
+      return unless self[chunk.tag].size == chunk.total
+      event = Oj.load(self[chunk.tag].sort.map(&:to_s).join)
+      @todo << event
+      # TODO: Release memory if buffer not completed
+      delete(chunk.tag)
+    end
+  end
+end