utreexo 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2db0a1b0bb2ecdc1be9477aee62cce16fc9ea24f1febd7c877f819a986ce6250
-  data.tar.gz: c35c3beafff28204c419f650236856b53e89a87e56270886976742718f399fd3
+  metadata.gz: f4df7507cb6f4a66261406b31c0b74ca81070e94fe747f328b09bbbfbf8ce38d
+  data.tar.gz: 275f3c81ee3acf4b1ecfd21dde961c8ac3b5f63627314268f8ef1cec45dd7d7e
 SHA512:
-  metadata.gz: 183873eaba066f361498edd47c1e94edc9d6d3bc891babb1443775dc45de345759c20de657e22eea7d2fcab1554228462675bc7cc58ab5939006c805772a1db0
-  data.tar.gz: 885eeb50daefb5b4cea34fc8463c17bed69e51577e92b2eaec2b24111ed3cf51cbc6606ef763d7e501b3a92455b0b2c00ec82bcc6eded81663116211837cf091
+  metadata.gz: 492bb3babdb31e371d615ebeafa0b25e58fc9e0d6e5a43a3aae934aa719ed580bc9d4507ec5565a65db0c246d6aa3110626f812fc76ee37512adebd1a5ed2bfb
+  data.tar.gz: f4b19fdf737d28475b0f6ce88f1a3f211b6ebdeb9811b391c3779aa9fc88092cb695c25d45685577d6824fbfceb1dba58b959ebf0b6b83a07e3424e90b6cf223

data/README.md

@@ -1,4 +1,4 @@
-# Utreexorb [![Build Status](https://travis-ci.org/chaintope/utreexorb.svg?branch=master)](https://travis-ci.org/chaintope/utreexorb) [![Gem Version](https://badge.fury.io/rb/utreexorb.svg)](https://badge.fury.io/rb/utreexorb) [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)
+# Utreexorb [![Build Status](https://travis-ci.org/chaintope/utreexorb.svg?branch=master)](https://travis-ci.org/chaintope/utreexorb) [![Gem Version](https://badge.fury.io/rb/utreexo.svg)](https://badge.fury.io/rb/utreexo) [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)
 
 This library is a Ruby implementation of [Utreexo](https://github.com/mit-dci/utreexo/blob/master/utreexo.pdf).
 
@@ -26,15 +26,15 @@ Or install it yourself as:
 require 'utreexo'
 
 # initialize forest.
- 
 f = Utreexo::Forest.new
 
 # add element to forest.
 f.add('a00000aa00000000000000000000000000000000000000000000000000000000')
 f.add('a00100aa00000000000000000000000000000000000000000000000000000000')
-f.add('a00200aa00000000000000000000000000000000000000000000000000000000')
-f.add('a00300aa00000000000000000000000000000000000000000000000000000000')
-f.add('a00400aa00000000000000000000000000000000000000000000000000000000')
+# if you want to tracking proof, set tracking flag to true.
+f.add('a00200aa00000000000000000000000000000000000000000000000000000000', true)
+f.add('a00300aa00000000000000000000000000000000000000000000000000000000', true)
+f.add('a00400aa00000000000000000000000000000000000000000000000000000000', true)
 
 # forest has 2 tree, height 2, height 0
 # accumulator root for height 2 tree
@@ -43,14 +43,33 @@ f.acc[2]
 # accumulator root for height 0 tree
 f.acc[0]
 => 'a00400aa00000000000000000000000000000000000000000000000000000000'
+
+# show forest.
+puts f
+07:2d04                         
+|---------------\               |---------------\               
+05:736b         06:1a8e         
+|-------\       |-------\       |-------\       |-------\       
+00:???? 01:???? 02:a002 03:a003 04:a004 
+```
+
+### Get proof
+
+If leaf tracking enabled, you can get its proof. If you add or remove element to the forest, the position and inclusion proof of the leaf being tracked are updated.
+
+```ruby
+proof = f.proof('a00200aa00000000000000000000000000000000000000000000000000000000')
+=> [2] leaf = a00200aa00000000000000000000000000000000000000000000000000000000, siblings = ["a00300aa00000000000000000000000000000000000000000000000000000000", "736b3e12120637186a0a8eef8ce45ed69b39119182cc749b793f05de3996f464"]
+
+# get all tracking proofs
+proofs = f.proofs
 ```
 
 ### Verify element.
 
 ```ruby
 # proof for 3rd element
-proof = Utreexo::Proof.new(2, 'a00200aa00000000000000000000000000000000000000000000000000000000',
-                                   ['a00300aa00000000000000000000000000000000000000000000000000000000', '736b3e12120637186a0a8eef8ce45ed69b39119182cc749b793f05de3996f464'])
+proof = f.proof('a00200aa00000000000000000000000000000000000000000000000000000000')
 
 f.include?(proof)
 => true
@@ -59,8 +78,6 @@ f.include?(proof)
 ### Remove element from forest.
 
 ```ruby
-proof = Utreexo::Proof.new(2, 'a00200aa00000000000000000000000000000000000000000000000000000000',
-                          ['a00300aa00000000000000000000000000000000000000000000000000000000', '736b3e12120637186a0a8eef8ce45ed69b39119182cc749b793f05de3996f464'])
 f.remove(proof)
 
 # If delete 3rd element, last item move to 3rd element position, and root hash changed.

data/lib/utreexo.rb

@@ -8,4 +8,14 @@ module Utreexo
   autoload :Forest, 'utreexo/forest'
   autoload :Proof, 'utreexo/proof'
 
+  module_function
+
+  # Calculate parent hash
+  # @param [String] left left node hash with hex format.
+  # @param [String] right left node hash with hex format.
+  # @return [String] a parent hash with hex format.
+  def parent(left, right)
+    Blake2b.hex([left + right].pack('H*'))
+  end
+
 end

data/lib/utreexo/forest.rb

@@ -6,23 +6,32 @@ module Utreexo
     attr_accessor :num_leaves
 
     # accumulator
-    attr_accessor :acc
+    attr_reader :acc
+
+    # tracking proofs
+    attr_reader :proofs
 
     def initialize
-      @height = 0
       @num_leaves = 0
-      @forest = []
       @acc = []
+      @proofs = []
     end
 
     # Add element to forest.
     # @param [String] leaf an element hash to be added with hex format.
-    def add(leaf)
+    def add(leaf, track = false)
       n = leaf
       h = 0
       r = acc[h]
+      proofs << Utreexo::Proof.new(num_leaves, leaf) if track
       until r.nil? do
-        n = parent(r, n)
+        # Update siblings for tracking proofs
+        p1 = find_proof(r)
+        p1.each{|p|p.siblings << n}
+        p2 = find_proof(n)
+        p2.each{|p|p.siblings << r}
+
+        n = Utreexo.parent(r, n)
         acc[h] = nil
         h += 1
         r = acc[h]
@@ -37,19 +46,40 @@ module Utreexo
       raise Utreexo::Error, 'The target element does not exist in the forest.' unless include?(proof)
       n = nil
       h = 0
+      @num_leaves -= 1
+      fl = forest_leaves
+      # update acc hash
+      is_switch = false
+      has_single_leaf = !acc[0].nil?
       while h < proof.siblings.length do
-        p = proof.siblings[h]
+        s = proof.siblings[h]
         if !n.nil?
-          n = parent(p, n)
+          n = ((1<<h) & proof.position) == 0 ? Utreexo.parent(n, s) : Utreexo.parent(s, n)
         elsif acc[h].nil?
-          acc[h] = p
+          acc[h] = s
         else
-          n = proof.right? ? parent(p, acc[h]) : parent(acc[h], p)
+          # pickup switch pair
+          is_switch = true
+          if has_single_leaf
+            switch_single_leaf(proof, s)
+          else
+            switch_leaf_block(proof, fl, h)
+          end
+          n = (((1<<h) & proof.position) == 0) ? Utreexo.parent(acc[h], s) : Utreexo.parent(s, acc[h])
           acc[h] = nil
         end
         h += 1
       end
       acc[h] = n
+
+      proofs.sort!{|a, b| a.position <=> b.position}
+      proofs.delete(proof)
+
+      # Update proofs
+      remove_unnecessary_siblings!(proof)
+      update_position!(proof) unless  is_switch
+
+      proofs.sort!{|a, b| a.position <=> b.position}
     end
 
     # Whether the element exists in the forest
@@ -60,26 +90,259 @@ module Utreexo
       n = proof.payload
       proof.siblings.each_with_index do |sibling, height|
         if ((1<<height) & proof.position) == 0
-          n = parent(n, sibling)
+          n = Utreexo.parent(n, sibling)
         else
-          n = parent(sibling, n)
+          n = Utreexo.parent(sibling, n)
         end
       end
       n == root
     end
 
+    # Get the current proof being tracked specified by leaf. If not tracking, return nil.
+    # @param [String] leaf
+    # @return [Utreexo::Proof]
+    def proof(leaf)
+      proofs.find{|p|p.payload == leaf}
+    end
+
     # get current height of the highest tree
     # @return [Integer] current height of the highest tree
-    def height
+    def highest_height
       i = acc.reverse.find_index{|i|!i.nil?}
       i ||= 0
       acc.length - i
     end
 
+    # show forest
+    def to_s
+      h = highest_height
+      outs = []
+      index = 0
+      h.times do |i|
+        diff = Math.log2(num_leaves) == (h - 1) ? i + 1 : i
+        row_len = 1 << (h - diff)
+        out = ''
+        line = ''
+        row_items = (num_leaves / (2**i))
+        row_len.times do |j|
+          out << "#{index.to_s.rjust(2, '0')}:"
+          node = (j.even? && (row_items - 1) == j) ? acc[i] : find_node(i, j)
+          out << (node ? "#{node[0..3]} " : "???? ")
+          out << (" " * (2 ** (3 + i)))[0...-8]
+          index += 1
+          break if (j + 2) > row_items
+        end
+        outs << out
+        break if i == (h - 1)
+        (row_len / 2).times do
+          line << '|'
+          line << ('--------' * (2 ** (i))).chop
+          line << "\\"
+          line << (" " * (2 ** (3 + i))).chop
+        end
+        outs << line
+      end
+      outs.reverse.join("\n")
+    end
+
     private
 
-    def parent(left, right)
-      Blake2b.hex([left + right].pack('H*'))
+    def find_node(height, index)
+      return find_proof_at(index)&.payload if height == 0
+      return acc[self.highest_height - 1] if height == (self.highest_height - 1)
+      if height == 1
+        p1 = find_proof_at(index * 2)
+        return Utreexo.parent(p1.payload, p1.siblings[0]) if p1
+        p2 = find_proof_at(index * 2 + 1)
+        return Utreexo.parent(p2.siblings[0], p2.payload) if p2
+      end
+      left_pos = (2 ** height) * index
+      if index.even?
+        left_pos += (2 ** height)
+      else
+        left_pos -= (2 ** height)
+      end
+      right_pos = left_pos + (2 ** height - 1)
+      targets = proofs.select{|p| left_pos <= p.position && p.position <= right_pos}
+      p = targets.find{|p|!p.siblings[height].nil?}
+      p.siblings[height] if p
+    end
+
+    # Calculate the proof associated with the target(self or parent).
+    # @param [String] target a target hash.
+    # @return [Array[Utreexo::Proof]] target proofs.
+    def find_proof(target)
+      proofs.select do |p|
+        n = p.payload
+        p.siblings.each_with_index do|s, h|
+          if ((1<<h) & p.position) == 0
+            n = Utreexo.parent(n, s)
+          else
+            n = Utreexo.parent(s, n)
+          end
+        end
+        n == target
+      end
+    end
+
+    def find_proof_at(index)
+      proofs.find{|p|p.position == index}
+    end
+
+    def remove_unnecessary_siblings!(proof)
+      return unless proof.siblings.size > 0
+      target = proof.payload
+      proofs.select{|p|p.siblings.include?(target)}.each do |p|
+        p.siblings = p.siblings[0...p.siblings.index(target)]
+      end
+      proof.siblings.each_with_index do |s, h|
+        target = ((1<<h) & proof.position) == 0 ? Utreexo.parent(target, s) : Utreexo.parent(s, target)
+        proofs.select{|p|p.siblings.include?(target)}.each do |p|
+          p.siblings = p.siblings[0...p.siblings.index(target)]
+        end
+      end
+    end
+
+    # update position
+    # @param [Utreexo::Proof] proof removed proof
+    def update_position!(proof)
+      proof_pos = proof.position
+      start_index = 0
+      h = highest_height
+      h.times do |i|
+        half_pos = 2 ** (h - (i + 1))
+        threshold = half_pos + start_index
+        proofs.each do |p|
+          next if p.position < start_index
+          if (highest_height - 1) == i
+            p.position -= 1 if proof.left?
+          elsif proof_pos < threshold
+            if p.position >= threshold
+              p.position -= half_pos
+            else
+              p.position += half_pos
+            end
+          end
+        end
+        proof_pos += half_pos if proof_pos < threshold
+        start_index += half_pos
+      end
+    end
+
+    # Get the number of leaves of each tree in the forest in ascending order.
+    # @return [Array[Integer]] the number of leaves of each tree in the forest.
+    def forest_leaves
+      acc.map.with_index{|a, i| a.nil? ? nil : 2 ** i}.compact.reverse
+    end
+
+    # Get the start index and end index of the leaf of the tree with the target leaf number in the forest.
+    # @param [Integer] forest_trees the number of leaves of each tree in the forest.
+    # @param [Integer] target_tree Number of leaves in target tree.
+    # @return [Range] start index and end index at the target tree.
+    def target_tree_range(forest_trees, target_tree)
+      i = forest_trees.index(target_tree)
+      left_pos = 0
+      i.times do |index|
+        left_pos += forest_trees[index]
+      end
+      left_pos..(left_pos + target_tree - 1)
+    end
+
+    # Get leaf tree height at pos.
+    # @param [Integer] pos leaf position.
+    # @return [Integer] tree height.
+    def tree_height(pos)
+      r = 0..0
+      tree_heights = acc.map.with_index{|a, i| a ? i : nil}.reverse
+      tree_heights[tree_heights.index(highest_height - 1)..-1].each do |h|
+        next unless h
+        r = (r.last...(r.last + 2**h))
+        return h if r.include?(pos)
+      end
+    end
+
+    # Switch one leaf and remove leaf in the forest.
+    # @param [Utreexo::Proof] proof proof of removed leaf
+    # @param [String] s currently being processed
+    def switch_single_leaf(proof, s)
+      p0 = proof(acc[0])
+      if p0
+        p0.siblings = proof.siblings
+        p0.position = proof.position
+      end
+      ps = proof(s)
+      ps.siblings[0] = acc[0] if ps
+
+      target = proof.payload
+      new_target = acc[0]
+      proof.siblings.each_with_index do |s, h|
+        if ((1<<h) & proof.position) == 0
+          target = Utreexo.parent(target, s)
+          new_target = Utreexo.parent(new_target, s)
+        else
+          target = Utreexo.parent(s, target)
+          new_target = Utreexo.parent(s, new_target)
+        end
+        proofs.select{|p|p.siblings.include?(target)}.each do |p|
+          p.siblings[p.siblings.index(target)] = new_target
+        end
+      end
+    end
+
+    # Switch leaf blocks to be removed in the forest.
+    # @param [Utreexo::Proof] proof proof of removed leaf
+    # @param [Integer] fl leaves count in the forest.
+    # @param [Integer] h the height currently being processed
+    def switch_leaf_block(proof, fl, h)
+      switch_size = 2 ** h
+      sw_to_range = target_tree_range(fl, switch_size)
+      sw_to = sw_to_range.map {|pos|proofs.find{|p|p.position == pos}}
+      sw_from_range = proof.switch_range(switch_size)
+      sw_from = {}
+      sw_from_range.each {|pos|sw_from[pos] = proofs.find{|p|p.position == pos}}
+      height = proof.tree_height
+      # sort from tree
+      sorted_from = sw_from.sort{|(k1, v1), (k2, v2)| proof.same_subtree_height(k2) <=> proof.same_subtree_height(k1)}
+
+      sw_from_range.each.with_index do |pos, i|
+        from = sorted_from[i][1]
+        to = sw_to[i]
+        if from
+          from.position = sw_to_range.first + i unless proof == from
+          from.siblings.clear if from.payload == proof.siblings[0] # proof's sibling
+        end
+        if to
+          to.position = sw_from_range.first + i
+          to.siblings = to.siblings.slice(0, h) + proof.siblings.slice(-(height - h), height - h)
+        end
+      end
+
+      # Update another branch's siblings in the same tree as the proof
+      updated_parents = proof.switched_parents(acc[h], h)
+      # right branch
+      branch = (sw_from_range.last + 1)..(proof.tree_leaves - 1)
+      branch.each do |pos|
+        p = find_proof_at(pos)
+        next unless p
+        sub_h = proof.same_subtree_height(pos) - 1
+        p.siblings = p.siblings.slice(0, sub_h)
+        (height - sub_h).times do |i|
+          target = acc[p.siblings.size]
+          target = i.even? ? updated_parents[i] : proof.siblings[p.siblings.size] unless target
+          p.siblings << target
+        end
+      end
+      # left branch
+      branch = 0..(sw_from_range.first - 1)
+      branch.each do |pos|
+        p = find_proof_at(pos)
+        next unless p
+        branch_height = Math.log2(branch.size).to_i
+        p.siblings = p.siblings.slice(0, branch_height)
+        (height - branch_height).times do
+          p.siblings << (acc[p.siblings.size] ? acc[p.siblings.size] : proof.siblings[p.siblings.size])
+        end
+      end
     end
 
   end

data/lib/utreexo/proof.rb

@@ -1,9 +1,9 @@
 module Utreexo
   class Proof
 
-    attr_reader :position # where at the bottom of the tree it sits
-    attr_reader :payload  # hash of the thing itself (what's getting proved)
-    attr_reader :siblings # hash of siblings up to a root
+    attr_accessor :position # where at the bottom of the tree it sits
+    attr_reader :payload    # hash of the thing itself (what's getting proved)
+    attr_accessor :siblings   # hash of siblings up to a root
 
     # initialize
     # @param [Integer] position Where at the bottom of the tree it sits
@@ -27,5 +27,73 @@ module Utreexo
       position.even?
     end
 
+    # Show proof
+    def to_s
+      "[#{position}] leaf = #{payload}, siblings = #{siblings}"
+    end
+
+    # Return tree height containing this element
+    # @return [Integer] tree height
+    def tree_height
+      siblings.size
+    end
+
+    # Returns the number of leaves in the tree that contains this element.
+    # @return [Integer] the number of leaves in the tree
+    def tree_leaves
+      2 ** tree_height
+    end
+
+    # Return the position of this proof's pair leaf.
+    # @return [Integer] the position of this proof's pair leaf
+    def pair_pos
+      right? ? position - 1 : position + 1
+    end
+
+    # Returns the position of the leaf that is switched together with this proof, when switching this proof.
+    # @param [Integer] leaves the number of leaves to be switched.
+    # @return [Range] Leaf range to be switched.
+    def switch_range(leaves)
+      l = tree_leaves
+      unit = l / leaves
+      unit.times do |i|
+        range = ((i * leaves)...((i + 1) * leaves))
+        return range.first..(range.last - 1) if range.include?(position)
+      end
+    end
+
+    # When replacing the parent of +height+ of this proof with +parent+ argument, returns the list of parent nodes to be updated.
+    # @param [String] parent the parent value to replace
+    # @param [Integer] parent_height the parent height to replace
+    # @return [Array[String]] a list of updated parents
+    def switched_parents(parent, parent_height)
+      n = parent
+      (tree_height - parent_height).times.map do |i|
+        if ((1<<(i + parent_height)) & position) == 0
+          n = Utreexo.parent(n, siblings[parent_height + i])
+        else
+          n = Utreexo.parent(siblings[parent_height + i], n)
+        end
+        n
+      end
+    end
+
+    # Get the height at which the leaves of +pos+ will be the same tree as the leaves of this proof.
+    # @param [Integer] pos target position
+    # @return [Integer] height
+    def same_subtree_height(pos)
+      raise Utreexo::Error, "pos: #{pos} does not in tree." unless (0...tree_leaves).include?(pos)
+      return 0 if position == pos
+      (tree_height + 1).times do |i|
+        same_group = false
+        groups = tree_leaves / (2 ** i)
+        (tree_leaves / groups).times do |j|
+          group = ((groups * j)...(groups * (j + 1)))
+          same_group = true if group.include?(position) && group.include?(pos)
+        end
+        return  tree_height - (i - 1) unless same_group
+      end
+    end
+
   end
 end

data/lib/utreexo/version.rb

@@ -1,3 +1,3 @@
 module Utreexo
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: utreexo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-16 00:00:00.000000000 Z
+date: 2019-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blake2b