money-tree-extended 0.11.0

data/lib/money-tree/support.rb

@@ -0,0 +1,127 @@
+require 'openssl'
+require 'base64'
+
+module MoneyTree
+  module Support
+    include OpenSSL
+    
+    INT32_MAX = 256 ** [1].pack("L*").size
+    INT64_MAX = 256 ** [1].pack("Q*").size
+    BASE58_CHARS = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+    
+    def int_to_base58(int_val, leading_zero_bytes=0)
+      base58_val, base = '', BASE58_CHARS.size
+      while int_val > 0
+        int_val, remainder = int_val.divmod(base)
+        base58_val = BASE58_CHARS[remainder] + base58_val
+      end
+      base58_val
+    end
+
+    def base58_to_int(base58_val)
+      int_val, base = 0, BASE58_CHARS.size
+      base58_val.reverse.each_char.with_index do |char,index|
+        raise ArgumentError, 'Value not a valid Base58 String.' unless char_index = BASE58_CHARS.index(char)
+        int_val += char_index*(base**index)
+      end
+      int_val
+    end
+
+    def encode_base58(hex)
+      leading_zero_bytes  = (hex.match(/^([0]+)/) ? $1 : '').size / 2
+      ("1"*leading_zero_bytes) + int_to_base58( hex.to_i(16) )
+    end
+
+    def decode_base58(base58_val)
+      s = base58_to_int(base58_val).to_s(16); s = (s.bytesize.odd? ? '0'+s : s)
+      s = '' if s == '00'
+      leading_zero_bytes = (base58_val.match(/^([1]+)/) ? $1 : '').size
+      s = ("00"*leading_zero_bytes) + s  if leading_zero_bytes > 0
+      s
+    end
+    alias_method :base58_to_hex, :decode_base58
+    
+    def to_serialized_base58(hex)
+      hash = sha256 hex
+      hash = sha256 hash
+      checksum = hash.slice(0..7)
+      address = hex + checksum
+      encode_base58 address
+    end
+    
+    def from_serialized_base58(base58)
+      hex = decode_base58 base58
+      checksum = hex.slice!(-8..-1)
+      compare_checksum = sha256(sha256(hex)).slice(0..7)
+      raise EncodingError unless checksum == compare_checksum
+      hex
+    end
+    
+    def digestify(digest_type, source, opts = {})
+      source = [source].pack("H*") unless opts[:ascii]
+      bytes_to_hex Digest.digest(digest_type, source)
+    end
+    
+    def sha256(source, opts = {})
+      digestify('SHA256', source, opts)
+    end
+    
+    def ripemd160(source, opts = {})
+      digestify('RIPEMD160', source, opts)
+    end
+    
+    def encode_base64(hex)
+      Base64.encode64([hex].pack("H*")).chomp
+    end
+    
+    def decode_base64(base64)
+      Base64.decode64(base64).unpack("H*")[0]
+    end
+    
+    def hmac_sha512(key, message)
+      digest = Digest::SHA512.new
+      HMAC.digest digest, key, message
+    end
+    
+    def hmac_sha512_hex(key, message)
+      md = hmac_sha512(key, message)
+      md.unpack("H*").first.rjust(64, '0')
+    end
+    
+    def bytes_to_int(bytes, base = 16)
+      if bytes.is_a?(Array)
+        bytes = bytes.pack("C*")
+      end
+      bytes.unpack("H*")[0].to_i(16)
+    end
+    
+    def int_to_hex(i, size=nil)
+      hex = i.to_s(16).downcase
+      if (hex.size % 2) != 0
+        hex = "#{0}#{hex}"
+      end
+
+      if size
+        hex.rjust(size, "0")
+      else
+        hex
+      end
+    end
+        
+    def int_to_bytes(i)
+      [int_to_hex(i)].pack("H*")
+    end
+    
+    def bytes_to_hex(bytes)
+      bytes.unpack("H*")[0].downcase
+    end
+    
+    def hex_to_bytes(hex)
+      [hex].pack("H*")
+    end
+    
+    def hex_to_int(hex)
+      hex.to_i(16)
+    end
+  end
+end

data/lib/money-tree/version.rb

@@ -0,0 +1,3 @@
+module MoneyTree
+  VERSION = "0.11.0"
+end

data/lib/money-tree.rb

@@ -0,0 +1,12 @@
+require "openssl_extensions"
+require "money-tree/version"
+require "money-tree/support"
+require "money-tree/networks"
+require "money-tree/key"
+require "money-tree/address"
+require "money-tree/networks"
+require "money-tree/node"
+
+module MoneyTree
+  
+end

data/lib/openssl_extensions.rb

@@ -0,0 +1,73 @@
+# encoding: ascii-8bit
+
+require 'openssl'
+require 'ffi'
+
+module MoneyTree
+  module OpenSSLExtensions
+    extend FFI::Library
+    ffi_lib ['libssl.so.1.0.0', 'libssl.so.10', 'libssl1.0.0', 'ssl']
+
+    NID_secp256k1 = 714
+    POINT_CONVERSION_COMPRESSED = 2
+    POINT_CONVERSION_UNCOMPRESSED = 4
+
+    attach_function :EC_KEY_free, [:pointer], :int
+    attach_function :EC_KEY_get0_group, [:pointer], :pointer
+    attach_function :EC_KEY_new_by_curve_name, [:int], :pointer
+    attach_function :EC_POINT_clear_free, [:pointer], :int
+    attach_function :EC_POINT_add, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :EC_POINT_point2hex, [:pointer, :pointer, :int, :pointer], :string
+    attach_function :EC_POINT_hex2point, [:pointer, :string, :pointer, :pointer], :pointer
+    attach_function :EC_POINT_new, [:pointer], :pointer
+    
+    def self.add(point_0, point_1)
+      validate_points(point_0, point_1)
+      eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
+      group = EC_KEY_get0_group(eckey)
+      
+      point_0_hex = point_0.to_bn.to_s(16)
+      point_0_pt = EC_POINT_hex2point(group, point_0_hex, nil, nil)
+      point_1_hex = point_1.to_bn.to_s(16)
+      point_1_pt = EC_POINT_hex2point(group, point_1_hex, nil, nil)
+
+      sum_point = EC_POINT_new(group)
+      success = EC_POINT_add(group, sum_point, point_0_pt, point_1_pt, nil)
+      hex = EC_POINT_point2hex(group, sum_point, POINT_CONVERSION_UNCOMPRESSED, nil)
+
+      EC_KEY_free(eckey)
+      EC_POINT_clear_free(sum_point)
+      EC_POINT_clear_free(point_0_pt)
+      EC_POINT_clear_free(point_1_pt)
+
+      eckey = nil
+      group = nil
+      sum_point = nil
+      point_0_pt = nil
+      point_1_pt = nil
+
+      hex
+    end
+
+    def self.validate_points(*points)
+      points.each do |point|
+        if !point.is_a?(OpenSSL::PKey::EC::Point)
+          raise ArgumentError, "point must be an OpenSSL::PKey::EC::Point object" 
+        elsif point.infinity?
+          raise ArgumentError, "point must not be infinity" 
+        end
+      end
+    end
+  end
+end
+
+
+class OpenSSL::PKey::EC::Point
+  include MoneyTree::OpenSSLExtensions
+  
+  def add(point)
+    sum_point_hex = MoneyTree::OpenSSLExtensions.add(self, point)
+    self.class.new group, OpenSSL::BN.new(sum_point_hex, 16)
+  end
+  
+end

data/money-tree.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'money-tree/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "money-tree-extended"
+  spec.version       = MoneyTree::VERSION
+  spec.authors       = ["Micah Winkelspecht", "Nikhar Ramchunder"]
+  spec.email         = ["winkelspecht@gmail.com"]
+  spec.description   = %q{A Ruby Gem implementation of Bitcoin HD Wallets (Extended)}
+  spec.summary       = %q{Bitcoin Hierarchical Deterministic Wallets in Ruby! (Bitcoin standard BIP0032)}
+  spec.homepage      = "https://github.com/nikharR/money-tree"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  
+  # # used with gem install ... -P HighSecurity
+  # spec.cert_chain  = ["certs/mattatgemco.pem"]
+  # # Sign gem when evaluating spec with `gem` command
+  # #  unless ENV has set a SKIP_GEM_SIGNING
+  # if ($0 =~ /gem\z/) and not ENV.include?("SKIP_GEM_SIGNING")
+  #   spec.signing_key = File.join(Gem.user_home, ".ssh", "gem-private_key.pem")
+  # end
+
+ 
+  spec.add_dependency "ffi"
+    
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "pry"
+end

data/spec/lib/money-tree/address_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe MoneyTree::Address do
+  describe "initialize" do
+    it "generates a private key by default" do
+      address = MoneyTree::Address.new
+      expect(address.private_key.key.length).to eql(64)
+    end
+    
+    it "generates a public key by default" do
+      address = MoneyTree::Address.new
+      expect(address.public_key.key.length).to eql(66)
+    end
+        
+    it "imports a private key in hex form" do
+      address = MoneyTree::Address.new private_key: "5eae5375fb5f7a0ea650566363befa2830ef441bdcb19198adf318faee86d64b"
+      expect(address.private_key.key).to eql("5eae5375fb5f7a0ea650566363befa2830ef441bdcb19198adf318faee86d64b")
+      expect(address.public_key.key).to eql("022dfc2557a007c93092c2915f11e8aa70c4f399a6753e2e908330014091580e4b")
+      expect(address.to_s).to eql("13uVqa35BMo4mYq9LiZrXVzoz9EFZ6aoXe")
+      expect(address.private_key.to_s).to eql("KzPkwAXJ4wtXHnbamTaJqoMrzwCUUJaqhUxnqYhnZvZH6KhgmDPK")
+      expect(address.public_key.to_s).to eql("13uVqa35BMo4mYq9LiZrXVzoz9EFZ6aoXe")
+    end
+    
+    it "imports a private key in compressed wif format" do
+      address = MoneyTree::Address.new private_key: "KzPkwAXJ4wtXHnbamTaJqoMrzwCUUJaqhUxnqYhnZvZH6KhgmDPK"
+      expect(address.private_key.key).to eql("5eae5375fb5f7a0ea650566363befa2830ef441bdcb19198adf318faee86d64b")
+      expect(address.public_key.key).to eql("022dfc2557a007c93092c2915f11e8aa70c4f399a6753e2e908330014091580e4b")
+      expect(address.to_s).to eql("13uVqa35BMo4mYq9LiZrXVzoz9EFZ6aoXe")
+    end
+    
+    it "imports a private key in uncompressed wif format" do
+      address = MoneyTree::Address.new private_key: "5JXz5ZyFk31oHVTQxqce7yitCmTAPxBqeGQ4b7H3Aj3L45wUhoa"
+      expect(address.private_key.key).to eql("5eae5375fb5f7a0ea650566363befa2830ef441bdcb19198adf318faee86d64b")
+      expect(address.public_key.key).to eql("022dfc2557a007c93092c2915f11e8aa70c4f399a6753e2e908330014091580e4b")
+    end
+  end
+  
+  describe "to_s" do
+    before do
+      @address = MoneyTree::Address.new private_key: "5eae5375fb5f7a0ea650566363befa2830ef441bdcb19198adf318faee86d64b"
+    end
+    
+    it "returns compressed base58 public key" do
+      expect(@address.to_s).to eql("13uVqa35BMo4mYq9LiZrXVzoz9EFZ6aoXe")
+      expect(@address.public_key.to_s).to eql("13uVqa35BMo4mYq9LiZrXVzoz9EFZ6aoXe")
+    end
+    
+    it "returns compressed WIF private key" do
+      expect(@address.private_key.to_s).to eql("KzPkwAXJ4wtXHnbamTaJqoMrzwCUUJaqhUxnqYhnZvZH6KhgmDPK")
+    end
+  end
+
+  context "testnet3" do
+    before do
+      @address = MoneyTree::Address.new network: :bitcoin_testnet
+    end
+
+    it "returns a testnet address" do
+      expect(%w(m n)).to include(@address.to_s(network: :bitcoin_testnet)[0])
+    end
+  end
+end