bitcoinrb 0.5.0 → 0.9.0

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
@@ -28,8 +29,7 @@ module Bitcoin
     # @param [Integer] key_type a key type which determine address type.
     # @param [Boolean] compressed [Deprecated] whether public key is compressed.
     # @return [Bitcoin::Key] a key object.
-    def initialize(priv_key: nil, pubkey: nil, key_type: nil, compressed: true)
-      puts "[Warning] Use key_type parameter instead of compressed. compressed parameter removed in the future." if key_type.nil? && !compressed.nil? && pubkey.nil?
+    def initialize(priv_key: nil, pubkey: nil, key_type: nil, compressed: true, allow_hybrid: false)
       if key_type
         @key_type = key_type
         compressed = @key_type != TYPES[:uncompressed]
@@ -39,13 +39,14 @@ module Bitcoin
       @secp256k1_module =  Bitcoin.secp_impl
       @priv_key = priv_key
       if @priv_key
-        raise ArgumentError, 'private key is not on curve' unless validate_private_key_range(@priv_key)
+        raise ArgumentError, Errors::Messages::INVALID_PRIV_KEY unless validate_private_key_range(@priv_key)
       end
       if pubkey
         @pubkey = pubkey
       else
         @pubkey = generate_pubkey(priv_key, compressed: compressed) if priv_key
       end
+      raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless fully_valid_pubkey?(allow_hybrid)
     end
 
     # generate key pair
@@ -63,9 +64,9 @@ module Bitcoin
       data = hex[2...-8].htb
       checksum = hex[-8..-1]
       raise ArgumentError, 'invalid version' unless version == Bitcoin.chain_params.privkey_version
-      raise ArgumentError, 'invalid checksum' unless Bitcoin.calc_checksum(version + data.bth) == checksum
+      raise ArgumentError, Errors::Messages::INVALID_CHECKSUM unless Bitcoin.calc_checksum(version + data.bth) == checksum
       key_len = data.bytesize
-      if key_len == COMPRESSED_PUBLIC_KEY_SIZE && data[-1].unpack('C').first == 1
+      if key_len == COMPRESSED_PUBLIC_KEY_SIZE && data[-1].unpack1('C') == 1
         key_type = TYPES[:compressed]
         data = data[0..-2]
       elsif key_len == 32
@@ -76,6 +77,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
@@ -88,30 +106,69 @@ module Bitcoin
     # sign +data+ with private key
     # @param [String] data a data to be signed with binary format
     # @param [Boolean] low_r flag to apply low-R.
-    # @param [String] extra_entropy the extra entropy for rfc6979.
+    # @param [String] extra_entropy the 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, low_r = true, extra_entropy = nil)
-      sig = secp256k1_module.sign_data(data, priv_key, extra_entropy)
-      if low_r && !sig_has_low_r?(sig)
-        counter = 1
-        until sig_has_low_r?(sig)
-          extra_entropy = [counter].pack('I*').bth.ljust(64, '0').htb
-          sig = secp256k1_module.sign_data(data, priv_key, extra_entropy)
-          counter += 1
+    def sign(data, low_r = true, extra_entropy = nil, algo: :ecdsa)
+      case algo
+      when :ecdsa
+        sig = secp256k1_module.sign_data(data, priv_key, extra_entropy)
+        if low_r && !sig_has_low_r?(sig)
+          counter = 1
+          until sig_has_low_r?(sig)
+            extra_entropy = [counter].pack('I*').bth.ljust(64, '0').htb
+            sig = secp256k1_module.sign_data(data, priv_key, extra_entropy)
+            counter += 1
+          end
         end
+        sig
+      when :schnorr
+        secp256k1_module.sign_data(data, priv_key, extra_entropy, algo: :schnorr)
+      else
+        raise ArgumentError "Unsupported algo specified: #{algo}"
       end
-      sig
+    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] origin original message
+    # @param [String] data original message
+    # @param [Symbol] algo signature algorithm. ecdsa(default) or schnorr.
     # @return [Boolean] verify result
-    def verify(sig, origin)
+    def verify(sig, data, algo: :ecdsa)
       return false unless valid_pubkey?
       begin
-        sig = ecdsa_signature_parse_der_lax(sig)
-        secp256k1_module.verify_sig(origin, sig, pubkey)
+        case algo
+        when :ecdsa
+          sig = ecdsa_signature_parse_der_lax(sig)
+          secp256k1_module.verify_sig(data, sig, pubkey)
+        when :schnorr
+          secp256k1_module.verify_sig(data, sig, xonly_pubkey, algo: :schnorr)
+        else
+          false
+        end
       rescue Exception
         false
       end
@@ -148,10 +205,16 @@ 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
+      pubkey[2..65]
+    end
+
     # check +pubkey+ (hex) is compress or uncompress pubkey.
     def self.compress_or_uncompress_pubkey?(pubkey)
       p = pubkey.htb
@@ -225,14 +288,8 @@ module Bitcoin
     end
 
     # fully validate whether this is a valid public key (more expensive than IsValid())
-    def fully_valid_pubkey?
-      return false unless valid_pubkey?
-      begin
-        point = ECDSA::Format::PointOctetString.decode(pubkey.htb, ECDSA::Group::Secp256k1)
-        ECDSA::Group::Secp256k1.valid_public_key?(point)
-      rescue ECDSA::Format::DecodeError
-        false
-      end
+    def fully_valid_pubkey?(allow_hybrid = false)
+      valid_pubkey? && secp256k1_module.parse_ec_pubkey?(pubkey, allow_hybrid)
     end
 
     private

data/lib/bitcoin/message/addr_v2.rb

@@ -0,0 +1,34 @@
+module Bitcoin
+  module Message
+
+    # addrv2 message class.
+    # https://github.com/bitcoin/bips/blob/master/bip-0155.mediawiki
+    class AddrV2 < Base
+
+      COMMAND = 'addrv2'
+
+      attr_reader :addrs
+
+      def initialize(addrs = [])
+        @addrs = addrs
+      end
+
+      def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        addr_count = Bitcoin.unpack_var_int_from_io(buf)
+        v2 = new
+        addr_count.times do
+          v2.addrs << NetworkAddr.parse_from_payload(buf, type: NetworkAddr::TYPE[:addr_v2])
+        end
+        v2
+      end
+
+      def to_payload
+        buf = Bitcoin.pack_var_int(addrs.size)
+        buf << (addrs.map { |a| a.to_payload(type: NetworkAddr::TYPE[:addr_v2])}.join)
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/base.rb

@@ -23,6 +23,22 @@ module Bitcoin
         raise 'to_payload must be implemented in a child class.'
       end
 
+      # Decode message data to message object.
+      # @param [String] message with binary format.
+      # @return [Bitcoin::Message::XXX] An instance of a class that inherits Bitcoin::Message::Base
+      # @raise [ArgumentError] Occurs for data that cannot be decoded.
+      def self.from_pkt(message)
+        buf = StringIO.new(message)
+        magic = buf.read(4)
+        raise ArgumentError, 'Invalid magic.' unless magic == Bitcoin.chain_params.magic_head.htb
+        command = buf.read(12).delete("\x00")
+        length = buf.read(4).unpack1('V')
+        checksum = buf.read(4)
+        payload = buf.read(length)
+        raise ArgumentError, 'Checksum do not match.' unless checksum == Bitcoin.double_sha256(payload)[0...4]
+        Bitcoin::Message.decode(command, payload&.bth)
+      end
+
     end
 
   end

data/lib/bitcoin/message/cfcheckpt.rb

@@ -19,8 +19,8 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        type = buf.read(1).unpack('C').first
-        hash = buf.read(32).unpack('H*').first
+        type = buf.read(1).unpack1('C')
+        hash = buf.read(32).unpack1('H*')
         count = Bitcoin.unpack_var_int_from_io(buf)
         headers = count.times.map{buf.read(32).bth}
         self.new(type, hash, headers)

data/lib/bitcoin/message/cfheaders.rb

@@ -21,7 +21,7 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        type = buf.read(1).unpack("C").first
+        type = buf.read(1).unpack1("C")
         hash = buf.read(32).bth
         header = buf.read(32).bth
         count = Bitcoin.unpack_var_int_from_io(buf)

data/lib/bitcoin/message/cfilter.rb

@@ -19,7 +19,7 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        type = buf.read(1).unpack("C").first
+        type = buf.read(1).unpack1("C")
         hash = buf.read(32).bth
         len = Bitcoin.unpack_var_int_from_io(buf)
         filter = buf.read(len).bth

data/lib/bitcoin/message/fee_filter.rb

@@ -15,7 +15,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        new(payload.unpack('Q').first)
+        new(payload.unpack1('Q'))
       end
 
       def to_payload

data/lib/bitcoin/message/filter_load.rb

@@ -23,9 +23,9 @@ module Bitcoin
         buf = StringIO.new(payload)
         filter_count = Bitcoin.unpack_var_int_from_io(buf)
         filter = buf.read(filter_count).unpack('C*')
-        func_count = buf.read(4).unpack('V').first
-        tweak = buf.read(4).unpack('V').first
-        flag = buf.read(1).unpack('C').first
+        func_count = buf.read(4).unpack1('V')
+        tweak = buf.read(4).unpack1('V')
+        flag = buf.read(1).unpack1('C')
         FilterLoad.new(Bitcoin::BloomFilter.new(filter, func_count, tweak), flag)
       end
 

data/lib/bitcoin/message/header_and_short_ids.rb

@@ -22,7 +22,7 @@ module Bitcoin
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
         header = Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
-        nonce = buf.read(8).unpack('q*').first
+        nonce = buf.read(8).unpack1('q*')
         short_ids_len = Bitcoin.unpack_var_int_from_io(buf)
         short_ids = short_ids_len.times.map do
            buf.read(6).reverse.bth.to_i(16)

data/lib/bitcoin/message/inventory.rb

@@ -26,7 +26,7 @@ module Bitcoin
       # parse inventory payload
       def self.parse_from_payload(payload)
         raise Error, 'invalid inventory size.' if payload.bytesize != 36
-        identifier = payload[0..4].unpack('V').first
+        identifier = payload[0..4].unpack1('V')
         hash = payload[4..-1].bth # internal byte order
         new(identifier, hash)
       end

data/lib/bitcoin/message/merkle_block.rb

@@ -20,7 +20,7 @@ module Bitcoin
         m = new
         buf = StringIO.new(payload)
         m.header = Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
-        m.tx_count = buf.read(4).unpack('V').first
+        m.tx_count = buf.read(4).unpack1('V')
         hash_count = Bitcoin.unpack_var_int_from_io(buf)
         hash_count.times do
           m.hashes << buf.read(32).bth

data/lib/bitcoin/message/network_addr.rb

@@ -1,10 +1,16 @@
 require 'ipaddr'
+require 'base32'
 
 module Bitcoin
   module Message
 
+    NETWORK_ID = {ipv4: 0x01, ipv6: 0x02, tor_v2: 0x03, tor_v3: 0x04, i2p: 0x05, cjdns: 0x06}
+    INTERNAL_IN_IPV6_PREFIX = "fd6b:88c0:8724"
+
     class NetworkAddr
 
+      TYPE = {legacy: 0x01, addr_v2: 0x02}
+
       # unix time.
       # Nodes advertising their own IP address set this to the current time.
       # Nodes advertising IP addresses they’ve connected to set this to the last time they connected to that node.
@@ -14,47 +20,164 @@ module Bitcoin
       # The services the node advertised in its version message.
       attr_accessor :services
 
-      attr_accessor :ip_addr # IPAddr
+      attr_accessor :net # network ID that defined by BIP-155
+
+      # Network address. The interpretation depends on networkID.
+      # If ipv4 or ipv6 this field is a IPAddr object, otherwise hex string.
+      attr_accessor :addr
 
       attr_accessor :port
 
       attr_reader :skip_time
 
-      def initialize(ip: '127.0.0.1', port: Bitcoin.chain_params.default_port, services: DEFAULT_SERVICE_FLAGS, time: Time.now.to_i)
+      def initialize(ip: '127.0.0.1', port: Bitcoin.chain_params.default_port,
+                     services: DEFAULT_SERVICE_FLAGS, time: Time.now.to_i, net: NETWORK_ID[:ipv4])
         @time = time
-        @ip_addr = IPAddr.new(ip)
         @port = port
         @services = services
+        @net = net
+        case net
+        when NETWORK_ID[:ipv4], NETWORK_ID[:ipv6]
+          @addr = IPAddr.new(ip) if ip
+        end
       end
 
-      def self.parse_from_payload(payload)
-        buf = payload.is_a?(String) ? StringIO.new(payload) : payload
-        has_time = buf.size > 26
-        addr = new(time: nil)
-        addr.time = buf.read(4).unpack('V').first if has_time
-        addr.services = buf.read(8).unpack('Q').first
-        addr.ip_addr = IPAddr::new_ntoh(buf.read(16))
-        addr.port = buf.read(2).unpack('n').first
-        addr
+      # Parse addr payload
+      # @param [String] payload payload of addr
+      # @param [Integer] type Address format type
+      # @return [NetworkAddr]
+      def self.parse_from_payload(payload, type: TYPE[:legacy])
+        case type
+        when TYPE[:legacy]
+          load_legacy_payload(payload)
+        when TYPE[:addr_v2]
+          load_addr_v2_payload(payload)
+        else
+          raise Bitcoin::Message::Error, "Unknown type: #{type}."
+        end
       end
 
       def self.local_addr
         addr = new
-        addr.ip_addr = IPAddr.new('127.0.0.1')
+        addr.addr = IPAddr.new('127.0.0.1')
         addr.port = Bitcoin.chain_params.default_port
         addr.services = DEFAULT_SERVICE_FLAGS
         addr
       end
 
-      def ip
-        ip_addr.ipv4_mapped? ? ip_addr.native : ip_addr.to_s
+      # Show addr string. e.g 127.0.0.1
+      def addr_string
+        case net
+        when NETWORK_ID[:ipv4]
+          addr.native
+        when NETWORK_ID[:ipv6]
+          if addr.to_s.start_with?(INTERNAL_IN_IPV6_PREFIX)
+            Base32.encode(addr.hton[6..-1]).downcase.delete('=') + ".internal"
+          else
+            addr.to_s
+          end
+        when NETWORK_ID[:tor_v2]
+          Base32.encode(addr.htb).downcase + ".onion"
+        when NETWORK_ID[:tor_v3]
+          # TORv3 onion_address = base32(PUBKEY | CHECKSUM | VERSION) + ".onion"
+          pubkey = addr.htb
+          checksum = OpenSSL::Digest.new('SHA3-256').digest('.onion checksum' + pubkey + "\x03")
+          Base32.encode(pubkey + checksum[0...2] + "\x03").downcase + ".onion"
+        when NETWORK_ID[:i2p]
+          Base32.encode(addr.htb).downcase.delete('=') + ".b32.i2p"
+        when NETWORK_ID[:cjdns]
+          addr.to_s
+        end
+      end
+
+      def to_payload(skip_time = false, type: TYPE[:legacy])
+        case type
+        when TYPE[:legacy]
+          legacy_payload(skip_time)
+        when TYPE[:addr_v2]
+          v2_payload
+        else
+          raise Bitcoin::Message::Error, "Unknown type: #{type}."
+        end
       end
 
-      def to_payload(skip_time = false)
+      # Load addr payload with legacy format.
+      def self.load_legacy_payload(payload)
+        buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+        has_time = buf.size > 26
+        addr = NetworkAddr.new(time: nil)
+        addr.time = buf.read(4).unpack1('V') if has_time
+        addr.services = buf.read(8).unpack1('Q')
+        addr.addr = IPAddr::new_ntoh(buf.read(16))
+        addr.port = buf.read(2).unpack1('n')
+        addr
+      end
+
+      # Load addr payload with addr v2 format.
+      def self.load_addr_v2_payload(payload)
+        buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+        addr = NetworkAddr.new(time: buf.read(4).unpack1('V'))
+        addr.services = Bitcoin.unpack_var_int_from_io(buf)
+        addr.net = buf.read(1).unpack1('C')
+        raise Bitcoin::Message::Error, "Unknown network id: #{addr.net}" unless NETWORK_ID.value?(addr.net)
+        addr_len = Bitcoin.unpack_var_int_from_io(buf)
+        addr.addr = case addr.net 
+                    when NETWORK_ID[:ipv4]
+                      raise Bitcoin::Message::Error, "Invalid IPv4 address." unless addr_len == 4
+                      IPAddr::new_ntoh(buf.read(addr_len))
+                    when NETWORK_ID[:ipv6]
+                      raise Bitcoin::Message::Error, "Invalid IPv6 address." unless addr_len == 16
+                      a = IPAddr::new_ntoh(buf.read(addr_len))
+                      raise Bitcoin::Message::Error, "Invalid IPv6 address." if a.ipv4_mapped?
+                      a
+                    when NETWORK_ID[:tor_v2]
+                      raise Bitcoin::Message::Error, "Invalid Tor v2 address." unless addr_len == 10
+                      buf.read(addr_len).bth
+                    when NETWORK_ID[:tor_v3]
+                      raise Bitcoin::Message::Error, "Invalid Tor v3 address." unless addr_len == 32
+                      buf.read(addr_len).bth
+                    when NETWORK_ID[:i2p]
+                      raise Bitcoin::Message::Error, "Invalid I2P address." unless addr_len == 32
+                      buf.read(addr_len).bth
+                    when NETWORK_ID[:cjdns]
+                      raise Bitcoin::Message::Error, "Invalid CJDNS address." unless addr_len == 16
+                      a = IPAddr::new_ntoh(buf.read(addr_len))
+                      raise Bitcoin::Message::Error, "Invalid CJDNS address." unless a.to_s.start_with?('fc00:')
+                      a
+                    end
+        addr.port = buf.read(2).unpack1('n')
+        addr
+      end
+
+      def legacy_payload(skip_time)
         p = ''
         p << [time].pack('V') unless skip_time
-        addr = ip_addr.ipv4? ? ip_addr.ipv4_mapped : ip_addr
-        p << [services].pack('Q') << addr.hton << [port].pack('n')
+        ip = addr.ipv4? ? addr.ipv4_mapped : addr
+        p << [services].pack('Q') << ip.hton << [port].pack('n')
+      end
+
+      def v2_payload
+        p = [time].pack('V')
+        p << Bitcoin.pack_var_int(services)
+        p << [net].pack('C')
+        case net
+        when NETWORK_ID[:ipv4]
+          p << Bitcoin.pack_var_int(4)
+          p << addr.to_i.to_s(16).htb
+        when NETWORK_ID[:ipv6]
+          p << Bitcoin.pack_var_int(16)
+          p << addr.hton
+        when NETWORK_ID[:tor_v2]
+          p << Bitcoin.pack_var_int(10)
+        when NETWORK_ID[:tor_v3]
+          p << Bitcoin.pack_var_int(32)
+        when NETWORK_ID[:i2p]
+          p << Bitcoin.pack_var_int(32)
+        when NETWORK_ID[:cjdns]
+          p << Bitcoin.pack_var_int(16)
+        end
+        p << [port].pack('n')
+        p
       end
 
     end

data/lib/bitcoin/message/ping.rb

@@ -14,7 +14,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        new(payload.unpack('Q').first)
+        new(payload.unpack1('Q'))
       end
 
       def to_payload

data/lib/bitcoin/message/pong.rb

@@ -14,7 +14,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        new(payload.unpack('Q').first)
+        new(payload.unpack1('Q'))
       end
 
       def to_payload

data/lib/bitcoin/message/send_addr_v2.rb

@@ -0,0 +1,13 @@
+module Bitcoin
+  module Message
+    class SendAddrV2 < Base
+
+      COMMAND = 'sendaddrv2'
+
+      def to_payload
+        ''
+      end
+
+    end
+  end
+end

data/lib/bitcoin/message/send_cmpct.rb

@@ -21,8 +21,8 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        mode = buf.read(1).unpack('c').first
-        version = buf.read(8).unpack('Q').first
+        mode = buf.read(1).unpack1('c')
+        version = buf.read(8).unpack1('Q')
         new(mode, version)
       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