RubyGems - btcruby - Versions diffs - 1.1.3 → 1.1.4 - Mend

btcruby 1.1.3 → 1.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

checksums.yaml +4 -4
data/RELEASE_NOTES.md +8 -0
data/lib/btcruby.rb +1 -0
data/lib/btcruby/script/opcode.rb +163 -156
data/lib/btcruby/script/script.rb +8 -201
data/lib/btcruby/script/script_chunk.rb +216 -0
data/lib/btcruby/version.rb +1 -1
data/spec/script_spec.rb +7 -1
metadata +3 -2

checksums.yaml CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 ADDED

@@ -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 CHANGED

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

data/spec/script_spec.rb CHANGED

@@ -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 CHANGED

@@ -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