btcruby 0.0.0 → 1.0.0

data/lib/btcruby/script.rb

@@ -0,0 +1,733 @@
+module BTC
+  class Script
+
+    # Serialized binary form of the script (payload)
+    attr_reader :data
+
+    # List of public keys if it is a multisig script.
+    # If it is not a multisig script, returns nil.
+    # See also #multisig_script?
+    attr_reader :multisig_public_keys
+
+    # Number of signatures required if it is a multisig script.
+    # If it is not a multisig script, returns nil.
+    # See also #multisig_script?
+    attr_reader :multisig_signatures_required
+
+    def initialize(hex: nil, # raw script data in hex
+                   data: nil, # raw script data in binary
+                   op_return: nil, # binary string for OP_RETURN script (or array of binary string)
+                   public_keys: nil, signatures_required: nil # multisig
+                   )
+      if data || hex
+        data ||= BTC::Data.data_from_hex(hex)
+        data = BTC::Data.ensure_binary_encoding(data)
+        @chunks = []
+        offset = 0
+        while offset < data.bytesize
+          chunk = Chunk.with_data(data, offset: offset)
+          if !chunk.canonical?
+            Diagnostics.current.add_message("BTC::Script: decoded non-canonical chunk at offset #{offset}: #{chunk.to_s}")
+          end
+          offset += chunk.size
+          @chunks << chunk
+        end
+      elsif op_return
+        @chunks = []
+        self << OP_RETURN << op_return
+      elsif public_keys || signatures_required
+        if !public_keys || public_keys.size < 1
+          raise ArgumentError, "Public keys must be an array of at least 1 pubkey"
+        end
+        if !signatures_required || signatures_required < 1
+          raise ArgumentError, "Number of required signatures must be greater than zero"
+        end
+        if signatures_required > public_keys.size
+          raise ArgumentError, "Number of required signatures must not exceed number of pubkeys."
+        end
+        if public_keys.size > 16
+          raise ArgumentError, "Maximum number of public keys exceeded (16)"
+        end
+
+        n_opcode = Opcode.opcode_for_small_integer(public_keys.size)
+        m_opcode = Opcode.opcode_for_small_integer(signatures_required)
+
+        @chunks = []
+        self << m_opcode << public_keys << n_opcode << OP_CHECKMULTISIG
+      else
+        # Empty script
+        @chunks = []
+      end
+    end
+
+    # Initializes a script with its binary representation.
+    # Returns nil if data is not a well-formed script.
+    def self.with_data(data)
+      raise ArgumentError, "Use Script.new(data: ...) instead"
+    end
+
+    # Initializes a script of form "OP_RETURN <data>"
+    def self.op_return_script(data)
+      raise ArgumentError, "Use Script.new(op_return:...) instead"
+    end
+
+    # Initializes a multisignature script "OP_<M> <pubkey1> ... <pubkeyN> OP_<N> OP_CHECKMULTISIG"
+    # N must be >= M, M and N should be from 1 to 16.
+    # If you need a more customized transaction with OP_CHECKMULTISIG, create it using other methods.
+    # `public_keys` is an array of binary strings.
+    def self.multisig(public_keys: [], signatures_required: 0)
+      self.new(public_keys: public_keys, signatures_required: signatures_required)
+    end
+
+
+    # Representation and conversion
+    # -----------------------------
+
+    # Returns true if this is a standard script
+    # As of September 2014, standard = public_key_hash_script? ||
+    #                                  p2sh_script? ||
+    #                                  standard_multisig_script? ||
+    #                                  public_key_script? ||
+    #                                  standard_op_return_script?
+    def standard?
+      public_key_hash_script? ||
+      script_hash_script? ||
+      standard_multisig_script? ||
+      public_key_script? ||
+      standard_op_return_script?
+    end
+
+    # Returns true if the script is a pay-to-pubkey script:
+    # "<pubkey> OP_CHECKSIG"
+    def public_key_script?
+      return false if @chunks.size != 2
+      return @chunks[0].pushdata? &&
+             @chunks[0].pushdata.size >= 33 &&
+             @chunks[1].opcode == OP_CHECKSIG
+    end
+
+    def p2pk?
+      return public_key_script?
+    end
+
+    # Returns a raw public key if this script is public_key_script?
+    def public_key
+      @chunks[0] && @chunks[0].pushdata
+    end
+
+    # Returns true if the script is a P2PKH script:
+    # "OP_DUP OP_HASH160 <20-byte hash> OP_EQUALVERIFY OP_CHECKSIG"
+    def public_key_hash_script?
+      return false if @chunks.size != 5
+      return @chunks[0].opcode == OP_DUP &&
+             @chunks[1].opcode == OP_HASH160 &&
+             @chunks[2].size == 21 &&
+             @chunks[3].opcode == OP_EQUALVERIFY &&
+             @chunks[4].opcode == OP_CHECKSIG
+    end
+
+    def p2pkh?
+      return public_key_hash_script?
+    end
+
+    # Returns public key hash if this script is public_key_hash_script?
+    def public_key_hash
+      @chunks[2] && @chunks[2].pushdata
+    end
+
+    # Returns true if the script is a P2SH script:
+    # "OP_HASH160 <20-byte hash> OP_EQUAL"
+    def script_hash_script?
+      return false if @chunks.size != 3
+      return @chunks[0].opcode == OP_HASH160 &&
+             @chunks[1].size == 21 &&
+             @chunks[2].opcode == OP_EQUAL
+    end
+
+    def p2sh?
+      return script_hash_script?
+    end
+
+    # Returns p2sh hash if this script is script_hash_script?
+    def script_hash
+      @chunks[1] && @chunks[1].pushdata
+    end
+
+    # Returns true if the script is "OP_<M> <pubkey1> ... <pubkeyN> OP_<N> OP_CHECKMULTISIG"
+    # where N is up to 15.
+    # Scripts with up to 15 signatures are considered standard and relayed quickly,
+    # but you are allowed to create more complex ones.
+    def standard_multisig_script?
+      return false if !multisig_script?
+
+      # Check chunks directly so we make sure OP_<N> are used, not pushdata.
+      # Bitcoin allows encoding multisig N and M parameters as pushdata
+      # (which will be interpreted as a little-endian bignum)
+      m_opcode = @chunks[0].opcode
+      n_opcode = @chunks[-2].opcode
+      if n_opcode >= OP_1 && n_opcode <= OP_15
+        if m_opcode >= OP_1 && m_opcode <= n_opcode
+          return true
+        end
+      end
+      return false
+    end
+
+    # Returns true if the script is in form "<M> <pubkey1> ... <pubkeyN> <N> OP_CHECKMULTISIG"
+    def multisig_script?
+      detect_multisig_if_needed
+      @is_multisig
+    end
+
+    # List of public keys if it is a multisig script.
+    # If it is not a multisig script, returns nil.
+    # See also #multisig_script?
+    def multisig_public_keys
+      detect_multisig_if_needed
+      @multisig_public_keys
+    end
+
+    # Number of signatures required if it is a multisig script.
+    # If it is not a multisig script, returns nil.
+    # See also #multisig_script?
+    def multisig_signatures_required
+      detect_multisig_if_needed
+      @multisig_signatures_required
+    end
+
+    # Returns true if this script is a 'OP_RETURN <data>' script and
+    # data size is within 40 bytes.
+    def standard_op_return_script?
+      retun false if !op_return_script? || @chunks.size != 2
+      @chunks[1].pushdata.bytesize <= 40
+    end
+
+    # Returns true if this script is of form 'OP_RETURN <data>'
+    def op_return_script?
+      return @chunks.size >= 2 &&
+             @chunks[0].opcode == OP_RETURN &&
+             @chunks[1..-1].all?{|c| c.pushdata? }
+    end
+
+    # Returns first data chunk if this script is 'OP_RETURN <data>'.
+    # Otherwise returns nil.
+    def op_return_data
+      return nil if !op_return_script?
+      return @chunks[1].pushdata
+    end
+
+    # Returns all data chunks if this script is 'OP_RETURN <data> [<data>...]'
+    # Most commonly returned array contains one binary string.
+    def op_return_items
+      return nil if !op_return_script?
+      return @chunks[1, @chunks.size-1].map{|c| c.pushdata}
+    end
+
+    # Returns `true` if this script may be a valid OpenAssets marker.
+    # Only checks the prefix and minimal length, does not validate the content.
+    # Use this method to quickly filter out non-asset transactions.
+    def open_assets_marker?
+      return false if !op_return_script?
+      data = op_return_data
+      return false if !data || data.bytesize < 6
+      if data[0, AssetMarker::PREFIX_V1.bytesize] == AssetMarker::PREFIX_V1
+        return true
+      end
+      false
+    end
+
+    # Returns pushdata if script starts with <pushdata> OP_DROP
+    # Returns nil if the script starts with some other opcodes or shorter than 2 opcodes.
+    def dropped_prefix_data
+      if @chunks.size >= 2 && @chunks[0].pushdata? && @chunks[1].opcode == OP_DROP
+        return @chunks[0].pushdata
+      end
+      nil
+    end
+
+    # If script starts with `<pushdata> OP_DROP`, these two opcodes are removed
+    # and a new script instance is returned.
+    def without_dropped_prefix_data
+      if dropped_prefix_data
+        return Script.new << @chunks[2..-1]
+      end
+      self
+    end
+
+    # Returns true if the script consists of push data operations only
+    # (including OP_<N>). Aka isPushOnly in BitcoinQT.
+    # Used in BIP16 (P2SH) implementation.
+    def data_only?
+      # Include PUSHDATA ops and OP_0..OP_16 literals.
+      @chunks.each do |chunk|
+        return false if chunk.opcode > OP_16
+      end
+      return true
+    end
+
+    # Serialized binary form of the script (payload)
+    def data
+      @chunks.inject("".b){|buf,c| buf << c.raw_data}
+    end
+
+    # Human-readable textual representation of the script
+    # (e.g. "OP_DUP OP_HASH160 5a73e920b7836c74f9e740a5bb885e8580557038 OP_EQUALVERIFY OP_CHECKSIG")
+    def to_s
+      @chunks.map{|c| c.to_s }.join(" ")
+    end
+
+    def to_hex
+      BTC::Data.hex_from_data(self.data)
+    end
+
+    # Returns an array of opcodes or pushdata strings.
+    # Integers are opcodes, strings are pushdata binary strings.
+    # OP_0 is treated as a zero-length pushdata.
+    def to_a
+      @chunks.map{|c| c.pushdata? ? c.pushdata : c.opcode }
+    end
+
+    # Complete copy of a script.
+    def dup
+      BTC::Script.new(data: self.data)
+    end
+
+    def ==(other)
+      return false if other == nil
+      self.data == other.data
+    end
+    alias_method :eql?, :==
+
+    def inspect
+      %{#<#{self.class.name} #{to_s.inspect} (#{self.data.bytesize} bytes)>}
+    end
+
+
+
+    # Conversion
+    # ----------
+
+
+    # Returns BTC::PublicKeyAddress or BTC::ScriptHashAddress if
+    # the script is a standard output script for these addresses.
+    # If the script is something different, returns nil.
+    def standard_address(network: nil)
+      if public_key_hash_script?
+        return BTC::PublicKeyAddress.new(hash: @chunks[2].pushdata, network: network)
+      elsif script_hash_script?
+        return BTC::ScriptHashAddress.new(hash: @chunks[1].pushdata, network: network)
+      elsif public_key_script?
+        return BTC::PublicKeyAddress.new(hash: BTC.hash160(@chunks[0].pushdata), network: network)
+      end
+      nil
+    end
+
+    # Wraps the recipient into an output P2SH script
+    # (OP_HASH160 <20-byte hash of the recipient> OP_EQUAL).
+    def p2sh_script
+      Script.new << OP_HASH160 << BTC.hash160(self.data) << OP_EQUAL
+    end
+
+
+    # Returns a dummy script matching this script on the input with
+    # the same size as an intended signature script.
+    # Only a few standard script types are supported.
+    # Set `strict` to false to allow imprecise guess for P2SH script.
+    # Returns nil if could not determine a matching script.
+    def simulated_signature_script(strict: true)
+      if public_key_hash_script?
+         # assuming non-compressed pubkeys to be conservative
+        return Script.new << Script.simulated_signature(hashtype: SIGHASH_ALL) << Script.simulated_uncompressed_pubkey
+
+      elsif public_key_script?
+        return Script.new << Script.simulated_signature(hashtype: SIGHASH_ALL)
+
+      elsif script_hash_script? && !strict
+        # This is a wild approximation, but works well if most p2sh scripts are 2-of-3 multisig scripts.
+        # If you have a very particular smart contract scheme you should not use TransactionBuilder which estimates fees this way.
+        return Script.new << OP_0 << [Script.simulated_signature(hashtype: SIGHASH_ALL)]*2 << Script.simulated_multisig_script(2,3).data
+
+      elsif multisig_script?
+        return Script.new << OP_0 << [Script.simulated_signature(hashtype: SIGHASH_ALL)]*self.multisig_signatures_required
+      else
+        return nil
+      end
+    end
+
+    # Returns a simulated signature with an optional hashtype byte attached
+    def self.simulated_signature(hashtype: nil)
+      "\x30" + "\xff"*71 + (hashtype ? WireFormat.encode_uint8(hashtype) : "")
+    end
+
+    # Returns a dummy uncompressed pubkey (65 bytes).
+    def self.simulated_uncompressed_pubkey
+      "\x04" + "\xff"*64
+    end
+
+    # Returns a dummy compressed pubkey (33 bytes).
+    def self.simulated_compressed_pubkey
+      "\x02" + "\xff"*32
+    end
+
+    # Returns a dummy script that simulates m-of-n multisig script
+    def self.simulated_multisig_script(m,n)
+      Script.new <<
+        Opcode.opcode_for_small_integer(m) <<
+        [simulated_uncompressed_pubkey]*n  << # assuming non-compressed pubkeys to be conservative
+        Opcode.opcode_for_small_integer(n) <<
+        OP_CHECKMULTISIG
+    end
+
+
+    # Modification
+    # ------------
+
+    # Appends a non-pushdata opcode to the script.
+    def append_opcode(opcode)
+      raise ArgumentError, "Invalid opcode value." if opcode > 0xff || opcode < 0
+      if opcode > 0 && opcode <= OP_PUSHDATA4
+        raise ArgumentError, "Cannot add pushdata opcode without data"
+      end
+      @chunks << Chunk.new(opcode.chr)
+      return self
+    end
+
+    # Appends a pushdata opcode with the most compact encoding.
+    # Optional opcode may be equal to OP_PUSHDATA1, OP_PUSHDATA2, or OP_PUSHDATA4.
+    # ArgumentError is raised if opcode does not represent a given data length.
+    def append_pushdata(pushdata, opcode: nil)
+      raise ArgumentError, "No pushdata is given" if !pushdata
+      encoded_pushdata = self.class.encode_pushdata(pushdata, opcode: opcode)
+      if !encoded_pushdata
+        raise ArgumentError, "Cannot encode pushdata with opcode #{opcode}"
+      end
+      @chunks << Chunk.new(encoded_pushdata)
+      return self
+    end
+
+    # Removes all occurences of opcode. Typically it's OP_CODESEPARATOR.
+    def delete_opcode(opcode)
+      @chunks = @chunks.inject([]) do |list, chunk|
+        list << chunk if chunk.opcode != opcode
+        list
+      end
+      return self
+    end
+
+    # Removes all occurences of a given pushdata.
+    def delete_pushdata(pushdata)
+      @chunks = @chunks.inject([]) do |list, chunk|
+        list << chunk if chunk.pushdata != pushdata
+        list
+      end
+      return self
+    end
+
+    # Appends script to the current script.
+    def append_script(script)
+      raise ArgumentError, "No script is given" if !script
+      @chunks += script.chunks
+      return self
+    end
+
+    # Appends an opcode (Integer), pushdata (String) or Script and returns self.
+    # If Array is passed, this method is recursively called for each element in the array.
+    def <<(object)
+      if object.is_a?(BTC::Script)
+        append_script(object)
+      elsif object.is_a?(Integer)
+        append_opcode(object)
+      elsif object.is_a?(String)
+        append_pushdata(object.b)
+      elsif object.is_a?(Array)
+        object.each do |element|
+          self << element
+        end
+      elsif object.is_a?(Chunk)
+        if object.pushdata?
+          append_pushdata(object.pushdata)
+        else
+          append_opcode(object.opcode)
+        end
+      else
+        raise ArgumentError, "Operand must be an integer, a string a BTC::Script instance or an array of any of those."
+      end
+      return self
+    end
+
+    # Returns a new instance with concatenation of two scripts.
+    def +(other)
+      self.dup << other
+    end
+
+
+
+
+
+
+    # Private API
+    # -----------
+
+    attr_reader :chunks
+
+    # If opcode is nil, then the most compact encoding will be chosen.
+    # Returns nil if opcode can't be used for data, or data is nil or too big.
+    def self.encode_pushdata(pushdata, opcode: nil)
+      raise ArgumentError, "Pushdata is missing" if !pushdata
+      if pushdata.bytesize < OP_PUSHDATA1 && opcode == nil
+        return BTC::WireFormat.encode_uint8(pushdata.bytesize) + pushdata
+      elsif pushdata.bytesize < 0xff && (opcode == nil || opcode == OP_PUSHDATA1)
+        return BTC::WireFormat.encode_uint8(OP_PUSHDATA1) +
+               BTC::WireFormat.encode_uint8(pushdata.bytesize) +
+               pushdata
+      elsif pushdata.bytesize < 0xffff && (opcode == nil || opcode == OP_PUSHDATA2)
+        return BTC::WireFormat.encode_uint8(OP_PUSHDATA2) +
+               BTC::WireFormat.encode_uint16le(pushdata.bytesize) +
+               pushdata
+      elsif pushdata.bytesize < 0xffffffff && (opcode == nil || opcode == OP_PUSHDATA4)
+         return BTC::WireFormat.encode_uint8(OP_PUSHDATA4) +
+                BTC::WireFormat.encode_uint32le(pushdata.bytesize) +
+                pushdata
+      else
+        raise ArgumentError, "Invalid opcode or data is too big"
+      end
+    end
+
+    def detect_multisig_if_needed
+      return if @is_multisig != nil
+      @is_multisig = detect_multisig
+    end
+
+    def detect_multisig
+      # multisig script must have at least 4 ops ("OP_1 <pubkey> OP_1 OP_CHECKMULTISIG")
+      return false if @chunks.size < 4
+      return false if @chunks.last.opcode != OP_CHECKMULTISIG
+
+      m_chunk = @chunks[0]
+      n_chunk = @chunks[-2]
+      m_opcode = m_chunk.opcode
+      n_opcode = n_chunk.opcode
+
+      m = Opcode.small_integer_from_opcode(m_opcode)
+      n = Opcode.small_integer_from_opcode(n_opcode)
+
+      # If m or n is not OP_<int>, but a pushdata with little-endian bignum.
+      if !m
+        return false if !m_chunk.pushdata?
+        m = BTC::BigNumber.new(signed_little_endian: m_chunk.pushdata).integer
+      end
+
+      if !n
+        return false if !n_chunk.pushdata?
+        n = BTC::BigNumber.new(signed_little_endian: n_chunk.pushdata).integer
+      end
+
+      return false if m < 1 || n < 1 || m > n
+
+      # We must have correct number of pubkeys in the script. 3 extra ops: OP_<M>, OP_<N> and OP_CHECKMULTISIG
+      return false if @chunks.size != (3 + n)
+
+      pubkeys = []
+      @chunks[1, n].each do |chunk|
+        return false if !chunk.pushdata? || chunk.pushdata.bytesize == 0
+        pubkeys << chunk.pushdata
+      end
+
+      # Now we extracted all pubkeys and verified the numbers.
+      @multisig_public_keys = pubkeys
+      @multisig_signatures_required = m
+      return true
+    end
+
+    # Script::Chunk represents either an opcode or a pushdata command.
+    class Chunk
+      # Raw data for this chunk.
+      # 1 byte for regular opcode, 1 or more bytes for pushdata command.
+      # We do not call it 'data' to avoid confusion with `pushdata` (see below).
+      # The encoding is guaranteed to be binary.
+      attr_reader :raw_data
+
+      # Opcode for this chunk (first byte of the raw_data).
+      attr_reader :opcode
+
+      # If opcode is OP_PUSHDATA*, contains pure data being pushed.
+      # If opcode is OP_0, returns an empty string.
+      # If opcode is not pushdata, returns nil.
+      attr_reader :pushdata
+
+      # Length of raw_data in bytes.
+      attr_reader :size
+      alias :length :size
+
+      # Returns true if this is a non-pushdata (also not OP_0) opcode.
+      def opcode?
+        !pushdata?
+      end
+
+      # Returns true if this is a pushdata chunk (or OP_0 opcode).
+      def pushdata?
+        # Compact pushdata opcodes are "virtual", just length prefixes.
+        # Attention: OP_0 is also "pushdata" code that pushes empty data.
+        self.opcode <= OP_PUSHDATA4
+      end
+
+      # Returns true if this chunk is in canonical form (the most compact one).
+      # Returns false if it contains pushdata with too big length prefix.
+      # Example of non-canonical chunk: 75 bytes pushed with OP_PUSHDATA1 instead
+      # of simple 0x4b prefix.
+      def canonical?
+        opcode = self.opcode
+        if opcode < OP_PUSHDATA1
+          return true # most compact pushdata is always canonical.
+        elsif opcode == OP_PUSHDATA1
+          return (self.raw_data.bytesize - (1+1)) >= OP_PUSHDATA1
+        elsif opcode == OP_PUSHDATA2
+          return (self.raw_data.bytesize - (1+2)) > 0xff
+        elsif opcode == OP_PUSHDATA4
+          return (self.raw_data.bytesize - (1+4)) > 0xffff
+        else
+          return true # all other opcodes are canonical (just 1 byte code)
+        end
+      end
+
+      def opcode
+        # raises StopIteration if raw_data is empty,
+        # but we don't allow empty raw_data for chunks.
+        raw_data.each_byte.next
+      end
+
+      def pushdata
+        return nil if !pushdata?
+        opcode = self.opcode
+        offset = 1 # by default, opcode is just a length prefix.
+        if opcode == OP_PUSHDATA1
+          offset += 1
+        elsif opcode == OP_PUSHDATA2
+          offset += 2
+        elsif opcode == OP_PUSHDATA4
+          offset += 4
+        end
+        self.raw_data[offset, self.raw_data.size - offset]
+      end
+
+      def size
+        self.raw_data.bytesize
+      end
+
+      def to_s
+        opcode = self.opcode
+
+        if self.opcode?
+          return "OP_0"       if opcode == OP_0
+          return "OP_1NEGATE" if opcode == OP_1NEGATE
+          if opcode >= OP_1 && opcode <= OP_16
+            return "OP_#{opcode + 1 - OP_1}"
+          end
+          return Opcode.name_for_opcode(opcode)
+        end
+
+        pushdata = self.pushdata
+        return "OP_0" if pushdata.bytesize == 0 # Empty data is encoded as OP_0.
+
+        string = ""
+
+        # If it's some weird readable string, show it as a readable string.
+        if data_is_ascii_printable?(pushdata) && (pushdata.bytesize < 20 || pushdata.bytesize > 65)
+          string = pushdata.encode(Encoding::ASCII)
+          # Escape escapes & single quote characters.
+          string.gsub!("\\", "\\\\")
+          string.gsub!("'", "\\'")
+          # Wrap in single quotes. Why not double? Because they are already used in JSON and we don't want to multiply the mess.
+          string = "'#{string}'"
+        else
+          string = BTC::Data.hex_from_data(pushdata)
+          # Shorter than 128-bit chunks are wrapped in square brackets to avoid ambiguity with big all-decimal numbers.
+          if (pushdata.bytesize < 16)
+              string = "[#{string}]"
+          end
+        end
+
+        # Pushdata with non-compact encoding will have explicit length prefix (1 for OP_PUSHDATA1, 2 for OP_PUSHDATA2 and 4 for OP_PUSHDATA4).
+        if !canonical?
+          prefix = 1
+          prefix = 2 if opcode == OP_PUSHDATA2
+          prefix = 4 if opcode == OP_PUSHDATA4
+          string = "#{prefix}:#{string}"
+        end
+
+        return string
+      end
+
+      # Parses the chunk with binary data. Assumes the encoding is binary.
+      def self.with_data(data, offset: 0)
+        raise ArgumentError, "Data is missing" if !data
+
+        opcode, _ = BTC::WireFormat.read_uint8(data: data, offset: offset)
+
+        raise ArgumentError, "Failed to read opcode of the script chunk" if !opcode
+
+        # push data opcode
+        if opcode <= OP_PUSHDATA4
+
+          length = data.bytesize
+
+          if opcode < OP_PUSHDATA1
+            pushdata_length = opcode
+            chunk_length = 1 + pushdata_length
+            if offset + chunk_length > length
+              raise ArgumentError, "PUSHDATA is longer than we have bytes available"
+            end
+            return self.new(data[offset, chunk_length])
+          elsif opcode == OP_PUSHDATA1
+            pushdata_length, _ = BTC::WireFormat.read_uint8(data: data, offset: offset + 1)
+            if !pushdata_length
+              raise ArgumentError, "Failed to read length for PUSHDATA1"
+            end
+            chunk_length = 1 + 1 + pushdata_length
+            if offset + chunk_length > length
+              raise ArgumentError, "PUSHDATA1 is longer than we have bytes available"
+            end
+            return self.new(data[offset, chunk_length])
+          elsif (opcode == OP_PUSHDATA2)
+            pushdata_length, _ = BTC::WireFormat.read_uint16le(data: data, offset: offset + 1)
+            if !pushdata_length
+              raise ArgumentError, "Failed to read length for PUSHDATA2"
+            end
+            chunk_length = 1 + 2 + pushdata_length
+            if offset + chunk_length > length
+              raise ArgumentError, "PUSHDATA2 is longer than we have bytes available"
+            end
+            return self.new(data[offset, chunk_length])
+          elsif (opcode == OP_PUSHDATA4)
+            pushdata_length, _ = BTC::WireFormat.read_uint32le(data: data, offset: offset + 1)
+            if !pushdata_length
+              raise ArgumentError, "Failed to read length for PUSHDATA4"
+            end
+            chunk_length = 1 + 4 + pushdata_length
+            if offset + chunk_length > length
+              raise ArgumentError, "PUSHDATA4 is longer than we have bytes available"
+            end
+            return self.new(data[offset, chunk_length])
+          end
+        else
+          # simple opcode - 1 byte
+          return self.new(data[offset, 1])
+        end
+      end
+
+      def initialize(raw_data)
+        @raw_data = raw_data
+      end
+
+      protected
+
+      def data_is_ascii_printable?(data)
+        data.each_byte do |byte|
+          return false if !(byte >= 0x20 && byte <= 0x7E)
+        end
+        return true
+      end
+
+    end # Chunk
+  end # Script
+end # BTC