bitcoinrb 0.2.9 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db45450b62847b14f755e93063e237e6f521a30de9125659dd2325b1b445d5b2
-  data.tar.gz: b1e446e457bdad6cc7d5449ffd7a97cf26fba50f0ec85659aa53584a01ac998d
+  metadata.gz: a5da63d0663778eba1816d008ebf369348bc75d214965b68c2ff7ce564e95ac3
+  data.tar.gz: 2a7e31c9f5b29b72b14e93103f1b69111a2283e390fb61fdad517a5aa764f9f4
 SHA512:
-  metadata.gz: 67767d3f68b7b1656730a43e1dce32c9dff0b43cdd603f813e6de1c4a1b3fe4c5c51784d6afb356db42a2cc230c2fa559e1ebc2f0992afe3bb55b3d635a05ffe
-  data.tar.gz: 4d38a01b81e90b79836c47cfd4912b6f70aba0ca257627fc0aba368ace227ee475b3205263e011c84fc00b43de4e33719b72c65fdddcb81210f5f35b19ba3bbd
+  metadata.gz: b062f7c6e944cac7787fdca7be284224961b9a675467bd6f55fa0d49ed502157507e098aee9b28998f600826d677ddc3f8b26947134591240b5d8ada5e004686
+  data.tar.gz: b32d9705400ac5bfb1cc252e4a79c66ff9fb2d8dcba1f530060b5c130e14726e412a5434d5769dd6824588374cbae99c797ae65a2478a92d53cc5fa664ab5a4e

data/.ruby-version

@@ -1 +1 @@
-2.6.2
+2.7.0

data/.travis.yml

@@ -1,8 +1,9 @@
 language: ruby
 rvm:
-  - 2.4.5
+  - 2.4.6
   - 2.5.5
-  - 2.6.2
+  - 2.6.3
+  - 2.7.0
 addons:
   apt:
     packages:

data/README.md

@@ -9,14 +9,15 @@ NOTE: Bitcoinrb work in progress, and there is a possibility of incompatible cha
 
 Bitcoinrb supports following feature:
 
-* Bitcoin script interpreter(including [BIP-65](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki), [BIP-68](https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki), [BIP-112](https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki))
-* De/serialization of Bitcoin protocol network messages
-* De/serialization of blocks and transactions
+* [Bitcoin script interpreter](https://github.com/chaintope/bitcoinrb/wiki/Script)(including [BIP-65](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki), [BIP-68](https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki), [BIP-112](https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki))
+* [De/serialization of Bitcoin protocol network messages](https://github.com/chaintope/bitcoinrb/wiki/P2P-Message)
+* De/serialization of blocks and [transactions](https://github.com/chaintope/bitcoinrb/wiki/Transaction)
 * Key generation and verification for ECDSA, including [BIP-32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) and [BIP-39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) supports.
 * ECDSA signature(RFC6979 -Deterministic ECDSA, LOW-S, LOW-R support)
 * Segwit support (parsing segwit payload, Bech32 address, sign for segwit tx, [BIP-141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki), [BIP-143](https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki), [BIP-144](https://github.com/bitcoin/bips/blob/master/bip-0144.mediawiki))
 * [BIP-173](https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki) Bech32 address support
 * [BIP-174](https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki) PSBT(Partially Signed Bitcoin Transaction) support
+* [BIP-85](https://github.com/bitcoin/bips/blob/master/bip-0085.mediawiki) Deterministic Entropy From BIP32 Keychains support by `Bitcoin::BIP85Entropy` class.
 * [WIP] SPV node
 * [WIP] 0ff-chain protocol
 
@@ -36,10 +37,10 @@ If you use node features, please install level DB as follows.
 
     $ brew install leveldb
 
-and put `leveldb-ruby` in your Gemfile and run bundle install.
+and put `leveldb-native` in your Gemfile and run bundle install.
 
-```
-gem leveldb-ruby
+```ruby
+gem 'leveldb-native'
 ```
 
 ## Installation

data/bitcoinrb.gemspec

@@ -29,19 +29,19 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'ffi'
   spec.add_runtime_dependency 'leb128', '~> 1.0.0'
   spec.add_runtime_dependency 'eventmachine_httpserver'
-  spec.add_runtime_dependency 'rest-client'
   spec.add_runtime_dependency 'iniparse'
   spec.add_runtime_dependency 'siphash'
   spec.add_runtime_dependency 'protobuf', '3.8.5'
   spec.add_runtime_dependency 'scrypt'
-  spec.add_runtime_dependency 'activesupport', '~> 5.2.3'
+  spec.add_runtime_dependency 'json_pure', '>= 2.3.1'
 
   # for options
-  spec.add_development_dependency 'leveldb-ruby'
+  spec.add_development_dependency 'leveldb-native'
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'timecop'
+  spec.add_development_dependency 'webmock', '~> 3.0'
 
 end

data/exe/bitcoinrbd

@@ -12,6 +12,11 @@ class BitcoinDaemon < DaemonSpawn::Base
     node.run
   end
 
+  def stop
+    puts "Stopping Bitcoinrb daemon : #{Time.now}"
+    node.shutdown
+  end
+
 end
 
 class Bitcoinrbd < Thor

data/lib/bitcoin.rb

@@ -14,6 +14,7 @@ require_relative 'openassets'
 
 module Bitcoin
 
+  autoload :Ext, 'bitcoin/ext'
   autoload :Util, 'bitcoin/util'
   autoload :ChainParams, 'bitcoin/chain_params'
   autoload :Message, 'bitcoin/message'
@@ -52,6 +53,11 @@ module Bitcoin
   autoload :BitStreamWriter, 'bitcoin/bit_stream'
   autoload :BitStreamReader, 'bitcoin/bit_stream'
   autoload :KeyPath, 'bitcoin/key_path'
+  autoload :Descriptor, 'bitcoin/descriptor'
+  autoload :SLIP39, 'bitcoin/slip39'
+  autoload :Aezeed, 'bitcoin/aezeed'
+  autoload :PaymentCode, 'bitcoin/payment_code'
+  autoload :BIP85Entropy, 'bitcoin/bip85_entropy'
 
   require_relative 'bitcoin/constants'
 
@@ -110,6 +116,11 @@ module Bitcoin
       [self].pack('H*')
     end
 
+    # binary convert to integer
+    def bti
+      bth.to_i(16)
+    end
+
     # reverse hex string endian
     def rhex
       htb.reverse.bth
@@ -154,6 +165,12 @@ module Bitcoin
       self[offset..-1]
     end
 
+    # whether value is hex or not hex
+    # @return [Boolean] return true if data is hex
+    def valid_hex?
+      !self[/\H/]
+    end
+
   end
 
   class ::Object
@@ -175,7 +192,7 @@ module Bitcoin
         if value.is_a?(Array)
           result.update(key => value.map{|v|v.to_h})
         else
-          result.update(key => value)
+          result.update(key => value.class.to_s.start_with?("Bitcoin::") ? value.to_h : value)
         end
       end
     end
@@ -191,6 +208,15 @@ module Bitcoin
     def itb
       to_even_length_hex.htb
     end
+
+    # convert bit string
+    def to_bits(length = nil )
+      if length
+        to_s(2).rjust(length, '0')
+      else
+        to_s(2)
+      end
+    end
   end
 
   class ::ECDSA::Signature
@@ -200,4 +226,10 @@ module Bitcoin
     end
   end
 
+  class ::ECDSA::Point
+    def to_hex(compression = true)
+      ECDSA::Format::PointOctetString.encode(self, compression: compression).bth
+    end
+  end
+
 end

data/lib/bitcoin/bip85_entropy.rb

@@ -0,0 +1,111 @@
+module Bitcoin
+
+  # Deterministic Entropy From BIP32 Keychains
+  # https://github.com/bitcoin/bips/blob/master/bip-0085.mediawiki
+  class BIP85Entropy
+
+    BIP85_PATH = 83696968 + HARDENED_THRESHOLD
+
+    include Bitcoin::KeyPath
+
+    attr_reader :root_key #hex format
+
+    # Import root key.
+    # @param [String] base58 master bip32 root key.
+    # @return [Bitcoin::BIP85Entropy]
+    def self.from_base58(base58)
+      key = Bitcoin::ExtKey.from_base58(base58)
+      self.new(key)
+    end
+
+    # derive entropy
+    # @param [String] path derive path.
+    # @return [Tuple(String, Object)] a tuple of entropy with hex format and results depending the application.
+    def derive(path)
+      raise ArgumentError, "Invalid BIP85 path format." unless path.start_with?("m/83696968'")
+      derived_key = root_key
+      parse_key_path(path).each{|num| derived_key = derived_key.derive(num)}
+      derived_key = derived_key.priv
+      entropy = Bitcoin.hmac_sha512("bip-entropy-from-k", derived_key.htb).bth
+      app_no = path.split('/')[2]
+      case app_no
+      when "39'"
+        bip39_entropy(path, entropy)
+      when "2'"
+        hd_seed_entropy(entropy)
+      when "32'"
+        xprv_entropy(entropy)
+      else
+        [entropy, entropy]
+      end
+    end
+
+    private
+
+    def initialize(root_key)
+      @root_key = root_key
+    end
+
+    # derive BIP39 entropy.
+    def bip39_entropy(path, entropy)
+      params = path.split('/')
+      word_len = params[4]
+      language = code_to_language(params[3])
+      entropy = case word_len
+                when "12'"
+                  entropy[0...32]
+                when "18'"
+                  entropy[0...48]
+                when "24'"
+                  entropy[0...64]
+                else
+                  raise ArgumentError, "Word length #{word_len} does not supported."
+                end
+      mnemonic = Bitcoin::Mnemonic.new(language)
+      [entropy, mnemonic.to_mnemonic(entropy)]
+    end
+
+    # derive HD-Seed WIF entropy.
+    def hd_seed_entropy(entropy)
+      result = entropy[0...64]
+      [result, Bitcoin::Key.new(priv_key: result).to_wif]
+    end
+
+    # derive xprv entropy
+    def xprv_entropy(entropy)
+      chaincode = entropy[0...64]
+      private_key = Bitcoin::Key.new(priv_key: entropy[64..-1])
+      ext_key = Bitcoin::ExtKey.new
+      ext_key.key = private_key
+      ext_key.chain_code = chaincode.htb
+      ext_key.depth = 0
+      ext_key.number = 0
+      ext_key.parent_fingerprint = Bitcoin::ExtKey::MASTER_FINGERPRINT
+      [entropy, ext_key.to_base58]
+    end
+
+    # convert language code to language string.
+    def code_to_language(code)
+      case code
+      when "0'"
+        "english"
+      when "1'"
+        "japanese"
+      when "3'"
+        "spanish"
+      when "4'"
+        "chinese_simplified"
+      when "5'"
+        "chinese_traditional"
+      when "6'"
+        "french"
+      when "7'"
+        "italian"
+      else
+        raise ArgumentError, "bitcoinrb does not support language: #{code}"
+      end
+    end
+
+  end
+
+end

data/lib/bitcoin/block_header.rb

@@ -3,6 +3,8 @@ module Bitcoin
   # Block Header
   class BlockHeader
 
+    include Bitcoin::HexConverter
+
     attr_accessor :version
     attr_accessor :prev_hash
     attr_accessor :merkle_root

data/lib/bitcoin/chain_params.rb

@@ -36,9 +36,6 @@ module Bitcoin
 
     attr_accessor :dust_relay_fee
 
-    # fork coin id.
-    attr_accessor :fork_id
-
     # mainnet genesis
     def self.mainnet
       init('mainnet')
@@ -73,11 +70,6 @@ module Bitcoin
       Bitcoin::Block.new(header)
     end
 
-    # whether fork coin.
-    def fork_chain?
-      !fork_id.nil?
-    end
-
     def self.init(name)
       i = YAML.load(File.open("#{__dir__}/chainparams/#{name}.yml"))
       i.dust_relay_fee ||= Bitcoin::DUST_RELAY_TX_FEE

data/lib/bitcoin/chainparams/regtest.yml

@@ -9,7 +9,7 @@ privkey_version: "ef"
 extended_privkey_version: "04358394"
 extended_pubkey_version: "043587cf"
 bip49_pubkey_p2wpkh_p2sh_version: "044a5262"
-bip49_pubkey_p2wsh_p2sh_version: "024285ef"
+bip49_pubkey_p2wsh_p2sh_version: "024289ef"
 bip49_privkey_p2wpkh_p2sh_version: "044a4e28"
 bip49_privkey_p2wsh_p2sh_version: "024285b5"
 bip84_pubkey_p2wpkh_version: "045f1cf6"

data/lib/bitcoin/chainparams/testnet.yml

@@ -9,7 +9,7 @@ privkey_version: "ef"
 extended_privkey_version: "04358394"
 extended_pubkey_version: "043587cf"
 bip49_pubkey_p2wpkh_p2sh_version: "044a5262"
-bip49_pubkey_p2wsh_p2sh_version: "024285ef"
+bip49_pubkey_p2wsh_p2sh_version: "024289ef"
 bip49_privkey_p2wpkh_p2sh_version: "044a4e28"
 bip49_privkey_p2wsh_p2sh_version: "024285b5"
 bip84_pubkey_p2wpkh_version: "045f1cf6"

data/lib/bitcoin/constants.rb

@@ -91,13 +91,6 @@ module Bitcoin
   # Signature hash types/flags
   SIGHASH_TYPE = { all: 1, none: 2, single: 3, anyonecanpay: 128 }
 
-  # SIGHASH_FORK_ID for replay protection of the fork coin
-  SIGHASH_FORK_ID = 0x40
-
-  # fork coin id.
-  FORK_ID_CASH = 0
-  FORK_ID_GOLD = 79
-
   # Maximum number length in bytes
   DEFAULT_MAX_NUM_SIZE = 4
 
@@ -146,9 +139,9 @@ module Bitcoin
   SCRIPT_ERR_SIG_HIGH_S = 54
   SCRIPT_ERR_SIG_NULLDUMMY = 55
   SCRIPT_ERR_PUBKEYTYPE = 56
-  SCRIPT_ERR_CLEANSTACK = 56
-  SCRIPT_ERR_MINIMALIF = 57
-  SCRIPT_ERR_SIG_NULLFAIL = 58
+  SCRIPT_ERR_CLEANSTACK = 57
+  SCRIPT_ERR_MINIMALIF = 58
+  SCRIPT_ERR_SIG_NULLFAIL = 59
 
   # softfork safeness
   SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS = 60

data/lib/bitcoin/descriptor.rb

@@ -0,0 +1,147 @@
+module Bitcoin
+
+  module Descriptor
+
+    include Bitcoin::Opcodes
+
+    # generate P2PK output for the given public key.
+    # @param [String] key private key or public key with hex format
+    # @return [Bitcoin::Script] P2PK script.
+    def pk(key)
+      Bitcoin::Script.new << extract_pubkey(key) << OP_CHECKSIG
+    end
+
+    # generate P2PKH output for the given public key.
+    # @param [String] key private key or public key with hex format.
+    # @return [Bitcoin::Script] P2PKH script.
+    def pkh(key)
+      Bitcoin::Script.to_p2pkh(Bitcoin.hash160(extract_pubkey(key)))
+    end
+
+    # generate P2PKH output for the given public key.
+    # @param [String] key private key or public key with hex format.
+    # @return [Bitcoin::Script] P2WPKH script.
+    def wpkh(key)
+      pubkey = extract_pubkey(key)
+      raise ArgumentError, "Uncompressed key are not allowed." unless compressed_key?(pubkey)
+      Bitcoin::Script.to_p2wpkh(Bitcoin.hash160(pubkey))
+    end
+
+    # generate P2SH embed the argument.
+    # @param [String or Script] script script to be embed.
+    # @return [Bitcoin::Script] P2SH script.
+    def sh(script)
+      script = script.to_hex if script.is_a?(Bitcoin::Script)
+      raise ArgumentError, "P2SH script is too large, 547 bytes is larger than #{Bitcoin::MAX_SCRIPT_ELEMENT_SIZE} bytes." if script.htb.bytesize > Bitcoin::MAX_SCRIPT_ELEMENT_SIZE
+      Bitcoin::Script.to_p2sh(Bitcoin.hash160(script))
+    end
+
+    # generate P2WSH embed the argument.
+    # @param [String or Script] script script to be embed.
+    # @return [Bitcoin::Script] P2WSH script.
+    def wsh(script)
+      script = Bitcoin::Script(script.htb) if script.is_a?(String)
+      raise ArgumentError, "P2SH script is too large, 547 bytes is larger than #{Bitcoin::MAX_SCRIPT_ELEMENT_SIZE} bytes." if script.to_payload.bytesize > Bitcoin::MAX_SCRIPT_ELEMENT_SIZE
+      raise ArgumentError, "Uncompressed key are not allowed." if script.get_pubkeys.any?{|p|!compressed_key?(p)}
+      Bitcoin::Script.to_p2wsh(script)
+    end
+
+    # an alias for the collection of `pk(KEY)` and `pkh(KEY)`.
+    # If the key is compressed, it also includes `wpkh(KEY)` and `sh(wpkh(KEY))`.
+    # @param [String] key private key or public key with hex format.
+    # @return [Array[Bitcoin::Script]]
+    def combo(key)
+      result = [pk(key), pkh(key)]
+      pubkey = extract_pubkey(key)
+      if compressed_key?(pubkey)
+        result << wpkh(key)
+        result << sh(result.last)
+      end
+      result
+    end
+
+    # generate multisig output for given keys.
+    # @param [Integer] threshold the threshold of multisig.
+    # @param [Array[String]] keys an array of keys.
+    # @return [Bitcoin::Script] multisig script.
+    def multi(threshold, *keys, sort: false)
+      raise ArgumentError, 'Multisig threshold is not valid.' unless threshold.is_a?(Integer)
+      raise ArgumentError, 'Multisig threshold cannot be 0, must be at least 1.' unless threshold > 0
+      raise ArgumentError, 'Multisig threshold cannot be larger than the number of keys.' if threshold > keys.size
+      raise ArgumentError, 'Multisig must have between 1 and 16 keys, inclusive.' if keys.size > 16
+      pubkeys = keys.map{|key| extract_pubkey(key) }
+      Bitcoin::Script.to_multisig_script(threshold, pubkeys, sort: sort)
+    end
+
+    # generate sorted multisig output for given keys.
+    # @param [Integer] threshold the threshold of multisig.
+    # @param [Array[String]] keys an array of keys.
+    # @return [Bitcoin::Script] multisig script.
+    def sortedmulti(threshold, *keys)
+      multi(threshold, *keys, sort: true)
+    end
+
+    private
+
+    # extract public key from KEY format.
+    # @param [String] key KEY string.
+    # @return [String] public key.
+    def extract_pubkey(key)
+      if key.start_with?('[') # BIP32 fingerprint
+        raise ArgumentError, 'Invalid key origin.' if key.count('[') > 1 || key.count(']') > 1
+        info = key[1...key.index(']')] # TODO
+        fingerprint, *paths = info.split('/')
+        raise ArgumentError, 'Fingerprint is not hex.' unless fingerprint.valid_hex?
+        raise ArgumentError, 'Fingerprint is not 4 bytes.' unless fingerprint.size == 8
+        key = key[(key.index(']') + 1)..-1]
+      else
+        raise ArgumentError, 'Invalid key origin.' if key.include?(']')
+      end
+
+      # check BIP32 derivation path
+      key, *paths = key.split('/')
+
+      if key.start_with?('xprv')
+        key = Bitcoin::ExtKey.from_base58(key)
+        key = derive_path(key, paths, true) if paths
+      elsif key.start_with?('xpub')
+        key = Bitcoin::ExtPubkey.from_base58(key)
+        key = derive_path(key, paths, false) if paths
+      else
+        begin
+          key = Bitcoin::Key.from_wif(key)
+        rescue ArgumentError
+          key_type =  compressed_key?(key) ? Bitcoin::Key::TYPES[:compressed] : Bitcoin::Key::TYPES[:uncompressed]
+          key = Bitcoin::Key.new(pubkey: key, key_type: key_type)
+        end
+      end
+      key = key.is_a?(Bitcoin::Key) ? key : key.key
+      raise ArgumentError, 'Invalid pubkey.' unless key.fully_valid_pubkey?
+      key.pubkey
+    end
+
+    def compressed_key?(key)
+      %w(02 03).include?(key[0..1]) && [key].pack("H*").bytesize == 33
+    end
+
+    def derive_path(key, paths, is_private)
+      paths.each do |path|
+        raise ArgumentError, 'xpub can not derive hardened key.' if !is_private && path.end_with?("'")
+        if is_private
+          hardened = path.end_with?("'")
+          path = hardened ? path[0..-2] : path
+          raise ArgumentError, 'Key path value is not a valid value.' unless path =~ /^[0-9]+$/
+          raise ArgumentError, 'Key path value is out of range.' if !hardened && path.to_i >= Bitcoin::HARDENED_THRESHOLD
+          key = key.derive(path.to_i, hardened)
+        else
+          raise ArgumentError, 'Key path value is not a valid value.' unless path =~ /^[0-9]+$/
+          raise ArgumentError, 'Key path value is out of range.' if path.to_i >= Bitcoin::HARDENED_THRESHOLD
+          key = key.derive(path.to_i)
+        end
+      end
+      key
+    end
+
+  end
+
+end