money-tree 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4fb106149c53cf468220d50f609604835f0771d0
+  data.tar.gz: ae65887642b07d8bcfdefae06452d4b0a91d0f2a
+SHA512:
+  metadata.gz: ea72d026539e19514e95d51a0e2404dfd594b6d524b4debfe491b762d0d1d24f1cc0d3ef0cbd1fb20db29de0403c7d7066d3190f4aca3736853bfd4d6354853a
+  data.tar.gz: c2e21de52d10e2f9d2917be4a6db7cd5e9c8b6588959963ead0648a6b219b479a1c5f67ac45299f0a31ff380562c6a138a449df656988a0ad1310a77f0762860

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in money-tree.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Micah Winkelspecht
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# MoneyTree
+
+MoneyTree is a Ruby implementation of Bitcoin Wallets. Specifically, it supports [Hierachical Deterministic wallets](http://) according to the protocol specified in [BIP0032](https://en.bitcoin.it/wiki/BIP_0032).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'money-tree'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install money-tree
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/money-tree.rb

@@ -0,0 +1,11 @@
+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/money-tree/address.rb

@@ -0,0 +1,15 @@
+module MoneyTree
+  class Address
+    attr_accessor :private_key, :public_key
+    
+    def initialize(opts = {})
+      @private_key = MoneyTree::PrivateKey.new key: opts[:private_key]
+      @public_key = MoneyTree::PublicKey.new(@private_key)
+    end
+    
+    def to_s
+      public_key.to_s
+    end
+
+  end
+end

data/lib/money-tree/key.rb

@@ -0,0 +1,200 @@
+# encoding ascii-8bit
+
+require 'openssl'
+require 'pry'
+
+module MoneyTree
+  class Key
+    include OpenSSL
+    include Support
+    class KeyInvalid < Exception; end
+    class KeyGenerationFailure < Exception; end
+    class KeyImportFailure < Exception; end
+    class KeyFormatNotFound < Exception; end
+    class InvalidWIFFormat < Exception; end
+    
+    attr_reader :options, :key
+    attr_accessor :ec_key
+    
+    GROUP_NAME = 'secp256k1'
+    GROUP_UNCOMPRESSED = "0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8".to_i(16)
+    GROUP_COMPRESSED = "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798".to_i(16)
+    ORDER = "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141".to_i(16)
+    
+    def valid?(eckey = nil)
+      eckey ||= ec_key
+      eckey.nil? ? false : eckey.check_key
+    end
+    
+    def to_bytes
+      hex_to_bytes to_hex
+    end
+    
+    def to_i
+      bytes_to_int to_bytes
+    end
+  end
+  
+  class PrivateKey < Key
+    
+    attr_reader :raw_key
+    
+    def initialize(opts = {})
+      @options = opts
+      # @ec_key = EC_KEY_new_by_curve_name(NID_secp256k1)
+      @ec_key = PKey::EC.new 'secp256k1'
+      if @options[:key]
+        @raw_key = @options[:key]
+        @key = parse_raw_key
+        import
+      else
+        generate
+        @key = to_hex
+      end
+    end
+    
+    def generate
+      ec_key.generate_key
+    end
+    
+    def import
+      ec_key.private_key = BN.new(key, 16)
+      set_public_key
+    end
+    
+    def calculate_public_key(opts = {})
+      opts[:compressed] = true unless opts[:compressed] == false
+      group = ec_key.group
+      group.point_conversion_form = opts[:compressed] ? :compressed : :uncompressed
+      point = group.generator.mul ec_key.private_key
+    end
+    
+    def set_public_key(opts = {})
+      ec_key.public_key = calculate_public_key(opts)
+    end
+    
+    def parse_raw_key
+      result = if raw_key.is_a?(Bignum) then int_to_hex(raw_key)
+      elsif hex_format? then raw_key
+      elsif compressed_wif_format? then from_wif
+      elsif uncompressed_wif_format? then from_wif
+      elsif base64_format? then from_base64
+      else 
+        raise raw_key.inspect
+        raise KeyFormatNotFound
+      end
+      result.downcase
+    end
+    
+    def from_wif(wif = raw_key)
+      compressed = wif.length == 52
+      validate_wif(wif)
+      hex = decode_base58(wif)
+      last_char = compressed ? -11 : -9
+      hex.slice(2..last_char)
+    end
+    
+    def from_base64
+      decode_base64(raw_key)
+    end
+    
+    def compressed_wif_format?
+      raw_key.length == 52 && MoneyTree::NETWORKS[:bitcoin][:compressed_wif_chars].include?(raw_key.slice(0))
+    end
+    
+    def uncompressed_wif_format?
+      raw_key.length == 51 && raw_key.slice(0) == MoneyTree::NETWORKS[:bitcoin][:uncompressed_wif_char]
+    end
+    
+    def base64_format?
+      raw_key.length == 44
+    end
+    
+    def hex_format?
+      raw_key.length == 64 && !raw_key[/\H/]
+    end
+    
+    def to_hex
+      int_to_hex @ec_key.private_key
+    end
+    
+    def to_wif(opts = {})
+      opts[:compressed] = true unless opts[:compressed] == false
+      source = MoneyTree::NETWORKS[:bitcoin][:privkey_version] + to_hex
+      source += MoneyTree::NETWORKS[:bitcoin][:privkey_compression_flag] if opts[:compressed]
+      hash = sha256(source)
+      hash = sha256(hash)
+      checksum = hash.slice(0..7)
+      source_with_checksum = source + checksum
+      encode_base58(source_with_checksum)
+    end
+
+    def wif_valid?(wif)
+      hex = decode_base58(wif)
+      return false unless hex.slice(0..1) == MoneyTree::NETWORKS[:bitcoin][:privkey_version]
+      checksum = hex.chars.to_a.pop(8).join
+      source = hex.slice(0..-9)
+      hash = sha256(source)
+      hash = sha256(hash)
+      hash_checksum = hash.slice(0..7)
+      checksum == hash_checksum
+    end
+    
+    def validate_wif(wif)
+      raise InvalidWIFFormat unless wif_valid?(wif)
+    end
+    
+    def to_base64
+      encode_base64(to_hex)
+    end
+    
+    def to_s
+      to_wif
+    end
+    
+  end
+  
+  class PublicKey < Key
+    attr_reader :private_key
+    
+    def initialize(p_key, opts = {})
+      raise "Must initialize with a MoneyTree::PrivateKey" unless p_key.is_a?(PrivateKey)
+      @private_key = p_key
+      @ec_key = @private_key.ec_key
+      @options = opts
+      @key = @options[:key] || to_hex
+    end
+    
+    def to_hex(opts = {})
+      int_to_hex to_i(opts)
+    end
+    
+    def to_i(opts = {})
+      private_key.calculate_public_key(opts).to_bn.to_i
+    end
+    
+    def to_ripemd160(opts = {})
+      hash = sha256 to_hex(opts)
+      ripemd160 hash
+    end
+    
+    def to_address(opts = {})
+      hash = to_ripemd160(opts)
+      address = MoneyTree::NETWORKS[:bitcoin][:address_version] + hash
+      to_serialized_base58 address
+    end
+    
+    def to_fingerprint(opts = {})
+      hash = to_ripemd160(opts)
+      hash.slice(0..7)
+    end
+
+    def to_s(opts = {})
+      to_address(opts)
+    end
+    
+    def to_bytes(opts = {})
+      int_to_bytes to_i(opts)
+    end
+  end
+end

data/lib/money-tree/networks.rb

@@ -0,0 +1,15 @@
+module MoneyTree
+  NETWORKS = {
+    bitcoin: {
+      address_version: '00',
+      p2sh_version: '05',
+      privkey_version: '80',
+      privkey_compression_flag: '01',
+      extended_privkey_version: "0488ade4",
+      extended_pubkey_version: "0488b21e",
+      compressed_wif_chars: %w(K L),
+      uncompressed_wif_char: '5',
+      protocol_version: 70001
+    }
+  }
+end

data/lib/money-tree/node.rb

@@ -0,0 +1,232 @@
+module MoneyTree
+  class Node
+    include Support
+    attr_reader :private_key, :public_key, :chain_code, :is_private, :depth, :index, :parent
+    
+    class PublicDerivationFailure < Exception; end
+    class InvalidKeyForIndex < Exception; end
+    
+    def initialize(opts = {})
+      @depth = opts[:depth]
+      @index = opts[:index]
+      @is_private = opts[:is_private]
+      @private_key = opts[:private_key]
+      @public_key = opts[:public_key]
+      @chain_code = opts[:chain_code]
+      @parent = opts[:parent]
+    end
+    
+    def is_private?
+      is_private == true
+    end
+    
+    def index_hex(i = index)
+      i.to_s(16).rjust(8, "0")
+    end
+    
+    def depth_hex(depth)
+      depth.to_s(16).rjust(2, "0")
+    end
+    
+    def private_derivation_private_key_message(i)
+      "\x00" + private_key.to_bytes + i_as_bytes(i)
+    end
+    
+    def public_derivation_private_key_message(i)
+      public_key.to_bytes << i_as_bytes(i)
+    end
+    
+    # TODO: Complete public key derivation message
+    # def public_derivation_public_key_message(i)
+    #   public_key.to_bytes + i_as_bytes(i)
+    # end
+    
+    def i_as_bytes(i)
+      [i].pack('N')
+    end
+    
+    def derive_private_key(i = 0)
+      message = i >= 0x80000000 ? private_derivation_private_key_message(i) : public_derivation_private_key_message(i)
+      hash = hmac_sha512 int_to_bytes(chain_code), message
+      left_int = left_from_hash(hash)
+      raise InvalidKeyForIndex if left_int >= MoneyTree::Key::ORDER # very low probability
+      child_private_key = (left_int + private_key.to_i) % MoneyTree::Key::ORDER
+      raise InvalidKeyForIndex if child_private_key == 0 # very low probability
+      child_chain_code = right_from_hash(hash)
+      return child_private_key, child_chain_code
+    end
+    
+    def left_from_hash(hash)
+      bytes_to_int hash.bytes.to_a[0..31]
+    end
+    
+    def right_from_hash(hash)
+      bytes_to_int hash.bytes.to_a[32..-1]
+    end
+
+    # TODO: Complete public key derivation
+    # def derive_public_key(i = 0, opts = {})
+    #   raise PublicDerivationFailure unless i < 0x80000000
+    #   hash = hmac_sha512([chain_code].pack("H*"), public_key.to_hex + index_hex(i))
+    #   temp_key = MoneyTree::PrivateKey.new key: hash[0..63]
+    #   temp_pub_key = MoneyTree::PublicKey.new temp_key
+    #   child_public_key = (temp_key.to_hex.to_i(16) + temp_pub_key.to_hex.to_i(16))
+    #   child_chain_code = hash[64..-1]
+    #   return child_public_key, child_chain_code
+    # end
+    
+    def to_serialized_hex(type = :public)
+      version_key = type.to_sym == :private ? :extended_privkey_version : :extended_pubkey_version
+      hex = MoneyTree::NETWORKS[:bitcoin][version_key] # version (4 bytes)
+      hex += depth_hex(depth) # depth (1 byte)
+      hex += depth.zero? ? '00000000' : parent.to_fingerprint# fingerprint of key (4 bytes)
+      hex += index_hex(index) # child number i (4 bytes)
+      hex += chain_code_hex
+      hex += type.to_sym == :private ? "00#{private_key.to_hex}" : public_key.to_hex
+    end
+    
+    def to_serialized_address(type = :public)
+      to_serialized_base58 to_serialized_hex(type)
+    end
+    
+    def to_identifier
+      public_key.to_ripemd160
+    end
+    
+    def to_fingerprint
+      to_identifier[0..7]
+    end
+    
+    def to_address
+      address = MoneyTree::NETWORKS[:bitcoin][:address_version] + to_identifier
+      to_serialized_base58 address
+    end
+    
+    def subnode(i = 0, opts = {})
+      # opts[:as_private] = is_private? unless opts[:as_private] == false
+      child_private_key, child_chain_code = derive_private_key(i)
+      child_private_key = MoneyTree::PrivateKey.new key: child_private_key
+      child_public_key = MoneyTree::PublicKey.new child_private_key
+      
+      MoneyTree::Node.new depth: depth+1, 
+                                index: i, 
+                                is_private: i >= 0x80000000,
+                                private_key: child_private_key,
+                                public_key: child_public_key,
+                                chain_code: child_chain_code,
+                                parent: self
+    end
+    
+    # path: a path of subkeys denoted by numbers and slashes. Use
+    #     p or i<0 for private key derivation. End with .pub to force
+    #     the key public.
+    # 
+    # Examples:
+    #     1p/-5/2/1 would call subkey(i=1, is_prime=True).subkey(i=-5).
+    #         subkey(i=2).subkey(i=1) and then yield the private key
+    #     0/0/458.pub would call subkey(i=0).subkey(i=0).subkey(i=458) and
+    #         then yield the public key
+    # 
+    # You should choose either the p or the negative number convention for private key derivation.
+    def node_for_path(path)
+      force_public = path[-4..-1] == '.pub'
+      path = path[0..-4] if force_public
+      parts = path.split('/')
+      nodes = []
+      parts.each_with_index do |part, depth|
+        if part =~ /m/i
+          nodes << self
+        else
+          i = parse_index(part)
+          nodes << nodes.last.subnode(i)
+        end
+      end
+      nodes.last
+    end
+    
+    def parse_index(path_part)
+      is_prime = %w(p ').include? path_part[-1]
+      i = path_part.to_i
+      
+      i = if i < 0
+        i
+      elsif is_prime
+        i | 0x80000000
+      else
+        i & 0x7fffffff
+      end
+    end
+    
+    def chain_code_hex
+      int_to_hex chain_code
+    end
+  end
+  
+  class Master < Node
+    module SeedGeneration
+      class Failure < Exception; end
+      class RNGFailure < Failure; end
+      class LengthFailure < Failure; end
+      class ValidityError < Failure; end
+      class ImportError < Failure; end
+      class TooManyAttempts < Failure; end
+    end
+    
+    HD_WALLET_BASE_KEY = "Bitcoin seed"
+    RANDOM_SEED_SIZE = 32
+    
+    attr_reader :seed, :seed_hash
+    
+    def initialize(opts = {})
+      @depth = 0
+      @index = 0
+      @is_private = true
+      @seed_generation_attempt = 0
+      opts[:seed] = [opts[:seed_hex]].pack("H*") if opts[:seed_hex]
+      if opts[:seed]
+        @seed = opts[:seed]
+        @seed_hash = generate_seed_hash(@seed)
+        raise SeedGeneration::ImportError unless seed_valid?(@seed_hash)
+      else
+        generate_seed_until_valid
+      end
+      set_master_keys
+    end
+    
+    def generate_seed_until_valid
+      begin
+        @seed = generate_seed
+        @seed_hash = generate_seed_hash(@seed)
+        raise SeedGeneration::ValidityError unless seed_valid?(@seed_hash)
+        @seed_generation_attempt = 0
+      rescue SeedGeneration::Failure
+        @seed_generation_attempt += 1
+        @seed_generation_attempt < 10 ? generate_seed_until_valid : raise(SeedGeneration::TooManyAttempts)
+      end
+    end
+    
+    def generate_seed
+      OpenSSL::Random.random_bytes(32)
+    end
+    
+    def generate_seed_hash(seed)
+      hmac_sha512 HD_WALLET_BASE_KEY, seed
+    end
+    
+    def seed_valid?(seed_hash)
+      return false unless seed_hash.bytesize == 64
+      master_key = left_from_hash(seed_hash)
+      !master_key.zero? && master_key < MoneyTree::Key::ORDER
+    end
+    
+    def is_hex?(str)
+      str =~ /^[0-9A-F]+$/i && str.length % 2 == 0
+    end
+
+    def set_master_keys
+      @private_key = MoneyTree::PrivateKey.new key: left_from_hash(seed_hash)
+      @chain_code = right_from_hash(seed_hash)
+      @public_key = MoneyTree::PublicKey.new @private_key
+    end
+  end
+end