ciri 0.0.1 → 0.0.2

data/lib/ciri/{utils/lib_c.rb → evm/errors.rb}

@@ -21,25 +21,35 @@
 # THE SOFTWARE.
 
 
-require 'ffi'
-
 module Ciri
-  module Utils
-
-    module LibC
-      extend FFI::Library
-      ffi_lib FFI::Library::LIBC
-
-      # memory allocators
-      attach_function :malloc, [:size_t], :pointer
-      attach_function :calloc, [:size_t], :pointer
-      attach_function :valloc, [:size_t], :pointer
-      attach_function :realloc, [:pointer, :size_t], :pointer
-      attach_function :free, [:pointer], :void
-
-      # memory movers
-      attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
-      attach_function :bcopy, [:pointer, :pointer, :size_t], :void
+  class EVM
+
+    class Error < StandardError
+    end
+
+    class InvalidTransition < Error
+    end
+
+    class InvalidTransaction < Error
+    end
+
+    # VM errors
+    class VMError < Error
+    end
+
+    class InvalidOpCodeError < VMError
+    end
+
+    class GasNotEnoughError < VMError
+    end
+
+    class StackError < VMError
+    end
+
+    class InvalidJumpError < VMError
+    end
+
+    class ReturnError < VMError
     end
 
   end

data/lib/ciri/evm/instruction.rb

@@ -37,7 +37,9 @@ module Ciri
       end
 
       def get_op(pos)
-        return OP::INVALID if pos >= (bytes_code || ''.b).size
+        code_size = (bytes_code || ''.b).size
+        return OP::STOP if pos == code_size
+        return OP::INVALID if pos >= code_size
         bytes_code[pos].ord
       end
 

data/lib/ciri/evm/{serialize.rb → log_entry.rb}

@@ -21,40 +21,22 @@
 # THE SOFTWARE.
 
 
+require 'ciri/rlp'
+require 'ciri/utils'
 require 'ciri/types/address'
+require 'ciri/types/number'
 
 module Ciri
   class EVM
-    module Serialize
 
-      extend self
+    class LogEntry
+      include RLP::Serializable
+      schema [{address: Types::Address}, {topics: [Types::Int32]}, :data]
 
-      def serialize(item)
-        case item
-        when Integer
-          Utils.big_endian_encode(item)
-        when Types::Address
-          item.to_s
-        else
-          item
-        end
+      def to_blooms
+        [address.to_s, *topics.map {|t| Utils.big_endian_encode(t, size: 32)}]
       end
-
-      def deserialize(type, item)
-        if type == Integer && !item.is_a?(Integer)
-          Utils.big_endian_decode(item.to_s)
-        elsif type == Types::Address && !item.is_a?(Types::Address)
-          # check if address represent in Integer
-          item = Utils.big_endian_encode(item) if item.is_a?(Integer)
-          Types::Address.new(item.size >= 20 ? item[-20..-1] : ''.b)
-        elsif type.nil?
-          # get serialized word
-          serialize(item).rjust(32, "\x00".b)
-        else
-          item
-        end
-      end
-
     end
+
   end
 end

data/lib/ciri/evm/machine_state.rb

@@ -21,13 +21,32 @@
 # THE SOFTWARE.
 
 
-require_relative 'serialize'
+require 'ciri/serialize'
+require 'ciri/evm/errors'
 
 module Ciri
   class EVM
 
     # represent current vm status, include stack, memory..
-    MachineState = Struct.new(:gas_remain, :pc, :memory, :memory_item, :stack, :output, keyword_init: true) do
+    class MachineState
+
+      attr_reader :remain_gas, :memory, :stack
+      attr_accessor :pc, :output, :memory_item
+
+      def initialize(remain_gas:, pc:, memory:, memory_item:, stack:, output: ''.b)
+        raise ArgumentError.new("remain_gas must more than 0") if remain_gas < 0
+        @remain_gas = remain_gas
+        @pc = pc
+        @memory = memory
+        @memory_item = memory_item
+        @stack = stack
+        @output = output
+      end
+
+      def consume_gas(gas)
+        raise GasNotEnoughError.new("can't consume gas to negative, remain_gas: #{remain_gas}, consumed: #{gas}") if gas > remain_gas
+        @remain_gas -= gas
+      end
 
       # fetch a list of items from stack
       def pop_list(count, type = nil)

data/lib/ciri/evm/op.rb

@@ -24,7 +24,6 @@
 require 'ciri/utils'
 require 'ciri/utils/number'
 require 'ciri/types/address'
-require_relative 'serialize'
 
 module Ciri
   class EVM
@@ -267,7 +266,7 @@ module Ciri
 
       def_op :EXTCODESIZE, 0x3b, 0, 1 do |vm|
         address = vm.pop(Address)
-        code_size = vm.find_account(address).code&.size || 0
+        code_size = vm.get_account_code(address).size
         vm.push code_size
       end
 
@@ -275,8 +274,7 @@ module Ciri
         address = vm.pop(Address)
         mem_pos, data_pos, size = vm.pop_list(3, Integer)
 
-        account = vm.find_account(address)
-        code = account.code || ''.b
+        code = vm.get_account_code(address)
         data_end_pos = data_pos + size - 1
         data = if data_pos >= code.size
                  ''.b
@@ -340,13 +338,13 @@ module Ciri
       end
 
       def_op :SLOAD, 0x54, 1, 1 do |vm|
-        key = vm.pop
+        key = vm.pop(Integer)
         vm.push vm.fetch(vm.instruction.address, key)
       end
 
       def_op :SSTORE, 0x55, 2, 0 do |vm|
-        key = vm.pop
-        value = vm.pop
+        key = vm.pop(Integer)
+        value = vm.pop(Integer)
 
         vm.store(vm.instruction.address, key, value)
       end
@@ -374,7 +372,7 @@ module Ciri
       end
 
       def_op :GAS, 0x5a, 0, 1 do |vm|
-        vm.push vm.machine_state.gas_remain
+        vm.push vm.machine_state.remain_gas
       end
 
       def_op :JUMPDEST, 0x5b, 0, 0
@@ -421,7 +419,7 @@ module Ciri
             pos, size = vm.pop_list(2, Integer)
             log_data = vm.memory_fetch(pos, size)
             vm.extend_memory(pos, size)
-            topics = vm.pop_list(i)
+            topics = vm.pop_list(i, Integer)
             vm.add_log_entry(topics, log_data)
           end
         end.call(i))
@@ -435,7 +433,7 @@ module Ciri
         init = vm.memory_fetch(mem_pos, size)
         vm.extend_memory(mem_pos, size)
 
-        contract_address = vm.create_contract(value: value, init: init)
+        contract_address, _ = vm.create_contract(value: value, init: init)
         vm.push contract_address
       end
 
@@ -504,7 +502,13 @@ module Ciri
       end
 
       STATICCALL = 0xfa
-      REVERT = 0xfd
+
+      # TODO REVERT need to be implement in forks
+      def_op :REVERT, -0xfd, 2, 0 do |vm|
+        index, size = vm.pop_list(2, Integer)
+        vm.output = vm.memory_fetch(index, size)
+        vm.extend_memory(index, size)
+      end
 
       def_op :INVALID, 0xfe, 0, 0 do |vm|
         raise 'should not invoke INVALID'
@@ -514,7 +518,6 @@ module Ciri
         refund_address = vm.pop(Address)
         refund_account = vm.find_account(refund_address)
 
-        vm.sub_state.suicide_accounts << vm.instruction.address
         contract_account = vm.find_account vm.instruction.address
 
         if refund_address != vm.instruction.address
@@ -523,12 +526,12 @@ module Ciri
 
         contract_account.balance = 0
 
-        vm.update_account(refund_account)
-        vm.update_account(contract_account)
+        vm.state.set_balance(refund_address, refund_account.balance)
+        vm.state.set_balance(vm.instruction.address, contract_account.balance)
 
         # register changed accounts
-        vm.add_refund_account(refund_account)
-        vm.add_suicide_account(contract_account)
+        vm.add_refund_account(refund_address)
+        vm.add_suicide_account(vm.instruction.address)
       end
 
     end

data/lib/ciri/evm/state.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require 'forwardable'
+require 'ciri/db/account_db'
+
+module Ciri
+  class EVM
+    class State
+
+      extend Forwardable
+
+      def_delegators :@account_db, :set_nonce, :increment_nonce, :set_balance, :add_balance, :touch_account,
+                     :find_account, :delete_account, :account_dead?, :store, :fetch, :set_account_code, :get_account_code
+
+      def initialize(db, state_root: nil)
+        @db = db
+        @account_db = DB::AccountDB.new(db, root_hash: state_root)
+      end
+
+      def snapshot
+        [state_root, @db.dup]
+      end
+
+      def revert(snapshot)
+        state_root, db = snapshot
+        @db = db
+        @account_db = DB::AccountDB.new(db, root_hash: state_root)
+      end
+
+      def commit(snapshot)
+        true
+      end
+
+      def state_root
+        @account_db.root_hash
+      end
+
+    end
+  end
+end

data/lib/ciri/evm/vm.rb

@@ -21,11 +21,13 @@
 # THE SOFTWARE.
 
 
+require 'ciri/utils/logger'
+require_relative 'errors'
 require_relative 'machine_state'
 require_relative 'instruction'
 require_relative 'sub_state'
 require_relative 'block_info'
-require_relative 'serialize'
+require_relative 'log_entry'
 
 module Ciri
   class EVM
@@ -40,25 +42,12 @@ module Ciri
     # other logic of EVM (include transaction logic) in EVM module.
     class VM
 
-      class VMError < StandardError
-      end
-      class InvalidOpCodeError < VMError
-      end
-      class GasNotEnoughError < VMError
-      end
-      class StackError < VMError
-      end
-      class InvalidJumpError < VMError
-      end
-      class ReturnError < VMError
-      end
-
       class << self
         # this method provide a simpler interface to create VM and execute code
         # VM.spawn(...) == VM.new(...)
         # @return VM
-        def spawn(state:, gas_limit:, header: nil, block_info: nil, instruction:, fork_config:)
-          ms = MachineState.new(gas_remain: gas_limit, pc: 0, stack: [], memory: "\x00".b * 256, memory_item: 0)
+        def spawn(state:, gas_limit:, header: nil, block_info: nil, instruction: EVM::Instruction.new, fork_config:)
+          ms = MachineState.new(remain_gas: gas_limit, pc: 0, stack: [], memory: "\x00".b * 256, memory_item: 0)
 
           block_info = block_info || header && BlockInfo.new(
             coinbase: header.beneficiary,
@@ -84,17 +73,18 @@ module Ciri
 
       # helper methods
       include Utils::Logger
-      include Serialize
 
-      def_delegators :@machine_state, :stack, :pc, :pop, :push, :pop_list, :get_stack,
-                     :memory_item, :memory_item=, :memory_store, :memory_fetch, :extend_memory
+      def_delegators :@machine_state, :stack, :pc, :pop, :push, :pop_list, :get_stack, :memory_item, :memory_item=,
+                     :memory_store, :memory_fetch, :extend_memory, :remain_gas, :consume_gas
       def_delegators :@instruction, :get_op, :get_code, :next_valid_instruction_pos, :get_data, :data, :sender
       def_delegators :@sub_state, :add_refund_account, :add_touched_account, :add_suicide_account
+      def_delegators :@state, :find_account, :account_dead?, :store, :fetch, :set_account_code, :get_account_code
 
-      attr_reader :machine_state, :instruction, :sub_state, :block_info, :fork_config
+      attr_reader :state, :machine_state, :instruction, :sub_state, :block_info, :fork_config
       attr_accessor :output, :exception
 
-      def initialize(state:, machine_state:, sub_state: nil, instruction:, block_info:, fork_config:)
+      def initialize(state:, machine_state:, sub_state: nil, instruction:, block_info:,
+                     fork_config:, burn_gas_on_exception: true)
         @state = state
         @machine_state = machine_state
         @instruction = instruction
@@ -102,31 +92,7 @@ module Ciri
         @output = nil
         @block_info = block_info
         @fork_config = fork_config
-      end
-
-      # store data to address
-      def store(address, key, data)
-        data_is_blank = Ciri::Utils.blank_binary?(data)
-        # key_is_blank = Ciri::Utils.blank_binary?(key)
-
-        return unless data && !data_is_blank
-
-        # remove unnecessary null byte from key
-        key = serialize(key).gsub(/\A\0+/, ''.b)
-        key = "\x00".b if key.empty?
-
-        account = find_account address
-        account.storage[key] = serialize(data).rjust(32, "\x00".b)
-        update_account(account)
-      end
-
-      # fetch data from address
-      def fetch(address, key)
-        # remove unnecessary null byte from key
-        key = serialize(key).gsub(/\A\0+/, ''.b)
-        key = "\x00".b if key.empty?
-
-        find_account(address).storage[key] || ''.b
+        @burn_gas_on_exception = burn_gas_on_exception
       end
 
       # run vm
@@ -138,21 +104,22 @@ module Ciri
       # low_level create_contract interface
       # CREATE_CONTRACT op is based on this method
       def create_contract(value:, init:)
-        account = find_account(instruction.address)
+        caller_address = instruction.address
+        account = find_account(caller_address)
 
         # return contract address 0 represent execution failed
         return 0 unless account.balance >= value || instruction.execute_depth > 1024
 
-        account.nonce += 1
+        state.increment_nonce(caller_address)
+        snapshot = state.snapshot
 
         # generate contract_address
-        material = RLP.encode_simple([instruction.address.to_s, account.nonce - 1])
+        material = RLP.encode_simple([caller_address.to_s, account.nonce])
         contract_address = Utils.sha3(material)[-20..-1]
 
         # initialize contract account
         contract_account = find_account(contract_address)
-        contract_account.nonce = 1
-        contract_account.code = Utils::BLANK_SHA3
+        # contract_account.nonce = 1
 
         # execute initialize code
         create_contract_instruction = instruction.dup
@@ -160,34 +127,48 @@ module Ciri
         create_contract_instruction.execute_depth += 1
         create_contract_instruction.address = contract_address
 
+        # TODO refactoring: Maybe should use call_message to execute data
         call_instruction(create_contract_instruction) do
           execute
 
-          if exception
-            update_account(Account.new_empty(contract_address))
+          deposit_code_gas = fork_config.calculate_deposit_code_gas(output)
+
+          if deposit_code_gas > remain_gas
+            # deposit_code_gas not enough
+            contract_address = 0
+          elsif exception
+            state.touch_account(contract_address)
             contract_address = 0
+            state.revert(snapshot)
           else
             # set contract code
-            contract_account.code = output || ''.b
+            set_account_code(contract_address, output)
+            # minus deposit_code_fee
+            machine_state.consume_gas deposit_code_gas
             # transact value
             account.balance -= value
             contract_account.balance += value
+
+            state.set_balance(contract_address, contract_account.balance)
+            state.set_balance(caller_address, account.balance)
+            state.commit(snapshot)
           end
+          [contract_address, exception]
         end
-
-        # update account
-        update_account(contract_account)
-        update_account(account)
-
-        contract_address
       end
 
       # low level call message interface
       # CALL, CALLCODE, DELEGATECALL ops is base on this method
-      def call_message(sender:, value:, receipt:, data:, code_address:)
+      def call_message(sender:, value:, receipt:, data:, code_address: receipt)
         # return status code 0 represent execution failed
         return [0, ''.b] unless value <= find_account(sender).balance && instruction.execute_depth <= 1024
 
+        state.increment_nonce(sender)
+
+        snapshot = state.snapshot
+
+        transact(sender: sender, value: value, to: receipt)
+
         message_call_instruction = instruction.dup
         message_call_instruction.address = receipt
         message_call_instruction.sender = sender
@@ -196,54 +177,48 @@ module Ciri
         message_call_instruction.execute_depth += 1
 
         message_call_instruction.data = data
-        message_call_instruction.bytes_code = find_account(code_address).code || ''.b
+        message_call_instruction.bytes_code = get_account_code(code_address)
 
-        transact(sender: sender, value: value, to: receipt)
         call_instruction(message_call_instruction) do
           execute
-          status = exception.nil? ? 0 : 1
-          [status, output || ''.b]
+
+          if exception
+            state.revert(snapshot)
+          else
+            state.commit(snapshot)
+          end
+
+          [status, output || ''.b, exception]
         end
       end
 
+      def status
+        exception.nil? ? 0 : 1
+      end
+
       # jump to pc
       # only valid if current op code is allowed to modify pc
       def jump_to(pc)
         @jump_to = pc
       end
 
-      def account_dead?(address)
-        Account.account_dead?(@state, address)
-      end
-
-      def find_account(address)
-        Account.find_account(@state, address)
-      end
-
-      # the only method which touch state
-      # VM do not consider state revert/commit, we let it to state implementation
-      def update_account(account)
-        address = account.address.to_s
-        @state[address] = account
-        add_touched_account(account)
-      end
-
       def add_log_entry(topics, log_data)
-        sub_state.log_series << [instruction.address, topics, log_data]
+        sub_state.log_series << LogEntry.new(address: instruction.address, topics: topics, data: log_data)
       end
 
       # transact value from sender to target address
       def transact(sender:, value:, to:)
-        sender = find_account(sender)
-        to = find_account(to)
+        sender_account = find_account(sender)
+        to_account = find_account(to)
 
-        raise VMError.new("balance not enough") if sender.balance < value
+        raise VMError.new("balance not enough") if sender_account.balance < value
 
-        sender.balance -= value
-        to.balance += value
+        sender_account.balance -= value
+        to_account.balance += value
 
-        update_account(sender)
-        update_account(to)
+        state.set_nonce(sender, sender_account.nonce)
+        state.set_balance(sender, sender_account.balance)
+        state.set_balance(to, to_account.balance)
       end
 
       # call instruction
@@ -268,13 +243,14 @@ module Ciri
       def execute
         loop do
           if (@exception ||= check_exception(@state, machine_state, instruction))
-            debug("exception: #{@exception}")
+            if @burn_gas_on_exception
+              debug("exception: #{@exception}, burn gas #{machine_state.remain_gas} to zero")
+              machine_state.consume_gas machine_state.remain_gas
+            end
             return [EMPTY_SET, machine_state, SubState::EMPTY, instruction, EMPTY_SET]
           elsif get_op(machine_state.pc) == OP::REVERT
             o = halt
-            gas_cost = fork_config.cost_of_operation[self]
-            machine_state.gas_remain -= gas_cost
-            return [EMPTY_SET, machine_state, sub_state, instruction, o]
+            return [EMPTY_SET, machine_state, SubState::EMPTY, instruction, o]
           elsif (o = halt) != EMPTY_SET
             return [@state, machine_state, sub_state, instruction, o]
           else
@@ -294,23 +270,23 @@ module Ciri
 
         raise "can't find operation #{w}, pc #{ms.pc}" unless operation
 
-        op_cost = fork_config.cost_of_operation[self]
-        old_memory_cost = fork_config.cost_of_memory[ms.memory_item]
-        ms.gas_remain -= op_cost
+        op_cost = fork_config.gas_of_operation(self)
+        old_memory_cost = fork_config.gas_of_memory(ms.memory_item)
+        ms.consume_gas op_cost
 
         prev_sub_state = sub_state.dup
 
         # call operation
         operation.call(self)
         # calculate gas_cost
-        new_memory_cost = fork_config.cost_of_memory[ms.memory_item]
+        new_memory_cost = fork_config.gas_of_memory(ms.memory_item)
         memory_gas_cost = new_memory_cost - old_memory_cost
 
-        if ms.gas_remain >= memory_gas_cost
-          ms.gas_remain -= memory_gas_cost
+        if ms.remain_gas >= memory_gas_cost
+          ms.consume_gas memory_gas_cost
         else
           # memory gas_not_enough
-          @exception = GasNotEnoughError.new "gas not enough: gas remain:#{ms.gas_remain} gas cost: #{memory_gas_cost}"
+          @exception = GasNotEnoughError.new "gas not enough: gas remain:#{ms.remain_gas} gas cost: #{memory_gas_cost}"
         end
 
         # revert sub_state and return if exception occur
@@ -356,8 +332,8 @@ module Ciri
           InvalidOpCodeError.new "can't find op code #{w}"
         when ms.stack.size < (consume = OP.input_count(w))
           StackError.new "stack not enough: stack:#{ms.stack.size} next consume: #{consume}"
-        when ms.gas_remain < (gas_cost = fork_config.cost_of_operation[self])
-          GasNotEnoughError.new "gas not enough: gas remain:#{ms.gas_remain} gas cost: #{gas_cost}"
+        when ms.remain_gas < (gas_cost = fork_config.gas_of_operation(self))
+          GasNotEnoughError.new "gas not enough: gas remain:#{ms.remain_gas} gas cost: #{gas_cost}"
         when w == OP::JUMP && instruction.destinations.include?(ms.get_stack(0, Integer))
           InvalidJumpError.new "invalid jump dest #{ms.get_stack(0, Integer)}"
         when w == OP::JUMPI && ms.get_stack(1, Integer) != 0 && instruction.destinations.include?(ms.get_stack(0, Integer))