bitcoinrb 0.8.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af836e45167490d93d1d9b5d8f29f4e473a78dc314b98cd789bb47e347a42037
-  data.tar.gz: 020fe745057f3b987c8bd8828be9f7f657d3085a7d8ee37cf0218b0761202325
+  metadata.gz: b6b5d0d0d17295086ec1cf989eb1df1be2d776bff6c5a38e85c34e21e258f56b
+  data.tar.gz: c93206160d6709f0050cbe8a001df40f712a6e8a779a61117c8c0cc911d4fd2f
 SHA512:
-  metadata.gz: 0db2c744f372a2e71c337cb8970bb8cad81f37aa81824504d5fe6ee46819516ca6869c3cab0af1474aa0906905496af3e8f97eacc6cdaf9b7eced0a6cd247ff2
-  data.tar.gz: dab1256db8085c43ec5ab5d784d465cbdb3d74e663d4f052fd76161decacd9fb5fe22b3c2f99cc20381dda8ea203d63866db45e6e8c8ed6d8b4a2d4c27acfe89
+  metadata.gz: fa5759ab05a69bfdaadda07d5cbf74c700bba2586f2544eaf823199c357b88405814dcaed7c6466a1a94e50027d5289a51f057d86815699e92862cb447b2478f
+  data.tar.gz: 8629b46d88f6674482bfaff89dffcf28e90edc857649aeaff56d579c12d0e4df99f9cc7cad63a31ecc1742afc64cfa089a7f86754be5614e27c145e0e693e1cb

data/.ruby-version

@@ -1 +1 @@
-ruby-3.0.0
+ruby-3.0.2

data/README.md

@@ -15,7 +15,7 @@ Bitcoinrb supports following feature:
 * 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
+* bech32([BIP-173](https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki)) and bech32m([BIP-350](https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki)) 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.
 * Schnorr signature([BIP-340](https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki))  

data/lib/bitcoin/constants.rb

@@ -3,6 +3,15 @@ module Bitcoin
   COIN = 100_000_000
   MAX_MONEY = 21_000_000 * COIN
 
+  # Byte size of the ripemd160 hash
+  RIPEMD160_SIZE = 20
+  # Byte size of the SHA256 hash
+  SHA256_SIZE = 32
+  # Byte size of the HASH160 hash
+  HASH160_SIZE = 20
+  # Byte size of the HASH256 hash
+  HASH256_SIZE = 32
+
   # The maximum allowed size for a serialized block, in bytes (only for buffer size limits)
   MAX_BLOCK_SERIALIZED_SIZE = 4_000_000
   # The maximum allowed weight for a block, see BIP 141 (network rule)
@@ -53,22 +62,28 @@ module Bitcoin
   MANDATORY_SCRIPT_VERIFY_FLAGS = SCRIPT_VERIFY_P2SH
 
   # Standard script verification flags that standard transactions will comply with.
-  STANDARD_SCRIPT_VERIFY_FLAGS = [MANDATORY_SCRIPT_VERIFY_FLAGS,
-                                  SCRIPT_VERIFY_DERSIG,
-                                  SCRIPT_VERIFY_STRICTENC,
-                                  SCRIPT_VERIFY_MINIMALDATA,
-                                  SCRIPT_VERIFY_NULLDUMMY,
-                                  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS,
-                                  SCRIPT_VERIFY_CLEANSTACK,
-                                  SCRIPT_VERIFY_MINIMALIF,
-                                  SCRIPT_VERIFY_NULLFAIL,
-                                  SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
-                                  SCRIPT_VERIFY_CHECKSEQUENCEVERIFY,
-                                  SCRIPT_VERIFY_LOW_S,
-                                  SCRIPT_VERIFY_WITNESS,
-                                  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM,
-                                  SCRIPT_VERIFY_WITNESS_PUBKEYTYPE,
-                                  SCRIPT_VERIFY_CONST_SCRIPTCODE].inject(SCRIPT_VERIFY_NONE){|flags, f| flags |= f}
+  STANDARD_SCRIPT_VERIFY_FLAGS = [
+    MANDATORY_SCRIPT_VERIFY_FLAGS,
+    SCRIPT_VERIFY_DERSIG,
+    SCRIPT_VERIFY_STRICTENC,
+    SCRIPT_VERIFY_MINIMALDATA,
+    SCRIPT_VERIFY_NULLDUMMY,
+    SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS,
+    SCRIPT_VERIFY_CLEANSTACK,
+    SCRIPT_VERIFY_MINIMALIF,
+    SCRIPT_VERIFY_NULLFAIL,
+    SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
+    SCRIPT_VERIFY_CHECKSEQUENCEVERIFY,
+    SCRIPT_VERIFY_LOW_S,
+    SCRIPT_VERIFY_WITNESS,
+    SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM,
+    SCRIPT_VERIFY_WITNESS_PUBKEYTYPE,
+    SCRIPT_VERIFY_CONST_SCRIPTCODE,
+    SCRIPT_VERIFY_TAPROOT,
+    SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION,
+    SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS,
+    SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE
+  ].inject(SCRIPT_VERIFY_NONE){|flags, f| flags |= f}
 
   # for script
 

data/lib/bitcoin/ext/object_ext.rb

@@ -0,0 +1,29 @@
+module Bitcoin
+  module Ext
+    module ObjectExt
+      refine Object do
+        def build_json
+          if self.is_a?(Array)
+            "[#{self.map{|o|o.to_h.to_json}.join(',')}]"
+          else
+            to_h.to_json
+          end
+        end
+
+        def to_h
+          return self if self.is_a?(String)
+          instance_variables.inject({}) do |result, var|
+            key = var.to_s
+            key.slice!(0) if key.start_with?('@')
+            value = instance_variable_get(var)
+            if value.is_a?(Array)
+              result.update(key => value.map{|v|v.to_h})
+            else
+              result.update(key => value.class.to_s.start_with?("Bitcoin::") ? value.to_h : value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/ext.rb

@@ -2,5 +2,6 @@ module Bitcoin
   module Ext
     autoload :JsonParser, 'bitcoin/ext/json_parser'
     autoload :ArrayExt, 'bitcoin/ext/array_ext'
+    autoload :ObjectExt, 'bitcoin/ext/object_ext'
   end
 end

data/lib/bitcoin/key.rb

@@ -30,7 +30,6 @@ module Bitcoin
     # @param [Boolean] compressed [Deprecated] whether public key is compressed.
     # @return [Bitcoin::Key] a key object.
     def initialize(priv_key: nil, pubkey: nil, key_type: nil, compressed: true, allow_hybrid: false)
-      puts "[Warning] Use key_type parameter instead of compressed. compressed parameter removed in the future." if key_type.nil? && !compressed.nil? && pubkey.nil?
       if key_type
         @key_type = key_type
         compressed = @key_type != TYPES[:uncompressed]
@@ -213,7 +212,6 @@ module Bitcoin
     # get xonly public key (32 bytes).
     # @return [String] xonly public key with hex format
     def xonly_pubkey
-      puts "Derive a public key whose y-coordinate is different from this public key." if compressed? && pubkey[0...2] != '02'
       pubkey[2..65]
     end
 

data/lib/bitcoin/network/message_handler.rb

@@ -4,6 +4,8 @@ module Bitcoin
     # P2P message handler used by peer connection class.
     module MessageHandler
 
+      using Bitcoin::Ext::ObjectExt
+
       # handle p2p message.
       def handle(message)
         peer.last_recv = Time.now.to_i

data/lib/bitcoin/psbt/input.rb

@@ -14,6 +14,11 @@ module Bitcoin
       attr_accessor :hd_key_paths
       attr_accessor :partial_sigs
       attr_accessor :sighash_type
+      attr_accessor :ripemd160_preimages
+      attr_accessor :sha256_preimages
+      attr_accessor :hash160_preimages
+      attr_accessor :hash256_preimages
+      attr_accessor :proprietaries
       attr_accessor :unknowns
 
       def initialize(non_witness_utxo: nil, witness_utxo: nil)
@@ -21,6 +26,11 @@ module Bitcoin
         @witness_utxo = witness_utxo
         @partial_sigs = {}
         @hd_key_paths = {}
+        @ripemd160_preimages = {}
+        @sha256_preimages = {}
+        @hash160_preimages = {}
+        @hash256_preimages = {}
+        @proprietaries = []
         @unknowns = {}
       end
 
@@ -59,7 +69,7 @@ module Bitcoin
             input.partial_sigs[pubkey.pubkey] = value
           when PSBT_IN_TYPES[:sighash]
             raise ArgumentError, 'Invalid input sighash type typed key.' unless key_len == 1
-            raise ArgumentError 'Duplicate Key, input sighash type already provided.' if input.sighash_type
+            raise ArgumentError, 'Duplicate Key, input sighash type already provided.' if input.sighash_type
             input.sighash_type = value.unpack1('I')
           when PSBT_IN_TYPES[:redeem_script]
             raise ArgumentError, 'Invalid redeemscript typed key.' unless key_len == 1
@@ -81,6 +91,25 @@ module Bitcoin
             raise ArgumentError, 'Invalid final script witness typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, input final scriptWitness already provided.' if input.final_script_witness
             input.final_script_witness = Bitcoin::ScriptWitness.parse_from_payload(value)
+          when PSBT_IN_TYPES[:ripemd160]
+            raise ArgumentError, 'Size of key was not the expected size for the type ripemd160 preimage' unless key.bytesize == RIPEMD160_SIZE
+            raise ArgumentError, 'Duplicate Key, input ripemd160 preimage already provided' if input.ripemd160_preimages[key.bth]
+            input.ripemd160_preimages[key.bth] = value.bth
+          when PSBT_IN_TYPES[:sha256]
+            raise ArgumentError, 'Size of key was not the expected size for the type sha256 preimage' unless key.bytesize == SHA256_SIZE
+            raise ArgumentError, 'Duplicate Key, input sha256 preimage already provided' if input.sha256_preimages[key.bth]
+            input.sha256_preimages[key.bth] = value.bth
+          when PSBT_IN_TYPES[:hash160]
+            raise ArgumentError, 'Size of key was not the expected size for the type hash160 preimage' unless key.bytesize == HASH160_SIZE
+            raise ArgumentError, 'Duplicate Key, input hash160 preimage already provided' if input.hash160_preimages[key.bth]
+            input.hash160_preimages[key.bth] = value.bth
+          when PSBT_IN_TYPES[:hash256]
+            raise ArgumentError, 'Size of key was not the expected size for the type hash256 preimage' unless key.bytesize == HASH256_SIZE
+            raise ArgumentError, 'Duplicate Key, input hash256 preimage already provided' if input.hash256_preimages[key.bth]
+            input.hash256_preimages[key.bth] = value.bth
+          when PSBT_IN_TYPES[:proprietary]
+            raise ArgumentError, 'Duplicate Key, key for proprietary value already provided.' if input.proprietaries.any?{|p| p.key == key}
+            input.proprietaries << Proprietary.new(key, value)
           else
             unknown_key = ([key_type].pack('C') + key).bth
             raise ArgumentError, 'Duplicate Key, key for unknown value already provided.' if input.unknowns[unknown_key]
@@ -102,9 +131,14 @@ module Bitcoin
           payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:redeem_script], value: redeem_script.to_payload) if redeem_script
           payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:witness_script], value: witness_script.to_payload) if witness_script
           payload << hd_key_paths.values.map(&:to_payload).join
+          payload << ripemd160_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:ripemd160], key: k.htb, value: v.htb)}.join
+          payload << sha256_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:sha256], key: k.htb, value: v.htb)}.join
+          payload << hash160_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:hash160], key: k.htb, value: v.htb)}.join
+          payload << hash256_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:hash256], key: k.htb, value: v.htb)}.join
         end
         payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:script_sig], value: final_script_sig.to_payload) if final_script_sig
         payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:script_witness], value: final_script_witness.to_payload) if final_script_witness
+        payload << proprietaries.map(&:to_payload).join
         payload << unknowns.map {|k,v|Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v}.join
         payload << PSBT_SEPARATOR.itb
         payload

data/lib/bitcoin/psbt/output.rb

@@ -7,10 +7,12 @@ module Bitcoin
       attr_accessor :redeem_script
       attr_accessor :witness_script
       attr_accessor :hd_key_paths
+      attr_accessor :proprietaries
       attr_accessor :unknowns
 
       def initialize
         @hd_key_paths = {}
+        @proprietaries = []
         @unknowns = {}
       end
 
@@ -41,6 +43,9 @@ module Bitcoin
           when PSBT_OUT_TYPES[:bip32_derivation]
             raise ArgumentError, 'Duplicate Key, pubkey derivation path already provided' if output.hd_key_paths[key.bth]
             output.hd_key_paths[key.bth] = Bitcoin::PSBT::HDKeyPath.new(key, Bitcoin::PSBT::KeyOriginInfo.parse_from_payload(value))
+          when PSBT_OUT_TYPES[:proprietary]
+            raise ArgumentError, 'Duplicate Key, key for proprietary value already provided.' if output.proprietaries.any?{|p| p.key == key}
+            output.proprietaries << Proprietary.new(key, value)
           else
             unknown_key = ([key_type].pack('C') + key).bth
             raise ArgumentError, 'Duplicate Key, key for unknown value already provided' if output.unknowns[unknown_key]
@@ -56,6 +61,7 @@ module Bitcoin
         payload << PSBT.serialize_to_vector(PSBT_OUT_TYPES[:redeem_script], value: redeem_script) if redeem_script
         payload << PSBT.serialize_to_vector(PSBT_OUT_TYPES[:witness_script], value: witness_script) if witness_script
         payload << hd_key_paths.values.map{|v|v.to_payload(PSBT_OUT_TYPES[:bip32_derivation])}.join
+        payload << proprietaries.map(&:to_payload).join
         payload << unknowns.map {|k,v|Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v}.join
         payload << PSBT_SEPARATOR.itb
         payload

data/lib/bitcoin/psbt/proprietary.rb

@@ -0,0 +1,44 @@
+module Bitcoin
+  module PSBT
+    # Proprietary element of PSBT
+    # https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#Proprietary_Use_Type
+    class Proprietary
+      attr_accessor :identifier # binary format
+      attr_accessor :sub_type # integer
+      attr_accessor :value # binary format
+
+      # @param [String] key key with binary format without key type(0xfc).
+      # @param [String] value value with binary format.
+      def initialize(key, value)
+        buf = StringIO.new(key)
+        id_len = Bitcoin.unpack_var_int_from_io(buf)
+        @identifier = buf.read(id_len)
+        @sub_type = Bitcoin.unpack_var_int_from_io(buf)
+        @value = value
+      end
+
+      # Show contents
+      # @return [String]
+      def to_s
+        "identifier: #{identifier&.bth}, sub type: #{sub_type}, value: #{value&.bth}"
+      end
+
+      # Get key data with key type(0xfc).
+      # @return [String] key data with binary format.
+      def key
+        k = [PSBT_GLOBAL_TYPES[:proprietary]].pack('C')
+        k << Bitcoin.pack_var_int(identifier ? identifier.bytesize : 0)
+        k << identifier if identifier
+        k << Bitcoin.pack_var_int(sub_type)
+        k
+      end
+
+      # Convert to payload
+      # @return [String] payload with binary format.
+      def to_payload
+        k = key
+        Bitcoin.pack_var_int(k.bytesize) + k + Bitcoin.pack_var_int(value.bytesize) + value
+      end
+    end
+  end
+end

data/lib/bitcoin/psbt/tx.rb

@@ -32,6 +32,7 @@ module Bitcoin
       attr_accessor :xpubs
       attr_reader :inputs
       attr_reader :outputs
+      attr_accessor :proprietaries
       attr_accessor :unknowns
       attr_accessor :version_number
 
@@ -40,6 +41,7 @@ module Bitcoin
         @xpubs = []
         @inputs = tx ? tx.in.map{Input.new}: []
         @outputs = tx ? tx.out.map{Output.new}: []
+        @proprietaries = []
         @unknowns = {}
       end
 
@@ -66,7 +68,7 @@ module Bitcoin
             found_sep = true
             break
           end
-          key_type = buf.read(1).unpack1('C')
+          key_type = Bitcoin.unpack_var_int_from_io(buf)
           key = buf.read(key_len - 1)
           value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
 
@@ -89,6 +91,9 @@ module Bitcoin
           when PSBT_GLOBAL_TYPES[:ver]
             partial_tx.version_number = value.unpack1('V')
             raise ArgumentError, "An unsupported version was detected." if SUPPORT_VERSION < partial_tx.version_number
+          when PSBT_GLOBAL_TYPES[:proprietary]
+            raise ArgumentError, 'Duplicate Key, key for proprietary value already provided.' if partial_tx.proprietaries.any?{|p| p.key == key}
+            partial_tx.proprietaries << Proprietary.new(key, value)
           else
             raise ArgumentError, 'Duplicate Key, key for unknown value already provided.' if partial_tx.unknowns[key]
             partial_tx.unknowns[([key_type].pack('C') + key).bth] = value
@@ -148,6 +153,7 @@ module Bitcoin
         payload << PSBT.serialize_to_vector(PSBT_GLOBAL_TYPES[:unsigned_tx], value: tx.to_payload)
         payload << xpubs.map(&:to_payload).join
         payload << PSBT.serialize_to_vector(PSBT_GLOBAL_TYPES[:ver], value: [version_number].pack('V')) if version_number
+        payload << proprietaries.map(&:to_payload).join
         payload << unknowns.map {|k,v|Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v}.join
 
         payload << PSBT_SEPARATOR.itb
@@ -162,6 +168,15 @@ module Bitcoin
         Base64.strict_encode64(to_payload)
       end
 
+      # Store the PSBT to a file.
+      # @param [String] path File path to store.
+      def to_file(path)
+        raise ArgumentError, 'The file already exists' if File.exist?(path)
+        File.open(path, 'w') do |f|
+          f.write(to_payload)
+        end
+      end
+
       # update input key-value maps.
       # @param [Bitcoin::Tx] prev_tx previous tx reference by input.
       # @param [Bitcoin::Script] redeem_script redeem script to set input.

data/lib/bitcoin/psbt.rb

@@ -9,14 +9,38 @@ module Bitcoin
     autoload :Output, 'bitcoin/psbt/output'
     autoload :KeyOriginInfo, 'bitcoin/psbt/key_origin_info'
     autoload :HDKeyPath, 'bitcoin/psbt/hd_key_path'
+    autoload :Proprietary, 'bitcoin/psbt/proprietary'
 
     # constants for PSBT
     PSBT_MAGIC_BYTES = 0x70736274
-    PSBT_GLOBAL_TYPES = {unsigned_tx: 0x00, xpub: 0x01, ver: 0xfb}
-    PSBT_IN_TYPES = {non_witness_utxo: 0x00, witness_utxo: 0x01, partial_sig: 0x02,
-                     sighash: 0x03, redeem_script: 0x04, witness_script: 0x05,
-                     bip32_derivation: 0x06, script_sig: 0x07, script_witness: 0x08}
-    PSBT_OUT_TYPES = {redeem_script: 0x00, witness_script: 0x01, bip32_derivation: 0x02}
+    PSBT_GLOBAL_TYPES = {
+      unsigned_tx: 0x00,
+      xpub: 0x01,
+      ver: 0xfb,
+      proprietary: 0xfc
+    }
+    PSBT_IN_TYPES = {
+      non_witness_utxo: 0x00,
+      witness_utxo: 0x01,
+      partial_sig: 0x02,
+      sighash: 0x03,
+      redeem_script: 0x04,
+      witness_script: 0x05,
+      bip32_derivation: 0x06,
+      script_sig: 0x07,
+      script_witness: 0x08,
+      ripemd160: 0x0a,
+      sha256: 0x0b,
+      hash160: 0x0c,
+      hash256: 0x0d,
+      proprietary: 0xfc
+    }
+    PSBT_OUT_TYPES = {
+      redeem_script: 0x00,
+      witness_script: 0x01,
+      bip32_derivation: 0x02,
+      proprietary: 0xfc
+    }
     PSBT_SEPARATOR = 0x00
 
     SUPPORT_VERSION = 0
@@ -31,6 +55,14 @@ module Bitcoin
       s << Bitcoin.pack_var_int(value.bytesize) << value
       s
     end
+
+    # Load PSBT from file.
+    # @param [String] path File path of PSBT.
+    # @return [Bitcoin::PSBT::Tx] PSBT object.
+    def load_from_file(path)
+      raise ArgumentError, 'File not found' unless File.exist?(path)
+      Bitcoin::PSBT::Tx.parse_from_payload(File.read(path))
+    end
   end
 
 end

data/lib/bitcoin/script/script.rb

@@ -551,7 +551,7 @@ module Bitcoin
     def p2pkh_addr
       return nil unless p2pkh?
       hash160 = chunks[2].pushed_data.bth
-      return nil unless hash160.htb.bytesize == 20
+      return nil unless hash160.htb.bytesize == RIPEMD160_SIZE
       Bitcoin.encode_base58_address(hash160, Bitcoin.chain_params.address_version)
     end
 
@@ -564,7 +564,7 @@ module Bitcoin
     def p2sh_addr
       return nil unless p2sh?
       hash160 = chunks[1].pushed_data.bth
-      return nil unless hash160.htb.bytesize == 20
+      return nil unless hash160.htb.bytesize == RIPEMD160_SIZE
       Bitcoin.encode_base58_address(hash160, Bitcoin.chain_params.p2sh_version)
     end
 

data/lib/bitcoin/script/script_interpreter.rb

@@ -163,9 +163,9 @@ module Bitcoin
             end
             return set_error(SCRIPT_ERR_STACK_SIZE) if stack.size > MAX_STACK_SIZE
             need_evaluate = true
+          elsif flag?(SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION)
+            return set_error(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION)
           end
-
-          return set_error(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION) if flag?(SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION)
           return true unless need_evaluate
         end
       elsif flag?(SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM)

data/lib/bitcoin/sighash_generator.rb

@@ -62,6 +62,7 @@ module Bitcoin
 
       def generate(tx, input_index, hash_type, opts)
         amount = opts[:amount]
+        raise ArgumentError, 'segwit sighash requires amount.' unless amount
         output_script = opts[:script_code]
         skip_separator_index = opts[:skip_separator_index]
         hash_prevouts = Bitcoin.double_sha256(tx.inputs.map{|i|i.out_point.to_payload}.join)
@@ -70,7 +71,9 @@ module Bitcoin
         amount = [amount].pack('Q')
         nsequence = [tx.inputs[input_index].sequence].pack('V')
         hash_outputs = Bitcoin.double_sha256(tx.outputs.map{|o|o.to_payload}.join)
-
+        if output_script.p2wsh?
+          warn('The output_script must be a witness script, not the P2WSH itself.')
+        end
         script_code = output_script.to_script_code(skip_separator_index)
 
         case (hash_type & 0x1f)

data/lib/bitcoin/taproot/leaf_node.rb

@@ -7,7 +7,7 @@ module Bitcoin
       # Initialize
       # @param [Bitcoin::Script] script Locking script
       # @param [Integer] leaf_ver The leaf version of this script.
-      def initialize(script, leaf_ver)
+      def initialize(script, leaf_ver = Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
         raise Taproot::Error, 'script must be Bitcoin::Script object' unless script.is_a?(Bitcoin::Script)
         @script = script
         @leaf_ver = leaf_ver

data/lib/bitcoin/taproot/simple_builder.rb

@@ -1,34 +1,50 @@
 module Bitcoin
   module Taproot
 
-    # Utility class to construct Taproot outputs from internal key and script tree.
+    # Utility class to construct Taproot outputs from internal key and script tree.keyPathSpending
     # SimpleBuilder builds a script tree that places all lock scripts, in the order they are added, as leaf nodes.
     # It is not possible to specify the depth of the locking script or to insert any intermediate nodes.
     class SimpleBuilder
       include Bitcoin::Opcodes
 
       attr_reader :internal_key # String with hex format
-      attr_reader :leaves # Array[LeafNode]
+      attr_reader :branches # List of branch that has two child leaves
 
       # Initialize builder.
       # @param [String] internal_key Internal public key with hex format.
-      # @param [Array[Bitcoin::Script]] scripts Scripts for each lock condition.
-      # @param [Integer] leaf_ver (Optional) The leaf version of tapscript.
-      # @raise [Bitcoin::Taproot::Builder] +internal_pubkey+ dose not xonly public key or script in +scripts+ does not instance of Bitcoin::Script.
+      # @param [Array[Bitcoin::Taproot::LeafNode]] leaves (Optional) Array of leaf nodes for each lock condition.
+      # @raise [Bitcoin::Taproot::Builder] +internal_pubkey+ dose not xonly public key or leaf in +leaves+ does not instance of Bitcoin::Taproot::LeafNode.
       # @return [Bitcoin::Taproot::SimpleBuilder]
-      def initialize(internal_key, *scripts, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+      def initialize(internal_key, leaves = [])
         raise Error, 'Internal public key must be 32 bytes' unless internal_key.htb.bytesize == 32
-        @leaves = scripts.map { |script| LeafNode.new(script, leaf_ver) }
+        raise Error, 'leaf must be Bitcoin::Taproot::LeafNode object' if leaves.find{ |leaf| !leaf.is_a?(Bitcoin::Taproot::LeafNode)}
+
+        @leaves = leaves
+        @branches = leaves.each_slice(2).map.to_a
         @internal_key = internal_key
       end
 
-      # Add lock script to leaf node.
-      # @param [Bitcoin::Script] script lock script.
-      # @param [Integer] leaf_ver (Optional) The leaf version of tapscript.
-      # @raise [Bitcoin::Taproot::Builder] If +script+ does not instance of Bitcoin::Script.
-      # @return [Bitcoin::Taproot::SimpleBuilder] self
-      def <<(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
-        leaves << LeafNode.new(script, leaf_ver)
+      # Add a leaf node to the end of the current branch.
+      # @param [Bitcoin::Taproot::LeafNode] leaf Leaf node to be added.
+      def add_leaf(leaf)
+        raise Error, 'leaf must be Bitcoin::Taproot::LeafNode object' unless leaf.is_a?(Bitcoin::Taproot::LeafNode)
+
+        if branches.last&.size == 1
+          branches.last << leaf
+        else
+          branches << [leaf]
+        end
+        self
+      end
+
+      # Add a pair of leaf nodes as a branch. If there is only one, add a branch with only one child.
+      # @param [Bitcoin::Taproot::LeafNode] leaf1 Leaf node to be added.
+      # @param [Bitcoin::Taproot::LeafNode] leaf2 Leaf node to be added.
+      def add_branch(leaf1, leaf2 = nil)
+        raise Error, 'leaf1 must be Bitcoin::Taproot::LeafNode object' unless leaf1.is_a?(Bitcoin::Taproot::LeafNode)
+        raise Error, 'leaf2 must be Bitcoin::Taproot::LeafNode object' if leaf2 && !leaf2.is_a?(Bitcoin::Taproot::LeafNode)
+
+        branches << (leaf2.nil? ? [leaf1] : [leaf1, leaf2])
         self
       end
 
@@ -42,8 +58,7 @@ module Bitcoin
       # Compute the tweaked public key.
       # @return [Bitcoin::Key] the tweaked public key
       def tweak_public_key
-        key = Bitcoin::Key.new(priv_key: tweak.bth, key_type: Key::TYPES[:compressed])
-        Bitcoin::Key.from_point(key.to_point + Bitcoin::Key.from_xonly_pubkey(internal_key).to_point)
+        Taproot.tweak_public_key(Bitcoin::Key.from_xonly_pubkey(internal_key), merkle_root)
       end
 
       # Compute the secret key for a tweaked public key.
@@ -51,29 +66,33 @@ module Bitcoin
       # @return [Bitcoin::Key] secret key for a tweaked public key
       def tweak_private_key(key)
         raise Error, 'Requires private key' unless key.priv_key
-        p = key.to_point
-        private_key = p.has_even_y? ? key.priv_key.to_i(16) : ECDSA::Group::Secp256k1.order - key.priv_key.to_i(16)
-        Bitcoin::Key.new(priv_key: ((tweak.bti + private_key) % ECDSA::Group::Secp256k1.order).to_even_length_hex)
+
+        Taproot.tweak_private_key(key, merkle_root)
       end
 
       # Generate control block needed to unlock with script-path.
-      # @param [Bitcoin::Script] script Script to use for unlocking.
-      # @param [Integer] leaf_ver leaf version of script.
+      # @param [Bitcoin::Taproot::LeafNode] leaf Leaf to use for unlocking.
       # @return [String] control block with binary format.
-      def control_block(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
-        path = inclusion_proof(script, leaf_ver: leaf_ver)
+      def control_block(leaf)
+        path = inclusion_proof(leaf)
         parity = tweak_public_key.to_point.has_even_y? ? 0 : 1
-        [parity + leaf_ver].pack("C") + internal_key.htb + path.join
+        [parity + leaf.leaf_ver].pack("C") + internal_key.htb + path.join
       end
 
-      # Generate inclusion proof for +script+.
-      # @param [Bitcoin::Script] script The script in script tree.
-      # @param [Integer] leaf_ver (Optional) The leaf version of tapscript.
+      # Generate inclusion proof for +leaf+.
+      # @param [Bitcoin::Taproot::LeafNode] leaf The leaf node in script tree.
       # @return [Array[String]] Inclusion proof.
-      def inclusion_proof(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
-        parents = leaves
-        parent_hash = leaf_hash(script, leaf_ver: leaf_ver)
+      # @raise [Bitcoin::Taproot::Error] If the specified +leaf+ does not exist
+      def inclusion_proof(leaf)
         proofs = []
+        target_branch = branches.find{|b| b.include?(leaf)}
+        raise Error 'Specified leaf does not exist' unless target_branch
+
+        # flatten each branch
+        proofs << hash_value(target_branch.find{|b| b != leaf}) if target_branch.size == 2
+        parent_hash = combine_hash(target_branch)
+        parents = branches.map {|pair| combine_hash(pair)}
+
         until parents.size == 1
           parents = parents.each_slice(2).map do |pair|
             combined = combine_hash(pair)
@@ -92,29 +111,26 @@ module Bitcoin
         proofs
       end
 
-      # Computes leaf hash
-      # @param [Bitcoin::Script] script
-      # @param [Integer] leaf_ver leaf version
-      # @@return [String] leaf hash with binary format.
-      def leaf_hash(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
-        raise Error, 'script does not exist' unless leaves.find{ |leaf| leaf.script == script}
-        LeafNode.new(script, leaf_ver).leaf_hash
-      end
-
       private
 
       # Compute tweak from script tree.
       # @return [String] tweak with binary format.
       def tweak
-        parents = leaves
+        Taproot.tweak(Bitcoin::Key.from_xonly_pubkey(internal_key), merkle_root)
+      end
+
+      # Calculate merkle root from branches.
+      # @return [String] merkle root with hex format.
+      def merkle_root
+        parents = branches.map {|pair| combine_hash(pair)}
         if parents.empty?
           parents = ['']
+        elsif parents.size == 1
+          parents = [combine_hash(parents)]
         else
           parents = parents.each_slice(2).map { |pair| combine_hash(pair) } until parents.size == 1
         end
-        t = Bitcoin.tagged_hash('TapTweak', internal_key.htb + parents.first)
-        raise Error, 'tweak value exceeds the curve order' if t.bti >= ECDSA::Group::Secp256k1.order
-        t
+        parents.first.bth
       end
 
       def combine_hash(pair)

data/lib/bitcoin/taproot.rb

@@ -5,5 +5,41 @@ module Bitcoin
 
     autoload :LeafNode, 'bitcoin/taproot/leaf_node'
     autoload :SimpleBuilder, 'bitcoin/taproot/simple_builder'
+
+    module_function
+
+    # Calculate tweak value from +internal_pubkey+ and +merkle_root+.
+    # @param [Bitcoin::Key] internal_key Internal key with hex format(x-only public key).
+    # @param [String] merkle_root Merkle root value of script tree with hex format.
+    # @return [String] teak value with binary format.
+    def tweak(internal_key, merkle_root)
+      raise Error, 'internal_key must be Bitcoin::Key object.' unless internal_key.is_a?(Bitcoin::Key)
+
+      merkle_root ||= ''
+      t = Bitcoin.tagged_hash('TapTweak', internal_key.xonly_pubkey.htb + merkle_root.htb)
+      raise Error, 'tweak value exceeds the curve order' if t.bti >= ECDSA::Group::Secp256k1.order
+
+      t
+    end
+
+    # Generate tweak public key form +internal_pubkey+ and +merkle_root+.
+    # @param [Bitcoin::Key] internal_key Internal key with hex format(x-only public key).
+    # @param [String] merkle_root Merkle root value of script tree with hex format.
+    # @return [Bitcoin::Key] Tweaked public key.
+    def tweak_public_key(internal_key, merkle_root)
+      t = tweak(internal_key, merkle_root)
+      key = Bitcoin::Key.new(priv_key: t.bth, key_type: Key::TYPES[:compressed])
+      Bitcoin::Key.from_point(key.to_point + internal_key.to_point)
+    end
+
+    # Generate tweak private key
+    #
+    def tweak_private_key(internal_private_key, merkle_root)
+      p = internal_private_key.to_point
+      private_key = p.has_even_y? ? internal_private_key.priv_key.to_i(16) :
+                      ECDSA::Group::Secp256k1.order - internal_private_key.priv_key.to_i(16)
+      t = tweak(internal_private_key, merkle_root)
+      Bitcoin::Key.new(priv_key: ((t.bti + private_key) % ECDSA::Group::Secp256k1.order).to_even_length_hex)
+    end
   end
 end

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.8.0"
+  VERSION = "1.1.0"
 end

data/lib/bitcoin.rb

@@ -194,32 +194,6 @@ module Bitcoin
 
   end
 
-  class ::Object
-
-    def build_json
-      if self.is_a?(Array)
-        "[#{self.map{|o|o.to_h.to_json}.join(',')}]"
-      else
-        to_h.to_json
-      end
-    end
-
-    def to_h
-      return self if self.is_a?(String)
-      instance_variables.inject({}) do |result, var|
-        key = var.to_s
-        key.slice!(0) if key.start_with?('@')
-        value = instance_variable_get(var)
-        if value.is_a?(Array)
-          result.update(key => value.map{|v|v.to_h})
-        else
-          result.update(key => value.class.to_s.start_with?("Bitcoin::") ? value.to_h : value)
-        end
-      end
-    end
-
-  end
-
   class ::Integer
     def to_even_length_hex
       hex = to_s(16)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 1.1.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-06-29 00:00:00.000000000 Z
+date: 2022-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -364,6 +364,7 @@ files:
 - lib/bitcoin/ext/array_ext.rb
 - lib/bitcoin/ext/ecdsa.rb
 - lib/bitcoin/ext/json_parser.rb
+- lib/bitcoin/ext/object_ext.rb
 - lib/bitcoin/ext_key.rb
 - lib/bitcoin/gcs_filter.rb
 - lib/bitcoin/key.rb
@@ -450,6 +451,7 @@ files:
 - lib/bitcoin/psbt/input.rb
 - lib/bitcoin/psbt/key_origin_info.rb
 - lib/bitcoin/psbt/output.rb
+- lib/bitcoin/psbt/proprietary.rb
 - lib/bitcoin/psbt/tx.rb
 - lib/bitcoin/rpc.rb
 - lib/bitcoin/rpc/bitcoin_core_client.rb
@@ -514,7 +516,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: The implementation of Bitcoin Protocol for Ruby.