bitcoinrb 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 900806837ee6cd6b011a50d6a58c37ea233079e8b86a594c6a5031c338f9a490
-  data.tar.gz: 34b437fee384d630d9b7f1a47faa8175692d9ebe21408d4720828140461b152c
+  metadata.gz: f2697b9fbcca175453c80fc67d70466845c7141e6b9e9f193b5825d34bd7ffa3
+  data.tar.gz: 61a5c26a7cfaf7abcc7c692386ff08091ea0249c9e8ea9ccb4f3231049319f47
 SHA512:
-  metadata.gz: 87bcfdb59403593475f90b49f9f67299bee3bfd8cfae7089080e95ab8e1ffddcdc21ebbb72f8ca49f1caea9d8df2ea5ca613eb97b698ddab3fb3d3c617611165
-  data.tar.gz: 55dcbb9ce3f10a5dd822e98605eb00fa74f3034a8852cdcd714b4dff5cd347cbdc55bffd49ae2f74cc4aeaad2bf86d01d635e7146207ccb6557f55ae0849ff0e
+  metadata.gz: 40574931606fc1ff074f638bda7042f86c0225a5661f37622971e0b9502e039c5010d31663c34846c80f0bff2d25a02122eb4773e30a6fadad72bb170260b114
+  data.tar.gz: aaefa2672459d1d133191aecf8cbe0e8391210647e109c6e5205e349e264ad2303b25c36d4812daf5f5f0e88fb15cc4b0bfc54653ba0a2b4a8bac9fd5fd9b5d6

data/.github/workflows/ruby.yml

@@ -22,7 +22,7 @@ jobs:
         ruby-version: ['3.0', '3.1', '3.2', '3.3']
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Install leveldb
       run: sudo apt-get install libleveldb-dev
     - name: Set up Ruby

data/README.md

@@ -1,6 +1,5 @@
 # Bitcoinrb [![Build Status](https://github.com/chaintope/bitcoinrb/actions/workflows/ruby.yml/badge.svg?branch=master)](https://github.com/chaintope/bitcoinrb/actions/workflows/ruby.yml) [![Gem Version](https://badge.fury.io/rb/bitcoinrb.svg)](https://badge.fury.io/rb/bitcoinrb) [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE) <img src="http://segwit.co/static/public/images/logo.png" width="100">
 
-
 Bitcoinrb is a Ruby implementation of Bitcoin Protocol.
 
 NOTE: Bitcoinrb work in progress, and there is a possibility of incompatible change. 
@@ -18,10 +17,9 @@ Bitcoinrb supports following feature:
 * 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))  
-* Taproot consensus([BIP-341](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki) and [BIP-342](https://github.com/bitcoin/bips/blob/master/bip-0342.mediawiki))  
-* [WIP] SPV node
-* [WIP] 0ff-chain protocol
+* Schnorr signature([BIP-340](https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki))
+* Taproot consensus([BIP-341](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki) and [BIP-342](https://github.com/bitcoin/bips/blob/master/bip-0342.mediawiki))
+* [Output script descriptor](https://github.com/chaintope/bitcoinrb/wiki/Output-Script-Descriptor) ([BIP-380](https://github.com/bitcoin/bips/blob/master/bip-0380.mediawiki), [BIP-381](https://github.com/bitcoin/bips/blob/master/bip-0381.mediawiki), [BIP-382](https://github.com/bitcoin/bips/blob/master/bip-0382.mediawiki), [BIP-383](https://github.com/bitcoin/bips/blob/master/bip-0383.mediawiki), [BIP-384](https://github.com/bitcoin/bips/blob/master/bip-0384.mediawiki), [BIP-385](https://github.com/bitcoin/bips/blob/master/bip-0385.mediawiki), [BIP-386](https://github.com/bitcoin/bips/blob/master/bip-0386.mediawiki), [BIP-387](https://github.com/bitcoin/bips/blob/master/bip-0387.mediawiki))
 
 ## Requirements
 
@@ -112,6 +110,10 @@ Therefore, some tests require this library. In a Linux environment, `spec/lib/li
 so there is no need to do anything. If you want to test in another environment,
 please set the library path in the environment variable `TEST_LIBSECP256K1_PATH`.
 
+In case the supplied linux `spec/lib/libsecp256k1.so` is not working (architecture), you might have to compile it yourself.
+Since if available in the repository, it might not be compiled using the `./configure --enable-module-recovery` option.
+Then `TEST_LIBSECP256K1_PATH=/path/to/secp256k1/.libs/libsecp256k1.so rspec` can be used.
+
 The libsecp256k1 library currently tested for operation with this library is `v0.4.0`.
 
 ## Contributing

data/lib/bitcoin/descriptor/addr.rb

@@ -0,0 +1,31 @@
+module Bitcoin
+  module Descriptor
+    class Addr < Expression
+      include Bitcoin::Util
+
+      attr_reader :addr
+
+      def initialize(addr)
+        raise ArgumentError, "Address must be string." unless addr.is_a?(String)
+        raise ArgumentError, "Address is not valid." unless valid_address?(addr)
+        @addr = addr
+      end
+
+      def type
+        :addr
+      end
+
+      def to_script
+        Bitcoin::Script.parse_from_addr(addr)
+      end
+
+      def top_level?
+        true
+      end
+
+      def args
+        addr
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/checksum.rb

@@ -0,0 +1,74 @@
+module Bitcoin
+  module Descriptor
+    # Descriptor checksum.
+    # https://github.com/bitcoin/bips/blob/master/bip-0380.mediawiki#checksum
+    module Checksum
+
+      INPUT_CHARSET = "0123456789()[],'/*abcdefgh@:$%{}IJKLMNOPQRSTUVWXYZ&+-.;<=>?!^_|~ijklmnopqrstuvwxyzABCDEFGH`#\"\\ "
+      CHECKSUM_CHARSET = Bech32::CHARSET
+      GENERATOR = [0xF5DEE51989, 0xA9FDCA3312, 0x1BAB10E32D, 0x3706B1677A, 0x644D626FFD]
+
+      module_function
+
+      # Verify that the checksum is correct in a descriptor
+      # @param [String] s Descriptor string.
+      # @return [Boolean]
+      def descsum_check(s)
+        return false unless s[-9] == '#'
+        s[-8..-1].each_char do |c|
+          return false unless CHECKSUM_CHARSET.include?(c)
+        end
+        symbols = descsum_expand(s[0...-9]) + s[-8..-1].each_char.map{|c|CHECKSUM_CHARSET.index(c)}
+        descsum_polymod(symbols) == 1
+      end
+
+      # Add a checksum to a descriptor without
+      # @param [String] s Descriptor string without checksum.
+      # @return [String] Descriptor string with checksum.
+      def descsum_create(s)
+        symbols = descsum_expand(s) + [0, 0, 0, 0, 0, 0, 0, 0]
+        checksum = descsum_polymod(symbols) ^ 1
+        result = 8.times.map do |i|
+          CHECKSUM_CHARSET[(checksum >> (5 * (7 - i))) & 31]
+        end.join
+        "#{s}##{result}"
+      end
+
+      # Internal function that does the character to symbol expansion.
+      # @param [String] s Descriptor string without checksum.
+      # @return [Array] symbols. An array of integer.
+      def descsum_expand(s)
+        groups = []
+        symbols = []
+        s.each_char do |c|
+          return nil unless INPUT_CHARSET.include?(c)
+          v = INPUT_CHARSET.index(c)
+          symbols << (v & 31)
+          groups << (v >> 5)
+          if groups.length == 3
+            symbols << (groups[0] * 9 + groups[1] * 3 + groups[2])
+            groups = []
+          end
+        end
+        symbols << groups[0] if groups.length == 1
+        symbols << (groups[0] * 3 + groups[1]) if groups.length == 2
+        symbols
+      end
+
+      # Internal function that computes the descriptor checksum.
+      # @param [Array] symbols
+      # @return [Integer]
+      def descsum_polymod(symbols)
+        chk = 1
+        symbols.each do |value|
+          top = chk >> 35
+          chk = (chk & 0x7FFFFFFFF) << 5 ^ value
+          5.times do |i|
+            chk ^= GENERATOR[i] if ((top >> i) & 1) == 1
+          end
+        end
+        chk
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/combo.rb

@@ -0,0 +1,30 @@
+module Bitcoin
+  module Descriptor
+    # combo() expression
+    class Combo < KeyExpression
+
+      def type
+        :combo
+      end
+
+      def to_scripts
+        candidates = [Pk.new(key), Pkh.new(key)]
+        pubkey = extract_pubkey(key)
+        if pubkey.compressed?
+          candidates << Wpkh.new(pubkey.pubkey)
+          candidates << Sh.new(candidates.last)
+        end
+        candidates.map(&:to_script)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Combo)
+        type == other.type && to_scripts == other.to_scripts
+      end
+
+      def top_level?
+        true
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/expression.rb

@@ -0,0 +1,122 @@
+module Bitcoin
+  module Descriptor
+    # Expression for descriptor.
+    class Expression
+
+      # Get expression type.
+      # @return [Symbol]
+      def type
+        raise NotImplementedError
+      end
+
+      # Convert to bitcoin script
+      # @return [Bitcoin::Script]
+      def to_script
+        raise NotImplementedError
+      end
+
+      # Whether this is top level or not.
+      # @return [Boolean]
+      def top_level?
+        raise NotImplementedError
+      end
+
+      # Get args for this expression.
+      # @return [String] args
+      def args
+        raise NotImplementedError
+      end
+
+      # Get descriptor string.
+      # @param [Boolean] checksum If true, append checksum.
+      # @return [String] Descriptor string.
+      def to_s(checksum: false)
+        desc = "#{type.to_s}(#{args})"
+        checksum ? Checksum.descsum_create(desc) : desc
+      end
+
+      # Convert to bitcoin script as hex string.
+      # @return [String]
+      def to_hex
+        to_script.to_hex
+      end
+
+      # Check whether +key+ is compressed public key or not.
+      # @return [Boolean]
+      def compressed_key?(key)
+        %w(02 03).include?(key[0..1]) && [key].pack("H*").bytesize == 33
+      end
+
+      # Extract public key from KEY format.
+      # @param [String] key KEY string.
+      # @return [Bitcoin::Key] public key.
+      def extract_pubkey(key)
+        if key.start_with?('[') # BIP32 fingerprint
+          raise ArgumentError, "Multiple ']' characters found for a single pubkey." if key.count('[') > 1 || key.count(']') > 1
+          info = key[1...key.index(']')]
+          fingerprint, *paths = info.split('/')
+          raise ArgumentError, "Fingerprint '#{fingerprint}' is not hex." unless fingerprint.valid_hex?
+          raise ArgumentError, "Fingerprint '#{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('/')
+
+        raise ArgumentError, "No key provided." unless key
+
+        if key.start_with?('xprv')
+          key = Bitcoin::ExtKey.from_base58(key)
+          key = derive_path(key, paths) if paths
+        elsif key.start_with?('xpub')
+          key = Bitcoin::ExtPubkey.from_base58(key)
+          key = derive_path(key, paths) if paths
+        else
+          begin
+            key = Bitcoin::Key.from_wif(key)
+          rescue ArgumentError
+            key = if key.length == 64
+                    Bitcoin::Key.from_xonly_pubkey(key)
+                  else
+                    key_type = compressed_key?(key) ? Bitcoin::Key::TYPES[:compressed] : Bitcoin::Key::TYPES[:uncompressed]
+                    Bitcoin::Key.new(pubkey: key, key_type: key_type)
+                  end
+          end
+        end
+        key = key.is_a?(Bitcoin::Key) ? key : key.key
+        raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless key.fully_valid_pubkey?
+        key
+      end
+
+      # Derive key using +paths+.
+      # @param [Bitcoin::ExtKey or Bitcoin::ExtPubkey] key
+      # @param [String] paths derivation path.
+      # @return [Bitcoin::Key]
+      def derive_path(key, paths)
+        is_private = key.is_a?(Bitcoin::ExtKey)
+        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
+
+      def ==(other)
+        return false unless other.is_a?(Expression)
+        type == other.type && to_script == other.to_script
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/key_expression.rb

@@ -0,0 +1,23 @@
+module Bitcoin
+  module Descriptor
+    class KeyExpression < Expression
+      attr_reader :key
+
+      # Constructor
+      # @raise [ArgumentError] If +key+ is invalid.
+      def initialize(key)
+        raise ArgumentError, "Key must be string." unless key.is_a? String
+        extract_pubkey(key)
+        @key = key
+      end
+
+      def args
+        key
+      end
+
+      def top_level?
+        false
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/multi.rb

@@ -0,0 +1,49 @@
+module Bitcoin
+  module Descriptor
+    # multi() expression
+    class Multi < Expression
+
+      attr_reader :threshold
+      attr_reader :keys
+
+      def initialize(threshold, keys)
+        validate!(threshold, keys)
+        @threshold = threshold
+        @keys = keys
+      end
+
+      def type
+        :multi
+      end
+
+      def to_script
+        Script.to_multisig_script(threshold, keys.map{|key| extract_pubkey(key).pubkey }, sort: false)
+      end
+
+      def to_hex
+        result = to_script
+        pubkey_count = result.get_pubkeys.length
+        raise RuntimeError, "Cannot have #{pubkey_count} pubkeys in bare multisig; only at most 3 pubkeys." if pubkey_count > 3
+        result.to_hex
+      end
+
+      def args
+        "#{threshold},#{keys.join(',')}"
+      end
+
+      def top_level?
+        false
+      end
+
+      private
+
+      def validate!(threshold, keys)
+        raise ArgumentError, "Multisig threshold '#{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 #{Bitcoin::MAX_PUBKEYS_PER_MULTISIG} keys, inclusive." if keys.size > Bitcoin::MAX_PUBKEYS_PER_MULTISIG
+        keys.each{|key| extract_pubkey(key) }
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/multi_a.rb

@@ -0,0 +1,43 @@
+module Bitcoin
+  module Descriptor
+    # multi_a() expression
+    # @see https://github.com/bitcoin/bips/blob/master/bip-0387.mediawiki
+    class MultiA < Multi
+      include Bitcoin::Opcodes
+
+      def type
+        :multi_a
+      end
+
+      def to_hex
+        raise RuntimeError, "Can only have multi_a/sortedmulti_a inside tr()."
+      end
+
+      def to_script
+        multisig_script(keys.map{|k| extract_pubkey(k).xonly_pubkey})
+      end
+
+      private
+
+      def multisig_script(keys)
+        script = Bitcoin::Script.new
+        keys.each.with_index do |k, i|
+          script << k
+          script << (i == 0 ? OP_CHECKSIG : OP_CHECKSIGADD)
+        end
+        script << threshold << OP_NUMEQUAL
+      end
+
+      def validate!(threshold, keys)
+        raise ArgumentError, "Multisig threshold '#{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 999 keys, inclusive." if keys.size > 999
+        keys.each do |key|
+          k = extract_pubkey(key)
+          raise ArgumentError, "Uncompressed key are not allowed." unless k.compressed?
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/pk.rb

@@ -0,0 +1,27 @@
+module Bitcoin
+  module Descriptor
+    # pk() expression
+    class Pk < KeyExpression
+      include Bitcoin::Opcodes
+
+      attr_accessor :xonly
+
+      def initialize(key)
+        super(key)
+        @xonly = false
+      end
+
+      def type
+        :pk
+      end
+
+      # Convert to bitcoin script.
+      # @return [Bitcoin::Script]
+      def to_script
+        k = extract_pubkey(key)
+        target_key = xonly ? k.xonly_pubkey : k.pubkey
+        Bitcoin::Script.new << target_key << OP_CHECKSIG
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/pkh.rb

@@ -0,0 +1,15 @@
+module Bitcoin
+  module Descriptor
+    # pkh() expression
+    class Pkh < KeyExpression
+
+      def type
+        :pkh
+      end
+
+      def to_script
+        Script.to_p2pkh(extract_pubkey(key).hash160)
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/raw.rb

@@ -0,0 +1,32 @@
+module Bitcoin
+  module Descriptor
+    class Raw < Expression
+
+      attr_reader :hex
+
+      # Constructor
+      # @param [String] hex
+      def initialize(hex)
+        raise ArgumentError, "Raw script must be string." unless hex.is_a?(String)
+        raise ArgumentError, "Raw script is not hex." unless hex.valid_hex?
+        @hex = hex
+      end
+
+      def type
+        :raw
+      end
+
+      def to_script
+        Bitcoin::Script.parse_from_payload(hex.htb)
+      end
+
+      def args
+        hex
+      end
+
+      def top_level?
+        true
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/script_expression.rb

@@ -0,0 +1,24 @@
+module Bitcoin
+  module Descriptor
+    class ScriptExpression < Expression
+
+      attr_reader :script
+
+      def initialize(script)
+        validate!(script)
+        @script = script
+      end
+
+      def args
+        script.to_s
+      end
+
+      private
+
+      def validate!(script)
+        raise ArgumentError, "Can only have #{script.type.to_s}() at top level." if script.is_a?(Expression) && script.top_level?
+        raise ArgumentError, 'Can only have multi_a/sortedmulti_a inside tr().' if script.is_a?(MultiA) || script.is_a?(SortedMultiA)
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/sh.rb

@@ -0,0 +1,31 @@
+module Bitcoin
+  module Descriptor
+    # sh expression
+    class Sh < ScriptExpression
+
+      def type
+        :sh
+      end
+
+      def to_script
+        script.to_script.to_p2sh
+      end
+
+      def top_level?
+        true
+      end
+
+      private
+
+      def validate!(script)
+        super(script)
+        raise ArgumentError, 'A function is needed within P2SH.' unless script.is_a?(Expression)
+        script_size = script.to_script.size
+        if script_size > Bitcoin::MAX_SCRIPT_ELEMENT_SIZE
+          raise ArgumentError,
+                "P2SH script is too large, #{script_size} bytes is larger than #{Bitcoin::MAX_SCRIPT_ELEMENT_SIZE} bytes."
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/sorted_multi.rb

@@ -0,0 +1,15 @@
+module Bitcoin
+  module Descriptor
+    # sortedmulti() expression
+    class SortedMulti < Multi
+
+      def type
+        :sortedmulti
+      end
+
+      def to_script
+        Script.to_multisig_script(threshold, keys.map{|key| extract_pubkey(key).pubkey }, sort: true)
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/sorted_multi_a.rb

@@ -0,0 +1,15 @@
+module Bitcoin
+  module Descriptor
+    # sortedmulti_a expression
+    # @see https://github.com/bitcoin/bips/blob/master/bip-0387.mediawiki
+    class SortedMultiA < MultiA
+      def type
+        :sortedmulti_a
+      end
+
+      def to_script
+        multisig_script( keys.map{|k| extract_pubkey(k).xonly_pubkey}.sort)
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/tr.rb

@@ -0,0 +1,91 @@
+module Bitcoin
+  module Descriptor
+    # tr() expression.
+    # @see https://github.com/bitcoin/bips/blob/master/bip-0386.mediawiki
+    class Tr < Expression
+
+      attr_reader :key
+      attr_reader :tree
+
+      # Constructor.
+      def initialize(key, tree = nil)
+        raise ArgumentError, "Key must be string." unless key.is_a?(String)
+        k = extract_pubkey(key)
+        raise ArgumentError, "Uncompressed key are not allowed." unless k.compressed?
+        validate_tree!(tree)
+        @key = key
+        @tree = tree
+      end
+
+      def type
+        :tr
+      end
+
+      def top_level?
+        true
+      end
+
+      def args
+        if tree.nil?
+          key
+        else
+          tree.is_a?(Array) ? "#{key},#{tree_string(tree)}" : "#{key},#{tree}"
+        end
+      end
+
+      def to_script
+        builder = build_tree_scripts
+        builder.build
+      end
+
+      private
+
+      def build_tree_scripts
+        internal_key = extract_pubkey(key)
+        return Bitcoin::Taproot::SimpleBuilder.new(internal_key.xonly_pubkey) if tree.nil?
+        if tree.is_a?(Expression)
+          tree.xonly = true if tree.respond_to?(:xonly)
+          Bitcoin::Taproot::SimpleBuilder.new(internal_key.xonly_pubkey, [Bitcoin::Taproot::LeafNode.new(tree.to_script)])
+        elsif tree.is_a?(Array)
+          Bitcoin::Taproot::CustomDepthBuilder.new(internal_key.xonly_pubkey, parse_tree_items(tree))
+        end
+      end
+
+      def parse_tree_items(arry)
+        items = []
+        arry.each do |item|
+          if item.is_a?(Array)
+            items << parse_tree_items(item)
+          elsif item.is_a?(Expression)
+            item.xonly = true
+            items << Bitcoin::Taproot::LeafNode.new(item.to_script)
+          else
+            raise RuntimeError, "Unsupported item #{item}"
+          end
+        end
+        items
+      end
+
+      def validate_tree!(tree)
+        return if tree.nil? || tree.is_a?(Expression)
+        if tree.is_a?(Array)
+          tree.each do |item|
+            validate_tree!(item)
+          end
+        else
+          raise ArgumentError, "tree must be a expression or array of expression."
+        end
+      end
+
+      def tree_string(tree)
+        buffer = '{'
+        left, right = tree
+        buffer << (left.is_a?(Array) ? tree_string(left) : left.to_s)
+        buffer << ","
+        buffer << (right.is_a?(Array) ? tree_string(right) : right.to_s)
+        buffer << '}'
+        buffer
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/wpkh.rb

@@ -0,0 +1,19 @@
+module Bitcoin
+  module Descriptor
+    # wpkh() expression
+    class Wpkh < KeyExpression
+      def initialize(key)
+        super(key)
+        raise ArgumentError, "Uncompressed key are not allowed." unless extract_pubkey(key).compressed?
+      end
+
+      def type
+        :wpkh
+      end
+
+      def to_script
+        Script.to_p2wpkh(extract_pubkey(key).hash160)
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor/wsh.rb

@@ -0,0 +1,30 @@
+module Bitcoin
+  module Descriptor
+    # wsh() expression
+    class Wsh < ScriptExpression
+
+      def type
+        :wsh
+      end
+
+      def to_script
+        Script.to_p2wsh(script.to_script)
+      end
+
+      def top_level?
+        false
+      end
+
+      def validate!(script)
+        super(script)
+        raise ArgumentError, 'A function is needed within P2WSH.' unless script.is_a?(Expression)
+        if script.is_a?(Wpkh) || script.is_a?(Wsh)
+          raise ArgumentError, "Can only have #{script.type}() at top level or inside sh()."
+        end
+        if script.to_script.get_pubkeys.any?{|p|!compressed_key?(p)}
+          raise ArgumentError, "Uncompressed key are not allowed."
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor.rb

@@ -3,145 +3,221 @@ module Bitcoin
   module Descriptor
 
     include Bitcoin::Opcodes
-
-    # generate P2PK output for the given public key.
+    autoload :Expression, 'bitcoin/descriptor/expression'
+    autoload :KeyExpression, 'bitcoin/descriptor/key_expression'
+    autoload :ScriptExpression, 'bitcoin/descriptor/script_expression'
+    autoload :Pk, 'bitcoin/descriptor/pk'
+    autoload :Pkh, 'bitcoin/descriptor/pkh'
+    autoload :Wpkh, 'bitcoin/descriptor/wpkh'
+    autoload :Sh, 'bitcoin/descriptor/sh'
+    autoload :Wsh, 'bitcoin/descriptor/wsh'
+    autoload :Combo, 'bitcoin/descriptor/combo'
+    autoload :Multi, 'bitcoin/descriptor/multi'
+    autoload :SortedMulti, 'bitcoin/descriptor/sorted_multi'
+    autoload :Raw, 'bitcoin/descriptor/raw'
+    autoload :Addr,  'bitcoin/descriptor/addr'
+    autoload :Tr,  'bitcoin/descriptor/tr'
+    autoload :MultiA,  'bitcoin/descriptor/multi_a'
+    autoload :SortedMultiA, 'bitcoin/descriptor/sorted_multi_a'
+    autoload :Checksum, 'bitcoin/descriptor/checksum'
+
+    module_function
+
+    # Generate P2PK output for the given public key.
     # @param [String] key private key or public key with hex format
-    # @return [Bitcoin::Script] P2PK script.
+    # @return [Bitcoin::Descriptor::Pk]
     def pk(key)
-      Bitcoin::Script.new << extract_pubkey(key) << OP_CHECKSIG
+      Pk.new(key)
     end
 
-    # generate P2PKH output for the given public key.
+    # Generate P2PKH output for the given public key.
     # @param [String] key private key or public key with hex format.
-    # @return [Bitcoin::Script] P2PKH script.
+    # @return [Bitcoin::Descriptor::Pkh]
     def pkh(key)
-      Bitcoin::Script.to_p2pkh(Bitcoin.hash160(extract_pubkey(key)))
+      Pkh.new(key)
     end
 
-    # generate P2PKH output for the given public key.
+    # Generate P2PKH output for the given public key.
     # @param [String] key private key or public key with hex format.
-    # @return [Bitcoin::Script] P2WPKH script.
+    # @return [Bitcoin::Descriptor::Wpkh]
     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))
+      Wpkh.new(key)
     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))
+    # Generate P2SH embed the argument.
+    # @param [Bitcoin::Descriptor::Base] exp script expression to be embed.
+    # @return [Bitcoin::Descriptor::Sh]
+    def sh(exp)
+      Sh.new(exp)
     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)
+    # Generate P2WSH embed the argument.
+    # @param [Bitcoin::Descriptor::Expression] exp script expression to be embed.
+    # @return [Bitcoin::Descriptor::Wsh]
+    def wsh(exp)
+      Wsh.new(exp)
     end
 
-    # an alias for the collection of `pk(KEY)` and `pkh(KEY)`.
+    # 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]]
+    # @return [Bitcoin::Descriptor::Combo]
     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
+      Combo.new(key)
     end
 
-    # generate multisig output for given keys.
+    # 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)
+    # @return [Bitcoin::Descriptor::Multi] multisig script.
+    def multi(threshold, *keys)
+      Multi.new(threshold, keys)
     end
 
-    # generate sorted multisig output for given keys.
+    # 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.
+    # @return [Bitcoin::Descriptor::SortedMulti]
     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
+      SortedMulti.new(threshold, keys)
+    end
 
-      # check BIP32 derivation path
-      key, *paths = key.split('/')
+    # Generate raw output script about +hex+.
+    # @param [String] hex Hex string of bitcoin script.
+    # @return [Bitcoin::Descriptor::Raw]
+    def raw(hex)
+      Raw.new(hex)
+    end
 
-      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)
+    # Generate raw output script about +hex+.
+    # @param [String] addr Bitcoin address.
+    # @return [Bitcoin::Descriptor::Addr]
+    def addr(addr)
+      Addr.new(addr)
+    end
+
+    # Generate taproot output script descriptor.
+    # @param [String] key
+    # @param [String] tree
+    # @return [Bitcoin::Descriptor::Tr]
+    def tr(key, tree = nil)
+      Tr.new(key, tree)
+    end
+
+    # Generate tapscript multisig output for given keys.
+    # @param [Integer] threshold the threshold of multisig.
+    # @param [Array[String]] keys an array of keys.
+    # @return [Bitcoin::Descriptor::MultiA] multisig script.
+    def multi_a(threshold, *keys)
+      MultiA.new(threshold, keys)
+    end
+
+    # Generate tapscript sorted multisig output for given keys.
+    # @param [Integer] threshold the threshold of multisig.
+    # @param [Array[String]] keys an array of keys.
+    # @return [Bitcoin::Descriptor::SortedMulti]
+    def sortedmulti_a(threshold, *keys)
+      SortedMultiA.new(threshold, keys)
+    end
+
+    # Parse descriptor string.
+    # @param [String] string Descriptor string.
+    # @return [Bitcoin::Descriptor::Expression]
+    def parse(string, top_level = true)
+      validate_checksum!(string)
+      content, _ = string.split('#')
+      exp, args_str = content.match(/(\w+)\((.+)\)/).captures
+      case exp
+      when 'pk'
+        pk(args_str)
+      when 'pkh'
+        pkh(args_str)
+      when 'wpkh'
+        wpkh(args_str)
+      when 'sh'
+        sh(parse(args_str, false))
+      when 'wsh'
+        wsh(parse(args_str, false))
+      when 'combo'
+        combo(args_str)
+      when 'multi', 'sortedmulti', 'multi_a', 'sortedmulti_a'
+        args = args_str.split(',')
+        threshold = args[0].to_i
+        keys = args[1..-1]
+        case exp
+        when 'multi'
+          multi(threshold, *keys)
+        when 'sortedmulti'
+          sortedmulti(threshold, *keys)
+        when 'multi_a'
+          raise ArgumentError, "Can only have multi_a/sortedmulti_a inside tr()." if top_level
+          multi_a(threshold, *keys)
+        when 'sortedmulti_a'
+          raise ArgumentError, "Can only have multi_a/sortedmulti_a inside tr()." if top_level
+          sortedmulti_a(threshold, *keys)
         end
+      when 'raw'
+        raw(args_str)
+      when 'addr'
+        addr(args_str)
+      when 'tr'
+        key, rest = args_str.split(',', 2)
+        if rest.nil?
+          tr(key)
+        elsif rest.start_with?('{')
+          tr(key, parse_nested_string(rest))
+        else
+          tr(key, parse(rest, false))
+        end
+      else
+        raise ArgumentError, "Parse failed: #{string}"
       end
-      key = key.is_a?(Bitcoin::Key) ? key : key.key
-      raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless key.fully_valid_pubkey?
-      key.pubkey
     end
 
-    def compressed_key?(key)
-      %w(02 03).include?(key[0..1]) && [key].pack("H*").bytesize == 33
+    # Validate descriptor checksum.
+    # @raise [ArgumentError] If +descriptor+ has invalid checksum.
+    def validate_checksum!(descriptor)
+      return unless descriptor.include?("#")
+      content, *checksums = descriptor.split("#")
+      raise ArgumentError, "Multiple '#' symbols." if checksums.length > 1
+      checksum = checksums.first
+      len = checksum.nil? ? 0 : checksum.length
+      raise ArgumentError, "Expected 8 character checksum, not #{len} characters." unless len == 8
+      _, calc_checksum = Checksum.descsum_create(content).split('#')
+      unless calc_checksum == checksum
+        raise ArgumentError, "Provided checksum '#{checksum}' does not match computed checksum '#{calc_checksum}'."
+      end
     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)
+    def parse_nested_string(string)
+      return nil if string.nil?
+      stack = []
+      current = []
+      buffer = ""
+      string.each_char do |c|
+        case c
+        when '{'
+          stack << current
+          current = []
+        when '}'
+          unless buffer.empty?
+            current << parse(buffer, false)
+            buffer = ""
+          end
+          nested = current
+          current = stack.pop
+          current << nested
+        when ','
+          unless buffer.empty?
+            current << parse(buffer, false)
+            buffer = ""
+          end
         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)
+          buffer << c
         end
       end
-      key
+      current << parse(buffer, false) unless buffer.empty?
+      current.first
     end
-
   end
-
 end

data/lib/bitcoin/key.rb

@@ -83,7 +83,7 @@ module Bitcoin
     # @return [Bitcoin::Key] key object has public key.
     def self.from_xonly_pubkey(xonly_pubkey)
       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])
+      Bitcoin::Key.new(pubkey: "02#{xonly_pubkey}", key_type: TYPES[:p2tr])
     end
 
     # Generate from public key point.

data/lib/bitcoin/script/script.rb

@@ -55,7 +55,9 @@ module Bitcoin
 
     # generate p2sh script with this as a redeem script
     # @return [Script] P2SH script
+    # @raise [RuntimeError] If the script size exceeds 520 bytes
     def to_p2sh
+      raise RuntimeError, "P2SH redeem script must be 520 bytes or less." if size > Bitcoin::MAX_SCRIPT_ELEMENT_SIZE
       Script.to_p2sh(to_hash160)
     end
 
@@ -74,9 +76,11 @@ module Bitcoin
     end
 
     # generate p2wsh script for +redeem_script+
-    # @param [Script] redeem_script target redeem script
-    # @param [Script] p2wsh script
+    # @param [Bitcoin::Script] redeem_script target redeem script
+    # @return [Bitcoin::Script] p2wsh script
+    # @raise [ArgumentError] If the script size exceeds 10,000 bytes
     def self.to_p2wsh(redeem_script)
+      raise ArgumentError, 'P2WSH witness script must be 10,000 bytes or less.' if redeem_script.size > Bitcoin::MAX_SCRIPT_SIZE
       new << WITNESS_VERSION_V0 << redeem_script.to_sha256
     end
 
@@ -146,7 +150,7 @@ module Bitcoin
                 end
           if buf.eof?
             s.chunks << [len].pack('C')
-          else buf.eof?
+          else
             chunk = (packed_size ? (opcode + packed_size) : (opcode)) + buf.read(len)
             s.chunks << chunk
           end
@@ -555,6 +559,7 @@ module Bitcoin
       return 'multisig' if multisig?
       return 'witness_v0_keyhash' if p2wpkh?
       return 'witness_v0_scripthash' if p2wsh?
+      return 'witness_v1_taproot' if p2tr?
       'nonstandard'
     end
 

data/lib/bitcoin/secp256k1/native.rb

@@ -7,7 +7,7 @@ module Bitcoin
     # binding for secp256k1 (https://github.com/bitcoin-core/secp256k1/)
     # tag: v0.4.0
     # this is not included by default, to enable set shared object path to ENV['SECP256K1_LIB_PATH']
-    # for linux, ENV['SECP256K1_LIB_PATH'] = '/usr/local/lib/libsecp256k1.so'
+    # for linux, ENV['SECP256K1_LIB_PATH'] = '/usr/local/lib/libsecp256k1.so' or '/usr/lib64/libsecp256k1.so'
     # for mac,
     module Native
       include ::FFI::Library

data/lib/bitcoin/taproot/custom_depth_builder.rb

@@ -0,0 +1,64 @@
+module Bitcoin
+  module Taproot
+    # A class that takes the script tree configuration as a nested array and constructs the Taproot output.
+    # TODO WIP
+    class CustomDepthBuilder < SimpleBuilder
+
+      attr_reader :tree
+
+      # Constructor
+      # @param [String] internal_key Internal public key with hex format.
+      # @param [Array] tree Script tree configuration as a nested array.
+      # @return [Bitcoin::Taproot::CustomDepthBuilder]
+      def initialize(internal_key, tree)
+        super(internal_key, [])
+        raise ArgumentError, "tree must be an array." unless tree.is_a?(Array)
+        raise ArgumentError, "tree must be binary tree." unless tree.length == 2
+        tree.each do |item|
+          unless item.is_a?(Array) || item.is_a?(Bitcoin::Taproot::LeafNode)
+            raise ArgumentError, "tree must consist of either an array or LeafNode."
+          end
+          raise ArgumentError, "tree must be binary tree." if item.is_a?(Array) && item.length != 2
+        end
+        @tree = tree
+      end
+
+      def add_leaf(leaf)
+        raise NotImplementedError
+      end
+
+      def add_branch(leaf1, leaf2 = nil)
+        raise NotImplementedError
+      end
+
+      def control_block(leaf)
+        raise NotImplementedError # TODO
+      end
+
+      def inclusion_proof(leaf)
+        raise NotImplementedError # TODO
+      end
+
+      private
+
+      def merkle_root
+        build_tree(tree).bth
+      end
+
+      def build_tree(tree)
+        left, right = tree
+        left_hash = if left.is_a?(Array)
+                      build_tree(left)
+                    else
+                      left
+                    end
+        right_hash = if right.is_a?(Array)
+                       build_tree(right)
+                     else
+                       right
+                     end
+        combine_hash([left_hash, right_hash])
+      end
+    end
+  end
+end

data/lib/bitcoin/taproot/simple_builder.rb

@@ -16,6 +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 ArgumentError, "Internal public key must be string." unless internal_key.is_a?(String)
         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)}
 
@@ -113,12 +114,6 @@ module Bitcoin
 
       private
 
-      # Compute tweak from script tree.
-      # @return [String] tweak with binary format.
-      def tweak
-        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

data/lib/bitcoin/taproot.rb

@@ -6,6 +6,7 @@ module Bitcoin
     autoload :LeafNode, 'bitcoin/taproot/leaf_node'
     autoload :ControlBlock, 'bitcoin/taproot/control_block'
     autoload :SimpleBuilder, 'bitcoin/taproot/simple_builder'
+    autoload :CustomDepthBuilder,  'bitcoin/taproot/custom_depth_builder'
 
     module_function
 

data/lib/bitcoin/tx.rb

@@ -111,7 +111,7 @@ module Bitcoin
     end
 
     def witness?
-      !inputs.find { |i| !i.script_witness.empty? }.nil?
+      inputs.any?(&:has_witness?)
     end
 
     def ==(other)

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "1.5.0"
+  VERSION = "1.6.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-03-14 00:00:00.000000000 Z
+date: 2024-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa_ext
@@ -350,6 +350,23 @@ files:
 - lib/bitcoin/chainparams/testnet.yml
 - lib/bitcoin/constants.rb
 - lib/bitcoin/descriptor.rb
+- lib/bitcoin/descriptor/addr.rb
+- lib/bitcoin/descriptor/checksum.rb
+- lib/bitcoin/descriptor/combo.rb
+- lib/bitcoin/descriptor/expression.rb
+- lib/bitcoin/descriptor/key_expression.rb
+- lib/bitcoin/descriptor/multi.rb
+- lib/bitcoin/descriptor/multi_a.rb
+- lib/bitcoin/descriptor/pk.rb
+- lib/bitcoin/descriptor/pkh.rb
+- lib/bitcoin/descriptor/raw.rb
+- lib/bitcoin/descriptor/script_expression.rb
+- lib/bitcoin/descriptor/sh.rb
+- lib/bitcoin/descriptor/sorted_multi.rb
+- lib/bitcoin/descriptor/sorted_multi_a.rb
+- lib/bitcoin/descriptor/tr.rb
+- lib/bitcoin/descriptor/wpkh.rb
+- lib/bitcoin/descriptor/wsh.rb
 - lib/bitcoin/errors.rb
 - lib/bitcoin/ext.rb
 - lib/bitcoin/ext/array_ext.rb
@@ -464,6 +481,7 @@ files:
 - lib/bitcoin/store/utxo_db.rb
 - lib/bitcoin/taproot.rb
 - lib/bitcoin/taproot/control_block.rb
+- lib/bitcoin/taproot/custom_depth_builder.rb
 - lib/bitcoin/taproot/leaf_node.rb
 - lib/bitcoin/taproot/simple_builder.rb
 - lib/bitcoin/tx.rb