bitcoinrb 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c9473a6381568e857b55cadaaad942065a2d9189fab7da542248c9e998d528e
-  data.tar.gz: 34b3ebf0c5826edf8241a1294aaa6662bdf1e92973968351ecb2a9d24eeb8402
+  metadata.gz: 544382f715d87eb79e185e310c827b2349c0af75c1bd89887a653510e226cd1f
+  data.tar.gz: c807d0965da7c06f71b248d5a543ccfff2375d702a6ab4db70698c4be245720d
 SHA512:
-  metadata.gz: eb63914be0f81eb46e76d6c7fb2bbc9e13db948da8c757fd7c9a7235918faff82b6cd770620a4096480b1d183495f0a930dcdd55aeb014484368b2b1ee91d660
-  data.tar.gz: 696e9d8081863c22c0b3322d32f4cca5200ceaf7553f8a97226b4696a04ee3a091ed384bdef6b28b573f4d9d81b80d37a0d65168d7eb86570df9325232ac1663
+  metadata.gz: 22ea36535fb045c35d28809f87c60f4451e2d37801e7a231772068c268d6e58cdeb086456ffc649091a5a28a82815af77f6d35ef286a7a101e53fa3f97e55a9a
+  data.tar.gz: 7ca7b637b77bdde57d2af3faf056184397b1d87fd98dd5c46933dfb40e716d5bf8ef56890691771b97d8e66dde1c9684cb1d03e9f74f99d4f8b5bbaeb6a37e2c

data/.github/workflows/ruby.yml

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

data/.ruby-version

@@ -1 +1 @@
-ruby-3.1.2
+ruby-3.2.0

data/README.md

@@ -67,6 +67,8 @@ And then add to your .rb file:
 
 ## Usage
 
+Examples can be found on the [wiki](https://github.com/chaintope/bitcoinrb/wiki).
+
 ### Chain selection
 
 The parameters of the blockchain are managed by `Bitcoin::ChainParams`. Switch chain parameters as follows:

data/bitcoinrb.gemspec

@@ -20,9 +20,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'ecdsa'
+  spec.add_runtime_dependency 'ecdsa_ext', '~> 0.5.0'
   spec.add_runtime_dependency 'eventmachine'
-  spec.add_runtime_dependency 'murmurhash3'
+  spec.add_runtime_dependency 'murmurhash3', '~> 0.1.7'
   spec.add_runtime_dependency 'bech32', '>= 1.3.0'
   spec.add_runtime_dependency 'daemon-spawn'
   spec.add_runtime_dependency 'thor'
@@ -31,9 +31,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'eventmachine_httpserver'
   spec.add_runtime_dependency 'iniparse'
   spec.add_runtime_dependency 'siphash'
-  spec.add_runtime_dependency 'protobuf', '3.8.5'
   spec.add_runtime_dependency 'json_pure', '>= 2.3.1'
-  spec.add_runtime_dependency 'bip-schnorr', '>= 0.4.0'
+  spec.add_runtime_dependency 'bip-schnorr', '>= 0.5.0'
   spec.add_runtime_dependency 'base32', '>= 0.3.4'
 
   # for options

data/lib/bitcoin/constants.rb

@@ -57,9 +57,8 @@ module Bitcoin
   SCRIPT_VERIFY_CONST_SCRIPTCODE = (1 << 16) # Making OP_CODESEPARATOR and FindAndDelete fail any non-segwit scripts
   SCRIPT_VERIFY_TAPROOT = (1 << 17) # Taproot/Tapscript validation (BIPs 341 & 342)
   SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION = (1 << 18) # Making unknown Taproot leaf versions non-standard
-  SCRIPT_VERIFY_DISCOURAGE_UNKNOWN_ANNEX = (1 << 19) # Making the use of (unknown) annexes non-standard (currently no annexes are known)
-  SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS = (1 << 20) # Making unknown OP_SUCCESS non-standard
-  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE = (1 << 21) # Making unknown public key versions (in BIP 342 scripts) non-standard
+  SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS = (1 << 19) # Making unknown OP_SUCCESS non-standard
+  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE = (1 << 20) # Making unknown public key versions (in BIP 342 scripts) non-standard
 
   MANDATORY_SCRIPT_VERIFY_FLAGS = SCRIPT_VERIFY_P2SH
 

data/lib/bitcoin/ext_key.rb

@@ -27,7 +27,8 @@ module Bitcoin
       l = Bitcoin.hmac_sha512('Bitcoin seed', seed.htb)
       left = l[0..31].bth.to_i(16)
       raise 'invalid key' if left >= CURVE_ORDER || left == 0
-      ext_key.key = Bitcoin::Key.new(priv_key: l[0..31].bth, key_type: Bitcoin::Key::TYPES[:compressed])
+      l_priv = ECDSA::Format::IntegerOctetString.encode(left, 32)
+      ext_key.key = Bitcoin::Key.new(priv_key: l_priv.bth, key_type: Bitcoin::Key::TYPES[:compressed])
       ext_key.chain_code = l[32..-1]
       ext_key
     end
@@ -110,8 +111,8 @@ module Bitcoin
       raise 'invalid key' if left >= CURVE_ORDER
       child_priv = (left + key.priv_key.to_i(16)) % CURVE_ORDER
       raise 'invalid key ' if child_priv >= CURVE_ORDER
-      new_key.key = Bitcoin::Key.new(
-          priv_key: child_priv.to_even_length_hex.rjust(64, '0'), key_type: key_type)
+      child_priv = ECDSA::Format::IntegerOctetString.encode(child_priv, 32)
+      new_key.key = Bitcoin::Key.new(priv_key: child_priv.bth, key_type: key_type)
       new_key.chain_code = l[32..-1]
       new_key.ver = version
       new_key
@@ -280,7 +281,8 @@ module Bitcoin
       l = Bitcoin.hmac_sha512(chain_code, data)
       left = l[0..31].bth.to_i(16)
       raise 'invalid key' if left >= CURVE_ORDER
-      p1 = Bitcoin::Key.new(priv_key: left.to_s(16), key_type: Bitcoin::Key::TYPES[:uncompressed]).to_point
+      l_priv = ECDSA::Format::IntegerOctetString.encode(left, 32)
+      p1 = Bitcoin::Key.new(priv_key: l_priv.bth, key_type: Bitcoin::Key::TYPES[:uncompressed]).to_point
       p2 = Bitcoin::Key.new(pubkey: pubkey, key_type: key_type).to_point
       new_key.pubkey = (p1 + p2).to_hex
       new_key.chain_code = l[32..-1]

data/lib/bitcoin/key.rb

@@ -39,6 +39,7 @@ module Bitcoin
       @secp256k1_module =  Bitcoin.secp_impl
       @priv_key = priv_key
       if @priv_key
+        raise ArgumentError, 'Private key must be 32 bytes.' unless priv_key.htb.bytesize == 32
         raise ArgumentError, Errors::Messages::INVALID_PRIV_KEY unless validate_private_key_range(@priv_key)
       end
       if pubkey
@@ -51,7 +52,7 @@ module Bitcoin
 
     # generate key pair
     def self.generate(key_type = TYPES[:compressed])
-      priv_key, pubkey = Bitcoin.secp_impl.generate_key_pair
+      priv_key, pubkey = Bitcoin.secp_impl.generate_key_pair(compressed: key_type != TYPES[:uncompressed])
       new(priv_key: priv_key, pubkey: pubkey, key_type: key_type)
     end
 
@@ -260,6 +261,12 @@ module Bitcoin
       pubkey[2..65]
     end
 
+    # Convert this key to decompress key.
+    # @return [String] decompress public key with hex format.
+    def decompress_pubkey
+      pubkey.htb.bytesize == PUBLIC_KEY_SIZE ? pubkey : to_point.to_hex(false)
+    end
+
     # check +pubkey+ (hex) is compress or uncompress pubkey.
     def self.compress_or_uncompress_pubkey?(pubkey)
       p = pubkey.htb

data/lib/bitcoin/message_sign.rb

@@ -6,14 +6,42 @@ module Bitcoin
 
     module_function
 
+    FORMAT_LEGACY = :legacy
+    FORMAT_SIMPLE = :simple
+    FORMAT_FULL = :full
+
     # Sign a message.
-    # @param [Bitcoin::Key] key Private key to sign with.
-    # @param [String] message The message to sign.
+    # @param [Bitcoin::Key] key Private key to sign.
+    # @param [String] message The message to be signed.
+    # @param [String] address An address of the key used for signing (required for full or simple format).
+    # @param [String] format Format of signature data. Default is +FORMAT_LEGACY+.
+    # @param [String] prefix (Optional) Prefix used in legacy format.
     # @return [String] Signature, base64 encoded.
-    def sign_message(key, message, prefix: Bitcoin.chain_params.message_magic)
-      digest = message_hash(message, prefix: prefix)
-      compact_sig = key.sign_compact(digest)
-      Base64.strict_encode64(compact_sig)
+    def sign_message(key, message, prefix: Bitcoin.chain_params.message_magic, format: FORMAT_LEGACY, address: nil)
+      validate_format!(format)
+      digest = message_hash(message, prefix: prefix, legacy: format == FORMAT_LEGACY)
+      sig = case format
+            when FORMAT_LEGACY
+              key.sign_compact(digest)
+            else
+              validate_address!(address)
+              addr = Bitcoin::Script.parse_from_addr(address)
+              sig_ver, algo = if addr.p2wpkh?
+                                [:witness_v0, :ecdsa]
+                              elsif addr.p2tr?
+                                [:taproot, :schnorr]
+                              else
+                                raise ArgumentError "#{address} dose not supported."
+                              end
+              tx = to_sign_tx(digest, address)
+              prev_out = Bitcoin::TxOut.new(script_pubkey: addr)
+              sighash = tx.sighash_for_input(0, addr, sig_version: sig_ver, amount: 0, prevouts: [prev_out])
+              sig = key.sign(sighash, algo: algo) + [Bitcoin::SIGHASH_TYPE[:all]].pack('C')
+              tx.in[0].script_witness.stack << sig
+              tx.in[0].script_witness.stack << key.pubkey.htb
+              format == FORMAT_SIMPLE ? tx.in[0].script_witness.to_payload : tx.to_payload
+            end
+      Base64.strict_encode64(sig)
     end
 
     # Verify a signed message.
@@ -23,25 +51,72 @@ module Bitcoin
     # @return [Boolean] Verification result.
     def verify_message(address, signature, message, prefix: Bitcoin.chain_params.message_magic)
       validate_address!(address)
-      sig = Base64.decode64(signature)
-      raise ArgumentError, 'Invalid signature length' unless sig.bytesize == Bitcoin::Key::COMPACT_SIGNATURE_SIZE
-      digest = message_hash(message, prefix: prefix)
-      pubkey = Bitcoin::Key.recover_compact(digest, sig)
-      return false unless pubkey
-      pubkey.to_p2pkh == address
+      begin
+        sig = Base64.strict_decode64(signature)
+      rescue ArgumentError
+        raise ArgumentError, 'Invalid signature'
+      end
+      begin
+        # Legacy verification
+        pubkey = Bitcoin::Key.recover_compact(message_hash(message, prefix: prefix, legacy: true), sig)
+        return false unless pubkey
+        pubkey.to_p2pkh == address
+      rescue ArgumentError
+        # 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)
+        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]))
+        interpreter.verify_script(Bitcoin::Script.new, script_pubkey, tx.in[0].script_witness)
+      end
     end
 
     # Hashes a message for signing and verification.
-    def message_hash(message, prefix: Bitcoin.chain_params.message_magic)
-      Bitcoin.double_sha256(Bitcoin.pack_var_string(prefix) << Bitcoin.pack_var_string(message))
+    def message_hash(message, prefix: Bitcoin.chain_params.message_magic, legacy: true)
+      if legacy
+        Bitcoin.double_sha256(Bitcoin.pack_var_string(prefix) << Bitcoin.pack_var_string(message))
+      else
+        Bitcoin.tagged_hash('BIP0322-signed-message', message)
+      end
     end
 
     def validate_address!(address)
       raise ArgumentError, 'Invalid address' unless Bitcoin.valid_address?(address)
       script = Bitcoin::Script.parse_from_addr(address)
-      raise ArgumentError, 'Address has no key' unless script.p2pkh?
+      raise ArgumentError, 'This address unsupported' if script.p2sh? || script.p2wsh?
+    end
+
+    def validate_format!(format)
+      unless [FORMAT_LEGACY, FORMAT_FULL, FORMAT_SIMPLE].include?(format)
+        raise ArgumentError "Invalid format specified."
+      end
+    end
+
+    def to_spend_tx(digest, addr)
+      validate_address!(addr)
+      message_challenge = Bitcoin::Script.parse_from_addr(addr)
+      tx = Bitcoin::Tx.new
+      tx.version = 0
+      tx.lock_time = 0
+      prev_out = Bitcoin::OutPoint.create_coinbase_outpoint
+      script_sig = Bitcoin::Script.new << Bitcoin::Opcodes::OP_0 << digest
+      tx.in << Bitcoin::TxIn.new(out_point: prev_out, sequence: 0, script_sig: script_sig)
+      tx.out << Bitcoin::TxOut.new(script_pubkey: message_challenge)
+      tx
+    end
+
+    def to_sign_tx(digest, addr)
+      tx = Bitcoin::Tx.new
+      tx.version = 0
+      tx.lock_time = 0
+      prev_out = Bitcoin::OutPoint.from_txid(to_spend_tx(digest, addr).txid, 0)
+      tx.in << Bitcoin::TxIn.new(out_point: prev_out, sequence: 0)
+      tx.out << Bitcoin::TxOut.new(script_pubkey: Bitcoin::Script.new << Bitcoin::Opcodes::OP_RETURN)
+      tx
     end
 
     private_class_method :validate_address!
+    private_class_method :validate_format!
   end
 end

data/lib/bitcoin/node/cli.rb

@@ -9,6 +9,12 @@ module Bitcoin
 
       class_option :network, aliases: '-n', default: :mainnet
 
+      desc 'decodepsbt <base64 psbt string>', "Return a JSON object representing the serialized, base64-encoded partially signed Bitcoin transaction."
+      def decodepsbt(base64)
+        psbt = Bitcoin::PSBT::Tx.parse_from_base64(base64)
+        puts JSON.pretty_generate(psbt.to_h)
+      end
+
       desc 'getblockchaininfo', 'Returns an object containing various state info regarding blockchain processing.'
       def getblockchaininfo
         request('getblockchaininfo')

data/lib/bitcoin/payment_code.rb

@@ -61,7 +61,7 @@ module Bitcoin
       raise ArgumentError, 'invalid version byte' unless hex[0..1] == VERSION_BYTE
       raise ArgumentError, 'invalid version' unless PaymentCode.support_version?(version)
       raise ArgumentError, 'invalid sign' unless PaymentCode.support_sign?(sign)
-      raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless Bitcoin::Key.new(priv_key: nil, pubkey: sign + public_key).fully_valid_pubkey?
+      raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless Bitcoin::Key.new(pubkey: sign + public_key).fully_valid_pubkey?
       raise ArgumentError, Errors::Messages::INVALID_CHECKSUM unless Bitcoin.calc_checksum(payment_code) == hex[-8..-1]
 
       x_value = payment_code[8..71]

data/lib/bitcoin/psbt/input.rb

@@ -283,6 +283,32 @@ module Bitcoin
         self
       end
 
+      def to_h
+        h = {}
+        h[:non_witness_utxo] = non_witness_utxo.to_h if non_witness_utxo
+        h[:witness_utxo] = witness_utxo.to_h if witness_utxo
+        h[:redeem_script] = redeem_script.to_h if redeem_script
+        h[:witness_script] = witness_script.to_h if redeem_script
+        h[:final_script_sig] = final_script_sig.to_h if final_script_sig
+        h[:final_script_witness] = final_script_witness.to_h if final_script_witness
+        h[:bip32_derivs] = hd_key_paths.values.map(&:to_h) unless hd_key_paths.empty?
+        h[:partial_signatures] = partial_sigs.map {|k, v| {"#{k}": v.bth}} unless partial_sigs.empty?
+        h[:sighash_type] = sighash_type if sighash_type
+        h[:ripemd160_preimages] = ripemd160_preimages.map {|k, v| {"#{k}": v}} unless ripemd160_preimages.empty?
+        h[:sha256_preimages] = sha256_preimages.map {|k, v| {"#{k}": v}} unless sha256_preimages.empty?
+        h[:hash160_preimages] = hash160_preimages.map {|k, v| {"#{k}": v}} unless hash160_preimages.empty?
+        h[:hash256_preimages] = hash256_preimages.map {|k, v| {"#{k}": v}} unless hash256_preimages.empty?
+        h[:proprietary] = proprietaries.map(&:to_h) unless proprietaries.empty?
+        h[:tap_key_sig] = tap_key_sig if tap_key_sig
+        h[:tap_script_sig] = tap_script_sigs.map {|k, v| {"#{k}": v}} unless tap_script_sigs.empty?
+        h[:tap_leaf_script] = tap_leaf_scripts.map {|k, v| {"#{k}": v}} unless tap_leaf_scripts.empty?
+        h[:tap_bip32_derivs] = tap_bip32_derivations.map{|k, v| {"#{k}": v}} unless tap_bip32_derivations.empty?
+        h[:tap_internal_key] = tap_internal_key if tap_internal_key
+        h[:tap_merkle_root] = tap_merkle_root if tap_merkle_root
+        h[:unknown] = unknowns.map {|k, v| {"#{k}": v.bth}} unless unknowns.empty?
+        h
+      end
+
     end
 
   end

data/lib/bitcoin/psbt/output.rb

@@ -100,7 +100,18 @@ module Bitcoin
         combined
       end
 
+      def to_h
+        h = {}
+        h[:redeem_script] = redeem_script.bth if redeem_script
+        h[:witness_script] = witness_script.bth if witness_script
+        h[:bip32_derivs] = hd_key_paths.values.map(&:to_h) unless hd_key_paths.empty?
+        h[:proprietary] = proprietaries.map(&:to_h) unless proprietaries.empty?
+        h[:tap_internal_key] = tap_internal_key if tap_internal_key
+        h[:tap_tree] = tap_tree if tap_tree
+        h[:tap_bip32_derivs] = tap_bip32_derivations.map{|k, v| {"#{k}": v}} unless tap_bip32_derivations.empty?
+        h[:unknown] = unknowns.map {|k, v| {"#{k}": v.bth}} unless unknowns.empty?
+        h
+      end
     end
-
   end
 end

data/lib/bitcoin/psbt/proprietary.rb

@@ -39,6 +39,10 @@ module Bitcoin
         k = key
         Bitcoin.pack_var_int(k.bytesize) + k + Bitcoin.pack_var_int(value.bytesize) + value
       end
+
+      def to_h
+        {identifier: identifier.bth, sub_type: sub_type, value: value.bth}
+      end
     end
   end
 end

data/lib/bitcoin/psbt/tx.rb

@@ -177,6 +177,18 @@ module Bitcoin
         end
       end
 
+      def to_h
+        {
+          tx: tx.to_h,
+          global_xpubs: xpubs.map(&:to_h),
+          psbt_version: version,
+          proprietary: proprietaries.map(&:to_h),
+          unknown: unknowns.map {|k, v| {"#{k}": v}},
+          inputs: inputs.map(&:to_h),
+          outputs: outputs.map(&:to_h)
+        }
+      end
+
       # update input key-value maps.
       # @param [Bitcoin::Tx] prev_tx previous tx reference by input.
       # @param [Bitcoin::Script] redeem_script redeem script to set input.

data/lib/bitcoin/script/script.rb

@@ -233,11 +233,28 @@ module Bitcoin
       OP_HASH160 == chunks[0].ord && OP_EQUAL == chunks[2].ord && chunks[1].bytesize == 21
     end
 
+    # Check whether this script is a P2PK format script.
+    # @return [Boolean] if P2PK return true, otherwise false
+    def p2pk?
+      return false unless chunks.size == 2
+      return false unless chunks[0].pushdata?
+      key_type = chunks[0].pushed_data[0].ord
+      case key_type
+      when 0x02, 0x03
+        return false unless chunks[0].pushed_data.bytesize == 33
+      when 0x04
+        return false unless chunks[0].pushed_data.bytesize == 65
+      else
+        return false
+      end
+      chunks[1].ord == OP_CHECKSIG
+    end
+
     def multisig?
       return false if chunks.size < 4 || chunks.last.ord != OP_CHECKMULTISIG
       pubkey_count = Opcodes.opcode_to_small_int(chunks[-2].opcode)
       sig_count = Opcodes.opcode_to_small_int(chunks[0].opcode)
-      return false unless pubkey_count || sig_count
+      return false if pubkey_count.nil? || sig_count.nil?
       sig_count <= pubkey_count
     end
 
@@ -543,11 +560,8 @@ module Bitcoin
 
     def to_h
       h = {asm: to_s, hex: to_hex, type: type}
-      addrs = addresses
-      unless addrs.empty?
-        h[:req_sigs] = multisig? ? Bitcoin::Opcodes.opcode_to_small_int(chunks[0].bth.to_i(16)) :addrs.size
-        h[:addresses] = addrs
-      end
+      addr = to_addr
+      h[:address] = addr if addr
       h
     end
 

data/lib/bitcoin/secp256k1/ruby.rb

@@ -1,3 +1,6 @@
+require 'ecdsa_ext'
+require 'ecdsa/ext/sign_verify'
+
 module Bitcoin
   module Secp256k1
 
@@ -10,9 +13,9 @@ module Bitcoin
       # generate ec private key and public key
       def generate_key_pair(compressed: true)
         private_key = 1 + SecureRandom.random_number(GROUP.order - 1)
-        public_key = GROUP.generator.multiply_by_scalar(private_key)
+        public_key = GROUP.generator.to_jacobian * private_key
         privkey = ECDSA::Format::IntegerOctetString.encode(private_key, 32)
-        pubkey = public_key.to_hex(compressed)
+        pubkey = public_key.to_affine.to_hex(compressed)
         [privkey.bth, pubkey]
       end
 
@@ -23,8 +26,8 @@ module Bitcoin
       end
 
       def generate_pubkey(privkey, compressed: true)
-        public_key = ECDSA::Group::Secp256k1.generator.multiply_by_scalar(privkey.to_i(16))
-        public_key.to_hex(compressed)
+        public_key = GROUP.generator.to_jacobian * privkey.to_i(16)
+        public_key.to_affine.to_hex(compressed)
       end
 
       # Check whether valid x-only public key or not.
@@ -132,7 +135,7 @@ module Bitcoin
         nonce = RFC6979.generate_rfc6979_nonce(privkey + data, extra_entropy)
 
         # port form ecdsa gem.
-        r_point = GROUP.new_point(nonce)
+        r_point = (GROUP.generator.to_jacobian * nonce).to_affine
 
         point_field = ECDSA::PrimeField.new(GROUP.order)
         r = point_field.mod(r_point.x)

data/lib/bitcoin/taproot.rb

@@ -40,7 +40,9 @@ module Bitcoin
       private_key = p.has_even_y? ? internal_private_key.priv_key.to_i(16) :
                       ECDSA::Group::Secp256k1.order - internal_private_key.priv_key.to_i(16)
       t = tweak(internal_private_key, merkle_root)
-      Bitcoin::Key.new(priv_key: ((t.bti + private_key) % ECDSA::Group::Secp256k1.order).to_even_length_hex)
+      private_key = ECDSA::Format::IntegerOctetString.encode(
+        (t.bti + private_key) % ECDSA::Group::Secp256k1.order, 32)
+      Bitcoin::Key.new(priv_key: private_key.bth)
     end
   end
 end

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "1.2.1"
+  VERSION = "1.4.0"
 end

data/lib/bitcoin.rb

@@ -46,7 +46,6 @@ module Bitcoin
   autoload :RPC, 'bitcoin/rpc'
   autoload :Wallet, 'bitcoin/wallet'
   autoload :BloomFilter, 'bitcoin/bloom_filter'
-  autoload :Payments, 'bitcoin/payments'
   autoload :PSBT, 'bitcoin/psbt'
   autoload :GCSFilter, 'bitcoin/gcs_filter'
   autoload :BlockFilter, 'bitcoin/block_filter'

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-28 00:00:00.000000000 Z
+date: 2023-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ecdsa
+  name: ecdsa_ext
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: eventmachine
   requirement: !ruby/object:Gem::Requirement
@@ -42,16 +42,16 @@ dependencies:
   name: murmurhash3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.7
 - !ruby/object:Gem::Dependency
   name: bech32
   requirement: !ruby/object:Gem::Requirement
@@ -164,20 +164,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: protobuf
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.8.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.8.5
 - !ruby/object:Gem::Dependency
   name: json_pure
   requirement: !ruby/object:Gem::Requirement
@@ -198,14 +184,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: base32
   requirement: !ruby/object:Gem::Requirement
@@ -439,13 +425,6 @@ files:
 - lib/bitcoin/opcodes.rb
 - lib/bitcoin/out_point.rb
 - lib/bitcoin/payment_code.rb
-- lib/bitcoin/payments.rb
-- lib/bitcoin/payments/output.pb.rb
-- lib/bitcoin/payments/payment.pb.rb
-- lib/bitcoin/payments/payment_ack.pb.rb
-- lib/bitcoin/payments/payment_details.pb.rb
-- lib/bitcoin/payments/payment_request.pb.rb
-- lib/bitcoin/payments/x509_certificates.pb.rb
 - lib/bitcoin/psbt.rb
 - lib/bitcoin/psbt/hd_key_path.rb
 - lib/bitcoin/psbt/input.rb
@@ -517,7 +496,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.23
+rubygems_version: 3.4.1
 signing_key: 
 specification_version: 4
 summary: The implementation of Bitcoin Protocol for Ruby.

data/lib/bitcoin/payments/output.pb.rb

@@ -1,20 +0,0 @@
-module Bitcoin
-  module Payments
-
-    # https://github.com/bitcoin/bips/blob/master/bip-0070.mediawiki#Output
-    class Output < Protobuf::Message
-
-      optional :uint64, :amount, 1, {default: 0}
-
-      required :bytes, :script, 2
-
-      # convert to TxOut object.
-      # @return [Bitcoin::TxOut]
-      def to_tx_out
-        Bitcoin::TxOut.new(value: amount, script_pubkey: Bitcoin::Script.parse_from_payload(script))
-      end
-
-    end
-
-  end
-end

data/lib/bitcoin/payments/payment.pb.rb

@@ -1,26 +0,0 @@
-module Bitcoin
-  module Payments
-
-    # https://github.com/bitcoin/bips/blob/master/bip-0070.mediawiki#Payment
-    class Payment < Protobuf::Message
-
-      optional :bytes, :merchant_data, 1
-
-      repeated :bytes, :transactions, 2
-
-      repeated Bitcoin::Payments::Output, :refund_to, 3
-
-      optional :string, :memo, 4
-
-      def self.parse_from_payload(payload)
-        decode(payload)
-      end
-
-      def transactions
-        @values[:transactions].map{|raw_tx|Bitcoin::Tx.parse_from_payload(raw_tx, strict: true)}
-      end
-
-    end
-
-  end
-end

data/lib/bitcoin/payments/payment_ack.pb.rb

@@ -1,17 +0,0 @@
-module Bitcoin
-  module Payments
-
-    # https://github.com/bitcoin/bips/blob/master/bip-0070.mediawiki#PaymentACK
-    class PaymentACK < Protobuf::Message
-
-      required Bitcoin::Payments::Payment, :payment, 1
-
-      optional :string, :memo, 2
-
-      def self.parse_from_payload(payload)
-        decode(payload)
-      end
-    end
-
-  end
-end

data/lib/bitcoin/payments/payment_details.pb.rb

@@ -1,24 +0,0 @@
-module Bitcoin
-  module Payments
-
-    # https://github.com/bitcoin/bips/blob/master/bip-0070.mediawiki#PaymentDetailsPaymentRequest
-    class PaymentDetails < Protobuf::Message
-
-      optional :string, :network, 1, {default: 'main'}
-
-      repeated Bitcoin::Payments::Output, :outputs, 2
-
-      required :uint64, :time, 3
-
-      optional :uint64, :expires, 4
-
-      optional :string, :memo, 5
-
-      optional :string, :payment_url, 6
-
-      optional :bytes, :merchant_data, 7
-
-    end
-
-  end
-end

data/lib/bitcoin/payments/payment_request.pb.rb

@@ -1,79 +0,0 @@
-module Bitcoin
-  module Payments
-
-    # https://github.com/bitcoin/bips/blob/master/bip-0070.mediawiki#PaymentDetailsPaymentRequest
-    class PaymentRequest < Protobuf::Message
-
-      optional :uint32, :payment_details_version, 1, {default: 1}
-
-      optional :string, :pki_type, 2, {default: 'none'}
-
-      optional :bytes, :pki_data, 3
-
-      required :bytes, :serialized_payment_details, 4
-
-      optional :bytes, :signature, 5
-
-      def self.parse_from_payload(payload)
-        self.decode(payload)
-      end
-
-      # verify +pki_data+.
-      # @return [Struct] pki information.
-      def verify_pki_data
-        d = Struct.new(:display_name, :merchant_sign_key, :root_auth, :root_auth_name)
-        d
-      end
-
-      # get payment details
-      # @return [Bitcoin::Payments:PaymentDetails]
-      def details
-        PaymentDetails.decode(serialized_payment_details)
-      end
-
-      # get certificates
-      # @return [Array[OpenSSL::X509::Certificate]]
-      def certs
-        return [] unless has_pki?
-        X509Certificates.decode(pki_data).certs
-      end
-
-      # whether exist +pki_data+.
-      def has_pki?
-        pki_type != 'none'
-      end
-
-      # verify signature.
-      def valid_sig?
-        return false unless has_pki?
-        digest = case pki_type
-                   when 'x509+sha256'
-                     OpenSSL::Digest::SHA256.new
-                   when 'x509+sha1'
-                     OpenSSL::Digest::SHA1.new
-                   else
-                     raise "pki_type: #{pki_type} is invalid type."
-                 end
-        certs.first.public_key.verify(digest, signature, sig_message)
-      end
-
-      # verify expire time for payment request.
-      def valid_time?
-        expires = details.expires
-        return true if expires == 0
-        Time.now.to_i <= expires
-      end
-
-      private
-
-      # Generate data to be signed
-      def sig_message
-        PaymentRequest.new(payment_details_version: payment_details_version,
-                           pki_type: pki_type, pki_data: pki_data, signature: '',
-                           serialized_payment_details: serialized_payment_details).encode
-      end
-
-    end
-
-  end
-end

data/lib/bitcoin/payments/x509_certificates.pb.rb

@@ -1,18 +0,0 @@
-module Bitcoin
-  module Payments
-
-    # https://github.com/bitcoin/bips/blob/master/bip-0070.mediawiki#Certificates
-    class X509Certificates < Protobuf::Message
-
-      repeated :bytes, :certificate, 1
-
-      # get certificates
-      # @return [Array[OpenSSL::X509::Certificate]]
-      def certs
-        certificate.map{|v|OpenSSL::X509::Certificate.new(v)}
-      end
-
-    end
-
-  end
-end

data/lib/bitcoin/payments.rb

@@ -1,14 +0,0 @@
-require 'protobuf'
-
-module Bitcoin
-  module Payments
-
-    autoload :Output, 'bitcoin/payments/output.pb'
-    autoload :Payment, 'bitcoin/payments/payment.pb'
-    autoload :PaymentACK, 'bitcoin/payments/payment_ack.pb'
-    autoload :PaymentDetails, 'bitcoin/payments/payment_details.pb'
-    autoload :PaymentRequest, 'bitcoin/payments/payment_request.pb'
-    autoload :X509Certificates, 'bitcoin/payments/x509_certificates.pb'
-
-  end
-end