mssmt 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2bf77bb8efa4e33fe73b3bd1b54e577e02097fadda8420924caf8df0ad9df21
-  data.tar.gz: a5715d5289504147a0b76f8c3935910df965cae05df2a284136735389f8daa27
+  metadata.gz: e99668bb044c1670cee5d94e301f8113321c04ce9ac06b697fcfa8eabf1668f9
+  data.tar.gz: 7928cf9abd46c85c505dc770c2cbcce33e82ce98c2f7f772872792366bcd6eaa
 SHA512:
-  metadata.gz: 30e1c75109384039d6d87ed9702e7bfbe2848e499285460b67da66dd80668e32590ce409d5deedd64a08ed5cae6f558d40817c73275a271c0b92c6a0f1cab8e0
-  data.tar.gz: 6231535740549dfdb317e122945464ec92789c24479f164058ebdb06a3bfb2cabd688a0b6c0eca4c48881e9a891f5b72532a7609b4ec27edf132f9986f6ad558
+  metadata.gz: 1b0b1648a73caed3a29c764c688b8077dea1beaa65da3772429470fc1ca1eab352b11128538e0e3b4daa2e8c578452360a562a08bd69bebe3bebadd228070f74
+  data.tar.gz: 653ad3b9270105b25a9dfea42414918cc0640cdc9359a7c9c01c712ee503f6689d81ee74796510099c3827fae53209fd2a7325392a36541f64b39447482d6e30

data/README.md

@@ -36,9 +36,9 @@ tree.insert(key, leaf)
 # Get root node
 root_node = tree.root_node
 # Root hash
-root_hash = tree.root_hash
+root_hash = tree.root_hash.unpack1('H*')
 # or
-root_node.node_hash
+root_node.node_hash.unpack1('H*')
 
 # Get leaf node in tree
 leaf = tree.get(key)

data/lib/mssmt/branch_node.rb

@@ -16,10 +16,19 @@ module MSSMT
       @left = left
       @right = right
       @sum = left.sum + right.sum
+      warn("sum:#{@sum} cause overflow.") if @sum > 0xffffffffffffffff # TODO
+      @sum = (@sum & 0xffffffffffffffff)
       @node_hash =
         Digest::SHA256.digest(
           "#{left.node_hash}#{right.node_hash}#{[@sum].pack("Q>")}"
         )
     end
+
+    # Check whether same branch|computed node or not.
+    # @return [Boolean]
+    def ==(other)
+      return false unless [BranchNode, ComputedNode].include?(other.class)
+      node_hash == other.node_hash && sum == other.sum
+    end
   end
 end

data/lib/mssmt/computed_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MSSMT
+  # Node within a MS-SMT that has already had its node_hash and sum computed, i.e., its preimage is not available.
+  class ComputedNode
+    attr_reader :node_hash, :sum
+
+    # Constructor
+    # @param [String] node_hash node hash with binary fomat.
+    # @param [Integer] sum
+    def initialize(node_hash, sum)
+      @node_hash = node_hash
+      warn("sum: #{sum} cause overflow.") if sum > 0xffffffffffffffff # TODO
+      @sum = sum
+    end
+
+    def ==(other)
+      return false unless [BranchNode, ComputedNode].include?(other.class)
+      node_hash == other.node_hash && sum == other.sum
+    end
+  end
+end

data/lib/mssmt/leaf_node.rb

@@ -10,7 +10,8 @@ module MSSMT
     # @param [Integer] sum integer value associated with the value
     def initialize(value, sum)
       @value = value
-      @sum = sum
+      warn("sum: #{sum} cause overflow.") if sum > 0xffffffffffffffff # TODO
+      @sum = sum & 0xffffffffffffffff
     end
 
     # Generate empty leaf node.
@@ -30,5 +31,10 @@ module MSSMT
     def empty?
       (value.nil? or value.empty?) && sum.zero?
     end
+
+    def ==(other)
+      return false unless other.is_a?(LeafNode)
+      node_hash == other.node_hash
+    end
   end
 end

data/lib/mssmt/proof.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+module MSSMT
+  # Merkle proof for MS-SMT.
+  class Proof
+    attr_reader :nodes
+
+    # Constructor
+    # @param [Array(MSSMT::BranchNode|MSSMT::LeafNode)] nodes Siblings that should be hashed with the leaf and
+    # its parents to arrive at the root of the MS-SMT.
+    def initialize(nodes)
+      @nodes = nodes
+    end
+
+    # Compresses a merkle proof by replacing its empty nodes with a bit vector.
+    # @return [MSSMT::CompressedProof]
+    def compress
+      bits = Array.new(nodes.length, false)
+      compact_nodes = []
+      nodes.each.each_with_index do |node, i|
+        if node.node_hash == Tree.empty_tree[Tree::MAX_LEVEL - i].node_hash
+          bits[i] = true
+        else
+          compact_nodes << node
+        end
+      end
+      CompressedProof.new(compact_nodes, bits)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Proof)
+      nodes == other.nodes
+    end
+  end
+
+  # Compressed MS-SMT merkle proof.
+  # Since merkle proofs for a MS-SMT are always constant size (255 nodes),
+  # we replace its empty nodes by a bit vector.
+  class CompressedProof < Proof
+    attr_reader :bits
+
+    # Constructor
+    # @param [Array(MSSMT::BranchNode|MSSMT::LeafNode)] nodes Siblings that should be hashed with the leaf and
+    # its parents to arrive at the root of the MS-SMT.
+    # @param [Array] bits +bits+ determines whether a sibling node within a proof is part of the empty tree.
+    # This allows us to efficiently compress proofs by not including any pre-computed nodes.
+    def initialize(nodes, bits)
+      super(nodes)
+      @bits = bits
+    end
+
+    # Decode compressed proof.
+    # @param [String] compressed proof with binary fomat.
+    # @return [MSSMT::CompressedProof]
+    def self.decode(data)
+      buf = data.is_a?(StringIO) ? data : StringIO.new(data)
+      nodes_len = buf.read(2).unpack1("n")
+      nodes =
+        nodes_len.times.map do
+          ComputedNode.new(buf.read(32), buf.read(8).unpack1("Q>"))
+        end
+      bytes = buf.read(MSSMT::Tree::MAX_LEVEL / 8)
+      bits = unpack_bits(bytes.unpack("C*"))
+      CompressedProof.new(nodes, bits)
+    end
+
+    # Decompress a compressed merkle proof by replacing its bit vector with the empty nodes it represents.
+    # @return [MSSMT::Proof]
+    def decompress
+      count = 0
+      full_nodes = []
+      bits.each.with_index do |b, i|
+        if b
+          full_nodes << Tree.empty_tree[Tree::MAX_LEVEL - i]
+        else
+          full_nodes << nodes[count]
+          count += 1
+        end
+      end
+      Proof.new(full_nodes)
+    end
+
+    # Encode the compressed proof.
+    # @return [String] encoded string.
+    def encode
+      buf = [nodes.length].pack("n")
+      nodes.each do |node|
+        buf << node.node_hash
+        buf << [node.sum].pack("Q>")
+      end
+      buf << pack_bits.pack("C*")
+      buf
+    end
+
+    def ==(other)
+      return false unless other.is_a?(CompressedProof)
+      bits == other.bits && nodes == other.nodes
+    end
+
+    private
+
+    def pack_bits
+      bytes = Array.new((bits.length + 8 - 1) / 8, 0)
+      bits.each_with_index do |b, i|
+        next unless b
+        byte_index = i / 8
+        bit_index = i % 8
+        bytes[byte_index] |= (1 << bit_index)
+      end
+      bytes
+    end
+
+    def self.unpack_bits(bytes)
+      bit_len = bytes.length * 8
+      bits = Array.new(bit_len, false)
+      bit_len.times do |i|
+        byte_index = i / 8
+        bit_index = i % 8
+        bits[i] = ((bytes[byte_index] >> bit_index) & 1) == 1
+      end
+      bits
+    end
+
+    private_class_method :unpack_bits
+  end
+end

data/lib/mssmt/tree.rb

@@ -10,10 +10,29 @@ module MSSMT
     # Index of the last bit for MS-SMT keys
     LAST_BIT_INDEX = MAX_LEVEL - 1
 
-    attr_reader :empty_tree, :store
+    attr_reader :store
+
+    def self.empty_tree
+      @empty_tree ||= build_empty_tree
+    end
+
+    # Generate empty tree.
+    # @return [Array]
+    def self.build_empty_tree
+      tree = Array.new(MSSMT::Tree::MAX_LEVEL + 1)
+      tree[MSSMT::Tree::MAX_LEVEL] = MSSMT::LeafNode.empty_leaf
+      MSSMT::Tree::MAX_LEVEL.times do |i|
+        branch =
+          MSSMT::BranchNode.new(
+            tree[MSSMT::Tree::MAX_LEVEL - i],
+            tree[MSSMT::Tree::MAX_LEVEL - i]
+          )
+        tree[MSSMT::Tree::MAX_LEVEL - (i + 1)] = branch
+      end
+      tree.freeze
+    end
 
     def initialize(store: MSSMT::Store::DefaultStore.new)
-      @empty_tree = build_empty_tree
       @store = store
     end
 
@@ -26,7 +45,7 @@ module MSSMT
     # Get root node in tree.
     # @return [MSSMT::BranchNode]
     def root_node
-      store.root.nil? ? empty_tree[0] : store.root
+      store.root.nil? ? Tree.empty_tree[0] : store.root
     end
 
     # Insert a leaf node at the given key within the MS-SMT.
@@ -49,10 +68,10 @@ module MSSMT
       root =
         walk_up(key, leaf, siblings) do |i, _, _, parent|
           prev_parent = prev_parents[MSSMT::Tree::MAX_LEVEL - 1 - i]
-          unless prev_parent == empty_tree[i].node_hash
+          unless prev_parent == Tree.empty_tree[i].node_hash
             store.delete_branch(prev_parent)
           end
-          unless parent.node_hash == empty_tree[i].node_hash
+          unless parent.node_hash == Tree.empty_tree[i].node_hash
             store.insert_branch(parent)
           end
         end
@@ -76,19 +95,19 @@ module MSSMT
 
     # Generate a merkle proof for the leaf node found at the given +key+.
     # @param [String] key key with hex format.
-    # @return [Array] merkle proof
+    # @return [MSSMT::Proof] merkle proof
     def merkle_proof(key)
       proof = Array.new(MAX_LEVEL)
       walk_down(key) { |i, _, sibling, _| proof[MAX_LEVEL - 1 - i] = sibling }
-      proof
+      MSSMT::Proof.new(proof)
     end
 
     # Verify whether a merkle proof for the leaf found at the given key is valid.
     # @param [String] key key with hex format.
     # @param [MSSMT::LeafNode] leaf leaf node.
-    # @param [Array] proof merkle proof.
+    # @param [MSSMT::Proof] proof merkle proof.
     def valid_merkle_proof?(key, leaf, proof)
-      root_hash == walk_up(key, leaf, proof).node_hash
+      root_hash == walk_up(key, leaf, proof.nodes).node_hash
     end
 
     private
@@ -110,7 +129,7 @@ module MSSMT
     end
 
     def get_node(height, key)
-      return empty_tree[height] if empty_tree[height].node_hash == key
+      return Tree.empty_tree[height] if Tree.empty_tree[height].node_hash == key
       store.branches[key] || store.leaves[key]
     end
 
@@ -152,21 +171,5 @@ module MSSMT
       value = [key].pack("H*")[idx / 8].ord
       (value >> (idx % 8)) & 1
     end
-
-    # Generate empty tree.
-    # @return [Array]
-    def build_empty_tree
-      tree = Array.new(MSSMT::Tree::MAX_LEVEL + 1)
-      tree[MSSMT::Tree::MAX_LEVEL] = MSSMT::LeafNode.empty_leaf
-      MSSMT::Tree::MAX_LEVEL.times do |i|
-        branch =
-          MSSMT::BranchNode.new(
-            tree[MSSMT::Tree::MAX_LEVEL - i],
-            tree[MSSMT::Tree::MAX_LEVEL - i]
-          )
-        tree[MSSMT::Tree::MAX_LEVEL - (i + 1)] = branch
-      end
-      tree
-    end
   end
 end

data/lib/mssmt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MSSMT
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/mssmt.rb

@@ -11,5 +11,8 @@ module MSSMT
   autoload :Store, "mssmt/store"
   autoload :LeafNode, "mssmt/leaf_node"
   autoload :BranchNode, "mssmt/branch_node"
+  autoload :ComputedNode, "mssmt/computed_node"
   autoload :Tree, "mssmt/tree"
+  autoload :Proof, "mssmt/proof"
+  autoload :CompressedProof, "mssmt/proof"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mssmt
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-17 00:00:00.000000000 Z
+date: 2022-10-29 00:00:00.000000000 Z
 dependencies: []
 description: Ruby implementation of Merkle Sum Sparse Merkle Tree
 email:
@@ -32,7 +32,9 @@ files:
 - bin/setup
 - lib/mssmt.rb
 - lib/mssmt/branch_node.rb
+- lib/mssmt/computed_node.rb
 - lib/mssmt/leaf_node.rb
+- lib/mssmt/proof.rb
 - lib/mssmt/store.rb
 - lib/mssmt/store/default_store.rb
 - lib/mssmt/tree.rb