bitcoinrb 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5026fc4446c5a88954149551d7168d8022e5aa41cd45cbf86b44ce62fdb308a5
-  data.tar.gz: a6a3708940e5eca7d8eba4ac71ca941e98ba5af7e09f516ea6e7583b38299c80
+  metadata.gz: af836e45167490d93d1d9b5d8f29f4e473a78dc314b98cd789bb47e347a42037
+  data.tar.gz: 020fe745057f3b987c8bd8828be9f7f657d3085a7d8ee37cf0218b0761202325
 SHA512:
-  metadata.gz: 0f3ce5cc15d9de9c0fbb578ec179a81148228bb7f12c9937f6a3fe6f73585d09f6d62798abe1255e95e5d415c0a0e7fdeeb51457245b16565c8908b76d2d0249
-  data.tar.gz: fc3f64635b4330c15152b9a38b49a2ec7b324d3a7940cd7a51c64a601d6f9e89a6731014a9f7d2c86cef8a0453b18beb39c5ecec288b8a77c24d73d615c2aebf
+  metadata.gz: 0db2c744f372a2e71c337cb8970bb8cad81f37aa81824504d5fe6ee46819516ca6869c3cab0af1474aa0906905496af3e8f97eacc6cdaf9b7eced0a6cd247ff2
+  data.tar.gz: dab1256db8085c43ec5ab5d784d465cbdb3d74e663d4f052fd76161decacd9fb5fe22b3c2f99cc20381dda8ea203d63866db45e6e8c8ed6d8b4a2d4c27acfe89

data/.github/workflows/ruby.yml

@@ -0,0 +1,37 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install leveldb
+      run: sudo apt-get install libleveldb-dev
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake spec

data/.rspec_parallel

@@ -0,0 +1,2 @@
+--format ParallelTests::RSpec::RuntimeLogger --out tmp/parallel_runtime_rspec.log
+--format ParallelTests::RSpec::SummaryLogger --out tmp/spec_summary.log

data/README.md

@@ -1,4 +1,4 @@
-# Bitcoinrb [![Build Status](https://travis-ci.org/chaintope/bitcoinrb.svg?branch=master)](https://travis-ci.org/chaintope/bitcoinrb) [![Gem Version](https://badge.fury.io/rb/bitcoinrb.svg)](https://badge.fury.io/rb/bitcoinrb) [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE) <img src="http://segwit.co/static/public/images/logo.png" width="100">
+# Bitcoinrb [![Build Status](https://github.com/chaintope/bitcoinrb/actions/workflows/ruby.yml/badge.svg?branch=master)](https://github.com/chaintope/bitcoinrb/actions/workflows/ruby.yml) [![Gem Version](https://badge.fury.io/rb/bitcoinrb.svg)](https://badge.fury.io/rb/bitcoinrb) [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE) <img src="http://segwit.co/static/public/images/logo.png" width="100">
 
 
 Bitcoinrb is a Ruby implementation of Bitcoin Protocol.

data/bitcoinrb.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   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.3.2'
+  spec.add_runtime_dependency 'bip-schnorr', '>= 0.4.0'
   spec.add_runtime_dependency 'base32', '>= 0.3.4'
 
   # for options
@@ -44,5 +44,5 @@ Gem::Specification.new do |spec|
   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'
 end

data/lib/bitcoin.rb

@@ -60,6 +60,8 @@ module Bitcoin
   autoload :BIP85Entropy, 'bitcoin/bip85_entropy'
   autoload :Errors, 'bitcoin/errors'
   autoload :SigHashGenerator, 'bitcoin/sighash_generator'
+  autoload :MessageSign, 'bitcoin/message_sign'
+  autoload :Taproot, 'bitcoin/taproot'
 
   require_relative 'bitcoin/constants'
   require_relative 'bitcoin/ext/ecdsa'

data/lib/bitcoin/constants.rb

@@ -73,7 +73,8 @@ module Bitcoin
   # for script
 
   # witness version
-  WITNESS_VERSION = 0x00
+  WITNESS_VERSION_V0 = 0x00
+  WITNESS_VERSION_V1 = Bitcoin::Opcodes::OP_1
 
   # Maximum script length in bytes
   MAX_SCRIPT_SIZE = 10000

data/lib/bitcoin/ext.rb

@@ -1,5 +1,6 @@
 module Bitcoin
   module Ext
     autoload :JsonParser, 'bitcoin/ext/json_parser'
+    autoload :ArrayExt, 'bitcoin/ext/array_ext'
   end
 end

data/lib/bitcoin/ext/array_ext.rb

@@ -0,0 +1,22 @@
+module Bitcoin
+  module Ext
+    module ArrayExt
+
+      refine Array do
+
+        # resize array content with +initial_value+.
+        # expect to behave like vec#resize in c++.
+        def resize!(new_size, initial_value = 0)
+          if size < new_size
+            (new_size - size).times{self.<< initial_value}
+          elsif size > new_size
+            (size - new_size).times{delete_at(-1)}
+          end
+          self
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bitcoin/ext/ecdsa.rb

@@ -3,6 +3,11 @@ class ::ECDSA::Signature
   def to_der
     ECDSA::Format::SignatureDerString.encode(self)
   end
+
+  def ==(other)
+    return false unless other.is_a?(ECDSA::Signature)
+    r == other.r && s == other.s
+  end
 end
 
 class ::ECDSA::Point

data/lib/bitcoin/ext_key.rb

@@ -280,7 +280,7 @@ 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::Secp256k1::GROUP.generator.multiply_by_scalar(left)
+      p1 = Bitcoin::Key.new(priv_key: left.to_s(16), 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

@@ -10,6 +10,7 @@ module Bitcoin
     COMPRESSED_PUBLIC_KEY_SIZE = 33
     SIGNATURE_SIZE = 72
     COMPACT_SIGNATURE_SIZE = 65
+    COMPACT_SIG_HEADER_BYTE = 0x1b
 
     attr_accessor :priv_key
     attr_accessor :pubkey
@@ -77,6 +78,23 @@ module Bitcoin
       new(priv_key: data.bth, key_type: key_type)
     end
 
+    # Generate from xonly public key.
+    # @param [String] xonly_pubkey xonly public key with hex format.
+    # @return [Bitcoin::Key] key object has public key.
+    def self.from_xonly_pubkey(xonly_pubkey)
+      raise ArgumentError, 'xonly_pubkey must be 32 bytes' unless xonly_pubkey.htb.bytesize == 32
+      Bitcoin::Key.new(pubkey: "02#{xonly_pubkey}", key_type: TYPES[:compressed])
+    end
+
+    # Generate from public key point.
+    # @param [ECDSA::Point] point Public key point.
+    # @param [Boolean] compressed whether compressed or not.
+    # @return [Bitcoin::Key]
+    def self.from_point(point, compressed: true)
+      pubkey = ECDSA::Format::PointOctetString.encode(point, compression: compressed).bth
+      Bitcoin::Key.new(pubkey: pubkey, key_type: TYPES[:compressed])
+    end
+
     # export private key with wif format
     def to_wif
       version = Bitcoin.chain_params.privkey_version
@@ -112,6 +130,29 @@ module Bitcoin
       end
     end
 
+    # Sign compact signature.
+    # @param [String] data message digest to be signed.
+    # @return [String] compact signature with binary format.
+    def sign_compact(data)
+      signature, rec = secp256k1_module.sign_compact(data, priv_key)
+      rec = Bitcoin::Key::COMPACT_SIG_HEADER_BYTE + rec + (compressed? ? 4 : 0)
+      [rec].pack('C') + ECDSA::Format::IntegerOctetString.encode(signature.r, 32) +
+        ECDSA::Format::IntegerOctetString.encode(signature.s, 32)
+    end
+
+    # Recover public key from compact signature.
+    # @param [String] data message digest using signature.
+    # @param [String] signature signature with binary format.
+    # @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
+      raise ArgumentError, 'Invalid signature parameter' if rec < 0 || rec > 15
+      rec = rec & 3
+      compressed = (rec_id - Bitcoin::Key::COMPACT_SIG_HEADER_BYTE) & 4 != 0
+      Bitcoin.secp_impl.recover_compact(data, signature, rec, compressed)
+    end
+
     # verify signature using public key
     # @param [String] sig signature data with binary format
     # @param [String] data original message
@@ -165,13 +206,14 @@ module Bitcoin
     # @return [ECDSA::Point]
     def to_point
       p = pubkey
-      p ||= generate_pubkey(priv_key, compressed: compressed)
+      p ||= generate_pubkey(priv_key, compressed: compressed?)
       ECDSA::Format::PointOctetString.decode(p.htb, Bitcoin::Secp256k1::GROUP)
     end
 
     # get xonly public key (32 bytes).
     # @return [String] xonly public key with hex format
     def xonly_pubkey
+      puts "Derive a public key whose y-coordinate is different from this public key." if compressed? && pubkey[0...2] != '02'
       pubkey[2..65]
     end
 

data/lib/bitcoin/message/tx.rb

@@ -16,7 +16,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        tx = Bitcoin::Tx.parse_from_payload(payload)
+        tx = Bitcoin::Tx.parse_from_payload(payload, strict: true)
         new(tx, tx.witness?)
       end
 

data/lib/bitcoin/message_sign.rb

@@ -0,0 +1,47 @@
+module Bitcoin
+
+  module MessageSign
+
+    class Error < StandardError; end
+
+    module_function
+
+    # Sign a message.
+    # @param [Bitcoin::Key] key Private key to sign with.
+    # @param [String] message The message to sign.
+    # @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)
+    end
+
+    # Verify a signed message.
+    # @param [String] address Signer's bitcoin address, it must refer to a public key.
+    # @param [String] signature The signature in base64 format.
+    # @param [String] message The message that was signed.
+    # @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
+    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))
+    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?
+    end
+
+    private_class_method :validate_address!
+  end
+end

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

@@ -17,7 +17,7 @@ module Bitcoin
       end
 
       def transactions
-        @values[:transactions].map{|raw_tx|Bitcoin::Tx.parse_from_payload(raw_tx)}
+        @values[:transactions].map{|raw_tx|Bitcoin::Tx.parse_from_payload(raw_tx, strict: true)}
       end
 
     end

data/lib/bitcoin/psbt/input.rb

@@ -44,7 +44,7 @@ module Bitcoin
           when PSBT_IN_TYPES[:non_witness_utxo]
             raise ArgumentError, 'Invalid non-witness utxo typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, input non-witness utxo already provided.' if input.non_witness_utxo
-            input.non_witness_utxo = Bitcoin::Tx.parse_from_payload(value)
+            input.non_witness_utxo = Bitcoin::Tx.parse_from_payload(value, strict: true)
           when PSBT_IN_TYPES[:witness_utxo]
             raise ArgumentError, 'Invalid input witness utxo typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, input witness utxo already provided.' if input.witness_utxo

data/lib/bitcoin/psbt/tx.rb

@@ -74,7 +74,7 @@ module Bitcoin
           when PSBT_GLOBAL_TYPES[:unsigned_tx]
             raise ArgumentError, 'Invalid global transaction typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, unsigned tx already provided.' if partial_tx.tx
-            partial_tx.tx = Bitcoin::Tx.parse_from_payload(value, non_witness: true)
+            partial_tx.tx = Bitcoin::Tx.parse_from_payload(value, non_witness: true, strict: true)
             partial_tx.tx.in.each do |tx_in|
               raise ArgumentError, 'Unsigned tx does not have empty scriptSigs and scriptWitnesses.' if !tx_in.script_sig.empty? || !tx_in.script_witness.empty?
             end

data/lib/bitcoin/rpc/request_handler.rb

@@ -75,7 +75,7 @@ module Bitcoin
 
       # broadcast transaction
       def sendrawtransaction(hex_tx)
-        tx = Bitcoin::Tx.parse_from_payload(hex_tx.htb)
+        tx = Bitcoin::Tx.parse_from_payload(hex_tx.htb, strict: true)
         # TODO check wether tx is valid
         node.broadcast(tx)
         tx.txid
@@ -84,7 +84,7 @@ module Bitcoin
       # decode tx data.
       def decoderawtransaction(hex_tx)
         begin
-          Bitcoin::Tx.parse_from_payload(hex_tx.htb).to_h
+          Bitcoin::Tx.parse_from_payload(hex_tx.htb, strict: true ).to_h
         rescue Exception
           raise ArgumentError.new('TX decode failed')
         end

data/lib/bitcoin/script/script.rb

@@ -21,7 +21,7 @@ module Bitcoin
 
     # generate P2WPKH script
     def self.to_p2wpkh(pubkey_hash)
-      new << WITNESS_VERSION << pubkey_hash
+      new << WITNESS_VERSION_V0 << pubkey_hash
     end
 
     # generate m of n multisig p2sh script
@@ -52,7 +52,7 @@ module Bitcoin
     end
 
     # generate m of n multisig script
-    # @param [String] m the number of signatures required for multisig
+    # @param [Integer] m the number of signatures required for multisig
     # @param [Array] pubkeys array of public keys that compose multisig
     # @return [Script] multisig script.
     def self.to_multisig_script(m, pubkeys, sort: false)
@@ -64,7 +64,7 @@ module Bitcoin
     # @param [Script] redeem_script target redeem script
     # @param [Script] p2wsh script
     def self.to_p2wsh(redeem_script)
-      new << WITNESS_VERSION << redeem_script.to_sha256
+      new << WITNESS_VERSION_V0 << redeem_script.to_sha256
     end
 
     # generate script from string.
@@ -87,17 +87,21 @@ module Bitcoin
     def self.parse_from_addr(addr)
       begin
         segwit_addr = Bech32::SegwitAddr.new(addr)
-        raise 'Invalid hrp.' unless Bitcoin.chain_params.bech32_hrp == segwit_addr.hrp
+        raise ArgumentError, 'Invalid address.' unless Bitcoin.chain_params.bech32_hrp == segwit_addr.hrp
         Bitcoin::Script.parse_from_payload(segwit_addr.to_script_pubkey.htb)
       rescue Exception => e
+        begin
         hex, addr_version = Bitcoin.decode_base58_address(addr)
+        rescue
+          raise ArgumentError, 'Invalid address.'
+        end
         case addr_version
         when Bitcoin.chain_params.address_version
           Bitcoin::Script.to_p2pkh(hex)
         when Bitcoin.chain_params.p2sh_version
           Bitcoin::Script.to_p2sh(hex)
         else
-          throw e
+          raise ArgumentError, 'Invalid address.'
         end
       end
     end
@@ -145,7 +149,7 @@ module Bitcoin
     end
 
     # Output script payload.
-    # @param [Boolean] length_prefixed Flag whether the length of the pyrode should be given at the beginning.(default: false)
+    # @param [Boolean] length_prefixed Flag whether the length of the payload should be given at the beginning.(default: false)
     # @return [String] payload
     def to_payload(length_prefixed = false)
       p = chunks.join
@@ -177,27 +181,40 @@ module Bitcoin
 
     # check whether standard script.
     def standard?
-      p2pkh? | p2sh? | p2wpkh? | p2wsh? | multisig? | standard_op_return?
+      p2pkh? | p2sh? | p2wpkh? | p2wsh? | p2tr? | multisig? | standard_op_return?
     end
 
-    # whether this script is a P2PKH format script.
+    # Check whether this script is a P2PKH format script.
+    # @return [Boolean] if P2PKH return true, otherwise false
     def p2pkh?
       return false unless chunks.size == 5
       [OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG] ==
           (chunks[0..1]+ chunks[3..4]).map(&:ord) && chunks[2].bytesize == 21
     end
 
-    # whether this script is a P2WPKH format script.
+    # Check whether this script is a P2WPKH format script.
+    # @return [Boolean] if P2WPKH return true, otherwise false
     def p2wpkh?
       return false unless chunks.size == 2
-      chunks[0].ord == WITNESS_VERSION && chunks[1].bytesize == 21
+      chunks[0].ord == WITNESS_VERSION_V0 && chunks[1].bytesize == 21
     end
 
+    # Check whether this script is a P2WPSH format script.
+    # @return [Boolean] if P2WPSH return true, otherwise false
     def p2wsh?
       return false unless chunks.size == 2
-      chunks[0].ord == WITNESS_VERSION && chunks[1].bytesize == 33
+      chunks[0].ord == WITNESS_VERSION_V0 && chunks[1].bytesize == 33
+    end
+
+    # Check whether this script is a P2TR format script.
+    # @return [Boolean] if P2TR return true, otherwise false
+    def p2tr?
+      return false unless chunks.size == 2
+      chunks[0].ord == WITNESS_VERSION_V1 && chunks[1].bytesize == 33
     end
 
+    # Check whether this script is a P2SH format script.
+    # @return [Boolean] if P2SH return true, otherwise false
     def p2sh?
       return false unless chunks.size == 3
       OP_HASH160 == chunks[0].ord && OP_EQUAL == chunks[2].ord && chunks[1].bytesize == 21
@@ -498,7 +515,7 @@ module Bitcoin
     end
 
     def ==(other)
-      return false unless other
+      return false unless other.is_a?(Script)
       chunks == other.chunks
     end
 

data/lib/bitcoin/script/script_interpreter.rb

@@ -3,6 +3,7 @@ module Bitcoin
   class ScriptInterpreter
 
     include Bitcoin::Opcodes
+    using Bitcoin::Ext::ArrayExt
 
     attr_reader :stack
     attr_reader :debug
@@ -55,6 +56,8 @@ module Bitcoin
         version, program = script_pubkey.witness_data
         stack_copy = stack.dup
         return false unless verify_witness_program(witness, version, program, false)
+        # Bypass the cleanstack check at the end. The actual stack is obviously not clean for witness programs.
+        stack.resize!(1, Script.encode_number(0))
       end
 
       # Additional validation for spend-to-script-hash transactions
@@ -697,7 +700,7 @@ module Bitcoin
       begin
         path_len = (control.bytesize - TAPROOT_CONTROL_BASE_SIZE) / TAPROOT_CONTROL_NODE_SIZE
         xonly_pubkey = control[1...TAPROOT_CONTROL_BASE_SIZE]
-        p = Bitcoin::Key.new(pubkey: "02#{xonly_pubkey.bth}", key_type: Key::TYPES[:compressed])
+        p = Bitcoin::Key.from_xonly_pubkey(xonly_pubkey.bth)
         k = leaf_hash
         path_len.times do |i|
           pos = (TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * i)

data/lib/bitcoin/script/tx_checker.rb

@@ -56,11 +56,9 @@ module Bitcoin
 
       return set_error(SCRIPT_ERR_SCHNORR_SIG_HASHTYPE) unless (hash_type <= 0x03 || (hash_type >= 0x81 && hash_type <= 0x83))
 
-      opts[:prevouts] = prevouts
-
       begin
-        sighash = tx.sighash_for_input(input_index, opts: opts, hash_type: hash_type, sig_version: sig_version)
-        key = Key.new(pubkey: "02#{pubkey}", key_type: Key::TYPES[:compressed])
+        sighash = tx.sighash_for_input(input_index, opts: opts, hash_type: hash_type, sig_version: sig_version, prevouts: prevouts)
+        key = Key.from_xonly_pubkey(pubkey)
         key.verify(sig, sighash, algo: :schnorr)
       rescue ArgumentError
         return set_error(SCRIPT_ERR_SCHNORR_SIG_HASHTYPE)

data/lib/bitcoin/secp256k1/native.rb

@@ -4,8 +4,8 @@
 module Bitcoin
   module Secp256k1
 
-    # binding for secp256k1 (https://github.com/bitcoin/bitcoin/tree/v0.14.2/src/secp256k1)
-    # tag: v0.14.2
+    # binding for secp256k1 (https://github.com/bitcoin-core/secp256k1/)
+    # commit: efad3506a8937162e8010f5839fdf3771dfcf516
     # this is not included by default, to enable set shared object path to ENV['SECP256K1_LIB_PATH']
     # for linux, ENV['SECP256K1_LIB_PATH'] = '/usr/local/lib/libsecp256k1.so'
     # for mac,
@@ -54,6 +54,10 @@ module Bitcoin
         attach_function(:secp256k1_schnorrsig_verify, [:pointer, :pointer, :pointer, :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)
       end
 
       def with_context(flags: (SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN))
@@ -116,6 +120,52 @@ module Bitcoin
         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
+      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 [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
+      end
+
       # verify signature
       # @param [String] data a data with binary format.
       # @param [String] sig signature data with binary format
@@ -194,18 +244,7 @@ module Bitcoin
         internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
         result = secp256k1_ec_pubkey_create(context, internal_pubkey, privkey.htb)
         raise 'error creating pubkey' unless result
-
-        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, internal_pubkey, SECP256K1_EC_COMPRESSED)
-                 else
-                   pubkey_len.put_uint64(0, 65)
-                   secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_UNCOMPRESSED)
-                 end
-        raise 'error serialize pubkey' unless result || pubkey_len.read_uint64 > 0
-        pubkey.read_string(pubkey_len.read_uint64).bth
+        serialize_pubkey_internal(context, internal_pubkey, compressed)
       end
 
       def sign_ecdsa(data, privkey, extra_entropy)
@@ -282,6 +321,21 @@ module Bitcoin
         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

@@ -43,14 +43,14 @@ module Bitcoin
 
       # sign data.
       # @param [String] data a data to be signed with binary format
-      # @param [String] privkey a private key using sign
+      # @param [String] privkey a private key using sign with hex format
       # @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)
+          sign_ecdsa(data, privkey, extra_entropy)&.first
         when :schnorr
           sign_schnorr(data, privkey, extra_entropy)
         else
@@ -58,6 +58,31 @@ module Bitcoin
         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)
+        sig, rec = sign_ecdsa(data, privkey, nil)
+        [ECDSA::Format::SignatureDerString.decode(sig), rec]
+      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 [Boolean] compressed whether compressed public key or not.
+      # @return [Bitcoin::Key] Recovered public key.
+      def recover_compact(data, signature, rec, compressed)
+        r = ECDSA::Format::IntegerOctetString.decode(signature[1...33])
+        s = ECDSA::Format::IntegerOctetString.decode(signature[33..-1])
+        ECDSA.recover_public_key(Bitcoin::Secp256k1::GROUP, data, ECDSA::Signature.new(r, s)).each do |p|
+          if p.y & 1 == rec
+            return Bitcoin::Key.from_point(p, compressed: compressed)
+          end
+        end
+      end
+
       # verify signature using public key
       # @param [String] data a SHA-256 message digest with binary format
       # @param [String] sig a signature for +data+ with binary format
@@ -113,11 +138,14 @@ module Bitcoin
         r = point_field.mod(r_point.x)
         return nil if r.zero?
 
+        rec = r_point.y & 1
+
         e = ECDSA.normalize_digest(data, GROUP.bit_length)
         s = point_field.mod(point_field.inverse(nonce) * (e + r * private_key))
 
         if s > (GROUP.order / 2) # convert low-s
           s = GROUP.order - s
+          rec ^= 1
         end
 
         return nil if s.zero?
@@ -125,7 +153,7 @@ module Bitcoin
         signature = ECDSA::Signature.new(r, s).to_der
         public_key = Bitcoin::Key.new(priv_key: privkey.bth).pubkey
         raise 'Creation of signature failed.' unless Bitcoin::Secp256k1::Ruby.verify_sig(data, signature, public_key)
-        signature
+        [signature, rec]
       end
 
       def sign_schnorr(data, privkey, aux_rand)

data/lib/bitcoin/taproot.rb

@@ -0,0 +1,9 @@
+module Bitcoin
+  module Taproot
+
+    class Error < StandardError; end
+
+    autoload :LeafNode, 'bitcoin/taproot/leaf_node'
+    autoload :SimpleBuilder, 'bitcoin/taproot/simple_builder'
+  end
+end

data/lib/bitcoin/taproot/leaf_node.rb

@@ -0,0 +1,23 @@
+module Bitcoin
+  module Taproot
+    class LeafNode
+
+      attr_reader :script, :leaf_ver
+
+      # Initialize
+      # @param [Bitcoin::Script] script Locking script
+      # @param [Integer] leaf_ver The leaf version of this script.
+      def initialize(script, leaf_ver)
+        raise Taproot::Error, 'script must be Bitcoin::Script object' unless script.is_a?(Bitcoin::Script)
+        @script = script
+        @leaf_ver = leaf_ver
+      end
+
+      # Calculate leaf hash.
+      # @return [String] leaf hash.
+      def leaf_hash
+        @hash_value ||= Bitcoin.tagged_hash('TapLeaf', [leaf_ver].pack('C') + Bitcoin.pack_var_string(script.to_payload))
+      end
+    end
+  end
+end

data/lib/bitcoin/taproot/simple_builder.rb

@@ -0,0 +1,139 @@
+module Bitcoin
+  module Taproot
+
+    # Utility class to construct Taproot outputs from internal key and script tree.
+    # SimpleBuilder builds a script tree that places all lock scripts, in the order they are added, as leaf nodes.
+    # It is not possible to specify the depth of the locking script or to insert any intermediate nodes.
+    class SimpleBuilder
+      include Bitcoin::Opcodes
+
+      attr_reader :internal_key # String with hex format
+      attr_reader :leaves # Array[LeafNode]
+
+      # Initialize builder.
+      # @param [String] internal_key Internal public key with hex format.
+      # @param [Array[Bitcoin::Script]] scripts Scripts for each lock condition.
+      # @param [Integer] leaf_ver (Optional) The leaf version of tapscript.
+      # @raise [Bitcoin::Taproot::Builder] +internal_pubkey+ dose not xonly public key or script in +scripts+ does not instance of Bitcoin::Script.
+      # @return [Bitcoin::Taproot::SimpleBuilder]
+      def initialize(internal_key, *scripts, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        raise Error, 'Internal public key must be 32 bytes' unless internal_key.htb.bytesize == 32
+        @leaves = scripts.map { |script| LeafNode.new(script, leaf_ver) }
+        @internal_key = internal_key
+      end
+
+      # Add lock script to leaf node.
+      # @param [Bitcoin::Script] script lock script.
+      # @param [Integer] leaf_ver (Optional) The leaf version of tapscript.
+      # @raise [Bitcoin::Taproot::Builder] If +script+ does not instance of Bitcoin::Script.
+      # @return [Bitcoin::Taproot::SimpleBuilder] self
+      def <<(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        leaves << LeafNode.new(script, leaf_ver)
+        self
+      end
+
+      # Build P2TR script.
+      # @return [Bitcoin::Script] P2TR script.
+      def build
+        q = tweak_public_key
+        Bitcoin::Script.new << OP_1 << q.xonly_pubkey
+      end
+
+      # Compute the tweaked public key.
+      # @return [Bitcoin::Key] the tweaked public key
+      def tweak_public_key
+        key = Bitcoin::Key.new(priv_key: tweak.bth, key_type: Key::TYPES[:compressed])
+        Bitcoin::Key.from_point(key.to_point + Bitcoin::Key.from_xonly_pubkey(internal_key).to_point)
+      end
+
+      # Compute the secret key for a tweaked public key.
+      # @param [Bitcoin::Key] key key object contains private key.
+      # @return [Bitcoin::Key] secret key for a tweaked public key
+      def tweak_private_key(key)
+        raise Error, 'Requires private key' unless key.priv_key
+        p = key.to_point
+        private_key = p.has_even_y? ? key.priv_key.to_i(16) : ECDSA::Group::Secp256k1.order - key.priv_key.to_i(16)
+        Bitcoin::Key.new(priv_key: ((tweak.bti + private_key) % ECDSA::Group::Secp256k1.order).to_even_length_hex)
+      end
+
+      # Generate control block needed to unlock with script-path.
+      # @param [Bitcoin::Script] script Script to use for unlocking.
+      # @param [Integer] leaf_ver leaf version of script.
+      # @return [String] control block with binary format.
+      def control_block(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        path = inclusion_proof(script, leaf_ver: leaf_ver)
+        parity = tweak_public_key.to_point.has_even_y? ? 0 : 1
+        [parity + leaf_ver].pack("C") + internal_key.htb + path.join
+      end
+
+      # Generate inclusion proof for +script+.
+      # @param [Bitcoin::Script] script The script in script tree.
+      # @param [Integer] leaf_ver (Optional) The leaf version of tapscript.
+      # @return [Array[String]] Inclusion proof.
+      def inclusion_proof(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        parents = leaves
+        parent_hash = leaf_hash(script, leaf_ver: leaf_ver)
+        proofs = []
+        until parents.size == 1
+          parents = parents.each_slice(2).map do |pair|
+            combined = combine_hash(pair)
+            unless pair.size == 1
+              if hash_value(pair[0]) == parent_hash
+                proofs << hash_value(pair[1])
+                parent_hash = combined
+              elsif hash_value(pair[1]) == parent_hash
+                proofs << hash_value(pair[0])
+                parent_hash = combined
+              end
+            end
+            combined
+          end
+        end
+        proofs
+      end
+
+      # Computes leaf hash
+      # @param [Bitcoin::Script] script
+      # @param [Integer] leaf_ver leaf version
+      # @@return [String] leaf hash with binary format.
+      def leaf_hash(script, leaf_ver: Bitcoin::TAPROOT_LEAF_TAPSCRIPT)
+        raise Error, 'script does not exist' unless leaves.find{ |leaf| leaf.script == script}
+        LeafNode.new(script, leaf_ver).leaf_hash
+      end
+
+      private
+
+      # Compute tweak from script tree.
+      # @return [String] tweak with binary format.
+      def tweak
+        parents = leaves
+        if parents.empty?
+          parents = ['']
+        else
+          parents = parents.each_slice(2).map { |pair| combine_hash(pair) } until parents.size == 1
+        end
+        t = Bitcoin.tagged_hash('TapTweak', internal_key.htb + parents.first)
+        raise Error, 'tweak value exceeds the curve order' if t.bti >= ECDSA::Group::Secp256k1.order
+        t
+      end
+
+      def combine_hash(pair)
+        if pair.size == 1
+          hash_value(pair[0])
+        else
+          hash1 = hash_value(pair[0])
+          hash2 = hash_value(pair[1])
+
+          # Lexicographically sort a and b's hash, and compute parent hash.
+          payload = hash1.bth < hash2.bth ? hash1 + hash2 : hash2 + hash1
+          Bitcoin.tagged_hash('TapBranch', payload)
+        end
+      end
+
+      def hash_value(leaf_or_branch)
+        leaf_or_branch.is_a?(LeafNode) ? leaf_or_branch.leaf_hash : leaf_or_branch
+      end
+    end
+  end
+
+end

data/lib/bitcoin/tx.rb

@@ -33,13 +33,13 @@ module Bitcoin
     alias_method :in, :inputs
     alias_method :out, :outputs
 
-    def self.parse_from_payload(payload, non_witness: false)
+    def self.parse_from_payload(payload, non_witness: false, strict: false)
       buf = payload.is_a?(String) ? StringIO.new(payload) : payload
       tx = new
       tx.version = buf.read(4).unpack1('V')
 
       in_count = Bitcoin.unpack_var_int_from_io(buf)
-      witness = false
+      has_witness = false
       if in_count.zero? && !non_witness
         tx.marker = 0
         tx.flag = buf.read(1).unpack1('c')
@@ -47,7 +47,7 @@ module Bitcoin
           buf.pos -= 1
         else
           in_count = Bitcoin.unpack_var_int_from_io(buf)
-          witness = true
+          has_witness = true
         end
       end
 
@@ -60,14 +60,14 @@ module Bitcoin
         tx.outputs << TxOut.parse_from_payload(buf)
       end
 
-      if witness
+      if has_witness
         in_count.times do |i|
           tx.inputs[i].script_witness = Bitcoin::ScriptWitness.parse_from_payload(buf)
         end
       end
 
+      raise ArgumentError, 'Transaction has unexpected data.' if strict &&  (buf.pos + 4) != buf.length
       tx.lock_time = buf.read(4).unpack1('V')
-
       tx
     end
 
@@ -192,8 +192,10 @@ module Bitcoin
     # @param [Integer] amount bitcoin amount locked in input. required for witness input only.
     # @param [Integer] skip_separator_index If output_script is P2WSH and output_script contains any OP_CODESEPARATOR,
     # the script code needs  is the witnessScript but removing everything up to and including the last executed OP_CODESEPARATOR before the signature checking opcode being executed.
+    # @param [Array[Bitcoin::TxOut] prevouts Previous outputs referenced by all Tx inputs, required for taproot.
+    # @return [String] signature hash with binary format.
     def sighash_for_input(input_index, output_script = nil, opts: {}, hash_type: SIGHASH_TYPE[:all],
-                          sig_version: :base, amount: nil, skip_separator_index: 0)
+                          sig_version: :base, amount: nil, skip_separator_index: 0, prevouts: [])
       raise ArgumentError, 'input_index must be specified.' unless input_index
       raise ArgumentError, 'does not exist input corresponding to input_index.' if input_index >= inputs.size
       raise ArgumentError, 'script_pubkey must be specified.' if [:base, :witness_v0].include?(sig_version) && output_script.nil?
@@ -202,6 +204,8 @@ module Bitcoin
       opts[:skip_separator_index] = skip_separator_index
       opts[:sig_version] = sig_version
       opts[:script_code] = output_script
+      opts[:prevouts] = prevouts
+      opts[:last_code_separator_pos] ||= 0xffffffff
       sig_hash_gen = SigHashGenerator.load(sig_version)
       sig_hash_gen.generate(self, input_index, hash_type, opts)
     end
@@ -211,7 +215,9 @@ module Bitcoin
     # @param [Bitcoin::Script] script_pubkey the script pubkey for target input.
     # @param [Integer] amount the amount of bitcoin, require for witness program only.
     # @param [Array] flags the flags used when execute script interpreter.
-    def verify_input_sig(input_index, script_pubkey, amount: nil, flags: STANDARD_SCRIPT_VERIFY_FLAGS)
+    # @param [Array[Bitcoin::TxOut]] prevouts Previous outputs referenced by all Tx inputs, required for taproot.
+    # @return [Boolean] result
+    def verify_input_sig(input_index, script_pubkey, amount: nil, flags: STANDARD_SCRIPT_VERIFY_FLAGS, prevouts: [])
       script_sig = inputs[input_index].script_sig
       has_witness = inputs[input_index].has_witness?
 
@@ -222,7 +228,7 @@ module Bitcoin
       end
 
       if has_witness
-        verify_input_sig_for_witness(input_index, script_pubkey, amount, flags)
+        verify_input_sig_for_witness(input_index, script_pubkey, amount, flags, prevouts)
       else
         verify_input_sig_for_legacy(input_index, script_pubkey, flags)
       end
@@ -255,16 +261,11 @@ module Bitcoin
     end
 
     # verify input signature for witness tx.
-    def verify_input_sig_for_witness(input_index, script_pubkey, amount, flags)
-      flags |= SCRIPT_VERIFY_WITNESS
-      flags |= SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
-      checker = Bitcoin::TxChecker.new(tx: self, input_index: input_index, amount: amount)
+    def verify_input_sig_for_witness(input_index, script_pubkey, amount, flags, prevouts)
+      checker = Bitcoin::TxChecker.new(tx: self, input_index: input_index, amount: amount, prevouts: prevouts)
       interpreter = Bitcoin::ScriptInterpreter.new(checker: checker, flags: flags)
       i = inputs[input_index]
-
-      script_sig = i.script_sig
-      witness = i.script_witness
-      interpreter.verify_script(script_sig, script_pubkey, witness)
+      interpreter.verify_script(i.script_sig, script_pubkey, i.script_witness)
     end
 
   end

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-19 00:00:00.000000000 Z
+date: 2021-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -198,14 +198,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: base32
   requirement: !ruby/object:Gem::Requirement
@@ -304,6 +304,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.11.1
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.20.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.20.1
 description: The implementation of Bitcoin Protocol for Ruby.
 email:
 - azuchi@chaintope.com
@@ -313,11 +327,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- ".rspec_parallel"
 - ".ruby-gemset"
 - ".ruby-version"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -346,6 +361,7 @@ files:
 - lib/bitcoin/descriptor.rb
 - lib/bitcoin/errors.rb
 - lib/bitcoin/ext.rb
+- lib/bitcoin/ext/array_ext.rb
 - lib/bitcoin/ext/ecdsa.rb
 - lib/bitcoin/ext/json_parser.rb
 - lib/bitcoin/ext_key.rb
@@ -400,6 +416,7 @@ files:
 - lib/bitcoin/message/tx.rb
 - lib/bitcoin/message/ver_ack.rb
 - lib/bitcoin/message/version.rb
+- lib/bitcoin/message_sign.rb
 - lib/bitcoin/mnemonic.rb
 - lib/bitcoin/mnemonic/wordlist/chinese_simplified.txt
 - lib/bitcoin/mnemonic/wordlist/chinese_traditional.txt
@@ -459,6 +476,9 @@ files:
 - lib/bitcoin/store/db/level_db.rb
 - lib/bitcoin/store/spv_chain.rb
 - lib/bitcoin/store/utxo_db.rb
+- lib/bitcoin/taproot.rb
+- lib/bitcoin/taproot/leaf_node.rb
+- lib/bitcoin/taproot/simple_builder.rb
 - lib/bitcoin/tx.rb
 - lib/bitcoin/tx_in.rb
 - lib/bitcoin/tx_out.rb

data/.travis.yml

@@ -1,14 +0,0 @@
-dist: bionic
-language: ruby
-rvm:
-  - 2.4.10
-  - 2.5.8
-  - 2.6.6
-  - 2.7.2
-  - 3.0.0
-addons:
-  apt:
-    packages:
-      - libleveldb-dev
-script:
-  - bundle exec parallel_test spec/ -n 6 --type rspec