bitcoinrb 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81a899ff49ba8888d3479e7f0c93c2124098c07c68dfd293349881d724c9393b
-  data.tar.gz: '052092011357a7abb68ec74bbbd5939b74d75aa83d5561ce088fc80c152b3341'
+  metadata.gz: a0cc5450016d6ffbb76d36dcccd415a485a8532ab8414d9beddb9a7e25305dba
+  data.tar.gz: 75d509c36069ce2dee667a0330962ae310c8062f24aa01d299e5692f6f069461
 SHA512:
-  metadata.gz: ce9d912ba951f85c95dd30b29f1f2d0330a168e6fdd119296186fc6e651ba92ab838c90b7d31cf1a99e17def444c6bcb9784eff6ceab0816b210428fbc77b36a
-  data.tar.gz: bc9f7c2e34f9f47def957b549e5c33f5a4940fb56ad2fb379f717811aedd0b5f1cc4089c0f67ff7ad1363eb9a7d7b4a4ea4405124a06b20a1674d02802720cfe
+  metadata.gz: c2457464548bd24c937eaf55aa53ff2b7ca01b5db0b57b66d7e6fef60142cde6ff2752d670e06bd6052470b6eef25af9f3b676ffe1842fd98c1fd9d590888556
+  data.tar.gz: 95d5649e3cacc1a155b0e033f0275d9f1806a9e39aad2bbe0c9b61809a10b76d117dddf94c0c68eae50e9dd52aa8e3f266244e2a400821d9172e2706a371c654

data/.github/workflows/ruby.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['3.0', '3.1', '3.2', '3.3']
+        ruby-version: ['3.1', '3.2', '3.3', '3.4']
 
     steps:
     - uses: actions/checkout@v4

data/.ruby-version

@@ -1 +1 @@
-ruby-3.3.0
+ruby-3.4.1

data/Gemfile

@@ -4,3 +4,11 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'parallel_tests'
+gem 'leveldb-native'
+gem 'bundler'
+gem 'rake', '>= 12.3.3'
+gem 'rspec', '~> 3.0'
+gem 'timecop'
+gem 'webmock', '>= 3.11.1'
+gem 'parallel', '>= 1.20.1'
+gem 'csv', '~> 3.3'

data/bitcoinrb.gemspec

@@ -26,22 +26,14 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'bech32', '>= 1.3.0'
   spec.add_runtime_dependency 'daemon-spawn'
   spec.add_runtime_dependency 'thor'
-  spec.add_runtime_dependency 'ffi'
   spec.add_runtime_dependency 'leb128', '~> 1.0.0'
   spec.add_runtime_dependency 'eventmachine_httpserver'
   spec.add_runtime_dependency 'iniparse'
   spec.add_runtime_dependency 'siphash'
-  spec.add_runtime_dependency 'json_pure', '>= 2.3.1'
+  spec.add_runtime_dependency 'json_pure', '>= 2.3.1', '< 2.8.0'
   spec.add_runtime_dependency 'bip-schnorr', '>= 0.7.0'
   spec.add_runtime_dependency 'base32', '>= 0.3.4'
-
-  # for options
-  spec.add_development_dependency 'leveldb-native'
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake', '>= 12.3.3'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'timecop'
-  spec.add_development_dependency 'webmock', '>= 3.11.1'
-  spec.add_development_dependency 'parallel', '>= 1.20.1'
+  spec.add_runtime_dependency 'base64', '~> 0.2.0'
+  spec.add_runtime_dependency 'observer', '~> 0.1.2'
+  spec.add_runtime_dependency 'secp256k1rb', '0.1.1'
 end

data/lib/bitcoin/bip324/ell_swift_pubkey.rb

@@ -19,7 +19,7 @@ module Bitcoin
       # Decode to public key.
       # @return [Bitcoin::Key] Decoded public key.
       def decode
-        if Bitcoin.secp_impl.is_a?(Bitcoin::Secp256k1::Native)
+        if Bitcoin.secp_impl.native?
           pubkey = Bitcoin.secp_impl.ellswift_decode(key)
           Bitcoin::Key.new(pubkey: pubkey, key_type: Bitcoin::Key::TYPES[:compressed])
         else

data/lib/bitcoin/bip324.rb

@@ -131,8 +131,8 @@ module Bitcoin
       raise ArgumentError, "ellswift_theirs must be a Bitcoin::BIP324::EllSwiftPubkey" unless ellswift_theirs.is_a?(Bitcoin::BIP324::EllSwiftPubkey)
       raise ArgumentError, "ellswift_ours must be a Bitcoin::BIP324::EllSwiftPubkey" unless ellswift_ours.is_a?(Bitcoin::BIP324::EllSwiftPubkey)
 
-      if Bitcoin.secp_impl.is_a?(Bitcoin::Secp256k1::Native)
-        Bitcoin::Secp256k1::Native.ellswift_ecdh_xonly(ellswift_theirs, ellswift_ours, priv_key, initiating)
+      if Bitcoin.secp_impl.native?
+        Bitcoin::Secp256k1::Native.ellswift_ecdh_xonly(ellswift_theirs.key, ellswift_ours.key, priv_key, initiating)
       else
         ecdh_point_x32 = ellswift_ecdh_xonly(ellswift_theirs, priv_key).htb
         content = initiating ? ellswift_ours.key + ellswift_theirs.key + ecdh_point_x32 :

data/lib/bitcoin/chain_params.rb

@@ -56,6 +56,11 @@ module Bitcoin
       init('signet')
     end
 
+    # testnet 4 genesis
+    def self.testnet4
+      init('testnet4')
+    end
+
     def mainnet?
       network == 'mainnet'
     end
@@ -72,6 +77,10 @@ module Bitcoin
       network == 'signet'
     end
 
+    def testnet4?
+      network == 'testnet4'
+    end
+
     def genesis_block
       header = Bitcoin::BlockHeader.new(
           genesis['version'], genesis['prev_hash'].rhex, genesis['merkle_root'].rhex,

data/lib/bitcoin/chainparams/mainnet.yml

@@ -27,9 +27,13 @@ proof_of_work_limit: 0x1d00ffff
 dns_seeds:
   - "seed.bitcoin.sipa.be"
   - "dnsseed.bluematt.me"
-  - "dnsseed.bitcoin.dashjr.org"
-  - "seed.bitcoinstats.com"
+  - "dnsseed.bitcoin.dashjr-list-of-p2p-nodes.us"
   - "seed.bitcoin.jonasschnelli.ch"
+  - "seed.btc.petertodd.net"
+  - "seed.bitcoin.sprovoost.nl"
+  - "dnsseed.emzy.de"
+  - "seed.bitcoin.wiz.biz"
+  - "seed.mainnet.achownodes.xyz"
 genesis:
   hash: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
   merkle_root: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"

data/lib/bitcoin/chainparams/regtest.yml

@@ -22,8 +22,7 @@ retarget_interval: 2016
 retarget_time: 1209600 # 2 weeks
 target_spacing: 600 # block interval
 max_money: 21000000
-bip34_height: 0
-genesis_hash: "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
+bip34_height: 1
 proof_of_work_limit: 0x207fffff
 dns_seeds:
 genesis:

data/lib/bitcoin/chainparams/signet.yml

@@ -22,12 +22,11 @@ retarget_interval: 2016
 retarget_time: 1209600 # 2 weeks
 target_spacing: 600 # block interval
 max_money: 21000000
-bip34_height: 227931
-genesis_hash: "00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"
+bip34_height: 1
 proof_of_work_limit: 0x1d00ffff
 dns_seeds:
-  - "178.128.221.177"
-  - "2a01:7c8:d005:390::5"
+  - "seed.signet.bitcoin.sprovoost.nl"
+  - "seed.signet.achownodes.xyz"
 genesis:
   hash: "00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"
   merkle_root: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"

data/lib/bitcoin/chainparams/testnet.yml

@@ -22,14 +22,14 @@ retarget_interval: 2016
 retarget_time: 1209600 # 2 weeks
 target_spacing: 600 # block interval
 max_money: 21000000
-bip34_height: 227931
-genesis_hash: "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
+bip34_height: 21111
 proof_of_work_limit: 0x1d00ffff
 dns_seeds:
   - "testnet-seed.bitcoin.jonasschnelli.ch"
-  - "seed.tbtc.petertodd.org"
+  - "seed.tbtc.petertodd.net"
+  - "seed.testnet.bitcoin.sprovoost.nl"
   - "testnet-seed.bluematt.me"
-  - "testnet-seed.bitcoin.schildbach.de"
+  - "seed.testnet.achownodes.xyz"
 genesis:
   hash: "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
   merkle_root: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"

data/lib/bitcoin/chainparams/testnet4.yml

@@ -0,0 +1,38 @@
+--- !ruby/object:Bitcoin::ChainParams
+network: "testnet4"
+magic_head: "1c163f28"
+message_magic: "Bitcoin Signed Message:\n"
+address_version: "6f"
+p2sh_version: "c4"
+bech32_hrp: 'tb'
+privkey_version: "ef"
+extended_privkey_version: "04358394"
+extended_pubkey_version: "043587cf"
+bip49_pubkey_p2wpkh_p2sh_version: "044a5262"
+bip49_pubkey_p2wsh_p2sh_version: "024289ef"
+bip49_privkey_p2wpkh_p2sh_version: "044a4e28"
+bip49_privkey_p2wsh_p2sh_version: "024285b5"
+bip84_pubkey_p2wpkh_version: "045f1cf6"
+bip84_pubkey_p2wsh_version: "02575483"
+bip84_privkey_p2wpkh_version: "045f18bc"
+bip84_privkey_p2wsh_version: "02575048"
+default_port: 48333
+protocol_version: 70013
+retarget_interval: 2016
+retarget_time: 1209600 # 2 weeks
+target_spacing: 600 # block interval
+max_money: 21000000
+bip34_height: 1
+proof_of_work_limit: 0x1d00ffff
+dns_seeds:
+  - "seed.testnet4.bitcoin.sprovoost.nl"
+  - "seed.testnet4.wiz.biz"
+genesis:
+  hash: "00000000da84f2bafbbc53dee25a72ae507ff4914b867c565be350b0da8bf043"
+  merkle_root: "7aa0a7ae1e223414cb807e40cd57e667b718e42aaf9306db9102fe28912b7b4e"
+  time: 1714777860
+  nonce: 393743547
+  bits: 0x1d00ffff
+  version: 1
+  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"
+bip44_coin_type: 1

data/lib/bitcoin/key.rb

@@ -146,11 +146,8 @@ module Bitcoin
     # @return [Bitcoin::Key] Recovered public key.
     def self.recover_compact(data, signature)
       rec_id = signature.unpack1('C')
-      rec = (rec_id - Bitcoin::Key::COMPACT_SIG_HEADER_BYTE) & 3
-      raise ArgumentError, 'Invalid signature parameter' if rec < 0 || rec > 3
-
       compressed = (rec_id - Bitcoin::Key::COMPACT_SIG_HEADER_BYTE) & 4 != 0
-      Bitcoin.secp_impl.recover_compact(data, signature, rec, compressed)
+      Bitcoin.secp_impl.recover_compact(data, signature, compressed)
     end
 
     # verify signature using public key
@@ -349,7 +346,7 @@ module Bitcoin
     # @raise ArgumentError If ent32 does not 32 bytes.
     def create_ell_pubkey
       raise ArgumentError, "private_key required." unless priv_key
-      if secp256k1_module.is_a?(Bitcoin::Secp256k1::Native)
+      if secp256k1_module.native?
         Bitcoin::BIP324::EllSwiftPubkey.new(secp256k1_module.ellswift_create(priv_key))
       else
         Bitcoin::BIP324::EllSwiftPubkey.new(Bitcoin::BIP324.xelligatorswift(xonly_pubkey))

data/lib/bitcoin/message_sign.rb

@@ -62,13 +62,23 @@ module Bitcoin
           pubkey = Bitcoin::Key.recover_compact(message_hash(message, prefix: prefix, legacy: true), sig)
           return false unless pubkey
           pubkey.to_p2pkh == address
-        rescue RuntimeError
-          return false
+        rescue Exception
+          false
         end
       elsif addr_script.witness_program?
         # BIP322 verification
-        tx = to_sign_tx(message_hash(message, prefix: prefix, legacy: false), address)
-        tx.in[0].script_witness = Bitcoin::ScriptWitness.parse_from_payload(sig)
+        digest = message_hash(message, prefix: prefix, legacy: false)
+        begin
+          # Full
+          tx = Bitcoin::Tx.parse_from_payload(sig)
+          validate_to_sign_tx!(tx)
+          to_spend = to_spend_tx(digest, address)
+          return false unless tx.in[0].out_point.tx_hash == to_spend.tx_hash
+        rescue Exception
+          # Simple
+          tx = to_sign_tx(digest, address)
+          tx.in[0].script_witness = Bitcoin::ScriptWitness.parse_from_payload(sig)
+        end
         script_pubkey = Bitcoin::Script.parse_from_addr(address)
         tx_out = Bitcoin::TxOut.new(script_pubkey: script_pubkey)
         flags = Bitcoin::STANDARD_SCRIPT_VERIFY_FLAGS
@@ -99,6 +109,14 @@ module Bitcoin
       end
     end
 
+    def validate_to_sign_tx!(tx)
+      raise ArgumentError, "Multiple inputs (proof of funds) are not supported." unless tx.in.length == 1
+      raise ArgumentError, "vin[0].prevout.n must be 0." unless tx.in[0].out_point.index == 0
+      raise ArgumentError, "Multiple outputs are not supported." unless tx.out.length == 1
+      raise ArgumentError, "vout[0].nValue must be 0." unless tx.out[0].value == 0
+      raise ArgumentError, "vout[0].scriptPubKey must be OP_RETURN." unless tx.out[0].script_pubkey == Bitcoin::Script.new << Bitcoin::Opcodes::OP_RETURN
+    end
+
     def to_spend_tx(digest, addr)
       validate_address!(addr)
       message_challenge = Bitcoin::Script.parse_from_addr(addr)
@@ -124,5 +142,6 @@ module Bitcoin
 
     private_class_method :validate_address!
     private_class_method :validate_format!
+    private_class_method :validate_to_sign_tx!
   end
 end

data/lib/bitcoin/psbt.rb

@@ -1,5 +1,3 @@
-require 'base64'
-
 module Bitcoin
 
   module PSBT

data/lib/bitcoin/secp256k1/native.rb

@@ -1,5 +1,6 @@
 # Porting part of the code from bitcoin-ruby. see the license.
 # https://github.com/lian/bitcoin-ruby/blob/master/COPYING
+require 'secp256k1'
 
 module Bitcoin
   module Secp256k1
@@ -10,91 +11,15 @@ module Bitcoin
     # for linux, ENV['SECP256K1_LIB_PATH'] = '/usr/local/lib/libsecp256k1.so' or '/usr/lib64/libsecp256k1.so'
     # for mac,
     module Native
-      include ::FFI::Library
-      extend self
-
-      SECP256K1_FLAGS_TYPE_MASK = ((1 << 8) - 1)
-      SECP256K1_FLAGS_TYPE_CONTEXT = (1 << 0)
-      SECP256K1_FLAGS_TYPE_COMPRESSION = (1 << 1)
-
-      SECP256K1_FLAGS_BIT_CONTEXT_VERIFY = (1 << 8)
-      SECP256K1_FLAGS_BIT_CONTEXT_SIGN = (1 << 9)
-      SECP256K1_FLAGS_BIT_COMPRESSION = (1 << 8)
-
-      # Flags to pass to secp256k1_context_create.
-      SECP256K1_CONTEXT_VERIFY = (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_VERIFY)
-      SECP256K1_CONTEXT_SIGN = (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_SIGN)
-
-      # Flag to pass to secp256k1_ec_pubkey_serialize and secp256k1_ec_privkey_export.
-      SECP256K1_EC_COMPRESSED = (SECP256K1_FLAGS_TYPE_COMPRESSION | SECP256K1_FLAGS_BIT_COMPRESSION)
-      SECP256K1_EC_UNCOMPRESSED = (SECP256K1_FLAGS_TYPE_COMPRESSION)
 
       module_function
 
-      def init
-        raise 'secp256k1 library dose not found.' unless File.exist?(ENV['SECP256K1_LIB_PATH'])
-        ffi_lib(ENV['SECP256K1_LIB_PATH'])
-        load_functions
-      end
-
-      def load_functions
-        attach_function(:secp256k1_context_create, [:uint], :pointer)
-        attach_function(:secp256k1_context_destroy, [:pointer], :void)
-        attach_function(:secp256k1_context_randomize, [:pointer, :pointer], :int)
-        attach_function(:secp256k1_ec_pubkey_create, [:pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ec_seckey_verify, [:pointer, :pointer], :int)
-        attach_function(:secp256k1_ecdsa_sign, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ec_pubkey_serialize, [:pointer, :pointer, :pointer, :pointer, :uint], :int)
-        attach_function(:secp256k1_ecdsa_signature_serialize_der, [:pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ec_pubkey_parse, [:pointer, :pointer, :pointer, :size_t], :int)
-        attach_function(:secp256k1_ecdsa_signature_parse_der, [:pointer, :pointer, :pointer, :size_t], :int)
-        attach_function(:secp256k1_ecdsa_signature_normalize, [:pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ecdsa_verify, [:pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_schnorrsig_sign32, [:pointer, :pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_schnorrsig_verify, [:pointer, :pointer, :pointer, :size_t, :pointer], :int)
-        attach_function(:secp256k1_keypair_create, [:pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_xonly_pubkey_parse, [:pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ecdsa_sign_recoverable, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ecdsa_recoverable_signature_serialize_compact, [:pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ecdsa_recover, [:pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ecdsa_recoverable_signature_parse_compact, [:pointer, :pointer, :pointer, :int], :int)
-        attach_function(:secp256k1_ellswift_decode, [:pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ellswift_create, [:pointer, :pointer, :pointer, :pointer], :int)
-        # Define function pointer
-        callback(:secp256k1_ellswift_xdh_hash_function, [:pointer, :pointer, :pointer, :pointer, :pointer], :int)
-        attach_variable(:secp256k1_ellswift_xdh_hash_function_bip324, :secp256k1_ellswift_xdh_hash_function)
-        attach_function(:secp256k1_ellswift_xdh, [:pointer, :pointer, :pointer, :pointer, :pointer, :int, :pointer, :pointer], :int)
-      end
-
-      def with_context(flags: (SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN))
-        init
-        begin
-          context = secp256k1_context_create(flags)
-          ret, tries, max = 0, 0, 20
-          while ret != 1
-            raise 'secp256k1_context_randomize failed.' if tries >= max
-            tries += 1
-            ret = secp256k1_context_randomize(context, FFI::MemoryPointer.from_string(SecureRandom.random_bytes(32)))
-          end
-          yield(context) if block_given?
-        ensure
-          secp256k1_context_destroy(context)
-        end
-      end
+      extend ::Secp256k1
 
-      # generate ec private key and public key
-      def generate_key_pair(compressed: true)
-        with_context do |context|
-          ret, tries, max = 0, 0, 20
-          while ret != 1
-            raise 'secp256k1_ec_seckey_verify in generate_key_pair failed.' if tries >= max
-            tries += 1
-            priv_key = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, SecureRandom.random_bytes(32))
-            ret = secp256k1_ec_seckey_verify(context, priv_key)
-          end
-          private_key =  priv_key.read_string(32).bth
-          [private_key , generate_pubkey_in_context(context,  private_key, compressed: compressed) ]
-        end
+      # Whether this module is native c wrapper or not?
+      # @return [Boolean]
+      def native?
+        true
       end
 
       # generate bitcoin key object
@@ -103,295 +28,76 @@ module Bitcoin
         Bitcoin::Key.new(priv_key: privkey, pubkey: pubkey, compressed: compressed)
       end
 
-      def generate_pubkey(priv_key, compressed: true)
-        with_context do |context|
-          generate_pubkey_in_context(context, priv_key, compressed: compressed)
-        end
-      end
-
-      # sign data.
-      # @param [String] data a data to be signed with binary format
-      # @param [String] privkey a private key with hex format using sign
-      # @param [String] extra_entropy a extra entropy with binary format for rfc6979
-      # @param [Symbol] algo signature algorithm. ecdsa(default) or schnorr.
-      # @return [String] signature data with binary format
-      def sign_data(data, privkey, extra_entropy = nil, algo: :ecdsa)
-        case algo
-        when :ecdsa
-          sign_ecdsa(data, privkey, extra_entropy)
-        when :schnorr
-          sign_schnorr(data, privkey, extra_entropy)
-        else
-          nil
-        end
-      end
-
       # Sign data with compact format.
       # @param [String] data a data to be signed with binary format
       # @param [String] privkey a private key using sign with hex format
       # @return [Array[signature, recovery id]]
       def sign_compact(data, privkey)
-        with_context do |context|
-          sig = FFI::MemoryPointer.new(:uchar, 65)
-          hash =FFI::MemoryPointer.new(:uchar, data.bytesize).put_bytes(0, data)
-          priv_key = privkey.htb
-          sec_key = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
-          result = secp256k1_ecdsa_sign_recoverable(context, sig, hash, sec_key, nil, nil)
-          raise 'secp256k1_ecdsa_sign_recoverable failed.' if result == 0
-
-          output = FFI::MemoryPointer.new(:uchar, 64)
-          rec = FFI::MemoryPointer.new(:uint64)
-          result = secp256k1_ecdsa_recoverable_signature_serialize_compact(context, output, rec, sig)
-          raise 'secp256k1_ecdsa_recoverable_signature_serialize_compact failed.' unless result == 1
-
-          raw_sig = output.read_string(64)
-          [ECDSA::Signature.new(raw_sig[0...32].bti, raw_sig[32..-1].bti), rec.read(:int)]
-        end
+        sig, rec_id = sign_recoverable(data, privkey)
+        [ECDSA::Signature.new(sig[0...64].to_i(16), sig[64..-1].to_i(16)), rec_id]
       end
 
       # Recover public key from compact signature.
       # @param [String] data message digest using signature.
-      # @param [String] signature signature with binary format.
-      # @param [Integer] rec recovery id.
+      # @param [String] signature signature with binary format(65 bytes).
       # @param [Boolean] compressed whether compressed public key or not.
       # @return [Bitcoin::Key] Recovered public key.
-      def recover_compact(data, signature, rec, compressed)
-        with_context do |context|
-          sig = FFI::MemoryPointer.new(:uchar, 65)
-          input = FFI::MemoryPointer.new(:uchar, 64).put_bytes(0, signature[1..-1])
-          result = secp256k1_ecdsa_recoverable_signature_parse_compact(context, sig, input, rec)
-          raise 'secp256k1_ecdsa_recoverable_signature_parse_compact failed.' unless result == 1
-
-          pubkey = FFI::MemoryPointer.new(:uchar, 64)
-          msg = FFI::MemoryPointer.new(:uchar, data.bytesize).put_bytes(0, data)
-          result = secp256k1_ecdsa_recover(context, pubkey, sig, msg)
-          raise 'secp256k1_ecdsa_recover failed.' unless result == 1
-
-          pubkey = serialize_pubkey_internal(context, pubkey.read_string(64), compressed)
-          Bitcoin::Key.new(pubkey: pubkey, compressed: compressed)
-        end
+      def recover_compact(data, signature, compressed)
+        pubkey = recover(data, signature, compressed)
+        Bitcoin::Key.new(pubkey: pubkey, compressed: compressed)
       end
 
-      # verify signature
-      # @param [String] data a data with binary format.
-      # @param [String] sig signature data with binary format
-      # @param [String] pubkey a public key with hex format using verify.
-      # # @param [Symbol] algo signature algorithm. ecdsa(default) or schnorr.
-      # @return [Boolean] verification result.
-      def verify_sig(data, sig, pubkey, algo: :ecdsa)
+      # Sign to data.
+      # @param [String] data The 32-byte message hash being signed with binary format.
+      # @param [String] private_key a private key with hex format using sign.
+      # @param [String] extra_entropy a extra entropy with binary format for rfc6979.
+      # @param [Symbol] algo signature algorithm. ecdsa(default) or schnorr.
+      # @return [String] signature data with binary format. If unsupported algorithm specified, return nil.
+      # @raise [ArgumentError] If invalid arguments specified.
+      def sign_data(data, private_key, extra_entropy = nil, algo: :ecdsa)
         case algo
         when :ecdsa
-          verify_ecdsa(data, sig, pubkey)
+          begin
+            sign_ecdsa(data, private_key, extra_entropy)
+          rescue ArgumentError
+            false
+          end
         when :schnorr
-          verify_schnorr(data, sig, pubkey)
+          begin
+            sign_schnorr(data, private_key, extra_entropy)
+          rescue ArgumentError
+            false
+          end
         else
-          false
-        end
-      end
-
-      # # validate whether this is a valid public key (more expensive than IsValid())
-      # @param [String] pub_key public key with hex format.
-      # @param [Boolean] allow_hybrid whether support hybrid public key.
-      # @return [Boolean] If valid public key return true, otherwise false.
-      def parse_ec_pubkey?(pub_key, allow_hybrid = false)
-        pub_key = pub_key.htb
-        return false if !allow_hybrid && ![0x02, 0x03, 0x04].include?(pub_key[0].ord)
-        with_context do |context|
-          pubkey = FFI::MemoryPointer.new(:uchar, pub_key.bytesize).put_bytes(0, pub_key)
-          internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
-          result = secp256k1_ec_pubkey_parse(context, internal_pubkey, pubkey, pub_key.bytesize)
-          result == 1
+          raise ArgumentError, "unknown algo: #{algo}"
         end
       end
 
-      # Create key pair data from private key.
-      # @param [String] priv_key with hex format
-      # @return [String] key pair data with hex format. data  = private key(32 bytes) | public key(64 bytes).
-      def create_keypair(priv_key)
-        with_context do |context|
-          priv_key = priv_key.htb
-          secret = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
-          raise 'priv_key is invalid.' unless secp256k1_ec_seckey_verify(context, secret)
-          keypair = FFI::MemoryPointer.new(:uchar, 96)
-          raise 'priv_key is invalid.' unless secp256k1_keypair_create(context, keypair, secret) == 1
-          keypair.read_string(96).bth
-        end
-      end
-
-      # Check whether valid x-only public key or not.
-      # @param [String] pub_key x-only public key with hex format(32 bytes).
-      # @return [Boolean] result.
-      def valid_xonly_pubkey?(pub_key)
-        begin
-          full_pubkey_from_xonly_pubkey(pub_key)
-        rescue Exception
-          return false
-        end
-        true
-      end
-
-      # Decode ellswift public key.
-      # @param [String] ell_key ElligatorSwift key with binary format.
-      # @return [String] Decoded public key with hex format
-      def ellswift_decode(ell_key)
-        with_context do |context|
-          ell64 = FFI::MemoryPointer.new(:uchar, ell_key.bytesize).put_bytes(0, ell_key)
-          internal = FFI::MemoryPointer.new(:uchar, 64)
-          result = secp256k1_ellswift_decode(context, internal, ell64)
-          raise ArgumentError, 'Decode failed.' unless result == 1
-          serialize_pubkey_internal(context, internal, true)
-        end
-      end
-
-      # Compute an ElligatorSwift public key for a secret key.
-      # @param [String] priv_key private key with hex format
-      # @return [String] ElligatorSwift public key with hex format.
-      def ellswift_create(priv_key)
-        with_context(flags: SECP256K1_CONTEXT_SIGN) do |context|
-          ell64 = FFI::MemoryPointer.new(:uchar, 64)
-          seckey32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, priv_key.htb)
-          result = secp256k1_ellswift_create(context, ell64, seckey32, nil)
-          raise ArgumentError, 'Failed to create ElligatorSwift public key.' unless result == 1
-          ell64.read_string(64).bth
-        end
-      end
-
-      # Compute X coordinate of shared ECDH point between elswift pubkey and privkey.
-      # @param [Bitcoin::BIP324::EllSwiftPubkey] their_ell_pubkey Their EllSwift public key.
-      # @param [Bitcoin::BIP324::EllSwiftPubkey] our_ell_pubkey Our EllSwift public key.
-      # @param [String] priv_key private key with hex format.
-      # @param [Boolean] initiating Whether your initiator or not.
-      # @return [String] x coordinate with hex format.
-      def ellswift_ecdh_xonly(their_ell_pubkey, our_ell_pubkey, priv_key, initiating)
-        with_context(flags: SECP256K1_CONTEXT_SIGN) do |context|
-          output = FFI::MemoryPointer.new(:uchar, 32)
-          our_ell_ptr = FFI::MemoryPointer.new(:uchar, 64).put_bytes(0, our_ell_pubkey.key)
-          their_ell_ptr = FFI::MemoryPointer.new(:uchar, 64).put_bytes(0, their_ell_pubkey.key)
-          seckey32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, priv_key.htb)
-          hashfp = secp256k1_ellswift_xdh_hash_function_bip324
-          result = secp256k1_ellswift_xdh(context, output,
-                                          initiating ? our_ell_ptr : their_ell_ptr,
-                                          initiating ? their_ell_ptr : our_ell_ptr,
-                                          seckey32,
-                                          initiating ? 0 : 1,
-                                          hashfp, nil)
-          raise ArgumentError, "secret was invalid or hashfp returned 0" unless result == 1
-          output.read_string(32).bth
-        end
-      end
-
-      private
-
-      # Calculate full public key(64 bytes) from public key(32 bytes).
-      # @param [String] pub_key x-only public key with hex format(32 bytes).
-      # @return [String] x-only public key with hex format(64 bytes).
-      def full_pubkey_from_xonly_pubkey(pub_key)
-        with_context do |context|
-          pubkey = pub_key.htb
-          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
-          full_pubkey.read_string(64).bth
-        end
-      end
-
-      def generate_pubkey_in_context(context, privkey, compressed: true)
-        internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
-        result = secp256k1_ec_pubkey_create(context, internal_pubkey, privkey.htb)
-        raise 'error creating pubkey' unless result
-        serialize_pubkey_internal(context, internal_pubkey, compressed)
-      end
-
-      def sign_ecdsa(data, privkey, extra_entropy)
-        with_context do |context|
-          secret = FFI::MemoryPointer.new(:uchar, privkey.htb.bytesize).put_bytes(0, privkey.htb)
-          raise 'priv_key is invalid' unless secp256k1_ec_seckey_verify(context, secret)
-
-          internal_signature = FFI::MemoryPointer.new(:uchar, 64)
-          msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
-          entropy = extra_entropy ? FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, extra_entropy) : nil
-
-          ret, tries, max = 0, 0, 20
-
-          while ret != 1
-            raise 'secp256k1_ecdsa_sign failed.' if tries >= max
-            tries += 1
-            ret = secp256k1_ecdsa_sign(context, internal_signature, msg32, secret, nil, entropy)
+      # Verify signature.
+      # @param [String] data The 32-byte message hash assumed to be signed.
+      # @param [String] signature signature data with binary format
+      # @param [String] pubkey a public key with hex format using verify.
+      # @param [Symbol] algo signature algorithm. ecdsa(default) or schnorr.
+      # @return [Boolean] verification result.
+      # @raise [ArgumentError] If invalid arguments specified.
+      def verify_sig(data, signature, pubkey, algo: :ecdsa)
+        case algo
+        when :ecdsa
+          begin
+            verify_ecdsa(data, signature, pubkey)
+          rescue ArgumentError
+            false
           end
-
-          signature = FFI::MemoryPointer.new(:uchar, 72)
-          signature_len = FFI::MemoryPointer.new(:uint64).put_uint64(0, 72)
-          result = secp256k1_ecdsa_signature_serialize_der(context, signature, signature_len, internal_signature)
-          raise 'secp256k1_ecdsa_signature_serialize_der failed' unless result
-
-          signature.read_string(signature_len.read_uint64)
-        end
-      end
-
-      def sign_schnorr(data, privkey, aux_rand = nil)
-        with_context do |context|
-          keypair = create_keypair(privkey).htb
-          keypair = FFI::MemoryPointer.new(:uchar, 96).put_bytes(0, keypair)
-          signature = FFI::MemoryPointer.new(:uchar, 64)
-          msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
-          aux_rand = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, aux_rand) if aux_rand
-          raise 'Failed to generate schnorr signature.' unless secp256k1_schnorrsig_sign32(context, signature, msg32, keypair, aux_rand) == 1
-          signature.read_string(64)
-        end
-      end
-
-      def verify_ecdsa(data, sig, pubkey)
-        with_context do |context|
-          return false if data.bytesize == 0
-          pubkey = pubkey.htb
-          pubkey = FFI::MemoryPointer.new(:uchar, pubkey.bytesize).put_bytes(0, pubkey)
-          internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
-          result = secp256k1_ec_pubkey_parse(context, internal_pubkey, pubkey, pubkey.size)
-          return false unless result
-
-          signature = FFI::MemoryPointer.new(:uchar, sig.bytesize).put_bytes(0, sig)
-          internal_signature = FFI::MemoryPointer.new(:uchar, 64)
-          result = secp256k1_ecdsa_signature_parse_der(context, internal_signature, signature, signature.size)
-          return false unless result
-
-          # libsecp256k1's ECDSA verification requires lower-S signatures, which have not historically been enforced in Bitcoin, so normalize them first.
-          secp256k1_ecdsa_signature_normalize(context, internal_signature, internal_signature)
-
-          msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
-          result = secp256k1_ecdsa_verify(context, internal_signature, msg32, internal_pubkey)
-
-          result == 1
-        end
-      end
-
-      def verify_schnorr(data, sig, pubkey)
-        with_context do |context|
-          return false if data.bytesize == 0
-          pubkey = full_pubkey_from_xonly_pubkey(pubkey).htb
-          xonly_pubkey = FFI::MemoryPointer.new(:uchar, pubkey.bytesize).put_bytes(0, pubkey)
-          signature = FFI::MemoryPointer.new(:uchar, sig.bytesize).put_bytes(0, sig)
-          msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
-          result = secp256k1_schnorrsig_verify(context, signature, msg32, 32, xonly_pubkey)
-          result == 1
+        when :schnorr
+          begin
+            verify_schnorr(data, signature, pubkey)
+          rescue ArgumentError
+            false
+          end
+        else
+          raise ArgumentError, "unknown algo: #{algo}"
         end
       end
-
-      # Serialize public key.
-      def serialize_pubkey_internal(context, pubkey_input, compressed)
-        pubkey = FFI::MemoryPointer.new(:uchar, 65)
-        pubkey_len = FFI::MemoryPointer.new(:uint64)
-        result = if compressed
-                   pubkey_len.put_uint64(0, 33)
-                   secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, pubkey_input, SECP256K1_EC_COMPRESSED)
-                 else
-                   pubkey_len.put_uint64(0, 65)
-                   secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, pubkey_input, SECP256K1_EC_UNCOMPRESSED)
-                 end
-        raise 'error serialize pubkey' unless result || pubkey_len.read_uint64 > 0
-        pubkey.read_string(pubkey_len.read_uint64).bth
-      end
-
     end
   end
 end

data/lib/bitcoin/secp256k1/ruby.rb

@@ -9,6 +9,13 @@ module Bitcoin
     module Ruby
 
       module_function
+      extend Schnorr::Util
+
+      # Whether this module is native c wrapper or not?
+      # @return [Boolean]
+      def native?
+        false
+      end
 
       # generate ec private key and public key
       def generate_key_pair(compressed: true)
@@ -72,11 +79,20 @@ module Bitcoin
 
       # Recover public key from compact signature.
       # @param [String] data message digest using signature.
-      # @param [String] signature signature with binary format.
-      # @param [Integer] rec recovery id.
+      # @param [String] signature signature with binary format(65 bytes).
       # @param [Boolean] compressed whether compressed public key or not.
       # @return [Bitcoin::Key] Recovered public key.
-      def recover_compact(data, signature, rec, compressed)
+      # @raise [ArgumentError] If invalid arguments specified.
+      def recover_compact(data, signature, compressed)
+        raise ArgumentError, "data must be String." unless data.is_a?(String)
+        raise ArgumentError, "signature must be String." unless signature.is_a?(String)
+        signature = hex2bin(signature)
+        raise ArgumentError, "signature must be 64 bytes." unless signature.bytesize == 65
+        data = hex2bin(data)
+        raise ArgumentError, "data must be 32 bytes." unless data.bytesize == 32
+        rec = (signature[0].ord - 0x1b) & 3
+        raise ArgumentError, "rec must be between 0 and 3." if rec < 0 || rec > 3
+
         group = Bitcoin::Secp256k1::GROUP
         r = ECDSA::Format::IntegerOctetString.decode(signature[1...33])
         s = ECDSA::Format::IntegerOctetString.decode(signature[33..-1])

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "1.7.0"
+  VERSION = "1.8.0"
 end

data/lib/bitcoin.rb

@@ -7,7 +7,7 @@ require 'schnorr'
 require 'securerandom'
 require 'json'
 require 'bech32'
-require 'ffi'
+require 'base64'
 require 'observer'
 require 'tmpdir'
 require_relative 'openassets'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - azuchi
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-08-17 00:00:00.000000000 Z
+date: 2025-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa_ext
@@ -94,20 +93,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: ffi
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: leb128
   requirement: !ruby/object:Gem::Requirement
@@ -171,6 +156,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -178,6 +166,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.8.0
 - !ruby/object:Gem::Dependency
   name: bip-schnorr
   requirement: !ruby/object:Gem::Requirement
@@ -207,103 +198,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.3.4
 - !ruby/object:Gem::Dependency
-  name: leveldb-native
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 12.3.3
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 12.3.3
-- !ruby/object:Gem::Dependency
-  name: rspec
+  name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
+        version: 0.2.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
-  name: timecop
+  name: observer
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.11.1
-  type: :development
+        version: 0.1.2
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.11.1
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
-  name: parallel
+  name: secp256k1rb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 1.20.1
-  type: :development
+        version: 0.1.1
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 1.20.1
+        version: 0.1.1
 description: The implementation of Bitcoin Protocol for Ruby.
 email:
 - azuchi@chaintope.com
@@ -348,6 +283,7 @@ files:
 - lib/bitcoin/chainparams/regtest.yml
 - lib/bitcoin/chainparams/signet.yml
 - lib/bitcoin/chainparams/testnet.yml
+- lib/bitcoin/chainparams/testnet4.yml
 - lib/bitcoin/constants.rb
 - lib/bitcoin/descriptor.rb
 - lib/bitcoin/descriptor/addr.rb
@@ -507,7 +443,6 @@ homepage: https://github.com/chaintope/bitcoinrb
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -522,8 +457,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: The implementation of Bitcoin Protocol for Ruby.
 test_files: []