money-tree 0.10.0 → 0.11.1

data/lib/money-tree/support.rb

@@ -1,16 +1,18 @@
-require 'openssl'
-require 'base64'
+require "base64"
+require "bech32"
+require "openssl"
 
 module MoneyTree
   module Support
     include OpenSSL
-    
+    extend self
+
     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
+
+    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
@@ -20,27 +22,28 @@ module MoneyTree
 
     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)
+      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) )
+      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 = 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
@@ -48,7 +51,14 @@ module MoneyTree
       address = hex + checksum
       encode_base58 address
     end
-    
+
+    def to_serialized_bech32(human_readable_part, hex)
+      segwit_addr = Bech32::SegwitAddr.new
+      segwit_addr.hrp = human_readable_part
+      segwit_addr.script_pubkey = "0000" + hex
+      segwit_addr.addr
+    end
+
     def from_serialized_base58(base58)
       hex = decode_base58 base58
       checksum = hex.slice!(-8..-1)
@@ -56,46 +66,46 @@ module MoneyTree
       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)
+      digestify("SHA256", source, opts)
     end
-    
+
     def ripemd160(source, opts = {})
-      digestify('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')
+      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)
+
+    def int_to_hex(i, size = nil)
       hex = i.to_s(16).downcase
       if (hex.size % 2) != 0
         hex = "#{0}#{hex}"
@@ -107,21 +117,36 @@ module MoneyTree
         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
+
+    def encode_p2wpkh_p2sh(value)
+      chk = [Digest::SHA256.hexdigest(Digest::SHA256.digest(value))].pack("H*")[0...4]
+      encode_base58 (value + chk).unpack("H*")[0]
+    end
+
+    def custom_hash_160(value)
+      [OpenSSL::Digest::RIPEMD160.hexdigest(Digest::SHA256.digest(value))].pack("H*")
+    end
+
+    def convert_p2wpkh_p2sh(key_hex, prefix)
+      push_20 = ["0014"].pack("H*")
+      script_sig = push_20 + custom_hash_160([key_hex].pack("H*"))
+      encode_p2wpkh_p2sh(prefix + custom_hash_160(script_sig))
+    end
   end
 end

data/lib/money-tree/version.rb

@@ -1,3 +1,3 @@
 module MoneyTree
-  VERSION = "0.10.0"
+  VERSION = "0.11.1"
 end

data/lib/money-tree.rb

@@ -1,12 +1,11 @@
-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/key"
 require "money-tree/networks"
 require "money-tree/node"
+require "money-tree/version"
+
+require "openssl_extensions"
 
-module MoneyTree
-  
-end
+module MoneyTree; end

data/lib/openssl_extensions.rb

@@ -1,73 +1,30 @@
 # encoding: ascii-8bit
 
-require 'openssl'
-require 'ffi'
+require "openssl"
 
 module MoneyTree
   module OpenSSLExtensions
-    extend FFI::Library
-    ffi_lib ['libssl.so.1.0.0', 'libssl.so.10', 'libssl1.0.0', 'ssl']
+    extend self
 
-    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)
+    def 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)
-      
+      group = OpenSSL::PKey::EC::Group.new("secp256k1")
       point_0_hex = point_0.to_bn.to_s(16)
-      point_0_pt = EC_POINT_hex2point(group, point_0_hex, nil, nil)
+      point_0_pt = OpenSSL::PKey::EC::Point.new(group, OpenSSL::BN.new(point_0_hex, 16))
       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
+      point_1_pt = OpenSSL::PKey::EC::Point.new(group, OpenSSL::BN.new(point_1_hex, 16))
+      sum_point = point_0_pt.add(point_1_pt)
+      sum_point.to_bn.to_s(16)
     end
 
-    def self.validate_points(*points)
+    def 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" 
+          raise ArgumentError, "point must be an OpenSSL::PKey::EC::Point object"
         elsif point.infinity?
-          raise ArgumentError, "point must not be 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

@@ -1,38 +1,30 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'money-tree/version'
+require "money-tree/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "money-tree"
-  spec.version       = MoneyTree::VERSION
-  spec.authors       = ["Micah Winkelspecht"]
-  spec.email         = ["winkelspecht@gmail.com"]
-  spec.description   = %q{A Ruby Gem implementation of Bitcoin HD Wallets}
-  spec.summary       = %q{Bitcoin Hierarchical Deterministic Wallets in Ruby! (Bitcoin standard BIP0032)}
-  spec.homepage      = "https://github.com/gemhq/money-tree"
-  spec.license       = "MIT"
+  spec.name = "money-tree"
+  spec.version = MoneyTree::VERSION
+  spec.authors = ["Micah Winkelspecht", "Afri Schoedon"]
+  spec.email = ["winkelspecht@gmail.com", "gems@q9f.cc"]
+  spec.description = %q{A Ruby Gem implementation of Bitcoin HD Wallets}
+  spec.summary = %q{Bitcoin Hierarchical Deterministic Wallets in Ruby! (Bitcoin standard BIP0032)}
+  spec.homepage = "https://github.com/GemHQ/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.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"
+  spec.metadata = {
+    "homepage_uri" => "https://github.com/GemHQ/money-tree",
+    "source_code_uri" => "https://github.com/GemHQ/money-tree",
+    "github_repo" => "https://github.com/GemHQ/money-tree",
+    "bug_tracker_uri" => "https://github.com/GemHQ/money-tree/issues",
+  }.freeze
+
+  spec.platform = Gem::Platform::RUBY
+  spec.required_ruby_version = ">= 2.6", "< 4.0"
 end

data/spec/{lib/money-tree → money-tree}/address_spec.rb

@@ -1,17 +1,23 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe MoneyTree::Address do
   describe "initialize" do
     it "generates a private key by default" do
       address = MoneyTree::Address.new
+      expect(address).to be
+      expect(address).to be_instance_of MoneyTree::Address
+      expect(address.private_key).to be_instance_of MoneyTree::PrivateKey
       expect(address.private_key.key.length).to eql(64)
     end
-    
+
     it "generates a public key by default" do
       address = MoneyTree::Address.new
+      expect(address).to be
+      expect(address).to be_instance_of MoneyTree::Address
+      expect(address.public_key).to be_instance_of MoneyTree::PublicKey
       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")
@@ -19,37 +25,65 @@ describe MoneyTree::Address do
       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")
+      expect(address.to_p2wpkh_p2sh).to eql("31vNN7WVDxjvc5XZVKW3qV4B3nFLxsRPnE")
+      expect(address.to_bech32).to eql("bc1qrlwlgt5d0sdtq882qvk3jc0sywucn76fwcmqma")
     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")
+      expect(address.to_p2wpkh_p2sh).to eql("31vNN7WVDxjvc5XZVKW3qV4B3nFLxsRPnE")
+      expect(address.to_bech32).to eql("bc1qrlwlgt5d0sdtq882qvk3jc0sywucn76fwcmqma")
     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")
+      expect(@address.to_p2wpkh_p2sh).to eql("31vNN7WVDxjvc5XZVKW3qV4B3nFLxsRPnE")
+      expect(@address.to_bech32).to eql("bc1qrlwlgt5d0sdtq882qvk3jc0sywucn76fwcmqma")
     end
-    
+
     it "returns compressed WIF private key" do
       expect(@address.private_key.to_s).to eql("KzPkwAXJ4wtXHnbamTaJqoMrzwCUUJaqhUxnqYhnZvZH6KhgmDPK")
     end
   end
 
+  context "bitcoin wiki" do
+    # ref https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses
+    subject(:wiki_v1) { MoneyTree::Address.new private_key: "18e14a7b6a307f426a94f8114701e7c8e774e7f9a47e2c2035db29a206321725" }
+
+    it "always regenerates the bitcoin wiki v1 example" do
+      expect(wiki_v1.public_key.key).to eq "0250863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352"
+      expect(wiki_v1.to_s).to eq "1PMycacnJaSqwwJqjawXBErnLsZ7RkXUAs"
+      expect(wiki_v1.to_p2wpkh_p2sh).to eql("3BxwGNjvG4CP14tAZodgYyZ7UTjruYDyAM")
+      expect(wiki_v1.to_bech32).to eql("bc1q7499s50fxu4c0qg23esvm5h8elvqkm33r2tdza")
+    end
+
+    # ref https://en.bitcoin.it/wiki/Bech32
+    subject(:wiki_bech32) { MoneyTree::Address.new private_key: "0000000000000000000000000000000000000000000000000000000000000001" }
+
+    it "always regenerates the bitcoin wiki v1 example" do
+      expect(wiki_bech32.public_key.key).to eq "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
+      expect(wiki_bech32.to_s).to eq "1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH"
+      expect(wiki_bech32.to_p2wpkh_p2sh).to eql("3JvL6Ymt8MVWiCNHC7oWU6nLeHNJKLZGLN")
+      expect(wiki_bech32.to_bech32).to eql("bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4")
+    end
+  end
+
   context "testnet3" do
     before do
       @address = MoneyTree::Address.new network: :bitcoin_testnet

data/spec/money-tree/money_tree_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe MoneyTree do
+  it "0.11.1 works" do
+
+    # placeholder to set up spec in future
+    expect(MoneyTree::VERSION).to eq "0.11.1"
+  end
+end