ruby-ethereum 0.9.0

data/lib/ethereum/trie/nibble_key.rb

@@ -0,0 +1,184 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class Trie
+
+    ##
+    # Nibble is half-byte.
+    #
+    class NibbleKey < Array
+
+      NIBBLE_TERM_FLAG  = 0b0010
+      NIBBLE_ODD_FLAG   = 0b0001
+      NIBBLE_TERMINATOR = 16
+
+      HEX_VALUES = (0..15).inject({}) {|h, i| h[i.to_s(16)] = i; h}.freeze
+
+      class <<self
+        ##
+        # Encode nibbles to string.
+        #
+        # @see `pack_nibbles` in pyethereum
+        #
+        # @param nibbles [Array[Integer]] array of nibbles to encode
+        #
+        # @return [String] encoded string
+        #
+        def encode(nibbles)
+          flags = 0
+
+          if nibbles.last == NIBBLE_TERMINATOR
+            flags |= NIBBLE_TERM_FLAG
+            nibbles = nibbles[0...-1]
+          end
+
+          odd = nibbles.size % 2
+          flags |= odd
+          if odd == 1
+            nibbles = [flags] + nibbles
+          else
+            nibbles = [flags, 0b0000] + nibbles
+          end
+
+          (nibbles.size/2).times.reduce('') do |s, i|
+            base = 2*i
+            s += (16*nibbles[base] + nibbles[base+1]).chr
+          end
+        end
+
+        ##
+        # Decode bytes to {NibbleKey}, with flags processed.
+        #
+        # @see `unpack_to_nibbles` in pyethereum
+        #
+        # @param bytes [String] compact hex encoded string.
+        #
+        # @return [NibbleKey] nibbles array, may have a terminator
+        #
+        def decode(bytes)
+          o = from_string bytes
+          flags = o[0]
+
+          o.push NIBBLE_TERMINATOR if flags & NIBBLE_TERM_FLAG > 0
+          fill = flags & NIBBLE_ODD_FLAG > 0 ? 1 : 2
+
+          new o[fill..-1]
+        end
+
+        ##
+        # Convert arbitrary string to {NibbleKey}.
+        #
+        # @see `bin_to_nibbles` in pyethereum
+        #
+        # @example
+        #   from_string('') # => []
+        #   from_string('h') # => [6, 8]
+        #   from_string('he') # => [6, 8, 6, 5]
+        #   from_string('hello') # => [6, 8, 6, 5, 6, 12, 6, 12, 6, 15]
+        #
+        # @param s [String] any string
+        #
+        # @return [NibbleKey] array of nibbles presented as interger smaller
+        #   than 16, has no terminator because plain string has no flags
+        #
+        def from_string(s)
+          nibbles = RLP::Utils.encode_hex(s).each_char.map {|nibble| HEX_VALUES[nibble] }
+          new nibbles
+        end
+
+        ##
+        # Convert array of nibbles to string.
+        #
+        # @see `nibbles_to_bin` in pyethereum
+        #
+        # @param nibbles [Array] array of nibbles
+        #
+        # @return [String] string represented by nibbles
+        #
+        def to_string(nibbles)
+          raise ArgumentError, "nibbles can only be in 0..15" if nibbles.any? {|x| x > 15 || x < 0 }
+          raise ArgumentError, "nibbles must be of even numbers" if nibbles.size % 2 == 1
+
+          (nibbles.size/2).times.map do |i|
+            base = i*2
+            (16*nibbles[base] + nibbles[base+1]).chr
+          end.join
+        end
+
+        def terminator
+          new([NIBBLE_TERMINATOR])
+        end
+      end
+
+      def initialize(*args)
+        super
+      end
+
+      def terminate?
+        last == NIBBLE_TERMINATOR
+      end
+
+      ##
+      # Get with or without terminator copy of this {NibbleKey}.
+      #
+      # @param flag [Bool] set true to get a copy with terminator, otherwise
+      #   set false
+      #
+      # @return [NibbleKey] a copy with or without terminator at end
+      #
+      def terminate(flag)
+        dup.tap do |copy|
+          if flag
+            copy.push NIBBLE_TERMINATOR unless copy.terminate?
+          else
+            copy.pop if copy.terminate?
+          end
+        end
+      end
+
+      ##
+      # test whether this is prefix of another {NibbleKey}
+      #
+      # @param another_key [NibbleKey] the full key to test
+      #
+      # @return [Bool]
+      #
+      def prefix?(another_key)
+        return false if another_key.size < size
+        another_key.take(size) == self
+      end
+
+      ##
+      # Find common prefix to another key.
+      #
+      # @param another_key [Array] another array of nibbles
+      #
+      # @return [Array] common prefix of both nibbles array
+      #
+      def common_prefix(another_key)
+        prefix = []
+
+        [size, another_key.size].min.times do |i|
+          break if self[i] != another_key[i]
+          prefix.push self[i]
+        end
+
+        self.class.new prefix
+      end
+
+      def encode
+        self.class.encode self
+      end
+
+      def to_string
+        self.class.to_string self
+      end
+
+      def +(array)
+        self.class.new(super(array))
+      end
+
+    end
+
+  end
+end

data/lib/ethereum/utils.rb

@@ -0,0 +1,191 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'digest'
+require 'digest/sha3'
+require 'openssl'
+
+module Ethereum
+  module Utils
+
+    extend self
+
+    include Constant
+
+    ##
+    # Not the keccak in sha3, although it's underlying lib named SHA3
+    #
+    def keccak256(x)
+      Digest::SHA3.new(256).digest(x)
+    end
+
+    def keccak512(x)
+      Digest::SHA3.new(512).digest(x)
+    end
+
+    def keccak256_rlp(x)
+      keccak256 RLP.encode(x)
+    end
+
+    def sha256(x)
+      Digest::SHA256.digest x
+    end
+
+    def double_sha256(x)
+      sha256 sha256(x)
+    end
+
+    def ripemd160(x)
+      Digest::RMD160.digest x
+    end
+
+    def hash160(x)
+      ripemd160 sha256(x)
+    end
+
+    def hash160_hex(x)
+      encode_hex hash160(x)
+    end
+
+    def mod_exp(x, y, n)
+      x.to_bn.mod_exp(y, n).to_i
+    end
+
+    def mod_mul(x, y, n)
+      x.to_bn.mod_mul(y, n).to_i
+    end
+
+    def to_signed(i)
+      i > Constant::INT_MAX ? (i-Constant::TT256) : i
+    end
+
+    def base58_check_to_bytes(s)
+      leadingzbytes = s.match(/\A1*/)[0]
+      data = Constant::BYTE_ZERO * leadingzbytes.size + BaseConvert.convert(s, 58, 256)
+
+      raise ChecksumError, "double sha256 checksum doesn't match" unless double_sha256(data[0...-4])[0,4] == data[-4..-1]
+      data[1...-4]
+    end
+
+    def bytes_to_base58_check(bytes, magicbyte=0)
+      bs = "#{magicbyte.chr}#{bytes}"
+      leadingzbytes = bs.match(/\A#{Constant::BYTE_ZERO}*/)[0]
+      checksum = double_sha256(bs)[0,4]
+      '1'*leadingzbytes.size + BaseConvert.convert("#{bs}#{checksum}", 256, 58)
+    end
+
+    def ceil32(x)
+      x % 32 == 0 ? x : (x + 32 - x%32)
+    end
+
+    def encode_hex(b)
+      RLP::Utils.encode_hex b
+    end
+
+    def decode_hex(s)
+      RLP::Utils.decode_hex s
+    end
+
+    def big_endian_to_int(s)
+      RLP::Sedes.big_endian_int.deserialize s.sub(/\A(\x00)+/, '')
+    end
+
+    def int_to_big_endian(n)
+      RLP::Sedes.big_endian_int.serialize n
+    end
+
+    def lpad(x, symbol, l)
+      return x if x.size >= l
+      symbol * (l - x.size) + x
+    end
+
+    def rpad(x, symbol, l)
+      return x if x.size >= l
+      x + symbol * (l - x.size)
+    end
+
+    def zpad(x, l)
+      lpad x, BYTE_ZERO, l
+    end
+
+    def zunpad(x)
+      x.sub /\A\x00+/, ''
+    end
+
+    def zpad_int(n, l=32)
+      zpad encode_int(n), l
+    end
+
+    def zpad_hex(s, l=32)
+      zpad decode_hex(s), l
+    end
+
+    def int_to_addr(x)
+      zpad_int x, 20
+    end
+
+    def encode_int(n)
+      raise ArgumentError, "Integer invalid or out of range: #{n}" unless n.is_a?(Integer) && n >= 0 && n <= UINT_MAX
+      int_to_big_endian n
+    end
+
+    def decode_int(v)
+      raise ArgumentError, "No leading zero bytes allowed for integers" if v.size > 0 && (v[0] == Constant::BYTE_ZERO || v[0] == 0)
+      big_endian_to_int v
+    end
+
+    def bytearray_to_int(arr)
+      o = 0
+      arr.each {|x| o = (o << 8) + x }
+      o
+    end
+
+    def int_array_to_bytes(arr)
+      arr.pack('C*')
+    end
+
+    def bytes_to_int_array(bytes)
+      bytes.unpack('C*')
+    end
+
+    def coerce_to_int(x)
+      if x.is_a?(Numeric)
+        x
+      elsif x.size == 40
+        big_endian_to_int decode_hex(x)
+      else
+        big_endian_to_int x
+      end
+    end
+
+    def coerce_to_bytes(x)
+      if x.is_a?(Numeric)
+        int_to_big_endian x
+      elsif x.size == 40
+        decode_hex(x)
+      else
+        x
+      end
+    end
+
+    def coerce_addr_to_hex(x)
+      if x.is_a?(Numeric)
+        encode_hex zpad(int_to_big_endian(x), 20)
+      elsif x.size == 40 || x.size == 0
+        x
+      else
+        encode_hex zpad(x, 20)[-20..-1]
+      end
+    end
+
+    def normalize_address(x, allow_blank: false)
+      address = Address.new(x)
+      raise ValueError, "address is blank" if !allow_blank && address.blank?
+      address.to_bytes
+    end
+
+    def mk_contract_address(sender, nonce)
+      keccak256_rlp([normalize_address(sender), nonce])[12..-1]
+    end
+
+  end
+end

data/lib/ethereum/version.rb

@@ -0,0 +1,5 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  VERSION = '0.9.0'
+end

data/lib/ethereum/vm.rb

@@ -0,0 +1,606 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'ethereum/vm/call_data'
+require 'ethereum/vm/message'
+require 'ethereum/vm/state'
+
+module Ethereum
+  class VM
+
+    class <<self
+      def code_cache
+        @code_cache ||= {}
+      end
+
+      def execute(*args)
+        new.execute(*args)
+      end
+    end
+
+    include Constant
+
+    def execute(ext, msg, code)
+      s = State.new gas: msg.gas
+
+      if VM.code_cache.has_key?(code)
+        processed_code = VM.code_cache[code]
+      else
+        processed_code = preprocess_code code
+        VM.code_cache[code] = processed_code
+      end
+
+      # for trace only
+      steps = 0
+      _prevop = nil
+
+      timestamp = Time.now
+      loop do
+        return peaceful_exit('CODE OUT OF RANGE', s.gas, []) if s.pc >= processed_code.size
+
+        op, in_args, out_args, fee, opcode, pushval = processed_code[s.pc]
+
+        return vm_exception('OUT OF GAS') if fee > s.gas
+        return vm_exception('INSUFFICIENT STACK', op: op, needed: in_args, available: s.stack.size) if in_args > s.stack.size
+        return vm_exception('STACK SIZE LIMIT EXCEEDED', op: op, pre_height: s.stack.size) if (s.stack.size - in_args + out_args) > 1024
+
+        s.gas -= fee
+        s.pc += 1
+
+        # This diverges from normal logging, as we use the logging namespace
+        # only to decide which features get logged in 'eth.vm.op', i.e.
+        # tracing can not be activated by activating a sub like
+        # 'eth.vm.op.stack'.
+        if Logger.trace?(log_vm_exit.name)
+          trace_data = {
+            stack: s.stack.map(&:to_s),
+            gas: s.gas + fee,
+            inst: opcode,
+            pc: s.pc-1,
+            op: op,
+            steps: steps
+          }
+
+          if %i(MLOAD MSTORE MSTORE8 SHA3 CALL CALLCODE CREATE CALLDATACOPY CODECOPY EXTCODECOPY).include?(_prevop)
+            if s.memory.size < 1024
+              trace_data[:memory] = Utils.encode_hex(Utils.int_array_to_bytes(s.memory))
+            else
+              trace_data[:sha3memory] = Utils.encode_hex(Utils.keccak256(Utils.int_array_to_bytes(s.memory)))
+            end
+          end
+
+          if %i(SSTORE SLOAD).include?(_prevop) || steps == 0
+            trace_data[:storage] = ext.log_storage(msg.to)
+          end
+
+          if steps == 0
+            trace_data[:depth] = msg.depth
+            trace_data[:address] = msg.to
+          end
+
+          if op[0,4] == 'PUSH'
+            trace_data[:pushvalue] = pushval
+          end
+
+          log_vm_op.trace('vm', **trace_data)
+
+          steps += 1
+          _prevop = op
+        end
+
+        # Invalid operation
+        return vm_exception('INVALID OP', opcode: opcode) if op == :INVALID
+
+        # Valid operations
+        stk = s.stack
+        mem = s.memory
+        if opcode < 0x10 # Stop & Arithmetic Operations
+          case op
+          when :STOP
+            return peaceful_exit('STOP', s.gas, [])
+          when :ADD
+            r = (stk.pop + stk.pop) & UINT_MAX
+            stk.push r
+          when :SUB
+            r = (stk.pop - stk.pop) & UINT_MAX
+            stk.push r
+          when :MUL
+            r = (stk.pop * stk.pop) & UINT_MAX
+            stk.push r
+          when :DIV
+            s0, s1 = stk.pop, stk.pop
+            stk.push(s1 == 0 ? 0 : s0 / s1)
+          when :MOD
+            s0, s1 = stk.pop, stk.pop
+            stk.push(s1 == 0 ? 0 : s0 % s1)
+          when :SDIV
+            s0, s1 = Utils.to_signed(stk.pop), Utils.to_signed(stk.pop)
+            r = s1 == 0 ? 0 : ((s0.abs / s1.abs * (s0*s1 < 0 ? -1 : 1)) & UINT_MAX)
+            stk.push r
+          when :SMOD
+            s0, s1 = Utils.to_signed(stk.pop), Utils.to_signed(stk.pop)
+            r = s1 == 0 ? 0 : ((s0.abs % s1.abs * (s0 < 0 ? -1 : 1)) & UINT_MAX)
+            stk.push r
+          when :ADDMOD
+            s0, s1, s2 = stk.pop, stk.pop, stk.pop
+            r = s2 == 0 ? 0 : (s0+s1) % s2
+            stk.push r
+          when :MULMOD
+            s0, s1, s2 = stk.pop, stk.pop, stk.pop
+            r = s2 == 0 ? 0 : Utils.mod_mul(s0, s1, s2)
+            stk.push r
+          when :EXP
+            base, exponent = stk.pop, stk.pop
+
+            # fee for exponent is dependent on its bytes
+            # calc n bytes to represent exponent
+            nbytes = Utils.encode_int(exponent).size
+            expfee = nbytes * Opcodes::GEXPONENTBYTE
+            if s.gas < expfee
+              s.gas = 0
+              return vm_exception('OOG EXPONENT')
+            end
+
+            s.gas -= expfee
+            stk.push Utils.mod_exp(base, exponent, TT256)
+          when :SIGNEXTEND # extend sign from bytes at s0 to left
+            s0, s1 = stk.pop, stk.pop
+            if s0 < 32
+              testbit = s0*8 + 7
+              mask = 1 << testbit
+              if s1 & mask == 0 # extend 0s
+                stk.push(s1 & (mask - 1))
+              else # extend 1s
+                stk.push(s1 | (TT256 - mask))
+              end
+            else
+              stk.push s1
+            end
+          end
+        elsif opcode < 0x20 # Comparison & Bitwise Logic Operations
+          case op
+          when :LT
+            s0, s1 = stk.pop, stk.pop
+            stk.push(s0 < s1 ? 1 : 0)
+          when :GT
+            s0, s1 = stk.pop, stk.pop
+            stk.push(s0 > s1 ? 1 : 0)
+          when :SLT
+            s0, s1 = Utils.to_signed(stk.pop), Utils.to_signed(stk.pop)
+            stk.push(s0 < s1 ? 1 : 0)
+          when :SGT
+            s0, s1 = Utils.to_signed(stk.pop), Utils.to_signed(stk.pop)
+            stk.push(s0 > s1 ? 1 : 0)
+          when :EQ
+            s0, s1 = stk.pop, stk.pop
+            stk.push(s0 == s1 ? 1 : 0)
+          when :ISZERO
+            s0 = stk.pop
+            stk.push(s0 == 0 ? 1 : 0)
+          when :AND
+            s0, s1 = stk.pop, stk.pop
+            stk.push(s0 & s1)
+          when :OR
+            s0, s1 = stk.pop, stk.pop
+            stk.push(s0 | s1)
+          when :XOR
+            s0, s1 = stk.pop, stk.pop
+            stk.push(s0 ^ s1)
+          when :NOT
+            s0 = stk.pop
+            stk.push(UINT_MAX - s0)
+          when :BYTE
+            s0, s1 = stk.pop, stk.pop
+            if s0 < 32
+              stk.push((s1 / 256**(31-s0)) % 256)
+            else
+              stk.push(0)
+            end
+          end
+        elsif opcode < 0x40 # SHA3 & Environmental Information
+          case op
+          when :SHA3
+            s0, s1 = stk.pop, stk.pop
+
+            s.gas -= Opcodes::GSHA3WORD * (Utils.ceil32(s1) / 32)
+            return vm_exception('OOG PAYING FOR SHA3') if s.gas < 0
+
+            return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, s0, s1)
+
+            data = Utils.int_array_to_bytes mem.safe_slice(s0,s1)
+            stk.push Utils.big_endian_to_int(Utils.keccak256(data))
+          when :ADDRESS
+            stk.push Utils.coerce_to_int(msg.to)
+          when :BALANCE
+            s0 = stk.pop
+            addr = Utils.coerce_addr_to_hex(s0 % 2**160)
+            stk.push ext.get_balance(addr)
+          when :ORIGIN
+            stk.push Utils.coerce_to_int(ext.tx_origin)
+          when :CALLER
+            stk.push Utils.coerce_to_int(msg.sender)
+          when :CALLVALUE
+            stk.push msg.value
+          when :CALLDATALOAD
+            stk.push msg.data.extract32(stk.pop)
+          when :CALLDATASIZE
+            stk.push msg.data.size
+          when :CALLDATACOPY
+            mstart, dstart, size = stk.pop, stk.pop, stk.pop
+
+            return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, mstart, size)
+            return vm_exception('OOG COPY DATA') unless data_copy(s, size)
+
+            msg.data.extract_copy(mem, mstart, dstart, size)
+          when :CODESIZE
+            stk.push processed_code.size
+          when :CODECOPY
+            mstart, cstart, size = stk.pop, stk.pop, stk.pop
+
+            return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, mstart, size)
+            return vm_exception('OOG COPY CODE') unless data_copy(s, size)
+
+            size.times do |i|
+              if cstart + i < processed_code.size
+                mem[mstart+i] = processed_code[cstart+i][4] # copy opcode
+              else
+                mem[mstart+i] = 0
+              end
+            end
+          when :GASPRICE
+            stk.push ext.tx_gasprice
+          when :EXTCODESIZE
+            addr = stk.pop
+            addr = Utils.coerce_addr_to_hex(addr % 2**160)
+            stk.push (ext.get_code(addr) || Constant::BYTE_EMPTY).size
+          when :EXTCODECOPY
+            addr, mstart, cstart, size = stk.pop, stk.pop, stk.pop, stk.pop
+            addr = Utils.coerce_addr_to_hex(addr % 2**160)
+            extcode = ext.get_code(addr) || Constant::BYTE_EMPTY
+            raise ValueError, "extcode must be string" unless extcode.is_a?(String)
+
+            return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, mstart, size)
+            return vm_exception('OOG COPY CODE') unless data_copy(s, size)
+
+            size.times do |i|
+              if cstart + i < extcode.size
+                mem[mstart+i] = extcode[cstart+i].ord
+              else
+                mem[mstart+i] = 0
+              end
+            end
+          end
+        elsif opcode < 0x50 # Block Information
+          case op
+          when :BLOCKHASH
+            s0 = stk.pop
+            stk.push Utils.big_endian_to_int(ext.block_hash(s0))
+          when :COINBASE
+            stk.push Utils.big_endian_to_int(ext.block_coinbase)
+          when :TIMESTAMP
+            stk.push ext.block_timestamp
+          when :NUMBER
+            stk.push ext.block_number
+          when :DIFFICULTY
+            stk.push ext.block_difficulty
+          when :GASLIMIT
+            stk.push ext.block_gas_limit
+          end
+        elsif opcode < 0x60 # Stack, Memory, Storage and Flow Operations
+          case op
+          when :POP
+            stk.pop
+          when :MLOAD
+            s0 = stk.pop
+            return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, s0, 32)
+
+            data = Utils.int_array_to_bytes mem.safe_slice(s0, 32)
+            stk.push Utils.big_endian_to_int(data)
+          when :MSTORE
+            s0, s1 = stk.pop, stk.pop
+            return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, s0, 32)
+
+            32.times.to_a.reverse.each do |i|
+              mem[s0+i] = s1 % 256
+              s1 /= 256
+            end
+          when :MSTORE8
+            s0, s1 = stk.pop, stk.pop
+            return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, s0, 1)
+            mem[s0] = s1 % 256
+          when :SLOAD
+            s0 = stk.pop
+            stk.push ext.get_storage_data(msg.to, s0)
+          when :SSTORE
+            s0, s1 = stk.pop, stk.pop
+
+            if ext.get_storage_data(msg.to, s0) != 0
+              gascost = s1 == 0 ? Opcodes::GSTORAGEKILL : Opcodes::GSTORAGEMOD
+              refund = s1 == 0 ? Opcodes::GSTORAGEREFUND : 0
+            else
+              gascost = s1 == 0 ? Opcodes::GSTORAGEMOD : Opcodes::GSTORAGEADD
+              refund = 0
+            end
+
+            return vm_exception('OUT OF GAS') if s.gas < gascost
+
+            s.gas -= gascost
+            ext.add_refund refund
+            ext.set_storage_data msg.to, s0, s1
+          when :JUMP
+            s0 = stk.pop
+            s.pc = s0
+
+            op_new = s.pc < processed_code.size ? processed_code[s.pc][0] : :STOP
+            return vm_exception('BAD JUMPDEST') if op_new != :JUMPDEST
+          when :JUMPI
+            s0, s1 = stk.pop, stk.pop
+            if s1 != 0
+              s.pc = s0
+              op_new = s.pc < processed_code.size ? processed_code[s.pc][0] : :STOP
+              return vm_exception('BAD JUMPDEST') if op_new != :JUMPDEST
+            end
+          when :PC
+            stk.push(s.pc - 1)
+          when :MSIZE
+            stk.push mem.size
+          when :GAS
+            stk.push s.gas # AFTER subtracting cost 1
+          end
+        elsif op[0,Opcodes::PREFIX_PUSH.size] == Opcodes::PREFIX_PUSH
+          pushnum = op[Opcodes::PREFIX_PUSH.size..-1].to_i
+          s.pc += pushnum
+          stk.push pushval
+        elsif op[0,Opcodes::PREFIX_DUP.size] == Opcodes::PREFIX_DUP
+          depth = op[Opcodes::PREFIX_DUP.size..-1].to_i
+          stk.push stk[-depth]
+        elsif op[0,Opcodes::PREFIX_SWAP.size] == Opcodes::PREFIX_SWAP
+          depth = op[Opcodes::PREFIX_SWAP.size..-1].to_i
+          temp = stk[-depth - 1]
+          stk[-depth - 1] = stk[-1]
+          stk[-1] = temp
+        elsif op[0,Opcodes::PREFIX_LOG.size] == Opcodes::PREFIX_LOG
+          # 0xa0 ... 0xa4, 32/64/96/128/160 + data.size gas
+          #
+          # a. Opcodes LOG0...LOG4 are added, takes 2-6 stake arguments:
+          #      MEMSTART MEMSZ (TOPIC1) (TOPIC2) (TOPIC3) (TOPIC4)
+          #
+          # b. Logs are kept track of during tx execution exactly the same way
+          #    as suicides (except as an ordered list, not a set).
+          #
+          #    Each log is in the form [address, [topic1, ... ], data] where:
+          #    * address is what the ADDRESS opcode would output
+          #    * data is mem[MEMSTART, MEMSZ]
+          #    * topics are as provided by the opcode
+          #
+          # c. The ordered list of logs in the transation are expreseed as
+          #    [log0, log1, ..., logN].
+          #
+          depth = op[Opcodes::PREFIX_LOG.size..-1].to_i
+          mstart, msz = stk.pop, stk.pop
+          topics = depth.times.map {|i| stk.pop }
+
+          s.gas -= msz * Opcodes::GLOGBYTE
+
+          return vm_exception("OOG EXTENDING MEMORY") unless mem_extend(mem, s, mstart, msz)
+
+          data = mem.safe_slice(mstart, msz)
+          ext.log(msg.to, topics, Utils.int_array_to_bytes(data))
+          log_log.trace('LOG', to: msg.to, topics: topics, data: data)
+        elsif op == :CREATE
+          value, mstart, msz = stk.pop, stk.pop, stk.pop
+
+          return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, mstart, msz)
+
+          if ext.get_balance(msg.to) >= value && msg.depth < 1024
+            cd = CallData.new mem, mstart, msz
+            create_msg = Message.new(msg.to, Constant::BYTE_EMPTY, value, s.gas, cd, depth: msg.depth+1)
+
+            o, gas, addr = ext.create create_msg
+            if o.true?
+              stk.push Utils.coerce_to_int(addr)
+              s.gas = gas
+            else
+              stk.push 0
+              s.gas = 0
+            end
+          else
+            stk.push(0)
+          end
+        elsif op == :CALL
+          gas, to, value, memin_start, memin_sz, memout_start, memout_sz = \
+            stk.pop, stk.pop, stk.pop, stk.pop, stk.pop, stk.pop, stk.pop
+
+          return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, memin_start, memin_sz)
+          return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, memout_start, memout_sz)
+
+          to = Utils.zpad_int(to)[12..-1] # last 20 bytes
+          extra_gas = (ext.account_exists(to) ? 0 : 1) * Opcodes::GCALLNEWACCOUNT +
+            (value > 0 ? 1 : 0) * Opcodes::GCALLVALUETRANSFER
+          submsg_gas = gas + Opcodes::GSTIPEND * (value > 0 ? 1 : 0)
+          total_gas = gas + extra_gas
+
+          return vm_exception('OUT OF GAS', needed: total_gas) if s.gas < total_gas
+
+          if ext.get_balance(msg.to) >= value && msg.depth < 1024
+            s.gas -= total_gas
+
+            cd = CallData.new mem, memin_start, memin_sz
+            call_msg = Message.new(msg.to, to, value, submsg_gas, cd, depth: msg.depth+1, code_address: to)
+
+            result, gas, data = ext.apply_msg call_msg
+            if result == 0
+              stk.push 0
+            else
+              stk.push 1
+              s.gas += gas
+              [data.size, memout_sz].min.times do |i|
+                mem[memout_start+i] = data[i]
+              end
+            end
+          else
+            s.gas -= (total_gas - submsg_gas)
+            stk.push(0)
+          end
+        elsif op == :CALLCODE || op == :DELEGATECALL
+          if op == :CALLCODE
+            gas, to, value, memin_start, memin_sz, memout_start, memout_sz = \
+              stk.pop, stk.pop, stk.pop, stk.pop, stk.pop, stk.pop, stk.pop
+          else
+            gas, to, memin_start, memin_sz, memout_start, memout_sz = \
+              stk.pop, stk.pop, stk.pop, stk.pop, stk.pop, stk.pop
+            value = 0
+          end
+
+          return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, memin_start, memin_sz)
+          return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, memout_start, memout_sz)
+
+          extra_gas = (value > 0 ? 1 : 0) * Opcodes::GCALLVALUETRANSFER
+          submsg_gas = gas + Opcodes::GSTIPEND * (value > 0 ? 1 : 0)
+          total_gas = gas + extra_gas
+
+          return vm_exception('OUT OF GAS', needed: total_gas) if s.gas < total_gas
+
+          if ext.get_balance(msg.to) >= value && msg.depth < 1024
+            s.gas -= total_gas
+
+            to = Utils.zpad_int(to)[12..-1] # last 20 bytes
+            cd = CallData.new mem, memin_start, memin_sz
+
+            if ext.post_homestead_hardfork && op == :DELEGATECALL
+              call_msg = Message.new(msg.sender, msg.to, msg.value, submsg_gas, cd, depth: msg.depth+1, code_address: to, transfers_value: false)
+            elsif op == :DELEGATECALL
+              return vm_exception('OPCODE INACTIVE')
+            else
+              call_msg = Message.new(msg.to, msg.to, value, submsg_gas, cd, depth: msg.depth+1, code_address: to)
+            end
+
+            result, gas, data = ext.apply_msg call_msg
+            if result == 0
+              stk.push 0
+            else
+              stk.push 1
+              s.gas += gas
+              [data.size, memout_sz].min.times do |i|
+                mem[memout_start+i] = data[i]
+              end
+            end
+          else
+            s.gas -= (total_gas - submsg_gas)
+            stk.push(0)
+          end
+        elsif op == :RETURN
+          s0, s1 = stk.pop, stk.pop
+          return vm_exception('OOG EXTENDING MEMORY') unless mem_extend(mem, s, s0, s1)
+          return peaceful_exit('RETURN', s.gas, mem.safe_slice(s0, s1))
+        elsif op == :SUICIDE
+          s0 = stk.pop
+          to = Utils.zpad_int(s0)[12..-1] # last 20 bytes
+
+          xfer = ext.get_balance(msg.to)
+          ext.set_balance(to, ext.get_balance(to)+xfer)
+          ext.set_balance(msg.to, 0)
+          ext.add_suicide(msg.to)
+
+          return 1, s.gas, []
+        end
+      end
+    end
+
+    # Preprocesses code, and determines which locations are in the middle of
+    # pushdata and thus invalid
+    def preprocess_code(code)
+      code = Utils.bytes_to_int_array code
+      ops = []
+
+      i = 0
+      while i < code.size
+        o = Opcodes::TABLE.fetch(code[i], [:INVALID, 0, 0, 0]) + [code[i], 0]
+        ops.push o
+
+        if o[0][0,Opcodes::PREFIX_PUSH.size] == Opcodes::PREFIX_PUSH
+          n = o[0][Opcodes::PREFIX_PUSH.size..-1].to_i
+          n.times do |j|
+            i += 1
+            byte = i < code.size ? code[i] : 0
+            o[-1] = (o[-1] << 8) + byte
+
+            # polyfill, these INVALID ops will be skipped in execution
+            ops.push [:INVALID, 0, 0, 0, byte, 0] if i < code.size
+          end
+        end
+
+        i += 1
+      end
+
+      ops
+    end
+
+    private
+
+    def log_vm_exit
+      @log_vm_exit ||= Logger.new 'eth.vm.exit'
+    end
+
+    def log_vm_op
+      @log_vm_op ||= Logger.new 'eth.vm.op'
+    end
+
+    def log_log
+      @log_log ||= Logger.new 'eth.vm.log'
+    end
+
+    def vm_exception(error, **kwargs)
+      log_vm_exit.trace('EXCEPTION', cause: error, **kwargs)
+      return 0, 0, []
+    end
+
+    def peaceful_exit(cause, gas, data, **kwargs)
+      log_vm_exit.trace('EXIT', cause: cause, **kwargs)
+      return 1, gas, data
+    end
+
+    def mem_extend(mem, s, start, sz)
+      if sz > 0
+        oldsize = mem.size / 32
+        old_totalfee = mem_fee oldsize
+
+        newsize = Utils.ceil32(start + sz) / 32
+        new_totalfee = mem_fee newsize
+
+        if old_totalfee < new_totalfee
+          memfee = new_totalfee - old_totalfee
+
+          if s.gas < memfee
+            s.gas = 0
+            return false
+          end
+          s.gas -= memfee
+
+          m_extend = (newsize - oldsize) * 32
+          mem.concat([0]*m_extend)
+        end
+      end
+
+      true
+    end
+
+    def data_copy(s, sz)
+      if sz > 0
+        copyfee = Opcodes::GCOPY * Utils.ceil32(sz) / 32
+
+        if s.gas < copyfee
+          s.gas = 0
+          return false
+        end
+        s.gas -= copyfee
+      end
+
+      true
+    end
+
+    def mem_fee(sz)
+      sz * Opcodes::GMEMORY + sz**2 / Opcodes::GQUADRATICMEMDENOM
+    end
+
+  end
+end