bitcoinrb 1.5.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 900806837ee6cd6b011a50d6a58c37ea233079e8b86a594c6a5031c338f9a490
-  data.tar.gz: 34b437fee384d630d9b7f1a47faa8175692d9ebe21408d4720828140461b152c
+  metadata.gz: 81a899ff49ba8888d3479e7f0c93c2124098c07c68dfd293349881d724c9393b
+  data.tar.gz: '052092011357a7abb68ec74bbbd5939b74d75aa83d5561ce088fc80c152b3341'
 SHA512:
-  metadata.gz: 87bcfdb59403593475f90b49f9f67299bee3bfd8cfae7089080e95ab8e1ffddcdc21ebbb72f8ca49f1caea9d8df2ea5ca613eb97b698ddab3fb3d3c617611165
-  data.tar.gz: 55dcbb9ce3f10a5dd822e98605eb00fa74f3034a8852cdcd714b4dff5cd347cbdc55bffd49ae2f74cc4aeaad2bf86d01d635e7146207ccb6557f55ae0849ff0e
+  metadata.gz: ce9d912ba951f85c95dd30b29f1f2d0330a168e6fdd119296186fc6e651ba92ab838c90b7d31cf1a99e17def444c6bcb9784eff6ceab0816b210428fbc77b36a
+  data.tar.gz: bc9f7c2e34f9f47def957b549e5c33f5a4940fb56ad2fb379f717811aedd0b5f1cc4089c0f67ff7ad1363eb9a7d7b4a4ea4405124a06b20a1674d02802720cfe

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/block.rb

@@ -4,11 +4,38 @@ module Bitcoin
     attr_accessor :header
     attr_accessor :transactions
 
+    # Constructor
+    # @param [Bitcoin::BlockHeader] header
+    # @param [Array] transactions An array of transaction.
+    # @raise [ArgumentError]
     def initialize(header, transactions = [])
+      raise ArgumentError, "header must be Bitcoin::BlockHeader." unless header.is_a?(Bitcoin::BlockHeader)
+      raise ArgumentError, "transactions must be an Array." unless transactions.is_a?(Array)
       @header = header
       @transactions = transactions
     end
 
+    # Create genesis block.
+    # @param [String] msg Message embedded in coinbase transaction.
+    # @param [Bitcoin::Script] script Coinbase transaction scriptPubkey.
+    # @param [Integer] time Block time.
+    # @param [Integer] nonce nonce.
+    # @param [Integer] bits nBits
+    # @param [Integer] version nVersion.
+    # @param [Integer] rewards Block rewards(satoshi).
+    def self.create_genesis(msg, script, time, nonce, bits, version, rewards = 50 * 100000000)
+      coinbase = Bitcoin::Tx.create_coinbase(msg, script, rewards)
+      header = BlockHeader.new(
+        version,
+        '00' * 32,
+        MerkleTree.build_from_leaf([coinbase.txid]).merkle_root.rhex,
+        time,
+        bits,
+        nonce
+      )
+      Block.new(header, [coinbase])
+    end
+
     def self.parse_from_payload(payload)
       Bitcoin::Message::Block.parse_from_payload(payload).to_block
     end

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 = extracted_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,30 @@
+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
+
+      # Get extracted key.
+      # @return [Bitcoin::Key] Extracted key.
+      def extracted_key
+        extract_pubkey(key)
+      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 = extracted_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(extracted_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/raw_tr.rb

@@ -0,0 +1,20 @@
+module Bitcoin
+  module Descriptor
+    # rawtr() expression
+    class RawTr < KeyExpression
+      include Bitcoin::Opcodes
+
+      def type
+        :rawtr
+      end
+
+      def top_level?
+        true
+      end
+
+      def to_script
+        Bitcoin::Script.new << OP_1 << extract_pubkey(key).xonly_pubkey
+      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