bitcoinrb 0.5.0 → 0.9.0

data/lib/bitcoin/message.rb

@@ -1,6 +1,8 @@
 module Bitcoin
   module Message
 
+    class Error < StandardError; end
+
     autoload :Base, 'bitcoin/message/base'
     autoload :Inventory, 'bitcoin/message/inventory'
     autoload :InventoriesParser, 'bitcoin/message/inventories_parser'
@@ -44,6 +46,8 @@ module Bitcoin
     autoload :CFCheckpt, 'bitcoin/message/cfcheckpt'
     autoload :CFilter, 'bitcoin/message/cfilter'
     autoload :CFHeaders, 'bitcoin/message/cfheaders'
+    autoload :SendAddrV2, 'bitcoin/message/send_addr_v2'
+    autoload :AddrV2, 'bitcoin/message/addr_v2'
 
     USER_AGENT = "/bitcoinrb:#{Bitcoin::VERSION}/"
 
@@ -73,5 +77,73 @@ module Bitcoin
         compact_witness: 70015
     }
 
+    module_function
+
+    # Decode P2P message.
+    # @param [String] command P2P message command string.
+    # @param [String] payload P2P message payload with hex format..
+    # @return [Bitcoin::Message::]
+    def decode(command, payload = nil)
+      payload = payload.htb if payload
+      case command
+      when Bitcoin::Message::Version::COMMAND
+        Bitcoin::Message::Version.parse_from_payload(payload)
+      when Bitcoin::Message::VerAck::COMMAND
+        Bitcoin::Message::VerAck.new
+      when Bitcoin::Message::GetAddr::COMMAND
+        Bitcoin::Message::GetAddr.new
+      when Bitcoin::Message::Addr::COMMAND
+        Bitcoin::Message::Addr.parse_from_payload(payload)
+      when Bitcoin::Message::SendHeaders::COMMAND
+        Bitcoin::Message::SendHeaders.new
+      when Bitcoin::Message::FeeFilter::COMMAND
+        Bitcoin::Message::FeeFilter.parse_from_payload(payload)
+      when Bitcoin::Message::Ping::COMMAND
+        Bitcoin::Message::Ping.parse_from_payload(payload)
+      when Bitcoin::Message::Pong::COMMAND
+        Bitcoin::Message::Pong.parse_from_payload(payload)
+      when Bitcoin::Message::GetHeaders::COMMAND
+        Bitcoin::Message::GetHeaders.parse_from_payload(payload)
+      when Bitcoin::Message::Headers::COMMAND
+        Bitcoin::Message::Headers.parse_from_payload(payload)
+      when Bitcoin::Message::Block::COMMAND
+        Bitcoin::Message::Block.parse_from_payload(payload)
+      when Bitcoin::Message::Tx::COMMAND
+        Bitcoin::Message::Tx.parse_from_payload(payload)
+      when Bitcoin::Message::NotFound::COMMAND
+        Bitcoin::Message::NotFound.parse_from_payload(payload)
+      when Bitcoin::Message::MemPool::COMMAND
+        Bitcoin::Message::MemPool.new
+      when Bitcoin::Message::Reject::COMMAND
+        Bitcoin::Message::Reject.parse_from_payload(payload)
+      when Bitcoin::Message::SendCmpct::COMMAND
+        Bitcoin::Message::SendCmpct.parse_from_payload(payload)
+      when Bitcoin::Message::Inv::COMMAND
+        Bitcoin::Message::Inv.parse_from_payload(payload)
+      when Bitcoin::Message::MerkleBlock::COMMAND
+        Bitcoin::Message::MerkleBlock.parse_from_payload(payload)
+      when Bitcoin::Message::CmpctBlock::COMMAND
+        Bitcoin::Message::CmpctBlock.parse_from_payload(payload)
+      when Bitcoin::Message::GetData::COMMAND
+        Bitcoin::Message::GetData.parse_from_payload(payload)
+      when Bitcoin::Message::GetCFHeaders::COMMAND
+        Bitcoin::Message::GetCFHeaders.parse_from_payload(payload)
+      when Bitcoin::Message::GetCFilters::COMMAND
+        Bitcoin::Message::GetCFilters.parse_from_payload(payload)
+      when Bitcoin::Message::GetCFCheckpt::COMMAND
+        Bitcoin::Message::GetCFCheckpt.parse_from_payload(payload)
+      when Bitcoin::Message::CFCheckpt::COMMAND
+        Bitcoin::Message::CFCheckpt.parse_from_payload(payload)
+      when Bitcoin::Message::CFHeaders::COMMAND
+        Bitcoin::Message::CFHeaders.parse_from_payload(payload)
+      when Bitcoin::Message::CFilter::COMMAND
+        Bitcoin::Message::CFilter.parse_from_payload(payload)
+      when Bitcoin::Message::SendAddrV2::COMMAND
+        Bitcoin::Message::SendAddrV2.new
+      when Bitcoin::Message::AddrV2::COMMAND
+        Bitcoin::Message::AddrV2.parse_from_payload(payload)
+      end
+    end
+
   end
 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/mnemonic.rb

@@ -39,7 +39,7 @@ module Bitcoin
     # @return [Array] the array of mnemonic word.
     def to_mnemonic(entropy)
       raise ArgumentError, 'entropy is empty.' if entropy.nil? || entropy.empty?
-      e = entropy.htb.unpack('B*').first
+      e = entropy.htb.unpack1('B*')
       seed = e + checksum(e)
       mnemonic_index = seed.chars.each_slice(11).map{|i|i.join.to_i(2)}
       word_master = load_words
@@ -61,7 +61,7 @@ module Bitcoin
     # @param [String] entropy an entropy with bit string format
     # @return [String] an entropy checksum with bit string format
     def checksum(entropy)
-      b = Bitcoin.sha256([entropy].pack('B*')).unpack('B*').first
+      b = Bitcoin.sha256([entropy].pack('B*')).unpack1('B*')
       b.slice(0, (entropy.length/32))
     end
 

data/lib/bitcoin/network/peer_discovery.rb

@@ -30,9 +30,7 @@ module Bitcoin
         logger.debug 'discover peer address from DNS seeds.'
         dns_seeds.map { |seed|
           begin
-            # x5 is a prefix for finding nodes that support NODE_BLOOM.
-            # https://github.com/bitcoin/bitcoin/pull/8083#issuecomment-221552835
-            Socket.getaddrinfo("x5.#{seed}", Bitcoin.chain_params.default_port).map{|a|a[2]}.uniq
+            Socket.getaddrinfo("#{seed}", Bitcoin.chain_params.default_port).map{|a|a[2]}.uniq
           rescue SocketError => e
             logger.error "SocketError occurred when load DNS seed: #{seed}, error: #{e.message}"
             nil

data/lib/bitcoin/node/configuration.rb

@@ -4,8 +4,10 @@ module Bitcoin
   module Node
     class Configuration
 
-      attr_reader :conf
+      attr_reader :conf # Hash
 
+      # initialize configuration
+      # @param [Hash] opts parameter for node.
       def initialize(opts = {})
         # TODO apply configuration file.
         opts[:network] = :mainnet unless opts[:network]

data/lib/bitcoin/node/spv.rb

@@ -13,6 +13,14 @@ module Bitcoin
       attr_accessor :wallet
       attr_accessor :bloom
 
+      # Initialize spv settings
+      # @param [Bitcoin::Node::Configuration] configuration configuration for spv.
+      #
+      # ```ruby
+      # config = Bitcoin::Node::Configuration.new(network: :mainnet)
+      # spv = Bitcoin::Node::SPV.new(config)
+      # spv.run
+      # ````
       def initialize(configuration)
         @chain = Bitcoin::Store::SPVChain.new
         @configuration = configuration

data/lib/bitcoin/opcodes.rb

@@ -136,6 +136,8 @@ module Bitcoin
     OP_NOP9 = 0xb8
     OP_NOP10 = 0xb9
 
+    OP_CHECKSIGADD = 0xba # BIP 342 opcodes (Tapscript)
+
     # https://en.bitcoin.it/wiki/Script#Pseudo-words
     OP_PUBKEYHASH = 0xfd
     OP_PUBKEY = 0xfe
@@ -145,6 +147,9 @@ module Bitcoin
     OPCODES_MAP = Hash[*(constants.grep(/^OP_/) - [:OP_NOP2, :OP_NOP3, :OP_CHECKLOCKTIMEVERIFY, :OP_CHECKSEQUENCEVERIFY]).map { |c| [const_get(c), c.to_s] }.flatten]
     NAME_MAP = Hash[*constants.grep(/^OP_/).map { |c| [c.to_s, const_get(c)] }.flatten]
 
+    OP_SUCCESSES = [0x50, 0x62, 0x89, 0x8a, 0x8d, 0x8e, (0x7e..0x81).to_a,
+                    (0x83..0x86).to_a, (0x95..0x99).to_a, (0xbb..0xfe).to_a].flatten
+
     def opcode_to_name(opcode)
       return OPCODES_MAP[opcode].delete('OP_') if opcode == OP_0 || (opcode <= OP_16 && opcode >= OP_1)
       OPCODES_MAP[opcode]
@@ -156,7 +161,8 @@ module Bitcoin
     end
 
     # whether opcode is predefined opcode
-    def defined?(opcode)
+    def defined?(opcode, allow_success = false)
+      return true if allow_success && op_success?(opcode)
       !opcode_to_name(opcode).nil?
     end
 
@@ -174,5 +180,12 @@ module Bitcoin
       nil
     end
 
+    # Check whether +opcode+ is OP_SUCCESSx or not?
+    # @param [Integer] opcode an opcode.
+    # @return [Boolean] if +opcode+ is OP_SUCCESSx return true, otherwise false.
+    def op_success?(opcode)
+      OP_SUCCESSES.include?(opcode)
+    end
+
   end
 end

data/lib/bitcoin/payment_code.rb

@@ -61,8 +61,8 @@ 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, 'invalid public key' unless Bitcoin::Key.new(priv_key: nil, pubkey: sign + public_key).fully_valid_pubkey?
-      raise ArgumentError, 'invalid checksum' unless Bitcoin.calc_checksum(payment_code) == hex[-8..-1]
+      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_CHECKSUM unless Bitcoin.calc_checksum(payment_code) == hex[-8..-1]
 
       x_value = payment_code[8..71]
       chain_code_hex = payment_code[72..135]

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

@@ -12,7 +12,7 @@ module Bitcoin
         pubkey = pubkey.encoding == Encoding::ASCII_8BIT ? pubkey : pubkey.htb
         raise ArgumentError, 'Size of key was not the expected size for the type BIP32 keypath.' unless [Bitcoin::Key::PUBLIC_KEY_SIZE, Bitcoin::Key::COMPRESSED_PUBLIC_KEY_SIZE].include?(pubkey.bytesize)
         pubkey = Bitcoin::Key.new(pubkey: pubkey.bth)
-        raise ArgumentError, 'Invalid pubkey' unless pubkey.fully_valid_pubkey?
+        raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless pubkey.fully_valid_pubkey?
         @pubkey = pubkey.pubkey
         @info = info
       end

data/lib/bitcoin/psbt/input.rb

@@ -36,7 +36,7 @@ module Bitcoin
             found_sep = true
             break
           end
-          key_type = buf.read(1).unpack('C').first
+          key_type = buf.read(1).unpack1('C')
           key = buf.read(key_len - 1)
           value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
 
@@ -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
@@ -54,13 +54,13 @@ module Bitcoin
               raise ArgumentError, 'Size of key was not the expected size for the type partial signature pubkey.'
             end
             pubkey = Bitcoin::Key.new(pubkey: key.bth)
-            raise ArgumentError, 'Invalid pubkey.' unless pubkey.fully_valid_pubkey?
+            raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless pubkey.fully_valid_pubkey?
             raise ArgumentError, 'Duplicate Key, input partial signature for pubkey already provided.' if input.partial_sigs[pubkey.pubkey]
             input.partial_sigs[pubkey.pubkey] = value
           when PSBT_IN_TYPES[:sighash]
             raise ArgumentError, 'Invalid input sighash type typed key.' unless key_len == 1
             raise ArgumentError 'Duplicate Key, input sighash type already provided.' if input.sighash_type
-            input.sighash_type = value.unpack('I').first
+            input.sighash_type = value.unpack1('I')
           when PSBT_IN_TYPES[:redeem_script]
             raise ArgumentError, 'Invalid redeemscript typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, input redeemScript already provided.' if input.redeem_script

data/lib/bitcoin/psbt/output.rb

@@ -26,7 +26,7 @@ module Bitcoin
             found_sep = true
             break
           end
-          key_type = buf.read(1).unpack('C').first
+          key_type = buf.read(1).unpack1('C')
           key = buf.read(key_len - 1)
           value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
           case key_type

data/lib/bitcoin/psbt/tx.rb

@@ -55,7 +55,7 @@ module Bitcoin
       # @return [Bitcoin::PartiallySignedTx]
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        raise ArgumentError, 'Invalid PSBT magic bytes.' unless buf.read(4).unpack('N').first == PSBT_MAGIC_BYTES
+        raise ArgumentError, 'Invalid PSBT magic bytes.' unless buf.read(4).unpack1('N') == PSBT_MAGIC_BYTES
         raise ArgumentError, 'Invalid PSBT separator.' unless buf.read(1).bth.to_i(16) == 0xff
         partial_tx = self.new
         found_sep = false
@@ -66,7 +66,7 @@ module Bitcoin
             found_sep = true
             break
           end
-          key_type = buf.read(1).unpack('C').first
+          key_type = buf.read(1).unpack1('C')
           key = buf.read(key_len - 1)
           value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
 
@@ -74,20 +74,20 @@ 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
           when PSBT_GLOBAL_TYPES[:xpub]
             raise ArgumentError, 'Size of key was not the expected size for the type global xpub.' unless key.size == Bitcoin::BIP32_EXTKEY_WITH_VERSION_SIZE
             xpub = Bitcoin::ExtPubkey.parse_from_payload(key)
-            raise ArgumentError, 'Invalid pubkey.' unless xpub.key.fully_valid_pubkey?
+            raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless xpub.key.fully_valid_pubkey?
             raise ArgumentError, 'Duplicate key, global xpub already provided' if partial_tx.xpubs.any?{|x|x.xpub == xpub}
             info = Bitcoin::PSBT::KeyOriginInfo.parse_from_payload(value)
             raise ArgumentError, "global xpub's depth and the number of indexes not matched." unless xpub.depth == info.key_paths.size
             partial_tx.xpubs << Bitcoin::PSBT::GlobalXpub.new(xpub, info)
           when PSBT_GLOBAL_TYPES[:ver]
-            partial_tx.version_number = value.unpack('V').first
+            partial_tx.version_number = value.unpack1('V')
             raise ArgumentError, "An unsupported version was detected." if SUPPORT_VERSION < partial_tx.version_number
           else
             raise ArgumentError, 'Duplicate Key, key for unknown value already provided.' if partial_tx.unknowns[key]
@@ -162,6 +162,15 @@ module Bitcoin
         Base64.strict_encode64(to_payload)
       end
 
+      # Store the PSBT to a file.
+      # @param [String] path File path to store.
+      def to_file(path)
+        raise ArgumentError, 'The file already exists' if File.exist?(path)
+        File.open(path, 'w') do |f|
+          f.write(to_payload)
+        end
+      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/psbt.rb

@@ -31,6 +31,14 @@ module Bitcoin
       s << Bitcoin.pack_var_int(value.bytesize) << value
       s
     end
+
+    # Load PSBT from file.
+    # @param [String] path File path of PSBT.
+    # @return [Bitcoin::PSBT::Tx] PSBT object.
+    def load_from_file(path)
+      raise ArgumentError, 'File not found' unless File.exist?(path)
+      Bitcoin::PSBT::Tx.parse_from_payload(File.read(path))
+    end
   end
 
 end

data/lib/bitcoin/rpc/bitcoin_core_client.rb

@@ -63,7 +63,7 @@ module Bitcoin
         response = http.request(request)
         body = response.body
         response = Bitcoin::Ext::JsonParser.new(body.gsub(/\\u([\da-fA-F]{4})/) { [$1].pack('H*').unpack('n*').pack('U*').encode('ISO-8859-1').force_encoding('UTF-8') }).parse
-        raise response['error'].to_s if response['error']
+        raise response['error'].to_json if response['error']
         response['result']
       end
       

data/lib/bitcoin/rpc/request_handler.rb

@@ -49,7 +49,7 @@ module Bitcoin
       # Returns connected peer information.
       def getpeerinfo
         node.pool.peers.map do |peer|
-          local_addr = "#{peer.remote_version.remote_addr.ip}:18333"
+          local_addr = "#{peer.remote_version.remote_addr.addr_string}:18333"
           {
             id: peer.id,
             addr: "#{peer.host}:#{peer.port}",
@@ -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
@@ -110,25 +114,28 @@ module Bitcoin
         if opcode.pushdata?
           pushcode = opcode.ord
           packed_size = nil
+          if buf.eof?
+            s.chunks << opcode
+            return s
+          end
           len = case pushcode
                   when OP_PUSHDATA1
                     packed_size = buf.read(1)
-                    packed_size.unpack('C').first
+                    packed_size.unpack1('C')
                   when OP_PUSHDATA2
                     packed_size = buf.read(2)
-                    packed_size.unpack('v').first
+                    packed_size.unpack1('v')
                   when OP_PUSHDATA4
                     packed_size = buf.read(4)
-                    packed_size.unpack('V').first
+                    packed_size.unpack1('V')
                   else
-                    pushcode if pushcode < OP_PUSHDATA1
+                    pushcode < OP_PUSHDATA1 ? pushcode : 0
                 end
-          if len
-            s.chunks << [len].pack('C') if buf.eof?
-            unless buf.eof?
-              chunk = (packed_size ? (opcode + packed_size) : (opcode)) + buf.read(len)
-              s.chunks << chunk
-            end
+          if buf.eof?
+            s.chunks << [len].pack('C')
+          else buf.eof?
+            chunk = (packed_size ? (opcode + packed_size) : (opcode)) + buf.read(len)
+            s.chunks << chunk
           end
         else
           if Opcodes.defined?(opcode.ord)
@@ -141,8 +148,12 @@ module Bitcoin
       s
     end
 
-    def to_payload
-      chunks.join
+    # Output script payload.
+    # @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
+      length_prefixed ? (Bitcoin.pack_var_int(p.length) << p) : p
     end
 
     def empty?
@@ -170,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
@@ -242,7 +266,7 @@ module Bitcoin
       return false if opcode != OP_0 && (opcode < OP_1 || opcode > OP_16)
       return false unless chunks[1].pushdata?
 
-      if size == (chunks[1][0].unpack('C').first + 2)
+      if size == (chunks[1][0].unpack1('C') + 2)
         program_size = chunks[1].pushed_data.bytesize
         return program_size >= 2 && program_size <= 40
       end
@@ -343,10 +367,14 @@ module Bitcoin
               v
             else
               data = c.pushed_data
-              if data.bytesize <= 4
-                Script.decode_number(data.bth) # for scriptnum
+              if data
+                if data.bytesize <= 4
+                  Script.decode_number(data.bth) # for scriptnum
+                else
+                  data.bth
+                end
               else
-                data.bth
+                c.bth
               end
             end
           else
@@ -393,8 +421,8 @@ module Bitcoin
       hex = '0' + hex unless (hex.length % 2).zero?
       v = hex.htb.reverse # change endian
 
-      v = v << (negative ? 0x80 : 0x00) unless (v[-1].unpack('C').first & 0x80) == 0
-      v[-1] = [v[-1].unpack('C').first | 0x80].pack('C') if negative
+      v = v << (negative ? 0x80 : 0x00) unless (v[-1].unpack1('C') & 0x80) == 0
+      v[-1] = [v[-1].unpack1('C') | 0x80].pack('C') if negative
       v.bth
     end
 
@@ -402,7 +430,7 @@ module Bitcoin
     def self.decode_number(s)
       v = s.htb.reverse
       return 0 if v.length.zero?
-      mbs = v[0].unpack('C').first
+      mbs = v[0].unpack1('C')
       v[0] = [mbs - 0x80].pack('C') unless (mbs & 0x80) == 0
       result = v.bth.to_i(16)
       result = -result unless (mbs & 0x80) == 0
@@ -487,7 +515,7 @@ module Bitcoin
     end
 
     def ==(other)
-      return false unless other
+      return false unless other.is_a?(Script)
       chunks == other.chunks
     end
 
@@ -553,6 +581,28 @@ module Bitcoin
       segwit_addr.addr
     end
 
+    # Check whether push data length is valid.
+    # @return [Boolean] if valid return true, otherwise false.
+    def valid_pushdata_length?(chunk)
+      buf = StringIO.new(chunk)
+      opcode = buf.read(1).ord
+      offset = 1
+      len = case opcode
+            when OP_PUSHDATA1
+              offset += 1
+              buf.read(1).unpack1('C')
+            when OP_PUSHDATA2
+              offset += 2
+              buf.read(2).unpack1('v')
+            when OP_PUSHDATA4
+              offset += 4
+              buf.read(4).unpack1('V')
+            else
+              opcode
+            end
+      chunk.bytesize == len + offset
+    end
+
   end
 
 end