btcruby 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96ac30298d4c5f04b49b6874d4a0f2f1e3548f4c
-  data.tar.gz: 31c8e3bbb67643b86c70336d30638a1c1172b5d1
+  metadata.gz: 496c31ea05b95ca3fe1971a17eea51f43a2c00b6
+  data.tar.gz: 6a8cbbe43cd39b004f188f32c90e6c492d7f78d2
 SHA512:
-  metadata.gz: 23d001c7a98c869e3c082181f5ed06321ff95dc1ae3e03647d6df60dc0abd58cfdaeb9ca16ac3dd65363c17339de52ccdb671461fc87fb130a55c4da5947a7d8
-  data.tar.gz: d89027d38e01c7414888d5c30bf55932b54f58ab1772f0211276d7be1816ed1374cbedde5c25fd9a94904dc74dc97d04d50177922053977136f5dae9097aa773
+  metadata.gz: 5de016754bc4fdec389d62e4fbce3b3f104a00eb698fb1647c02c7531223cfb41066e3c13eb0a286cb91ba59950493af8edd9c061f427c0317cc424b699b3e43
+  data.tar.gz: 4514a56b1c78db5e1e3beaf3fc5983b964451bf4a007adeb359d2c16b05e0e4b291ecdf06917b689446f33ec22ef5bf9a36cfd6496d2bc37a955896a01606e23

data/RELEASE_NOTES.md

@@ -2,6 +2,14 @@
 BTCRuby Release Notes
 =====================
 
+1.1.4 (August 18, 2015)
+-----------------------
+
+* Public API for `ScriptChunk` instances.
+* Added `ScriptChunk#data_only?`.
+* Added `ScriptChunk#interpreted_data`.
+
+
 1.1.3 (August 17, 2015)
 -----------------------
 

data/lib/btcruby.rb

@@ -32,6 +32,7 @@ require_relative 'btcruby/validation.rb'
 require_relative 'btcruby/script/script_error.rb'
 require_relative 'btcruby/script/script_flags.rb'
 require_relative 'btcruby/script/script_number.rb'
+require_relative 'btcruby/script/script_chunk.rb'
 require_relative 'btcruby/script/script.rb'
 require_relative 'btcruby/script/script_interpreter.rb'
 require_relative 'btcruby/script/opcode.rb'

data/lib/btcruby/script/opcode.rb

@@ -38,161 +38,168 @@ module BTC
       return nil
     end
   end
-
-  # 1. Operators pushing data on stack.
-
-  # Push 1 byte 0x00 on the stack
-  OP_FALSE = 0x00
-  OP_0     = 0x00
-
-  # Any opcode with value < PUSHDATA1 is a length of the string to be pushed on the stack.
-  # So opcode 0x01 is followed by 1 byte of data, 0x09 by 9 bytes and so on up to 0x4b (75 bytes)
-
-  # PUSHDATA<N> opcode is followed by N-byte length of the string that follows.
-  OP_PUSHDATA1 = 0x4c # followed by a 1-byte length of the string to push (allows pushing 0..255 bytes).
-  OP_PUSHDATA2 = 0x4d # followed by a 2-byte length of the string to push (allows pushing 0..65535 bytes).
-  OP_PUSHDATA4 = 0x4e # followed by a 4-byte length of the string to push (allows pushing 0..4294967295 bytes).
-  OP_1NEGATE   = 0x4f # pushes -1 number on the stack
-  OP_RESERVED  = 0x50 # Not assigned. If executed, transaction is invalid.
-
-  # OP_<N> pushes number <N> on the stack
-  OP_TRUE = 0x51
-  OP_1    = 0x51
-  OP_2    = 0x52
-  OP_3    = 0x53
-  OP_4    = 0x54
-  OP_5    = 0x55
-  OP_6    = 0x56
-  OP_7    = 0x57
-  OP_8    = 0x58
-  OP_9    = 0x59
-  OP_10   = 0x5a
-  OP_11   = 0x5b
-  OP_12   = 0x5c
-  OP_13   = 0x5d
-  OP_14   = 0x5e
-  OP_15   = 0x5f
-  OP_16   = 0x60
-
-  # 2. Control flow operators
-
-  OP_NOP      = 0x61 # Does nothing
-  OP_VER      = 0x62 # Not assigned. If executed, transaction is invalid.
-
-  # BitcoinQT executes all operators from OP_IF to OP_ENDIF even inside "non-executed" branch (to keep track of nesting).
-  # Since OP_VERIF and OP_VERNOTIF are not assigned, even inside a non-executed branch they will fall in "default:" switch case
-  # and cause the script to fail. Some other ops like OP_VER can be present inside non-executed branch because they'll be skipped.
-  OP_IF       = 0x63 # If the top stack value is not 0, the statements are executed. The top stack value is removed.
-  OP_NOTIF    = 0x64 # If the top stack value is 0, the statements are executed. The top stack value is removed.
-  OP_VERIF    = 0x65 # Not assigned. Script is invalid with that opcode (even if inside non-executed branch).
-  OP_VERNOTIF = 0x66 # Not assigned. Script is invalid with that opcode (even if inside non-executed branch).
-  OP_ELSE     = 0x67 # Executes code if the previous OP_IF or OP_NOTIF was not executed.
-  OP_ENDIF    = 0x68 # Finishes if/else block
-
-  OP_VERIFY   = 0x69 # Removes item from the stack if it's not 0x00 or 0x80 (negative zero). Otherwise, marks script as invalid.
-  OP_RETURN   = 0x6a # Marks transaction as invalid.
-
-  # Stack ops
-  OP_TOALTSTACK   = 0x6b # Moves item from the stack to altstack
-  OP_FROMALTSTACK = 0x6c # Moves item from the altstack to stack
-  OP_2DROP = 0x6d
-  OP_2DUP  = 0x6e
-  OP_3DUP  = 0x6f
-  OP_2OVER = 0x70
-  OP_2ROT  = 0x71
-  OP_2SWAP = 0x72
-  OP_IFDUP = 0x73
-  OP_DEPTH = 0x74
-  OP_DROP  = 0x75
-  OP_DUP   = 0x76
-  OP_NIP   = 0x77
-  OP_OVER  = 0x78
-  OP_PICK  = 0x79
-  OP_ROLL  = 0x7a
-  OP_ROT   = 0x7b
-  OP_SWAP  = 0x7c
-  OP_TUCK  = 0x7d
-
-  # Splice ops
-  OP_CAT    = 0x7e # Disabled opcode. If executed, transaction is invalid.
-  OP_SUBSTR = 0x7f # Disabled opcode. If executed, transaction is invalid.
-  OP_LEFT   = 0x80 # Disabled opcode. If executed, transaction is invalid.
-  OP_RIGHT  = 0x81 # Disabled opcode. If executed, transaction is invalid.
-  OP_SIZE   = 0x82
-
-  # Bit logic
-  OP_INVERT = 0x83 # Disabled opcode. If executed, transaction is invalid.
-  OP_AND    = 0x84 # Disabled opcode. If executed, transaction is invalid.
-  OP_OR     = 0x85 # Disabled opcode. If executed, transaction is invalid.
-  OP_XOR    = 0x86 # Disabled opcode. If executed, transaction is invalid.
-
-  OP_EQUAL = 0x87        # Last two items are removed from the stack and compared. Result (true or false) is pushed to the stack.
-  OP_EQUALVERIFY = 0x88  # Same as OP_EQUAL, but removes the result from the stack if it's true or marks script as invalid.
-
-  OP_RESERVED1 = 0x89 # Disabled opcode. If executed, transaction is invalid.
-  OP_RESERVED2 = 0x8a # Disabled opcode. If executed, transaction is invalid.
-
-  # Numeric
-  OP_1ADD      = 0x8b  # adds 1 to last item, pops it from stack and pushes result.
-  OP_1SUB      = 0x8c  # substracts 1 to last item, pops it from stack and pushes result.
-  OP_2MUL      = 0x8d  # Disabled opcode. If executed, transaction is invalid.
-  OP_2DIV      = 0x8e  # Disabled opcode. If executed, transaction is invalid.
-  OP_NEGATE    = 0x8f  # negates the number, pops it from stack and pushes result.
-  OP_ABS       = 0x90  # replaces number with its absolute value
-  OP_NOT       = 0x91  # replaces number with True if it's zero, False otherwise.
-  OP_0NOTEQUAL = 0x92  # replaces number with True if it's not zero, False otherwise.
-
-  OP_ADD    = 0x93  # (x y -- x+y)
-  OP_SUB    = 0x94  # (x y -- x-y)
-  OP_MUL    = 0x95  # Disabled opcode. If executed, transaction is invalid.
-  OP_DIV    = 0x96  # Disabled opcode. If executed, transaction is invalid.
-  OP_MOD    = 0x97  # Disabled opcode. If executed, transaction is invalid.
-  OP_LSHIFT = 0x98  # Disabled opcode. If executed, transaction is invalid.
-  OP_RSHIFT = 0x99  # Disabled opcode. If executed, transaction is invalid.
-
-  OP_BOOLAND            = 0x9a
-  OP_BOOLOR             = 0x9b
-  OP_NUMEQUAL           = 0x9c
-  OP_NUMEQUALVERIFY     = 0x9d
-  OP_NUMNOTEQUAL        = 0x9e
-  OP_LESSTHAN           = 0x9f
-  OP_GREATERTHAN        = 0xa0
-  OP_LESSTHANOREQUAL    = 0xa1
-  OP_GREATERTHANOREQUAL = 0xa2
-  OP_MIN                = 0xa3
-  OP_MAX                = 0xa4
-
-  OP_WITHIN = 0xa5
-
-  # Crypto
-  OP_RIPEMD160      = 0xa6
-  OP_SHA1           = 0xa7
-  OP_SHA256         = 0xa8
-  OP_HASH160        = 0xa9
-  OP_HASH256        = 0xaa
-  OP_CODESEPARATOR  = 0xab # This opcode is rarely used because it's useless, but we need to support it anyway.
-  OP_CHECKSIG       = 0xac
-  OP_CHECKSIGVERIFY = 0xad
-  OP_CHECKMULTISIG  = 0xae
-  OP_CHECKMULTISIGVERIFY = 0xaf
-
-  # Expansion
-  OP_NOP1  = 0xb0
-  OP_NOP2  = 0xb1
-  OP_CHECKLOCKTIMEVERIFY = OP_NOP2 # See BIP65
-  OP_NOP3  = 0xb2
-  OP_NOP4  = 0xb3
-  OP_NOP5  = 0xb4
-  OP_NOP6  = 0xb5
-  OP_NOP7  = 0xb6
-  OP_NOP8  = 0xb7
-  OP_NOP9  = 0xb8
-  OP_NOP10 = 0xb9
-
-  OP_INVALIDOPCODE = 0xff
-
-  OPCODE_NAME_TO_VALUE = Hash[*constants.grep(/^OP_/).map{|c| [c.to_s, const_get(c)] }.flatten]
-  OPCODE_VALUE_TO_NAME = Hash[*constants.grep(/^OP_/).map{|c| [const_get(c), c.to_s] }.flatten]
-
+  
+  # All opcodes are defined in Opcodes module so they can be included in
+  # a different namespace without the baggage of other BTC identifiers.
+  module Opcodes
+
+    # 1. Operators pushing data on stack.
+
+    # Push 1 byte 0x00 on the stack
+    OP_FALSE = 0x00
+    OP_0     = 0x00
+
+    # Any opcode with value < PUSHDATA1 is a length of the string to be pushed on the stack.
+    # So opcode 0x01 is followed by 1 byte of data, 0x09 by 9 bytes and so on up to 0x4b (75 bytes)
+
+    # PUSHDATA<N> opcode is followed by N-byte length of the string that follows.
+    OP_PUSHDATA1 = 0x4c # followed by a 1-byte length of the string to push (allows pushing 0..255 bytes).
+    OP_PUSHDATA2 = 0x4d # followed by a 2-byte length of the string to push (allows pushing 0..65535 bytes).
+    OP_PUSHDATA4 = 0x4e # followed by a 4-byte length of the string to push (allows pushing 0..4294967295 bytes).
+    OP_1NEGATE   = 0x4f # pushes -1 number on the stack
+    OP_RESERVED  = 0x50 # Not assigned. If executed, transaction is invalid.
+
+    # OP_<N> pushes number <N> on the stack
+    OP_TRUE = 0x51
+    OP_1    = 0x51
+    OP_2    = 0x52
+    OP_3    = 0x53
+    OP_4    = 0x54
+    OP_5    = 0x55
+    OP_6    = 0x56
+    OP_7    = 0x57
+    OP_8    = 0x58
+    OP_9    = 0x59
+    OP_10   = 0x5a
+    OP_11   = 0x5b
+    OP_12   = 0x5c
+    OP_13   = 0x5d
+    OP_14   = 0x5e
+    OP_15   = 0x5f
+    OP_16   = 0x60
+
+    # 2. Control flow operators
+
+    OP_NOP      = 0x61 # Does nothing
+    OP_VER      = 0x62 # Not assigned. If executed, transaction is invalid.
+
+    # BitcoinQT executes all operators from OP_IF to OP_ENDIF even inside "non-executed" branch (to keep track of nesting).
+    # Since OP_VERIF and OP_VERNOTIF are not assigned, even inside a non-executed branch they will fall in "default:" switch case
+    # and cause the script to fail. Some other ops like OP_VER can be present inside non-executed branch because they'll be skipped.
+    OP_IF       = 0x63 # If the top stack value is not 0, the statements are executed. The top stack value is removed.
+    OP_NOTIF    = 0x64 # If the top stack value is 0, the statements are executed. The top stack value is removed.
+    OP_VERIF    = 0x65 # Not assigned. Script is invalid with that opcode (even if inside non-executed branch).
+    OP_VERNOTIF = 0x66 # Not assigned. Script is invalid with that opcode (even if inside non-executed branch).
+    OP_ELSE     = 0x67 # Executes code if the previous OP_IF or OP_NOTIF was not executed.
+    OP_ENDIF    = 0x68 # Finishes if/else block
+
+    OP_VERIFY   = 0x69 # Removes item from the stack if it's not 0x00 or 0x80 (negative zero). Otherwise, marks script as invalid.
+    OP_RETURN   = 0x6a # Marks transaction as invalid.
+
+    # Stack ops
+    OP_TOALTSTACK   = 0x6b # Moves item from the stack to altstack
+    OP_FROMALTSTACK = 0x6c # Moves item from the altstack to stack
+    OP_2DROP = 0x6d
+    OP_2DUP  = 0x6e
+    OP_3DUP  = 0x6f
+    OP_2OVER = 0x70
+    OP_2ROT  = 0x71
+    OP_2SWAP = 0x72
+    OP_IFDUP = 0x73
+    OP_DEPTH = 0x74
+    OP_DROP  = 0x75
+    OP_DUP   = 0x76
+    OP_NIP   = 0x77
+    OP_OVER  = 0x78
+    OP_PICK  = 0x79
+    OP_ROLL  = 0x7a
+    OP_ROT   = 0x7b
+    OP_SWAP  = 0x7c
+    OP_TUCK  = 0x7d
+
+    # Splice ops
+    OP_CAT    = 0x7e # Disabled opcode. If executed, transaction is invalid.
+    OP_SUBSTR = 0x7f # Disabled opcode. If executed, transaction is invalid.
+    OP_LEFT   = 0x80 # Disabled opcode. If executed, transaction is invalid.
+    OP_RIGHT  = 0x81 # Disabled opcode. If executed, transaction is invalid.
+    OP_SIZE   = 0x82
+
+    # Bit logic
+    OP_INVERT = 0x83 # Disabled opcode. If executed, transaction is invalid.
+    OP_AND    = 0x84 # Disabled opcode. If executed, transaction is invalid.
+    OP_OR     = 0x85 # Disabled opcode. If executed, transaction is invalid.
+    OP_XOR    = 0x86 # Disabled opcode. If executed, transaction is invalid.
+
+    OP_EQUAL = 0x87        # Last two items are removed from the stack and compared. Result (true or false) is pushed to the stack.
+    OP_EQUALVERIFY = 0x88  # Same as OP_EQUAL, but removes the result from the stack if it's true or marks script as invalid.
+
+    OP_RESERVED1 = 0x89 # Disabled opcode. If executed, transaction is invalid.
+    OP_RESERVED2 = 0x8a # Disabled opcode. If executed, transaction is invalid.
+
+    # Numeric
+    OP_1ADD      = 0x8b  # adds 1 to last item, pops it from stack and pushes result.
+    OP_1SUB      = 0x8c  # substracts 1 to last item, pops it from stack and pushes result.
+    OP_2MUL      = 0x8d  # Disabled opcode. If executed, transaction is invalid.
+    OP_2DIV      = 0x8e  # Disabled opcode. If executed, transaction is invalid.
+    OP_NEGATE    = 0x8f  # negates the number, pops it from stack and pushes result.
+    OP_ABS       = 0x90  # replaces number with its absolute value
+    OP_NOT       = 0x91  # replaces number with True if it's zero, False otherwise.
+    OP_0NOTEQUAL = 0x92  # replaces number with True if it's not zero, False otherwise.
+
+    OP_ADD    = 0x93  # (x y -- x+y)
+    OP_SUB    = 0x94  # (x y -- x-y)
+    OP_MUL    = 0x95  # Disabled opcode. If executed, transaction is invalid.
+    OP_DIV    = 0x96  # Disabled opcode. If executed, transaction is invalid.
+    OP_MOD    = 0x97  # Disabled opcode. If executed, transaction is invalid.
+    OP_LSHIFT = 0x98  # Disabled opcode. If executed, transaction is invalid.
+    OP_RSHIFT = 0x99  # Disabled opcode. If executed, transaction is invalid.
+
+    OP_BOOLAND            = 0x9a
+    OP_BOOLOR             = 0x9b
+    OP_NUMEQUAL           = 0x9c
+    OP_NUMEQUALVERIFY     = 0x9d
+    OP_NUMNOTEQUAL        = 0x9e
+    OP_LESSTHAN           = 0x9f
+    OP_GREATERTHAN        = 0xa0
+    OP_LESSTHANOREQUAL    = 0xa1
+    OP_GREATERTHANOREQUAL = 0xa2
+    OP_MIN                = 0xa3
+    OP_MAX                = 0xa4
+
+    OP_WITHIN = 0xa5
+
+    # Crypto
+    OP_RIPEMD160      = 0xa6
+    OP_SHA1           = 0xa7
+    OP_SHA256         = 0xa8
+    OP_HASH160        = 0xa9
+    OP_HASH256        = 0xaa
+    OP_CODESEPARATOR  = 0xab # This opcode is rarely used because it's useless, but we need to support it anyway.
+    OP_CHECKSIG       = 0xac
+    OP_CHECKSIGVERIFY = 0xad
+    OP_CHECKMULTISIG  = 0xae
+    OP_CHECKMULTISIGVERIFY = 0xaf
+
+    # Expansion
+    OP_NOP1  = 0xb0
+    OP_NOP2  = 0xb1
+    OP_CHECKLOCKTIMEVERIFY = OP_NOP2 # See BIP65
+    OP_NOP3  = 0xb2
+    OP_NOP4  = 0xb3
+    OP_NOP5  = 0xb4
+    OP_NOP6  = 0xb5
+    OP_NOP7  = 0xb6
+    OP_NOP8  = 0xb7
+    OP_NOP9  = 0xb8
+    OP_NOP10 = 0xb9
+
+    OP_INVALIDOPCODE = 0xff
+
+    OPCODE_NAME_TO_VALUE = Hash[*constants.grep(/^OP_/).map{|c| [c.to_s, const_get(c)] }.flatten]
+    OPCODE_VALUE_TO_NAME = Hash[*constants.grep(/^OP_/).map{|c| [const_get(c), c.to_s] }.flatten]
+  end
+  
+  # Make all opcodes available as BTC::OP_...
+  include Opcodes
 end
 

data/lib/btcruby/script/script.rb

@@ -13,6 +13,9 @@ module BTC
     # If it is not a multisig script, returns nil.
     # See also #multisig_script?
     attr_reader :multisig_signatures_required
+    
+    # Returns an array of chunks that constitute the script.
+    attr_reader :chunks
 
     def initialize(hex: nil, # raw script data in hex
                    data: nil, # raw script data in binary
@@ -25,7 +28,7 @@ module BTC
         @chunks = []
         offset = 0
         while offset < data.bytesize
-          chunk = Chunk.with_data(data, offset: offset)
+          chunk = ScriptChunk.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
@@ -249,7 +252,7 @@ module BTC
     def data_only?
       # Include PUSHDATA ops and OP_0..OP_16 literals.
       @chunks.each do |chunk|
-        return false if chunk.opcode > OP_16
+        return false if !chunk.data_only?
       end
       return true
     end
@@ -377,7 +380,7 @@ module BTC
       if opcode > 0 && opcode <= OP_PUSHDATA4
         raise ArgumentError, "Cannot add pushdata opcode without data"
       end
-      @chunks << Chunk.new(opcode.chr)
+      @chunks << ScriptChunk.new(opcode.chr)
       return self
     end
 
@@ -390,7 +393,7 @@ module BTC
       if !encoded_pushdata
         raise ArgumentError, "Cannot encode pushdata with opcode #{opcode}"
       end
-      @chunks << Chunk.new(encoded_pushdata)
+      @chunks << ScriptChunk.new(encoded_pushdata)
       return self
     end
 
@@ -434,7 +437,7 @@ module BTC
         object.each do |element|
           self << element
         end
-      elsif object.is_a?(Chunk)
+      elsif object.is_a?(ScriptChunk)
         @chunks << object
       else
         raise ArgumentError, "Operand must be an integer, a string a BTC::Script instance or an array of any of those."
@@ -490,8 +493,6 @@ module BTC
     # 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)
@@ -561,199 +562,5 @@ module BTC
       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.to_hex(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
-
-      def ==(other)
-        @raw_data == other.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

data/lib/btcruby/script/script_chunk.rb

@@ -0,0 +1,216 @@
+module BTC
+  # ScriptChunk represents either an opcode or a pushdata command.
+  class ScriptChunk
+    # 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.
+      opcode <= OP_PUSHDATA4
+    end
+
+    def data_only?
+      opcode <= OP_16
+    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.
+    # Note: this is not as strict as `check_minimal_push` in ScriptInterpreter.
+    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
+    
+    # Returns corresponding data for data_only opcodes:
+    # pushdata or OP_N-encoded numbers.
+    # For all other opcodes returns nil.
+    def interpreted_data
+      if d = pushdata
+        return d
+      end
+      opcode = self.opcode
+      if opcode == OP_1NEGATE || (opcode >= OP_1 && opcode <= OP_16)
+        ScriptNumber.new(integer: opcode - OP_1 + 1).data
+      else
+        nil
+      end
+    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.to_hex(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
+
+    def ==(other)
+      @raw_data == other.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 # ScriptChunk
+end

data/lib/btcruby/version.rb

@@ -1,3 +1,3 @@
 module BTC
-  VERSION = "1.1.3".freeze
+  VERSION = "1.1.4".freeze
 end

data/spec/script_spec.rb

@@ -71,7 +71,7 @@ describe BTC::Script do
   end
 
 
-  it "removing subscript does not modify receiver" do
+  it "removing subscript does not modify the receiver" do
     s = Script.new << OP_DUP << OP_HASH160 << OP_CODESEPARATOR << "some data" << OP_EQUALVERIFY << OP_CHECKSIG
     s1 = s.dup
     s2 = s1.find_and_delete(Script.new << OP_HASH160)
@@ -91,4 +91,10 @@ describe BTC::Script do
     s2.must_equal(Script.new.append_pushdata("foo", opcode:OP_PUSHDATA1))
   end
 
+  it "should parse interpreted data and pushdata correctly" do
+    script = Script.new << OP_0 << OP_1NEGATE << OP_NOP << OP_RESERVED << OP_1 << OP_16 << "1" << "2" << "chancellor"
+    script.chunks.map{|c| c.interpreted_data }.must_equal ["", "\x81".b, nil, nil, "\x01".b, "\x10".b, "1", "2", "chancellor"]
+    script.chunks.map{|c| c.pushdata }.must_equal ["", nil, nil, nil, nil, nil, "1", "2", "chancellor"]
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: btcruby
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - Oleg Andreev
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-17 00:00:00.000000000 Z
+date: 2015-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -108,6 +108,7 @@ files:
 - lib/btcruby/script/opcode.rb
 - lib/btcruby/script/p2sh_plugin.rb
 - lib/btcruby/script/script.rb
+- lib/btcruby/script/script_chunk.rb
 - lib/btcruby/script/script_error.rb
 - lib/btcruby/script/script_flags.rb
 - lib/btcruby/script/script_interpreter.rb