bitcoinrb 0.3.1 → 0.7.0

data/lib/bitcoin/out_point.rb

@@ -3,6 +3,8 @@ module Bitcoin
   # outpoint class
   class OutPoint
 
+    include Bitcoin::HexConverter
+
     COINBASE_HASH = '0000000000000000000000000000000000000000000000000000000000000000'
     COINBASE_INDEX = 4294967295
 
@@ -39,6 +41,11 @@ module Bitcoin
       tx_hash.rhex
     end
 
+    def to_s
+      return "[#{index}]" unless tx_hash
+      "#{txid}[#{index}]"
+    end
+
   end
 
 end

data/lib/bitcoin/payment_code.rb

@@ -0,0 +1,92 @@
+module Bitcoin
+
+  # BIP47 payment code
+  class PaymentCode < ExtKey
+
+    include Bitcoin::HexConverter
+
+    attr_accessor :x_value
+    attr_accessor :sign
+
+    VERSION_BYTE = '47'
+    SUPPORT_VERSIONS = ['01']
+    SUPPORT_SIGNS = ['02', '03']
+
+    def initialize
+      @version = '01'
+      @features_bits = '00'
+      @reserve_field = '0' * 26
+    end
+
+    # generate master key from seed.
+    # @params [String] seed a seed data with hex format.
+    def self.generate_master(seed)
+      master_ext_key = super.derive(47, harden=true).derive(0, harden=true).derive(0, harden=true)
+      compressed_pubkey = master_ext_key.pub
+
+      payment_code = PaymentCode.new
+      payment_code.depth = master_ext_key.depth
+      payment_code.key = master_ext_key.key
+      payment_code.sign = compressed_pubkey[0..1]
+      payment_code.x_value = compressed_pubkey[2..-1]
+      payment_code.chain_code = master_ext_key.chain_code
+      payment_code
+    end
+
+    # Base58 encoded payment code
+    def to_base58
+      payment_code_with_version_byte = VERSION_BYTE + to_hex
+      Bitcoin::Base58.encode(payment_code_with_version_byte + Bitcoin.calc_checksum(payment_code_with_version_byte))
+    end
+
+    # serialize payment code
+    def to_payload
+      @version.htb << @features_bits.htb << @sign.htb << @x_value.htb << @chain_code << @reserve_field.htb
+    end
+
+    # get notification address
+    def notification_address
+      ext_pubkey.derive(0).addr
+    end
+
+    # decode base58 encoded payment code
+    # @params [String] base58_payment_code base58 encoded payment code
+    def self.from_base58(base58_payment_code)
+      hex = Bitcoin::Base58.decode(base58_payment_code)
+      version = hex[2..3]
+      sign = hex[6..7]
+      public_key = hex[8..71]
+      payment_code = hex[0...-8]
+
+      raise ArgumentError, 'invalid version byte' unless hex[0..1] == VERSION_BYTE
+      raise ArgumentError, 'invalid version' unless PaymentCode.support_version?(version)
+      raise ArgumentError, 'invalid sign' unless PaymentCode.support_sign?(sign)
+      raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless Bitcoin::Key.new(priv_key: nil, pubkey: sign + public_key).fully_valid_pubkey?
+      raise ArgumentError, Errors::Messages::INVALID_CHECKSUM unless Bitcoin.calc_checksum(payment_code) == hex[-8..-1]
+
+      x_value = payment_code[8..71]
+      chain_code_hex = payment_code[72..135]
+
+      payment_code_pubkey = PaymentCode.new
+      payment_code_pubkey.depth = 3
+      payment_code_pubkey.sign = sign
+      payment_code_pubkey.x_value = x_value
+      payment_code_pubkey.chain_code = [chain_code_hex].pack('H*')
+
+      payment_code_pubkey.to_payload
+    end
+
+    # check whether +version+ is supported version bytes.
+    def self.support_version?(version)
+      SUPPORT_VERSIONS.include?(version)
+    end
+
+    # check whether +sign+ is supported version bytes.
+    def self.support_sign?(sign)
+      SUPPORT_SIGNS.include?(sign)
+    end
+
+  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))
 
@@ -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
@@ -93,7 +93,8 @@ module Bitcoin
 
       def to_payload
         payload = ''
-        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:non_witness_utxo], value: non_witness_utxo.to_payload) if non_witness_utxo
+        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:non_witness_utxo], value:
+            (witness_utxo && valid_witness_input?) ? non_witness_utxo.serialize_old_format : non_witness_utxo.to_payload) if non_witness_utxo
         payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:witness_utxo], value: witness_utxo.to_payload) if witness_utxo
         if final_script_sig.nil? && final_script_witness.nil?
           payload << partial_sigs.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:partial_sig], key: k.htb, value: v)}.join
@@ -109,15 +110,6 @@ module Bitcoin
         payload
       end
 
-      # Sanity check
-      # @return [Boolean]
-      def sane?
-        return false if non_witness_utxo && witness_utxo
-        return false if witness_script && witness_utxo.nil?
-        return false if final_script_witness && witness_utxo.nil?
-        true
-      end
-
       # Check whether input's scriptPubkey is correct witness.
       # @return [Boolean]
       def valid_witness_input?
@@ -141,7 +133,6 @@ module Bitcoin
       # @param [Bitcoin::TxOut] utxo utxo object which input refers.
       # @return [Boolean]
       def ready_to_sign?(utxo)
-        return false unless sane?
         return valid_witness_input? if witness_utxo
         valid_non_witness_input?(utxo) # non_witness_utxo
       end
@@ -177,8 +168,8 @@ module Bitcoin
         combined.witness_script = witness_script
         combined.sighash_type = sighash_type
         sigs = Hash[partial_sigs.merge(psbi.partial_sigs)]
-        redeem_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if redeem_script && redeem_script.multisig?
-        witness_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if witness_script && witness_script.multisig?
+        redeem_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if redeem_script&.multisig?
+        witness_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if witness_script&.multisig?
         combined.hd_key_paths = hd_key_paths.merge(psbi.hd_key_paths)
         combined
       end
@@ -190,7 +181,7 @@ module Bitcoin
         if non_witness_utxo
           self.final_script_sig = Bitcoin::Script.new << Bitcoin::Opcodes::OP_0 if redeem_script.multisig?
           partial_sigs.values.each {|sig|final_script_sig << sig}
-          final_script_sig << redeem_script.to_payload.bth
+          final_script_sig << redeem_script.to_hex
           self.partial_sigs = {}
           self.hd_key_paths = {}
           self.redeem_script = nil

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

@@ -2,6 +2,7 @@ module Bitcoin
   module PSBT
 
     class GlobalXpub
+      include Bitcoin::HexConverter
 
       attr_reader :xpub # Bitcoin::ExtPubkey
       attr_reader :info # Bitcoin::PSBT::KeyOriginInfo
@@ -16,7 +17,7 @@ module Bitcoin
       end
 
       def to_h
-        {xpub: xpub.to_payload.bth}.merge(info.to_h)
+        {xpub: xpub.to_hex}.merge(info.to_h)
       end
 
       def to_s
@@ -25,6 +26,8 @@ module Bitcoin
     end
 
     class Tx
+      include Bitcoin::HexConverter
+
       attr_accessor :tx
       attr_accessor :xpubs
       attr_reader :inputs
@@ -52,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
@@ -63,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))
 
@@ -78,13 +81,13 @@ module Bitcoin
           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]
@@ -117,10 +120,6 @@ module Bitcoin
 
         raise ArgumentError, 'Outputs provided does not match the number of outputs in transaction.' unless partial_tx.outputs.size == partial_tx.tx.out.size
 
-        partial_tx.inputs.each do |input|
-          raise ArgumentError, 'PSBT is not sane.' unless input.sane?
-        end
-
         partial_tx
       end
 
@@ -149,11 +148,9 @@ module Bitcoin
         payload << PSBT.serialize_to_vector(PSBT_GLOBAL_TYPES[:unsigned_tx], value: tx.to_payload)
         payload << xpubs.map(&:to_payload).join
         payload << PSBT.serialize_to_vector(PSBT_GLOBAL_TYPES[:ver], value: [version_number].pack('V')) if version_number
-
         payload << unknowns.map {|k,v|Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v}.join
 
         payload << PSBT_SEPARATOR.itb
-
         payload << inputs.map(&:to_payload).join
         payload << outputs.map(&:to_payload).join
         payload
@@ -177,14 +174,12 @@ module Bitcoin
             utxo = prev_tx.out[tx_in.out_point.index]
             raise ArgumentError, 'redeem script does not match utxo.' if redeem_script && !utxo.script_pubkey.include?(redeem_script.to_hash160)
             raise ArgumentError, 'witness script does not match redeem script.' if redeem_script && witness_script && !redeem_script.include?(witness_script.to_sha256)
-            if utxo.script_pubkey.witness_program? || (redeem_script && redeem_script.witness_program?)
-              inputs[i].witness_utxo = utxo
-            else
-              inputs[i].non_witness_utxo = prev_tx
-            end
+            inputs[i].witness_utxo = utxo if utxo.script_pubkey.witness_program? || redeem_script&.witness_program?
+            inputs[i].non_witness_utxo = prev_tx
             inputs[i].redeem_script = redeem_script if redeem_script
             inputs[i].witness_script = witness_script if witness_script
             inputs[i].hd_key_paths = hd_key_paths.map(&:pubkey).zip(hd_key_paths).to_h
+            break
           end
         end
       end

data/lib/bitcoin/rpc/bitcoin_core_client.rb

@@ -1,4 +1,4 @@
-require 'rest-client'
+require 'net/http'
 
 module Bitcoin
   module RPC
@@ -53,20 +53,30 @@ module Bitcoin
             :params => params,
             :id => 'jsonrpc'
         }
-        post(server_url, @config[:timeout], @config[:open_timeout], data.to_json, content_type: :json) do |respdata, request, result|
-          raise result.message if !result.kind_of?(Net::HTTPSuccess) && respdata.empty?
-          response = JSON.parse(respdata.gsub(/\\u([\da-fA-F]{4})/) { [$1].pack('H*').unpack('n*').pack('U*').encode('ISO-8859-1').force_encoding('UTF-8') })
-          raise response['error'] if response['error']
-          response['result']
-        end
+        uri = URI.parse(server_url)
+        http = Net::HTTP.new(uri.hostname, uri.port)
+        http.use_ssl = uri.scheme === "https"
+        request = Net::HTTP::Post.new(uri.path.empty? ? '/' : uri.path)
+        request.basic_auth(uri.user, uri.password)
+        request.content_type = 'application/json'
+        request.body = data.to_json
+        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_json if response['error']
+        response['result']
       end
-
-      def post(url, timeout, open_timeout, payload, headers={}, &block)
-        RestClient::Request.execute(method: :post, url: url, timeout: timeout,
-                                    open_timeout: open_timeout, payload: payload, headers: headers, &block)
+      
+      # Call CLI command on Ruby-like method names.
+      # e.g. generate_to_address, send_to_address, get_wallet_info
+      def method_missing(name, *args)
+        if name.to_s.include?('_')
+          send(name.to_s.gsub('_', '').to_sym, args)
+        else
+          super
+        end
       end
 
     end
-
   end
 end

data/lib/bitcoin/rpc/request_handler.rb

@@ -42,14 +42,14 @@ module Bitcoin
               nextblockhash: node.chain.next_hash(block_hash).rhex
           }
         else
-          entry.header.to_payload.bth
+          entry.header.to_hex
         end
       end
 
       # 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}",
@@ -96,7 +96,7 @@ module Bitcoin
           script = Bitcoin::Script.parse_from_payload(hex_script.htb)
           h = script.to_h
           h.delete(:hex)
-          h[:p2sh] = script.to_p2sh.addresses.first unless script.p2sh?
+          h[:p2sh] = script.to_p2sh.to_addr unless script.p2sh?
           h
         rescue Exception
           raise ArgumentError.new('Script decode failed')

data/lib/bitcoin/script/script.rb

@@ -6,6 +6,7 @@ module Bitcoin
   # bitcoin script
   class Script
     include Bitcoin::Opcodes
+    include Bitcoin::HexConverter
 
     attr_accessor :chunks
 
@@ -109,25 +110,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)
@@ -140,15 +144,21 @@ module Bitcoin
       s
     end
 
-    def to_payload
-      chunks.join
+    # Output script payload.
+    # @param [Boolean] length_prefixed Flag whether the length of the pyrode 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?
       chunks.size == 0
     end
 
+    # @deprecated
     def addresses
+      puts "WARNING: Bitcoin::Script#addresses is deprecated. Use Bitcoin::Script#to_addr instead."
       return [p2pkh_addr] if p2pkh?
       return [p2sh_addr] if p2sh?
       return [bech32_addr] if witness_program?
@@ -156,6 +166,15 @@ module Bitcoin
       []
     end
 
+    # convert to address
+    # @return [String] if script type is p2pkh or p2sh or witness program, return address, otherwise nil.
+    def to_addr
+      return p2pkh_addr if p2pkh?
+      return p2sh_addr if p2sh?
+      return bech32_addr if witness_program?
+      nil
+    end
+
     # check whether standard script.
     def standard?
       p2pkh? | p2sh? | p2wpkh? | p2wsh? | multisig? | standard_op_return?
@@ -230,7 +249,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
@@ -324,16 +343,21 @@ module Bitcoin
         when Integer
           opcode_to_name(c)
         when String
+          return c if c.empty?
           if c.pushdata?
             v = Opcodes.opcode_to_small_int(c.ord)
             if v
               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
@@ -351,7 +375,7 @@ module Bitcoin
 
     # generate hash160 hash for payload
     def to_hash160
-      Bitcoin.hash160(to_payload.bth)
+      Bitcoin.hash160(to_hex)
     end
 
     # script size
@@ -380,8 +404,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
 
@@ -389,7 +413,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
@@ -488,7 +512,7 @@ module Bitcoin
     end
 
     def to_h
-      h = {asm: to_s, hex: to_payload.bth, type: type}
+      h = {asm: to_s, hex: to_hex, type: type}
       addrs = addresses
       unless addrs.empty?
         h[:req_sigs] = multisig? ? Bitcoin::Opcodes.opcode_to_small_int(chunks[0].bth.to_i(16)) :addrs.size
@@ -504,12 +528,6 @@ module Bitcoin
       (size > 0 && op_return?) || size > Bitcoin::MAX_SCRIPT_SIZE
     end
 
-    # convert payload to hex data.
-    # @return [String] script with hex format.
-    def to_hex
-      to_payload.bth
-    end
-
     private
 
     # generate p2pkh address. if script dose not p2pkh, return nil.
@@ -542,10 +560,32 @@ module Bitcoin
     def bech32_addr
       segwit_addr = Bech32::SegwitAddr.new
       segwit_addr.hrp = Bitcoin.chain_params.bech32_hrp
-      segwit_addr.script_pubkey = to_payload.bth
+      segwit_addr.script_pubkey = to_hex
       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