btcruby 1.0.9 → 1.1

data/lib/btcruby/script/script_number.rb

@@ -0,0 +1,254 @@
+module BTC
+  # (Based on CScriptNum)
+  # Numeric opcodes (OP_1ADD, etc) are restricted to operating on 4-byte integers.
+  # The semantics are subtle, though: operands must be in the range [-2^31 +1...2^31 -1],
+  # but results may overflow (and are valid as long as they are not used in a subsequent
+  # numeric operation). ScriptNumber enforces those semantics by storing results as
+  # an int64 and allowing out-of-range values to be returned as a vector of bytes but
+  # throwing an exception if arithmetic is done or the result is interpreted as an integer.
+  class ScriptNumberError < ArgumentError; end
+
+  class ScriptNumber
+    DEFAULT_MAX_SIZE = 4
+    
+    INT64_MAX = 0x7fffffffffffffff
+    INT64_MIN = -INT64_MAX - 1
+
+    def initialize(integer: nil, boolean: nil, data: nil, hex: nil, require_minimal: true, max_size: DEFAULT_MAX_SIZE)
+      if integer
+        assert(integer >= INT64_MIN && integer <= INT64_MAX, "Integer must be within int64 range")
+        @integer = integer
+      elsif data || hex
+        data ||= BTC.from_hex(hex)
+        if data.bytesize > max_size
+          raise ScriptNumberError, "script number overflow (#{data.bytesize} > #{max_size})"
+        end
+        if require_minimal && data.bytesize > 0
+          # Check that the number is encoded with the minimum possible
+          # number of bytes.
+          #
+          # If the most-significant-byte - excluding the sign bit - is zero
+          # then we're not minimal. Note how this test also rejects the
+          # negative-zero encoding, 0x80.
+          if (data.bytes.last & 0x7f) == 0
+            # One exception: if there's more than one byte and the most
+            # significant bit of the second-most-significant-byte is set
+            # it would conflict with the sign bit. An example of this case
+            # is +-255, which encode to 0xff00 and 0xff80 respectively.
+            # (big-endian).
+            if data.bytesize <= 1 || (data.bytes[data.bytesize - 2] & 0x80) == 0
+              raise ScriptNumberError, "non-minimally encoded script number"
+            end
+          end
+        end
+        @integer = self.class.decode_integer(data)
+      elsif boolean == false || boolean == true
+        @integer = boolean ? 1 : 0
+      else
+        raise ArgumentError
+      end
+    end
+
+    # Operators
+
+    def ==(other); @integer == other.to_i; end
+    def !=(other); @integer != other.to_i; end
+    def <=(other); @integer <= other.to_i; end
+    def  <(other); @integer  < other.to_i; end
+    def >=(other); @integer >= other.to_i; end
+    def  >(other); @integer  > other.to_i; end
+    
+    def +(other); self.class.new(integer: @integer + other.to_i); end
+    def -(other); self.class.new(integer: @integer - other.to_i); end
+    
+    def +@
+      self
+    end
+
+    def -@
+      assert(@integer > INT64_MIN && @integer <= INT64_MAX, "Integer will not be within int64 range after negation")
+      self.class.new(integer: -@integer)
+    end
+    
+
+
+    # Conversion Methods
+
+    def to_i
+      @integer
+    end
+
+    def to_s
+      @integer.to_s
+    end
+
+    def data
+      self.class.encode_integer(@integer)
+    end
+
+    def to_hex
+      BTC.to_hex(data)
+    end
+
+    def self.decode_integer(data)
+      return 0 if data.empty?
+
+      result = 0
+
+      bytes = data.bytes
+      bytes.each_with_index do |byte, i|
+        result |= bytes[i] << 8*i
+      end
+
+      # If the input vector's most significant byte is 0x80, remove it from
+      # the result's msb and return a negative.
+      if (bytes.last & 0x80) != 0
+        return -(result & ~(0x80 << (8 * (bytes.size - 1))));
+      end
+      return result
+    end
+
+    def self.encode_integer(value)
+      return "".b if value == 0
+
+      result = []
+      negative = value < 0
+      absvalue = negative ? -value : value
+
+      while absvalue != 0
+        result.push(absvalue & 0xff)
+        absvalue >>= 8
+      end
+
+      # - If the most significant byte is >= 0x80 and the value is positive, push a
+      # new zero-byte to make the significant byte < 0x80 again.
+      #
+      # - If the most significant byte is >= 0x80 and the value is negative, push a
+      # new 0x80 byte that will be popped off when converting to an integral.
+      #
+      # - If the most significant byte is < 0x80 and the value is negative, add
+      # 0x80 to it, since it will be subtracted and interpreted as a negative when
+      # converting to an integral.
+
+      if (result.last & 0x80) != 0
+        result.push(negative ? 0x80 : 0)
+      elsif negative
+        result[result.size - 1] = result.last | 0x80
+      end
+
+      BTC.data_from_bytes(result)
+    end
+    
+    def assert(condition, message)
+      raise message if !condition
+    end
+
+  end
+end
+
+if $0 == __FILE__
+  require 'btcruby'
+
+  include BTC
+  def run_tests
+
+    # Decoding
+
+    [-1000000000000000,-10000,-100,-1,0,1,10,1000,100000000000000].each do |i|
+      should_equal(ScriptNumber.new(integer: i).to_i, i, "Must return integer as-is.")
+    end
+
+    should_equal(ScriptNumber.new(data: "").to_i,          0,   "Must parse empty string as zero.")
+    should_equal(ScriptNumber.new(data: "\x01").to_i,      1,   "Must parse 0x01 as 1.")
+    should_equal(ScriptNumber.new(data: "\xff").to_i,     -127, "Must parse 0xff as -127.")
+    should_equal(ScriptNumber.new(data: "\xff\x00").to_i,  255, "Must parse 0xff00 as 255.")
+    should_equal(ScriptNumber.new(data: "\x81").to_i,     -1,   "Must parse 0x81 as -1.")
+    should_equal(ScriptNumber.new(data: "\x8f").to_i,     -15,  "Must parse 0x8f as -0x0f.")
+    should_equal(ScriptNumber.new(data: "\x00\x81").to_i, -256, "Must parse 0x0081 as -256.")
+    should_equal(ScriptNumber.new(data: "\xff\x80").to_i, -255, "Must decode -255.")
+
+    should_raise('non-minimally encoded script number') { ScriptNumber.new(data: "\x00") }
+    should_raise('non-minimally encoded script number') { ScriptNumber.new(data: "\x80") }
+    should_raise('non-minimally encoded script number') { ScriptNumber.new(data: "\x00\x80") }
+    should_raise('non-minimally encoded script number') { ScriptNumber.new(data: "\x01\x80") }
+    should_raise('non-minimally encoded script number') { ScriptNumber.new(data: "\x00\x00\x80") }
+    should_raise('non-minimally encoded script number') { ScriptNumber.new(data: "\x00\x10\x80") }
+    should_raise('non-minimally encoded script number') { ScriptNumber.new(data: "\x10\x00\x80") }
+    should_raise('script number overflow (3 > 2)')      { ScriptNumber.new(data: "\x00\x00\x80", max_size: 2) }
+
+    # Encoding
+
+    should_equal(ScriptNumber.new(integer:  0).to_hex,      "")
+    should_equal(ScriptNumber.new(integer:  1).to_hex,      "01")
+    should_equal(ScriptNumber.new(integer: -1).to_hex,      "81")
+    should_equal(ScriptNumber.new(integer:  255).to_hex,    "ff00")
+    should_equal(ScriptNumber.new(integer: -255).to_hex,    "ff80")
+    should_equal(ScriptNumber.new(integer:  0xffff).to_hex, "ffff00")
+    should_equal(ScriptNumber.new(integer: -0xffff).to_hex, "ffff80")
+
+    # Back and forth test
+
+    (-100000..10000).each do |i|
+      d = ScriptNumber.new(integer: i).data
+      #puts BTC.to_hex(d) if i % 16 == 0
+      i2 = ScriptNumber.new(data: d).to_i
+      should_equal(i, i2)
+    end
+    
+    # Booleans
+    
+    should_equal(ScriptNumber.new(boolean: true), 1)
+    should_equal(ScriptNumber.new(boolean: false), 0)
+
+    # Equality
+
+    should_equal(ScriptNumber.new(integer: 0) == 0, true)
+    should_equal(ScriptNumber.new(integer: 1) == 1, true)
+    should_equal(ScriptNumber.new(integer: -1) == -1, true)
+
+    should_equal(ScriptNumber.new(integer: 0) == ScriptNumber.new(integer: 0), true)
+    should_equal(ScriptNumber.new(integer: 1) == ScriptNumber.new(integer: 1), true)
+    should_equal(ScriptNumber.new(integer: -1) == ScriptNumber.new(integer: -1), true)
+    
+    should_equal(ScriptNumber.new(integer: 0) != 0, false)
+    should_equal(ScriptNumber.new(integer: 1) != 1, false)
+    should_equal(ScriptNumber.new(integer: -1) != -1, false)
+
+    should_equal(ScriptNumber.new(integer: 0) != ScriptNumber.new(integer: 0), false)
+    should_equal(ScriptNumber.new(integer: 1) != ScriptNumber.new(integer: 1), false)
+    should_equal(ScriptNumber.new(integer: -1) != ScriptNumber.new(integer: -1), false)
+    
+    # Arithmetic
+    
+    sn = ScriptNumber.new(integer: 123)
+    sn -= 1
+    should_equal(sn, 122)
+    
+    puts "All tests passed."
+  end
+
+  def should_equal(a, b, msg = 'Must equal')
+    a == b or raise "#{msg} Expected #{b.inspect}, received #{a.inspect}."
+  end
+
+  def should_raise(message)
+    raised = false
+    begin
+      yield
+    rescue => e
+      if e.message == message
+        raised = true
+      else
+        raise "Raised unexpected exception: #{e}"
+      end
+    end
+    if !raised
+      raise "Should have raised #{message.inspect}!"
+    end
+  end
+
+  run_tests
+end
+
+
+

data/lib/btcruby/script/signature_checker.rb

@@ -0,0 +1,14 @@
+module BTC
+  # Protocol for signature checkers
+  module SignatureChecker
+    # Returns a boolean indicating if signature is valid for the given public key
+    def check_signature(script_signature: nil, public_key:nil, script:nil)
+      false
+    end
+    # Returns a boolean indicating if lock time is valid.
+    # lock_time is ScriptNumber instance.
+    def check_lock_time(lock_time)
+      false
+    end
+  end
+end

data/lib/btcruby/script/test_signature_checker.rb

@@ -0,0 +1,53 @@
+module BTC
+  class TestSignatureChecker
+    include SignatureChecker
+    
+    def initialize(signature_hash: nil, timestamp: nil)
+      @signature_hash = signature_hash
+      @timestamp = timestamp
+    end
+    
+    # for testing check_signature
+    def signature_hash
+      @signature_hash
+    end
+    
+    # for testing check_lock_time
+    def timestamp
+      @timestamp
+    end
+    
+    def check_signature(script_signature:nil, public_key:nil, script:nil)
+      # Signature must be long enough to contain a sighash byte.
+      return false if script_signature.size < 1
+      
+      # Extract raw ECDSA signature by stripping off the last hashtype byte
+      ecdsa_sig = script_signature[0..-2]
+
+      key = BTC::Key.new(public_key: public_key)
+      result = key.verify_ecdsa_signature(ecdsa_sig, hash)
+      return result
+    end
+
+    def check_lock_time(lock_time)
+      # There are two times of nLockTime: lock-by-blockheight
+      # and lock-by-blocktime, distinguished by whether
+      # nLockTime < LOCKTIME_THRESHOLD.
+      #
+      # We want to compare apples to apples, so fail the script
+      # if the type of nLockTime being tested is not the same as
+      # the nLockTime in the transaction.
+      if !(
+           (timestamp <  LOCKTIME_THRESHOLD && lock_time <  LOCKTIME_THRESHOLD) ||
+           (timestamp >= LOCKTIME_THRESHOLD && lock_time >= LOCKTIME_THRESHOLD)
+       )
+        return false
+      end
+
+      # Now that we know we're comparing apples-to-apples, the
+      # comparison is a simple numeric one.
+      return timestamp >= lock_time
+    end
+    
+  end
+end

data/lib/btcruby/script/transaction_signature_checker.rb

@@ -0,0 +1,66 @@
+module BTC
+  class TransactionSignatureChecker
+    include SignatureChecker
+    
+    attr_accessor :transaction
+    attr_accessor :input_index
+    def initialize(transaction: nil, input_index: nil)
+      @transaction = transaction
+      @input_index = input_index
+    end
+    
+    def check_signature(script_signature:nil, public_key:nil, script:nil)
+      # Signature must be long enough to contain a sighash byte.
+      return false if script_signature.size < 1
+      
+      hashtype = script_signature[-1].bytes.first
+
+      # Extract raw ECDSA signature by stripping off the last hashtype byte
+      ecdsa_sig = script_signature[0..-2]
+
+      key = BTC::Key.new(public_key: public_key)
+      hash = @transaction.signature_hash(input_index: @input_index, output_script: script, hash_type: hashtype)
+      result = key.verify_ecdsa_signature(ecdsa_sig, hash)
+      return result
+    end
+
+    def check_lock_time(lock_time)
+      # There are two times of nLockTime: lock-by-blockheight
+      # and lock-by-blocktime, distinguished by whether
+      # nLockTime < LOCKTIME_THRESHOLD.
+      #
+      # We want to compare apples to apples, so fail the script
+      # if the type of nLockTime being tested is not the same as
+      # the nLockTime in the transaction.
+      if !(
+           (@transaction.lock_time <  LOCKTIME_THRESHOLD && lock_time <  LOCKTIME_THRESHOLD) ||
+           (@transaction.lock_time >= LOCKTIME_THRESHOLD && lock_time >= LOCKTIME_THRESHOLD)
+       )
+        return false
+      end
+
+      # Now that we know we're comparing apples-to-apples, the
+      # comparison is a simple numeric one.
+      if lock_time > @transaction.lock_time
+        return false
+      end
+
+      # Finally the nLockTime feature can be disabled and thus
+      # CHECKLOCKTIMEVERIFY bypassed if every txin has been
+      # finalized by setting nSequence to maxint. The
+      # transaction would be allowed into the blockchain, making
+      # the opcode ineffective.
+      #
+      # Testing if this vin is not final is sufficient to
+      # prevent this condition. Alternatively we could test all
+      # inputs, but testing just this input minimizes the data
+      # required to prove correct CHECKLOCKTIMEVERIFY execution.
+      if @transaction.inputs[@input_index].final?
+        return false
+      end
+
+      return true
+    end
+    
+  end
+end

data/lib/btcruby/transaction_input.rb

@@ -78,7 +78,7 @@ module BTC
         @previous_hash    = previous_hash    || ZERO_HASH256
         @previous_hash    = BTC.hash_from_id(previous_id) if previous_id
         @previous_index   = previous_index   || INVALID_INDEX
-        @coinbase_data    = coinbase_data
+        @coinbase_data    = coinbase_data    || "".b
         @signature_script = signature_script || BTC::Script.new
         @sequence         = sequence         || MAX_SEQUENCE
       end

data/lib/btcruby/version.rb

@@ -1,3 +1,3 @@
 module BTC
-  VERSION = "1.0.9".freeze
+  VERSION = "1.1".freeze
 end

data/lib/btcruby/wire_format.rb

@@ -184,12 +184,44 @@ module BTC
 
       intbuf + stringbuf
     end
-    
-    
+
+
+    # Reads varint length prefix, then calls the block appropriate number of times to read the items.
+    # Returns an array of items.
+    def read_array(data: nil, stream: nil, offset: 0)
+      count, len = read_varint(data: data, stream: stream, offset: offset)
+      return [nil, len] if !count
+      (0...count).map do |i|
+        yield
+      end
+    end
+
+    def encode_array(array, &block)
+      write_array(array, &block)
+    end
+
+    def write_array(array, data: nil, stream: nil, &block)
+      raise ArgumentError, "Array must be present" if !array
+      raise ArgumentError, "Parsing block must be present" if !block
+      intbuf = write_varint(array.size, data: data, stream: stream)
+      array.inject(intbuf) do |buf, e|
+        string = block.call(e)
+        stringbuf = BTC::Data.ensure_binary_encoding(string)
+        data << stringbuf if data
+        stream.write(stringbuf) if stream
+        buf << stringbuf
+        buf
+      end
+    end
+
+
+
+
+
     # LEB128 encoding used in Open Assets protocol
-    
+
     # Decodes an unsigned integer encoded in LEB128.
-    # Returns `[value, length]` where `value` is an integer decoded from LEB128 and `length` 
+    # Returns `[value, length]` where `value` is an integer decoded from LEB128 and `length`
     # is a number of bytes read (includes length prefix and offset bytes).
     def read_uleb128(data: nil, stream: nil, offset: 0)
       if (data && stream) || (!data && !stream)
@@ -252,8 +284,8 @@ module BTC
       stream.write(buf) if stream
       buf
     end
-    
-    
+
+
 
     PACK_FORMAT_UINT8    = "C".freeze
     PACK_FORMAT_INT8     = "c".freeze
@@ -291,11 +323,11 @@ module BTC
     def read_int32le(data: nil, stream: nil, offset: 0)
       _read_fixint(name: :int32le,  length: 4, pack_format: PACK_FORMAT_INT32LE,  data: data, stream: stream, offset: offset)
     end
-    
+
     def read_uint32be(data: nil, stream: nil, offset: 0) # used in BIP32
       _read_fixint(name: :uint32be, length: 4, pack_format: PACK_FORMAT_UINT32BE, data: data, stream: stream, offset: offset)
     end
-    
+
     def read_int32be(data: nil, stream: nil, offset: 0)
       _read_fixint(name: :int32be,  length: 4, pack_format: PACK_FORMAT_INT32BE,  data: data, stream: stream, offset: offset)
     end