bitcoinrb 1.4.0 → 1.6.0

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