bitcoinrb 1.6.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2697b9fbcca175453c80fc67d70466845c7141e6b9e9f193b5825d34bd7ffa3
-  data.tar.gz: 61a5c26a7cfaf7abcc7c692386ff08091ea0249c9e8ea9ccb4f3231049319f47
+  metadata.gz: a0cc5450016d6ffbb76d36dcccd415a485a8532ab8414d9beddb9a7e25305dba
+  data.tar.gz: 75d509c36069ce2dee667a0330962ae310c8062f24aa01d299e5692f6f069461
 SHA512:
-  metadata.gz: 40574931606fc1ff074f638bda7042f86c0225a5661f37622971e0b9502e039c5010d31663c34846c80f0bff2d25a02122eb4773e30a6fadad72bb170260b114
-  data.tar.gz: aaefa2672459d1d133191aecf8cbe0e8391210647e109c6e5205e349e264ad2303b25c36d4812daf5f5f0e88fb15cc4b0bfc54653ba0a2b4a8bac9fd5fd9b5d6
+  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/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/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/descriptor/combo.rb

@@ -9,7 +9,7 @@ module Bitcoin
 
       def to_scripts
         candidates = [Pk.new(key), Pkh.new(key)]
-        pubkey = extract_pubkey(key)
+        pubkey = extracted_key
         if pubkey.compressed?
           candidates << Wpkh.new(pubkey.pubkey)
           candidates << Sh.new(candidates.last)

data/lib/bitcoin/descriptor/key_expression.rb

@@ -18,6 +18,13 @@ module Bitcoin
       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/pk.rb

@@ -18,7 +18,7 @@ module Bitcoin
       # Convert to bitcoin script.
       # @return [Bitcoin::Script]
       def to_script
-        k = extract_pubkey(key)
+        k = extracted_key
         target_key = xonly ? k.xonly_pubkey : k.pubkey
         Bitcoin::Script.new << target_key << OP_CHECKSIG
       end

data/lib/bitcoin/descriptor/pkh.rb

@@ -8,7 +8,7 @@ module Bitcoin
       end
 
       def to_script
-        Script.to_p2pkh(extract_pubkey(key).hash160)
+        Script.to_p2pkh(extracted_key.hash160)
       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/wpkh.rb

@@ -12,7 +12,7 @@ module Bitcoin
       end
 
       def to_script
-        Script.to_p2wpkh(extract_pubkey(key).hash160)
+        Script.to_p2wpkh(extracted_key.hash160)
       end
     end
   end

data/lib/bitcoin/descriptor.rb

@@ -19,6 +19,7 @@ module Bitcoin
     autoload :Tr,  'bitcoin/descriptor/tr'
     autoload :MultiA,  'bitcoin/descriptor/multi_a'
     autoload :SortedMultiA, 'bitcoin/descriptor/sorted_multi_a'
+    autoload :RawTr,  'bitcoin/descriptor/raw_tr'
     autoload :Checksum, 'bitcoin/descriptor/checksum'
 
     module_function
@@ -104,6 +105,13 @@ module Bitcoin
       Tr.new(key, tree)
     end
 
+    # Generate taproot output script descriptor.
+    # @param [String] key
+    # @return [Bitcoin::Descriptor::RawTr]
+    def rawtr(key)
+      RawTr.new(key)
+    end
+
     # Generate tapscript multisig output for given keys.
     # @param [Integer] threshold the threshold of multisig.
     # @param [Array[String]] keys an array of keys.
@@ -169,6 +177,8 @@ module Bitcoin
         else
           tr(key, parse(rest, false))
         end
+      when 'rawtr'
+        rawtr(args_str)
       else
         raise ArgumentError, "Parse failed: #{string}"
       end

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,16 +62,27 @@ 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)
-        interpreter = Bitcoin::ScriptInterpreter.new(checker: Bitcoin::TxChecker.new(tx: tx, input_index: 0, prevouts: [tx_out]))
+        flags = Bitcoin::STANDARD_SCRIPT_VERIFY_FLAGS
+        interpreter = Bitcoin::ScriptInterpreter.new(flags: flags, checker: Bitcoin::TxChecker.new(tx: tx, input_index: 0, prevouts: [tx_out]))
         interpreter.verify_script(Bitcoin::Script.new, script_pubkey, tx.in[0].script_witness)
       else
         raise ArgumentError, "This address unsupported."
@@ -98,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)
@@ -123,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/script_witness.rb

@@ -11,6 +11,7 @@ module Bitcoin
 
     def self.parse_from_payload(payload)
       buf = payload.is_a?(StringIO) ? payload : StringIO.new(payload)
+      return self.new if buf.eof?
       size = Bitcoin.unpack_var_int_from_io(buf)
       stack = size.times.map do
         buf.read(Bitcoin.unpack_var_int_from_io(buf))

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

@@ -0,0 +1,5 @@
+module Bitcoin
+  module SilentPayment
+    autoload :Addr, 'bitcoin/sp/addr'
+  end
+end

data/lib/bitcoin/sp/addr.rb

@@ -0,0 +1,55 @@
+module Bitcoin
+  module SilentPayment
+    class Addr
+
+      HRP_MAINNET = 'sp'
+      HRP_TESTNET = 'tsp'
+      MAX_CHARACTERS = 1023
+
+      attr_reader :version
+      attr_reader :scan_key
+      attr_reader :spend_key
+
+      # Constructor.
+      # @param [Bitcoin::Key] scan_key
+      # @param [Bitcoin::Key] spend_key
+      def initialize(version, scan_key:, spend_key:)
+        raise ArgumentError, "version must be integer." unless version.is_a?(Integer)
+        raise ArgumentError, "scan_key must be Bitcoin::Key." unless scan_key.is_a?(Bitcoin::Key)
+        raise ArgumentError, "spend_key must be Bitcoin::Key." unless spend_key.is_a?(Bitcoin::Key)
+        raise ArgumentError, "version '#{version}' is unsupported." unless version.zero?
+
+        @version = version
+        @scan_key = scan_key
+        @spend_key = spend_key
+      end
+
+      # Parse silent payment address.
+      # @param [String] A silent payment address.
+      # @return [Bitcoin::SilentPayment::Addr]
+      def self.from_string(addr)
+        raise ArgumentError, "addr must be string." unless addr.is_a?(String)
+        hrp, data, spec = Bech32.decode(addr, MAX_CHARACTERS)
+        unless hrp == Bitcoin.chain_params.mainnet? ? HRP_MAINNET : HRP_TESTNET
+          raise ArgumentError, "The specified hrp is different from the current network HRP."
+        end
+        raise ArgumentError, "spec must be bech32m." unless spec == Bech32::Encoding::BECH32M
+
+        ver = data[0]
+        payload = Bech32.convert_bits(data[1..-1], 5, 8, false).pack("C*")
+        scan_key = Bitcoin::Key.new(pubkey: payload[0...33].bth, key_type: Bitcoin::Key::TYPES[:compressed])
+        spend_key = Bitcoin::Key.new(pubkey: payload[33..-1].bth, key_type: Bitcoin::Key::TYPES[:compressed])
+        Addr.new(ver, scan_key: scan_key, spend_key: spend_key)
+      end
+
+      # Get silent payment address.
+      # @return [String]
+      def to_s
+        hrp = Bitcoin.chain_params.mainnet? ? HRP_MAINNET : HRP_TESTNET
+        payload = [scan_key.pubkey + spend_key.pubkey].pack("H*").unpack('C*')
+        Bech32.encode(hrp, [version] + Bech32.convert_bits(payload, 8, 5), Bech32::Encoding::BECH32M)
+      end
+
+    end
+  end
+end

data/lib/bitcoin/tx.rb

@@ -33,6 +33,19 @@ module Bitcoin
     alias_method :in, :inputs
     alias_method :out, :outputs
 
+    # Create coinbase transaction.
+    # @param [String] msg Message embedded in coinbase transaction.
+    # @param [Bitcoin::Script] script Coinbase transaction scriptPubkey.
+    # @param [Integer] rewards Coinbase Transaction Rewards
+    # @return [Bitcoin::Tx] Coinbase transaction.
+    def self.create_coinbase(msg, script, rewards = 50 * 100000000)
+      coinbase = Tx.new
+      script_sig = Bitcoin::Script.new << 486604799 << "04" << msg.bth
+      coinbase.in << TxIn.new(out_point: OutPoint.create_coinbase_outpoint, script_sig: script_sig)
+      coinbase.out << TxOut.new(value: rewards, script_pubkey: script)
+      coinbase
+    end
+
     def self.parse_from_payload(payload, non_witness: false, strict: false)
       buf = payload.is_a?(String) ? StringIO.new(payload) : payload
       tx = new

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "1.6.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'
@@ -61,6 +61,7 @@ module Bitcoin
   autoload :SigHashGenerator, 'bitcoin/sighash_generator'
   autoload :MessageSign, 'bitcoin/message_sign'
   autoload :Taproot, 'bitcoin/taproot'
+  autoload :SilentPayment, 'bitcoin/silent_payment'
   autoload :BIP324, 'bitcoin/bip324'
 
   require_relative 'bitcoin/constants'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.8.0
 platform: ruby
 authors:
 - azuchi
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-09 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
@@ -360,6 +296,7 @@ files:
 - lib/bitcoin/descriptor/pk.rb
 - lib/bitcoin/descriptor/pkh.rb
 - lib/bitcoin/descriptor/raw.rb
+- lib/bitcoin/descriptor/raw_tr.rb
 - lib/bitcoin/descriptor/script_expression.rb
 - lib/bitcoin/descriptor/sh.rb
 - lib/bitcoin/descriptor/sorted_multi.rb
@@ -469,10 +406,12 @@ files:
 - lib/bitcoin/secp256k1/rfc6979.rb
 - lib/bitcoin/secp256k1/ruby.rb
 - lib/bitcoin/sighash_generator.rb
+- lib/bitcoin/silent_payment.rb
 - lib/bitcoin/slip39.rb
 - lib/bitcoin/slip39/share.rb
 - lib/bitcoin/slip39/sss.rb
 - lib/bitcoin/slip39/wordlist/english.txt
+- lib/bitcoin/sp/addr.rb
 - lib/bitcoin/store.rb
 - lib/bitcoin/store/chain_entry.rb
 - lib/bitcoin/store/db.rb
@@ -504,7 +443,6 @@ homepage: https://github.com/chaintope/bitcoinrb
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -519,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: []