liability-proof 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 977147c8250bb363215bad2fd155bc13aec6269f
+  data.tar.gz: c84794a53390071cb9800bf692eff4c0e2bf2b0d
+SHA512:
+  metadata.gz: 662738943559c4e770f91d11de77a39af291418c775b8a0b7a774aa710bf5d51e3f5a60e26a887c4486676c815df9eb1615314391ce65e2d82861eac84dbae89
+  data.tar.gz: e5e98a75e127860b41ed67cc102a8bc370c0ffdea3b6960daf59b9599ea346e7e5fec3311307d8ec2a7d6a9683949f6ea64f9d0a3104bb75f1cfd19035e2f395

data/README.markdown

@@ -0,0 +1,44 @@
+Liability Proof
+===============
+
+If you're not familiar with *liability proof* or *the Merkle approach*, check this page: [Proving Your Bitcoin Reserves](https://iwilcox.me.uk/2014/proving-bitcoin-reserves). Basically, every mordern exchanges should prove they really hold the bitcoins/money they claim to.
+
+### Requirements ###
+
+* ruby 2.0.0 or higher (if you want to run 'rake test' in this gem you'll need ruby 2.1.0 or higher)
+* openssl
+
+### Install ###
+
+    gem install liability-proof
+
+### Usage ###
+
+As command line tool:
+
+    # Generate root.json and partial tree json for each account in accounts.json.
+    # The generated file format conforms with the standard in progress:
+    # https://github.com/olalonde/blind-liability-proof#serialized-data-formats-work-in-progress--draft
+    lproof generate -f accounts.json
+
+    # verify specified partial tree is valid, i.e. the root node calculated from
+    # from the partial tree matches the root node in root.json
+    lproof verify -r root.json -f partial_trees/jan.json
+
+As library: check `LiabilityProof::Generator` and `LiabilityProof::Verifier` for example.
+
+### License ###
+
+LiabilityProof is a ruby gem released under MIT license. See [http://peatio.mit-license.org](http://peatio.mit-license.org) for more information.
+
+### How To Contribute ###
+
+Just create an issue or open a pull request :)
+
+### Other implementations ###
+
+* clojure: https://github.com/zw/PoLtree/blob/master/src/uk/me/iwilcox/poltree.clj
+* node.js: http://olalonde.github.io/blind-liability-proof
+* c++: https://github.com/bifubao/proof_of_reserves
+* python: https://github.com/ConceptPending/proveit
+

data/bin/lproof

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'liability-proof'
+require 'optparse'
+
+options = {}
+
+opt_parser = OptionParser.new do |opt|
+  opt.banner = "Usage: #{$0} COMMAND [OPTIONS]"
+  opt.separator ""
+  opt.separator "Commands"
+  opt.separator "    generate: generate json of root node and partial trees"
+  opt.separator "    verify: verify specified partial tree is valid (matches root node)"
+  opt.separator ""
+  opt.separator "Options"
+
+  opt.on("-f", "--file source.json", "Specify source file. For generate command, it should contain accounts data; for verify command, it should contain the partial tree.") do |f|
+    options[:file] = f
+  end
+
+  opt.on("-r", "--root root.json", "Specify root node data file. For generate command it's the destination to write data; for verify command it's the source to read data.") do |f|
+    options[:root] = f
+  end
+
+  options[:partial_trees_dir] = 'partial_trees'
+  opt.on("--partial-trees-dir DIR", "Specify the directory to store generated partial tree json files, default to 'partial_trees'.") do |d|
+    options[:partial_trees_dir] = d
+  end
+end
+
+opt_parser.parse!
+
+case ARGV[0]
+when 'generate'
+  LiabilityProof::Generator.new(options).write!
+when 'verify'
+  LiabilityProof::Verifier.new(options).verify!
+else
+  puts opt_parser
+end

data/lib/liability-proof.rb

@@ -0,0 +1,13 @@
+module LiabilityProof
+
+  autoload :Tree,      'liability-proof/tree'
+  autoload :Generator, 'liability-proof/generator'
+  autoload :Verifier,  'liability-proof/verifier'
+
+  module_function
+
+  def sha256_base64(message)
+    Base64.encode64(OpenSSL::Digest::SHA256.new.digest(message)).strip
+  end
+
+end

data/lib/liability-proof/generator.rb

@@ -0,0 +1,48 @@
+require 'json'
+require 'fileutils'
+
+module LiabilityProof
+  class Generator
+
+    def initialize(options)
+      @accounts_path     = options.delete(:file) || 'accounts.json'
+      @root_path         = options.delete(:root) || 'root.json'
+
+      @partial_trees_dir = options.delete(:partial_trees_dir) || 'partial_trees'
+      FileUtils.mkdir @partial_trees_dir unless File.exists?(@partial_trees_dir)
+
+      accounts = JSON.parse File.read(@accounts_path)
+      @tree    = LiabilityProof::Tree.new accounts
+    end
+
+    def root_json
+      { 'root' => {
+          'hash'  => @tree.root.hash,
+          'value' => @tree.root.value_string }}
+    end
+
+    def partial_tree_json(user)
+      { 'partial_tree' => @tree.partial(user) }
+    end
+
+    def write!
+      write_root_json
+      @tree.indices.keys.each {|user| write_partial_tree(user) }
+    end
+
+    private
+
+    def write_root_json
+      File.open(@root_path, 'w') do |f|
+        f.write JSON.dump(root_json)
+      end
+    end
+
+    def write_partial_tree(user)
+      File.open(File.join(@partial_trees_dir, "#{user}.json"), 'w') do |f|
+        f.write JSON.dump(partial_tree_json(user))
+      end
+    end
+
+  end
+end

data/lib/liability-proof/tree.rb

@@ -0,0 +1,82 @@
+require 'base64'
+require 'bigdecimal'
+require 'openssl'
+
+module LiabilityProof
+  class Tree
+
+    autoload :Node, 'liability-proof/tree/node'
+    autoload :LeafNode, 'liability-proof/tree/leaf_node'
+    autoload :InteriorNode, 'liability-proof/tree/interior_node'
+
+    attr :root, :indices
+
+    def initialize(accounts)
+      raise ArgumentError, 'accounts is empty' unless accounts && accounts.size > 0
+
+      @accounts = accounts
+      @root     = generate
+      @indices  = Hash[index_leaves(@root)]
+    end
+
+    def partial(user)
+      h = { 'data' => nil }
+      _partial user, @root, @indices[user].dup, h
+      h
+    end
+
+    private
+
+    def _partial(user, node, index, acc)
+      if node.is_a?(LeafNode)
+        acc['data'] = node.as_json
+
+        if node.user == user
+          acc['data'].merge!({
+            'user'  => user,
+            'nonce' => node.nonce
+          })
+        end
+      else
+        follow_direction = index.shift
+        other_direction  = follow_direction == :left ? :right : :left
+        follow_child     = node.send follow_direction
+        other_child      = node.send other_direction
+
+        acc[other_direction.to_s]  = { 'data' => other_child.as_json }
+        acc[follow_direction.to_s] = { 'data' => nil }
+        _partial user, follow_child, index, acc[follow_direction.to_s]
+      end
+    end
+
+    def generate
+      leaves = @accounts.map {|a| LeafNode.new(a) }
+      combine leaves
+    end
+
+    def combine(nodes)
+      return nodes.first if nodes.size <= 1
+
+      parents = nodes.each_slice(2).map do |(left, right)|
+        # if right is not nil, return combined interior node;
+        # otherwise keep the left leaf node
+        right ? InteriorNode.new(left, right) : left
+      end
+
+      combine parents
+    end
+
+    # Walk the tree and produce indices, each index include the destination
+    # leaf and the path from given node to it.
+    #
+    # The path is expressed as an array of directions, e.g. :left, :right
+    def index_leaves(node, index=[])
+      if node.is_a?(LeafNode)
+        [[node.user, index]]
+      else
+        index_leaves(node.left, index+[:left]) + index_leaves(node.right, index+[:right])
+      end
+    end
+
+  end
+end

data/lib/liability-proof/tree/interior_node.rb

@@ -0,0 +1,23 @@
+module LiabilityProof
+  class Tree
+
+    class InteriorNode < Struct.new(:left, :right, :value, :hash)
+      include ::LiabilityProof::Tree::Node
+
+      def initialize(left, right)
+        super(left, right)
+
+        self.value = left.value + right.value
+        self.hash  = generate_hash
+      end
+
+      private
+
+      def generate_hash
+        LiabilityProof.sha256_base64 "#{value_string}#{left.hash}#{right.hash}"
+      end
+
+    end
+
+  end
+end

data/lib/liability-proof/tree/leaf_node.rb

@@ -0,0 +1,34 @@
+module LiabilityProof
+  class Tree
+
+    class LeafNode < Struct.new(:user, :value, :nonce, :hash)
+      include ::LiabilityProof::Tree::Node
+
+      def initialize(account)
+        value = BigDecimal.new(account['value'] || account['balance'])
+        super(account['user'], value)
+
+        self.nonce = account['nonce'] || generate_nonce
+        self.hash  = account['hash']  || generate_hash
+
+        if account['user'] && account['hash'] && account['nonce']
+          raise ArgumentError, "Hash doesn't match" if generate_hash != account['hash']
+        end
+      end
+
+      private
+
+      # a 16 bytes random string encoded in 32 hex digits
+      def generate_nonce
+        OpenSSL::Random.random_bytes(16).unpack("H*").first
+      end
+
+      # a sha256 hash encoded in 64 hex digits
+      def generate_hash
+        LiabilityProof.sha256_base64 "#{user}|#{value_string}|#{nonce}"
+      end
+
+    end
+
+  end
+end

data/lib/liability-proof/tree/node.rb

@@ -0,0 +1,17 @@
+module LiabilityProof
+  class Tree
+
+    module Node
+
+      def as_json
+        { 'value' => value_string, 'hash' => hash }
+      end
+
+      def value_string
+        value.to_s('F')
+      end
+
+    end
+
+  end
+end

data/lib/liability-proof/verifier.rb

@@ -0,0 +1,56 @@
+require 'json'
+
+module LiabilityProof
+  class Verifier
+
+    def initialize(options)
+      @root_path = options.delete(:root) || 'root.json'
+      @partial_tree_path = options.delete(:file)
+    end
+
+    def root_json
+      @root_json ||= JSON.parse File.read(@root_path)
+    end
+
+    def partial_tree_json
+      @partial_tree_json ||= JSON.parse File.read(@partial_tree_path)
+    end
+
+    def expect_root
+      root_json['root']
+    end
+
+    def match?
+      partial_tree = partial_tree_json['partial_tree']
+      reduce(partial_tree).as_json == expect_root
+    end
+
+    def verify!
+      if match?
+        puts "Partial tree verified successfully!\n\n"
+        puts "User: #{@user_node.user}"
+        puts "Balance: #{@user_node.value_string}"
+      else
+        raise "Mismatch! Expected root: #{expect_root.inspect}"
+      end
+    rescue
+      puts "INVALID partial tree!"
+      puts "ERROR: #{$!}"
+    end
+
+    private
+
+    def reduce(node)
+      if node['data']
+        leaf = Tree::LeafNode.new node['data']
+        @user_node = leaf if leaf.user
+        leaf
+      else
+        left  = reduce node['left']
+        right = reduce node['right']
+        Tree::InteriorNode.new(left, right)
+      end
+    end
+
+  end
+end

data/lib/liability-proof/version.rb

@@ -0,0 +1,3 @@
+module LiabilityProof
+  VERSION = '0.0.3'
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: liability-proof
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Peatio Opensource
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-17 00:00:00.000000000 Z
+dependencies: []
+description: Check https://iwilcox.me.uk/2014/proving-bitcoin-reserves for more details.
+email:
+- community@peatio.com
+executables:
+- lproof
+extensions: []
+extra_rdoc_files: []
+files:
+- README.markdown
+- bin/lproof
+- lib/liability-proof.rb
+- lib/liability-proof/generator.rb
+- lib/liability-proof/tree.rb
+- lib/liability-proof/tree/interior_node.rb
+- lib/liability-proof/tree/leaf_node.rb
+- lib/liability-proof/tree/node.rb
+- lib/liability-proof/verifier.rb
+- lib/liability-proof/version.rb
+homepage: https://github.com/peatio/liability-proof
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: An implementation of Greg Maxwell's Merkle approach to prove Bitcoin liabilities.
+test_files: []