bitcoinrb 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d105b6b0882459caee5c30db5e4ca8700a274c8fac2cd27f863e61719a1b484
-  data.tar.gz: fb458ded6c3c0a892bcb546f6e753b160aeff8afaa917a5510eefd090d048dbe
+  metadata.gz: cbc1459b87de8addec350661eb84c3a8bd87503eff03d6bad50c329660fc2749
+  data.tar.gz: ccb70c6d406a1b4f7134c7c8b8f13f536ba8197d3479b4fca635c073cccd6f11
 SHA512:
-  metadata.gz: b6062ddface7588de792e84b2c6c6394ffb145dd27aaf5fe22aae0ba191491478b958bf481a55c3f8547aa0a6066e8c7439c7ef4b625b26446dd5583f54cb61c
-  data.tar.gz: 6768c846fb94280e5ef4f776f15ac532f1868142998d37bf551070be925a4ad7b19243322f287d1f607f1abf24816cad337735ff2eb6be3caa5afe4c187171fa
+  metadata.gz: 5ed8400e197cb53d7232265b87f201174e60dae37952e075dae4e4f961b41e9967a24fa2998845100212747493a0dc2bd0b03a79ca208a2beb824cfd48f4a9bf
+  data.tar.gz: 7585bf0a8179d1144a6f6310a63817538075a111ca92a248c2469df962c2fb913f091abffacdf57096cfb183ebe40406080ce807deca3c052c1a63b1934d895c

data/lib/bitcoin/block_header.rb

@@ -21,8 +21,12 @@ module Bitcoin
       @nonce = nonce
     end
 
+    # Parse block header from payload.
+    # @param [String|StringIO] payload block header paylaod
+    # @return [Bitcoin::BlockHeader]
     def self.parse_from_payload(payload)
-      version, prev_hash, merkle_root, time, bits, nonce = payload.unpack('Va32a32VVV')
+      buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+      version, prev_hash, merkle_root, time, bits, nonce = buf.read(80).unpack('Va32a32VVV')
       new(version, prev_hash.bth, merkle_root.bth, time, bits, nonce)
     end
 

data/lib/bitcoin/constants.rb

@@ -11,6 +11,8 @@ module Bitcoin
   HASH160_SIZE = 20
   # Byte size of the HASH256 hash
   HASH256_SIZE = 32
+  # Byte size of x-only public key
+  X_ONLY_PUBKEY_SIZE = 32
 
   # The maximum allowed size for a serialized block, in bytes (only for buffer size limits)
   MAX_BLOCK_SERIALIZED_SIZE = 4_000_000

data/lib/bitcoin/key.rb

@@ -17,7 +17,7 @@ module Bitcoin
     attr_accessor :key_type
     attr_reader :secp256k1_module
 
-    TYPES = {uncompressed: 0x00, compressed: 0x01, p2pkh: 0x10, p2wpkh: 0x11, p2wpkh_p2sh: 0x12}
+    TYPES = {uncompressed: 0x00, compressed: 0x01, p2pkh: 0x10, p2wpkh: 0x11, p2wpkh_p2sh: 0x12, p2tr: 0x13}
 
     MIN_PRIV_KEY_MOD_ORDER = 0x01
     # Order of secp256k1's generator minus 1.
@@ -81,7 +81,7 @@ module Bitcoin
     # @param [String] xonly_pubkey xonly public key with hex format.
     # @return [Bitcoin::Key] key object has public key.
     def self.from_xonly_pubkey(xonly_pubkey)
-      raise ArgumentError, 'xonly_pubkey must be 32 bytes' unless xonly_pubkey.htb.bytesize == 32
+      raise ArgumentError, "xonly_pubkey must be #{X_ONLY_PUBKEY_SIZE} bytes" unless xonly_pubkey.htb.bytesize == X_ONLY_PUBKEY_SIZE
       Bitcoin::Key.new(pubkey: "02#{xonly_pubkey}", key_type: TYPES[:compressed])
     end
 
@@ -180,23 +180,68 @@ module Bitcoin
     end
 
     # get pay to pubkey hash address
-    # @deprecated
+    # @return [String] address
     def to_p2pkh
       Bitcoin::Script.to_p2pkh(hash160).to_addr
     end
 
     # get pay to witness pubkey hash address
-    # @deprecated
+    # @return [String] address
     def to_p2wpkh
       Bitcoin::Script.to_p2wpkh(hash160).to_addr
     end
 
+    # Get pay to taproot address
+    # @return [String] address
+    def to_p2tr
+      Bitcoin::Script.to_p2tr(self).to_addr
+    end
+
     # get p2wpkh address nested in p2sh.
     # @deprecated
     def to_nested_p2wpkh
       Bitcoin::Script.to_p2wpkh(hash160).to_p2sh.to_addr
     end
 
+    # Determine if it is a P2PKH from key_type.
+    # @return [Boolean]
+    def p2pkh?
+      [TYPES[:uncompressed], TYPES[:compressed], TYPES[:p2pkh]].include?(key_type)
+    end
+
+    # Determine if it is a P2WPKH from key_type.
+    # @return [Boolean]
+    def p2wpkh?
+      key_type == TYPES[:p2wpkh]
+    end
+
+    # Determine if it is a nested P2WPKH from key_type.
+    # @return [Boolean]
+    def nested_p2wpkh?
+      key_type == TYPES[:p2wpkh_p2sh]
+    end
+
+    # Determine if it is a nested P2TR from key_type.
+    # @return [Boolean]
+    def p2tr?
+      key_type == TYPES[:p2tr]
+    end
+
+    # Returns the address corresponding to key_type.
+    # @return [String] address
+    def to_addr
+      case key_type
+      when TYPES[:uncompressed], TYPES[:compressed], TYPES[:p2pkh]
+        to_p2pkh
+      when TYPES[:p2wpkh]
+        to_p2wpkh
+      when TYPES[:p2wpkh_p2sh]
+        to_nested_p2wpkh
+      when TYPES[:p2tr]
+        to_p2tr
+      end
+    end
+
     def compressed?
       key_type != TYPES[:uncompressed]
     end

data/lib/bitcoin/out_point.rb

@@ -20,6 +20,15 @@ module Bitcoin
       self.new(txid.rhex, index)
     end
 
+    # Parse from payload
+    # @param [String|StringIO] payload prvout payload with binary format
+    # @return [Bitcoin::OutPoint]
+    def self.parse_from_payload(payload)
+      buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+      hash, index = buf.read(36).unpack('a32V')
+      OutPoint.new(hash.bth, index)
+    end
+
     def coinbase?
       tx_hash == COINBASE_HASH && index == COINBASE_INDEX
     end

data/lib/bitcoin/psbt/input.rb

@@ -19,6 +19,12 @@ module Bitcoin
       attr_accessor :hash160_preimages
       attr_accessor :hash256_preimages
       attr_accessor :proprietaries
+      attr_accessor :tap_key_sig
+      attr_accessor :tap_script_sigs
+      attr_accessor :tap_leaf_scripts
+      attr_accessor :tap_bip32_derivations
+      attr_accessor :tap_internal_key
+      attr_accessor :tap_merkle_root
       attr_accessor :unknowns
 
       def initialize(non_witness_utxo: nil, witness_utxo: nil)
@@ -31,6 +37,9 @@ module Bitcoin
         @hash160_preimages = {}
         @hash256_preimages = {}
         @proprietaries = []
+        @tap_script_sigs = {}
+        @tap_leaf_scripts = {}
+        @tap_bip32_derivations = {}
         @unknowns = {}
       end
 
@@ -110,6 +119,35 @@ module Bitcoin
           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)
+          when PSBT_IN_TYPES[:tap_key_sig]
+            raise ArgumentError, 'Size of key was not the expected size for the type tap key sig' unless key_len == 1
+            raise ArgumentError, 'Invalid schnorr signature size for the type tap key sig' unless [64, 65].include?(value.bytesize)
+            input.tap_key_sig = value.bth
+          when PSBT_IN_TYPES[:tap_script_sig]
+            raise ArgumentError, 'Duplicate Key, key for tap script sig value already provided.' if input.tap_script_sigs[key.bth]
+            raise ArgumentError, 'Size of key was not the expected size for the type tap script sig' unless key.bytesize == (X_ONLY_PUBKEY_SIZE + 32)
+            raise ArgumentError, 'Invalid schnorr signature size for the type tap script sig' unless [64, 65].include?(value.bytesize)
+            input.tap_script_sigs[key.bth] = value.bth
+          when PSBT_IN_TYPES[:tap_leaf_script]
+            begin
+              cb = Bitcoin::Taproot::ControlBlock.parse_from_payload(key)
+              raise ArgumentError, 'Duplicate Key, key for tap leaf script value already provided.' if input.tap_leaf_scripts[cb]
+              input.tap_leaf_scripts[cb] = value.bth
+            rescue Bitcoin::Taproot::Error => e
+              raise ArgumentError, e.message
+            end
+          when PSBT_IN_TYPES[:tap_bip32_derivation]
+            raise ArgumentError, 'Duplicate Key, key for tap bip32 derivation value already provided.' if input.tap_bip32_derivations[key.bth]
+            raise ArgumentError, 'Size of key was not the expected size for the type tap bip32 derivation' unless key.bytesize == X_ONLY_PUBKEY_SIZE
+            input.tap_bip32_derivations[key.bth] = value.bth
+          when PSBT_IN_TYPES[:tap_internal_key]
+            raise ArgumentError, 'Size of key was not the expected size for the type tap internal key' unless key_len == 1
+            raise ArgumentError, 'Invalid x-only public key size for the type tap internal key' unless value.bytesize == X_ONLY_PUBKEY_SIZE
+            input.tap_internal_key = value.bth
+          when PSBT_IN_TYPES[:tap_merkle_root]
+            raise ArgumentError, 'Size of key was not the expected size for the type tap merkle root' unless key_len == 1
+            raise ArgumentError, 'Invalid merkle root hash size for the type tap merkle root' unless value.bytesize == 32
+            input.tap_merkle_root = value.bth
           else
             unknown_key = ([key_type].pack('C') + key).bth
             raise ArgumentError, 'Duplicate Key, key for unknown value already provided.' if input.unknowns[unknown_key]
@@ -135,6 +173,12 @@ module Bitcoin
           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
+          payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_key_sig], value: tap_key_sig.htb) if tap_key_sig
+          payload << tap_script_sigs.map{|k, v| PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_script_sig], key: k.htb, value: v.htb)}.join
+          payload << tap_leaf_scripts.map{|k, v| PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_leaf_script], key: k.to_payload, value: v.htb)}.join
+          payload << tap_bip32_derivations.map{|k, v| PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_bip32_derivation], key: k.htb, value: v.htb)}.join
+          payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_internal_key], value: tap_internal_key.htb) if tap_internal_key
+          payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_merkle_root], value: tap_merkle_root.htb) if tap_merkle_root
         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

data/lib/bitcoin/psbt/output.rb

@@ -8,11 +8,15 @@ module Bitcoin
       attr_accessor :witness_script
       attr_accessor :hd_key_paths
       attr_accessor :proprietaries
+      attr_accessor :tap_internal_key
+      attr_accessor :tap_tree
+      attr_accessor :tap_bip32_derivations
       attr_accessor :unknowns
 
       def initialize
         @hd_key_paths = {}
         @proprietaries = []
+        @tap_bip32_derivations = {}
         @unknowns = {}
       end
 
@@ -46,6 +50,17 @@ module Bitcoin
           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)
+          when PSBT_OUT_TYPES[:tap_internal_key]
+            raise ArgumentError, 'Invalid output tap internal key typed key.' unless key_len == 1
+            raise ArgumentError, 'Invalid x-only public key size for the type tap internal key' unless value.bytesize == X_ONLY_PUBKEY_SIZE
+            output.tap_internal_key = value.bth
+          when PSBT_OUT_TYPES[:tap_tree]
+            raise ArgumentError, 'Invalid output tap tree typed key.' unless key_len == 1
+            output.tap_tree = value.bth # TODO implement builder.
+          when PSBT_OUT_TYPES[:tap_bip32_derivation]
+            raise ArgumentError, 'Duplicate Key, key for tap bip32 derivation value already provided.' if output.tap_bip32_derivations[key.bth]
+            raise ArgumentError, 'Size of key was not the expected size for the type tap bip32 derivation' unless key.bytesize == X_ONLY_PUBKEY_SIZE
+            output.tap_bip32_derivations[key.bth] = value.bth
           else
             unknown_key = ([key_type].pack('C') + key).bth
             raise ArgumentError, 'Duplicate Key, key for unknown value already provided' if output.unknowns[unknown_key]
@@ -62,6 +77,9 @@ module Bitcoin
         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 << PSBT.serialize_to_vector(PSBT_OUT_TYPES[:tap_internal_key], value: tap_internal_key.htb) if tap_internal_key
+        payload << PSBT.serialize_to_vector(PSBT_OUT_TYPES[:tap_tree], value: tap_tree.htb) if tap_tree
+        payload << tap_bip32_derivations.map{|k, v|PSBT.serialize_to_vector(PSBT_OUT_TYPES[:tap_bip32_derivation], key: k.htb, value: v.htb)}.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.rb

@@ -33,12 +33,21 @@ module Bitcoin
       sha256: 0x0b,
       hash160: 0x0c,
       hash256: 0x0d,
+      tap_key_sig: 0x13,
+      tap_script_sig: 0x14,
+      tap_leaf_script: 0x15,
+      tap_bip32_derivation: 0x16,
+      tap_internal_key: 0x17,
+      tap_merkle_root: 0x18,
       proprietary: 0xfc
     }
     PSBT_OUT_TYPES = {
       redeem_script: 0x00,
       witness_script: 0x01,
       bip32_derivation: 0x02,
+      tap_internal_key: 0x05,
+      tap_tree: 0x06,
+      tap_bip32_derivation: 0x07,
       proprietary: 0xfc
     }
     PSBT_SEPARATOR = 0x00

data/lib/bitcoin/script/script.rb

@@ -15,15 +15,28 @@ module Bitcoin
     end
 
     # generate P2PKH script
+    # @param [String] pubkey_hash public key hash with hex format
     def self.to_p2pkh(pubkey_hash)
       new << OP_DUP << OP_HASH160 << pubkey_hash << OP_EQUALVERIFY << OP_CHECKSIG
     end
 
     # generate P2WPKH script
+    # @param [String] pubkey_hash public key hash with hex format
+    # @return [Bitcoin::Script]
     def self.to_p2wpkh(pubkey_hash)
       new << WITNESS_VERSION_V0 << pubkey_hash
     end
 
+    # Generate P2TR script
+    # @param [String or Bitcoin::Key] xonly_pubkey public key with hex format or Bitcoin::Key
+    # @return [Bitcoin::Script]
+    # @raise ArgumentError
+    def self.to_p2tr(xonly_pubkey)
+      xonly_pubkey = xonly_pubkey.xonly_pubkey if xonly_pubkey.is_a?(Bitcoin::Key)
+      raise ArgumentError, 'Invalid public key size' unless xonly_pubkey.htb.bytesize == Bitcoin::WITNESS_V1_TAPROOT_SIZE
+      new << OP_1 << xonly_pubkey
+    end
+
     # generate m of n multisig p2sh script
     # @param [String] m the number of signatures required for multisig
     # @param [Array] pubkeys array of public keys that compose multisig

data/lib/bitcoin/script/script_interpreter.rb

@@ -136,16 +136,15 @@ module Bitcoin
         else
           sig_version = :tapscript
           # Script path spending (stack size is >1 after removing optional annex)
-          control = stack.pop.htb
-          script_payload = stack.pop.htb
-          if control.bytesize < TAPROOT_CONTROL_BASE_SIZE || control.bytesize > TAPROOT_CONTROL_MAX_SIZE ||
-              (control.bytesize - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE != 0
+          begin
+          control = Bitcoin::Taproot::ControlBlock.parse_from_payload(stack.pop.htb)
+          rescue Bitcoin::Taproot::Error
             return set_error(SCRIPT_ERR_TAPROOT_WRONG_CONTROL_SIZE)
           end
-          leaf_ver = control[0].bti & TAPROOT_LEAF_MASK
-          opts[:leaf_hash] = Bitcoin.tagged_hash('TapLeaf', [leaf_ver].pack('C') + Bitcoin.pack_var_string(script_payload))
+          script_payload = stack.pop.htb
+          opts[:leaf_hash] = Bitcoin.tagged_hash('TapLeaf', [control.leaf_ver].pack('C') + Bitcoin.pack_var_string(script_payload))
           return set_error(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH) unless valid_taproot_commitment?(control, program, opts[:leaf_hash])
-          if (control[0].bti & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT
+          if control.leaf_ver == TAPROOT_LEAF_TAPSCRIPT
             opts[:weight_left] = witness.to_payload.bytesize + VALIDATION_WEIGHT_OFFSET
             script_pubkey = Bitcoin::Script.parse_from_payload(script_payload)
             script_pubkey.chunks.each do |c|
@@ -698,19 +697,11 @@ module Bitcoin
     # check whether valid taproot commitment.
     def valid_taproot_commitment?(control, program, leaf_hash)
       begin
-        path_len = (control.bytesize - TAPROOT_CONTROL_BASE_SIZE) / TAPROOT_CONTROL_NODE_SIZE
-        xonly_pubkey = control[1...TAPROOT_CONTROL_BASE_SIZE]
-        p = Bitcoin::Key.from_xonly_pubkey(xonly_pubkey.bth)
+        p = Bitcoin::Key.from_xonly_pubkey(control.internal_key)
         k = leaf_hash
-        path_len.times do |i|
-          pos = (TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * i)
-          e = control[pos...(pos + TAPROOT_CONTROL_NODE_SIZE)]
-          k = Bitcoin.tagged_hash('TapBranch', k.bth < e.bth ? k + e : e + k)
-        end
-        t = Bitcoin.tagged_hash('TapTweak', xonly_pubkey + k)
-        key = Bitcoin::Key.new(priv_key: t.bth, key_type: Key::TYPES[:compressed])
-        q = key.to_point + p.to_point
-        return q.x == program.bti && (control[0].bti & 1) == (q.y % 2)
+        control.paths.each { |e| k = Bitcoin.tagged_hash('TapBranch', k.bth < e ? k + e.htb : e.htb + k) }
+        q = Bitcoin::Taproot.tweak_public_key(p, k.bth).to_point
+        return q.x == program.bti && control.parity == (q.y % 2)
       rescue ArgumentError
         return false
       end
@@ -751,7 +742,7 @@ module Bitcoin
       pubkey_size = pubkey.htb.bytesize
       if pubkey_size == 0
         return set_error(SCRIPT_ERR_PUBKEYTYPE)
-      elsif pubkey_size == 32
+      elsif pubkey_size == X_ONLY_PUBKEY_SIZE
         if success
           result = checker.check_schnorr_sig(sig, pubkey, :tapscript, opts)
           return checker.has_error? ? set_error(checker.error_code) : set_error(SCRIPT_ERR_SCHNORR_SIG) unless result
@@ -760,7 +751,6 @@ module Bitcoin
         return set_error(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_PUBKEYTYPE) if flag?(SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE)
       end
       success
-      # return true
     end
 
   end

data/lib/bitcoin/secp256k1/native.rb

@@ -232,7 +232,7 @@ module Bitcoin
       def full_pubkey_from_xonly_pubkey(pub_key)
         with_context do |context|
           pubkey = pub_key.htb
-          raise ArgumentError, 'Pubkey size must be 32 bytes.' unless pubkey.bytesize == 32
+          raise ArgumentError, "Pubkey size must be #{X_ONLY_PUBKEY_SIZE} bytes." unless pubkey.bytesize == X_ONLY_PUBKEY_SIZE
           xonly_pubkey = FFI::MemoryPointer.new(:uchar, pubkey.bytesize).put_bytes(0, pubkey)
           full_pubkey = FFI::MemoryPointer.new(:uchar, 64)
           raise ArgumentError, 'An invalid public key was specified.' unless secp256k1_xonly_pubkey_parse(context, full_pubkey, xonly_pubkey) == 1

data/lib/bitcoin/secp256k1/ruby.rb

@@ -32,7 +32,7 @@ module Bitcoin
       # @return [Boolean] result.
       def valid_xonly_pubkey?(pub_key)
         pubkey = pub_key.htb
-        return false unless pubkey.bytesize == 32
+        return false unless pubkey.bytesize == X_ONLY_PUBKEY_SIZE
         begin
           ECDSA::Format::PointOctetString.decode(pubkey, ECDSA::Group::Secp256k1)
         rescue Exception

data/lib/bitcoin/taproot/control_block.rb

@@ -0,0 +1,47 @@
+module Bitcoin
+  module Taproot
+    class ControlBlock
+      include Bitcoin::HexConverter
+
+      attr_accessor :parity
+      attr_accessor :leaf_ver
+      attr_accessor :internal_key
+      attr_accessor :paths
+
+      # @param [Integer] parity
+      # @param [Integer] leaf_ver
+      # @param [String] internal_key public key with hex format.
+      # @param [Array[String]] paths array of hash values of sibling nodes in the tree that serve as proof of inclusion
+      def initialize(parity, leaf_ver, internal_key, paths = [])
+        @parity = parity
+        @leaf_ver = leaf_ver
+        @internal_key = internal_key
+        @paths = paths
+      end
+
+      # parse control block from payload.
+      # @raise [Bitcoin::Taproot::Error]
+      # @return [Bitcoin::Taproot::ControlBlock]
+      def self.parse_from_payload(payload)
+        raise Bitcoin::Taproot::Error, 'Invalid data length for Control Block' if payload.bytesize > TAPROOT_CONTROL_MAX_SIZE
+        raise Bitcoin::Taproot::Error, 'Invalid data length for path in Control Block' unless (payload.bytesize - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE == 0
+        control, internal_key, paths = payload.unpack('Ca32a*')
+        parity = control & 1
+        leaf_ver = control - parity
+        raw_paths = StringIO.new(paths)
+        paths = (paths.bytesize / 32).times.map { raw_paths.read(32).bth }
+        ControlBlock.new(parity, leaf_ver, internal_key.bth, paths)
+      end
+
+      # Convert to payload.
+      # @return [String] payload with binary format.
+      def to_payload
+        [parity + leaf_ver].pack("C") + internal_key.htb + paths.map(&:htb).join
+      end
+
+      def ==(other)
+        to_payload == other.to_payload
+      end
+    end
+  end
+end

data/lib/bitcoin/taproot/simple_builder.rb

@@ -16,7 +16,7 @@ module Bitcoin
       # @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, leaves = [])
-        raise Error, 'Internal public key must be 32 bytes' unless internal_key.htb.bytesize == 32
+        raise Error, "Internal public key must be #{X_ONLY_PUBKEY_SIZE} bytes" unless internal_key.htb.bytesize == X_ONLY_PUBKEY_SIZE
         raise Error, 'leaf must be Bitcoin::Taproot::LeafNode object' if leaves.find{ |leaf| !leaf.is_a?(Bitcoin::Taproot::LeafNode)}
 
         @leaves = leaves
@@ -72,11 +72,11 @@ module Bitcoin
 
       # Generate control block needed to unlock with script-path.
       # @param [Bitcoin::Taproot::LeafNode] leaf Leaf to use for unlocking.
-      # @return [String] control block with binary format.
+      # @return [Bitcoin::Taproot::ControlBlock] control block.
       def control_block(leaf)
         path = inclusion_proof(leaf)
         parity = tweak_public_key.to_point.has_even_y? ? 0 : 1
-        [parity + leaf.leaf_ver].pack("C") + internal_key.htb + path.join
+        ControlBlock.new(parity, leaf.leaf_ver, internal_key, path.map(&:bth))
       end
 
       # Generate inclusion proof for +leaf+.

data/lib/bitcoin/taproot.rb

@@ -4,6 +4,7 @@ module Bitcoin
     class Error < StandardError; end
 
     autoload :LeafNode, 'bitcoin/taproot/leaf_node'
+    autoload :ControlBlock, 'bitcoin/taproot/control_block'
     autoload :SimpleBuilder, 'bitcoin/taproot/simple_builder'
 
     module_function

data/lib/bitcoin/tx_in.rb

@@ -34,8 +34,7 @@ module Bitcoin
     def self.parse_from_payload(payload)
       buf = payload.is_a?(String) ? StringIO.new(payload) : payload
       i = new
-      hash, index = buf.read(36).unpack('a32V')
-      i.out_point = OutPoint.new(hash.bth, index)
+      i.out_point = OutPoint.parse_from_payload(buf)
       sig_length = Bitcoin.unpack_var_int_from_io(buf)
       if sig_length == 0
         i.script_sig = Bitcoin::Script.new

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-22 00:00:00.000000000 Z
+date: 2022-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -479,6 +479,7 @@ files:
 - lib/bitcoin/store/spv_chain.rb
 - lib/bitcoin/store/utxo_db.rb
 - lib/bitcoin/taproot.rb
+- lib/bitcoin/taproot/control_block.rb
 - lib/bitcoin/taproot/leaf_node.rb
 - lib/bitcoin/taproot/simple_builder.rb
 - lib/bitcoin/tx.rb
@@ -516,7 +517,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.23
 signing_key: 
 specification_version: 4
 summary: The implementation of Bitcoin Protocol for Ruby.