ciri 0.0.2 → 0.0.3

data/lib/ciri/evm/sub_state.rb

@@ -1,24 +1,18 @@
 # frozen_string_literal: true
 
-# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+# Copyright 2018 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:
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
 #
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
+#     http://www.apache.org/licenses/LICENSE-2.0
 #
-# 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.
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 
 module Ciri
@@ -27,17 +21,17 @@ module Ciri
     # sub state contained changed accounts and log_series
     class SubState
 
-      EMPTY = SubState.new.freeze
-
       attr_reader :suicide_accounts, :log_series, :touched_accounts, :refunds
 
       def initialize(suicide_accounts: [], log_series: [], touched_accounts: [], refunds: [])
-        @suicide_accounts = Set.new(suicide_accounts)
+        @suicide_accounts = suicide_accounts
         @log_series = log_series
-        @touched_accounts = Set.new(touched_accounts)
-        @refunds = Set.new(refunds)
+        @touched_accounts = touched_accounts
+        @refunds = refunds
       end
 
+      EMPTY = SubState.new.freeze
+
       # support safety copy
       def initialize_copy(orig)
         super
@@ -48,15 +42,15 @@ module Ciri
       end
 
       def add_refund_account(account)
-        @refunds.add account
+        @refunds << account
       end
 
       def add_touched_account(account)
-        @touched_accounts.add account
+        @touched_accounts << account
       end
 
       def add_suicide_account(account)
-        @suicide_accounts.add account
+        @suicide_accounts << account
       end
     end
 

data/lib/ciri/evm/vm.rb

@@ -1,34 +1,31 @@
 # frozen_string_literal: true
 
-# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+# Copyright 2018 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:
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
 #
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
+#     http://www.apache.org/licenses/LICENSE-2.0
 #
-# 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.
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 
 require 'ciri/utils/logger'
+require 'ciri/core_ext'
 require_relative 'errors'
+require_relative 'execution_context'
 require_relative 'machine_state'
 require_relative 'instruction'
 require_relative 'sub_state'
 require_relative 'block_info'
 require_relative 'log_entry'
 
+using Ciri::CoreExt
 module Ciri
   class EVM
 
@@ -42,57 +39,30 @@ module Ciri
     # other logic of EVM (include transaction logic) in EVM module.
     class VM
 
-      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: 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,
-            difficulty: header.difficulty,
-            gas_limit: header.gas_limit,
-            number: header.number,
-            timestamp: header.timestamp
-          )
-
-          vm = VM.new(
-            state: state,
-            machine_state: ms,
-            block_info: block_info,
-            instruction: instruction,
-            fork_config: fork_config
-          )
-          yield vm if block_given?
-          vm
-        end
-      end
-
       extend Forwardable
 
       # helper methods
       include Utils::Logger
 
-      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
+      def_delegators :machine_state, :stack, :pop, :push, :pop_list, :get_stack, :memory_item, :memory_item=,
+                     :memory_store, :memory_fetch, :extend_memory
+      def_delegators :state, :find_account, :account_dead?, :store, :fetch,
+                     :set_account_code, :get_account_code, :account_exist?
 
-      attr_reader :state, :machine_state, :instruction, :sub_state, :block_info, :fork_config
-      attr_accessor :output, :exception
+      # delegate methods to current execution_context
+      def_delegators :execution_context, :instruction, :sub_state, :machine_state, :block_info, :fork_schema,
+                     :pc, :output, :exception, :set_output, :set_exception, :set_pc, :status, :depth,
+                     :gas_limit, :refund_gas, :reset_refund_gas, :consume_gas, :remain_gas, :jump_to, :jump_pc
+      def_delegators :instruction, :get_op, :get_code, :next_valid_instruction_pos, :get_data, :data, :sender, :destinations
+      def_delegators :sub_state, :add_refund_account, :add_touched_account, :add_suicide_account
 
-      def initialize(state:, machine_state:, sub_state: nil, instruction:, block_info:,
-                     fork_config:, burn_gas_on_exception: true)
+      attr_reader :state, :execution_context, :burn_gas_on_exception, :max_depth, :stack_size
+
+      def initialize(state:, burn_gas_on_exception: true, max_depth: 1024, stack_size: 1024)
         @state = state
-        @machine_state = machine_state
-        @instruction = instruction
-        @sub_state = sub_state || SubState.new
-        @output = nil
-        @block_info = block_info
-        @fork_config = fork_config
         @burn_gas_on_exception = burn_gas_on_exception
+        @max_depth = max_depth
+        @stack_size = stack_size
       end
 
       # run vm
@@ -103,54 +73,52 @@ module Ciri
 
       # low_level create_contract interface
       # CREATE_CONTRACT op is based on this method
-      def create_contract(value:, init:)
-        caller_address = instruction.address
+      def create_contract(context: self.execution_context)
+        caller_address = context.instruction.sender
+        value = context.instruction.value
         account = find_account(caller_address)
 
         # return contract address 0 represent execution failed
-        return 0 unless account.balance >= value || instruction.execute_depth > 1024
-
-        state.increment_nonce(caller_address)
+        return 0 unless account.balance >= value || depth > max_depth
         snapshot = state.snapshot
 
         # generate contract_address
-        material = RLP.encode_simple([caller_address.to_s, account.nonce])
-        contract_address = Utils.sha3(material)[-20..-1]
+        material = RLP.encode_simple([caller_address.to_s, account.nonce - 1])
+        contract_address = Utils.keccak(material)[-20..-1]
+
+        transact(sender: caller_address, value: value, to: contract_address)
 
         # initialize contract account
         contract_account = find_account(contract_address)
-        # contract_account.nonce = 1
-
-        # execute initialize code
-        create_contract_instruction = instruction.dup
-        create_contract_instruction.bytes_code = init
-        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
+        context.instruction.address = contract_address
+        with_context(context) do
+          if contract_account.has_code? || contract_account.nonce > 0
+            err = ContractCollisionError.new("address #{contract_address.to_hex} collision")
+            debug(err.message)
+            set_exception(err)
+          else
+            execute
+          end
 
-          deposit_code_gas = fork_config.calculate_deposit_code_gas(output)
+          deposit_code_gas = fork_schema.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)
+            # state.touch_account(contract_address)
             contract_address = 0
+            if burn_gas_on_exception
+              debug("exception: #{exception}, burn gas #{remain_gas} to zero... op code: 0x#{get_op(pc).to_s(16)}")
+              consume_gas remain_gas
+            end
+            execution_context.revert
             state.revert(snapshot)
           else
             # set contract code
             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)
+            consume_gas deposit_code_gas
             state.commit(snapshot)
           end
           [contract_address, exception]
@@ -159,30 +127,34 @@ module Ciri
 
       # low level call message interface
       # CALL, CALLCODE, DELEGATECALL ops is base on this method
-      def call_message(sender:, value:, receipt:, data:, code_address: receipt)
+      def call_message(context: self.execution_context, code_address: context.instruction.address)
+        address = context.instruction.address
+        value = context.instruction.value
+        sender = context.instruction.sender
         # return status code 0 represent execution failed
-        return [0, ''.b] unless value <= find_account(sender).balance && instruction.execute_depth <= 1024
-
-        state.increment_nonce(sender)
+        return [0, ''.b] unless value <= find_account(sender).balance && depth <= max_depth
 
         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
-        message_call_instruction.value = value
-
-        message_call_instruction.execute_depth += 1
-
-        message_call_instruction.data = data
-        message_call_instruction.bytes_code = get_account_code(code_address)
-
-        call_instruction(message_call_instruction) do
-          execute
+        transact(sender: sender, value: value, to: address)
+        # enter new execution context
+        with_context(context) do
+          begin
+            if (precompile_contract = fork_schema.find_precompile_contract(code_address))
+              precompile_contract.call(self)
+            else
+              execute
+            end
+          rescue GasNotEnoughError => e
+            set_exception(e)
+          end
 
           if exception
+            if burn_gas_on_exception
+              debug("exception: #{exception}, burn gas #{remain_gas} to zero... op code: 0x#{get_op(pc).to_s(16)}")
+              consume_gas remain_gas
+            end
+            execution_context.revert
+
             state.revert(snapshot)
           else
             state.commit(snapshot)
@@ -192,16 +164,6 @@ module Ciri
         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 add_log_entry(topics, log_data)
         sub_state.log_series << LogEntry.new(address: instruction.address, topics: topics, data: log_data)
       end
@@ -209,50 +171,23 @@ module Ciri
       # transact value from sender to target address
       def transact(sender:, value:, to:)
         sender_account = find_account(sender)
-        to_account = find_account(to)
-
         raise VMError.new("balance not enough") if sender_account.balance < value
-
-        sender_account.balance -= value
-        to_account.balance += value
-
-        state.set_nonce(sender, sender_account.nonce)
-        state.set_balance(sender, sender_account.balance)
-        state.set_balance(to, to_account.balance)
-      end
-
-      # call instruction
-      def call_instruction(new_instruction)
-        origin_instruction = instruction
-        origin_pc = pc
-        @instruction = new_instruction
-        @machine_state.pc = 0
-
-        return_value = yield
-
-        @instruction = origin_instruction
-        @machine_state.pc = origin_pc
-        # clear up state
-        @exception = nil
-        @output = ''.b
-        return_value
+        state.add_balance(sender, -value)
+        state.add_balance(to, value)
       end
 
       # Execute instruction with states
       # Ξ(σ,g,I,T) ≡ (σ′,μ′ ,A,o)
       def execute
         loop do
-          if (@exception ||= check_exception(@state, machine_state, instruction))
-            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
+          if exception || set_exception(check_exception(@state, machine_state, instruction))
+            debug("check exception: #{exception}")
+            return
+          elsif get_op(pc) == OP::REVERT
             o = halt
-            return [EMPTY_SET, machine_state, SubState::EMPTY, instruction, o]
+            return
           elsif (o = halt) != EMPTY_SET
-            return [@state, machine_state, sub_state, instruction, o]
+            return
           else
             operate
             next
@@ -260,55 +195,60 @@ module Ciri
         end
       end
 
+      def with_context(new_context)
+        origin_context = execution_context
+        @execution_context = new_context
+        return_value = yield
+        @execution_context = origin_context
+        return_value
+      end
+
+      def extend_memory(pos, size)
+        machine_state.extend_memory(execution_context, pos, size)
+      end
+
       private
 
       # O(σ, μ, A, I) ≡ (σ′, μ′, A′, I)
       def operate
-        ms = machine_state
-        w = get_op(ms.pc)
+        w = get_op(pc)
         operation = OP.get(w)
 
-        raise "can't find operation #{w}, pc #{ms.pc}" unless operation
+        raise "can't find operation #{w}, pc #{pc}" unless operation
 
-        op_cost = fork_config.gas_of_operation(self)
-        old_memory_cost = fork_config.gas_of_memory(ms.memory_item)
-        ms.consume_gas op_cost
+        op_cost, op_refund = fork_schema.gas_of_operation(self)
 
-        prev_sub_state = sub_state.dup
+        debug("depth: #{depth} pc: #{pc} #{operation.name} gas: #{op_cost} stack: #{stack.size} logs: #{sub_state.log_series.size}")
 
-        # call operation
-        operation.call(self)
-        # calculate gas_cost
-        new_memory_cost = fork_config.gas_of_memory(ms.memory_item)
-        memory_gas_cost = new_memory_cost - old_memory_cost
+        consume_gas op_cost
+        refund_gas op_refund if op_refund && op_refund > 0
 
-        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.remain_gas} gas cost: #{memory_gas_cost}"
+        # call operation
+        begin
+          operation.call(self)
+        rescue VMError => e
+          set_exception(e)
         end
 
         # revert sub_state and return if exception occur
         if exception
-          @sub_state = prev_sub_state
+          execution_context.revert
           return
         end
 
-        debug("depth: #{instruction.execute_depth} pc: #{ms.pc} #{operation.name} gas: #{op_cost + memory_gas_cost} stack: #{stack.size} logs: #{sub_state.log_series.size}")
-        ms.pc = case
-                when w == OP::JUMP
-                  @jump_to
-                when w == OP::JUMPI
-                  @jump_to
-                else
-                  next_valid_instruction_pos(ms.pc, w)
-                end
+        set_pc case
+               when w == OP::JUMP
+                 jump_pc
+               when w == OP::JUMPI && jump_pc
+                 jump_pc
+               else
+                 next_valid_instruction_pos(pc, w)
+               end
       end
 
       # determinate halt or not halt
       def halt
-        w = get_op(machine_state.pc)
+        w = get_op(pc)
         if w == OP::RETURN || w == OP::REVERT
           operate
           output
@@ -324,27 +264,25 @@ module Ciri
 
       # check status
       def check_exception(state, ms, instruction)
-        w = instruction.get_op(ms.pc)
+        w = instruction.get_op(pc)
         case
-        when w == OP::INVALID
-          InvalidOpCodeError.new "can't find op code #{w}"
-        when OP.input_count(w).nil?
-          InvalidOpCodeError.new "can't find op code #{w}"
+        when w == OP::INVALID || OP.input_count(w).nil?
+          InvalidOpCodeError.new "can't find op code 0x#{w.to_s(16)} pc: #{pc}"
         when ms.stack.size < (consume = OP.input_count(w))
           StackError.new "stack not enough: stack:#{ms.stack.size} next consume: #{consume}"
-        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))
+        when remain_gas < (gas_cost = fork_schema.gas_of_operation(self).yield_self {|gas_cost, _| gas_cost})
+          GasNotEnoughError.new "gas not enough: gas remain:#{remain_gas} gas cost: #{gas_cost}"
+        when w == OP::JUMP && !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))
+        when w == OP::JUMPI && ms.get_stack(1, Integer) != 0 && !destinations.include?(ms.get_stack(0, Integer))
           InvalidJumpError.new "invalid condition jump dest #{ms.get_stack(0, Integer)}"
         when w == OP::RETURNDATACOPY && ms.get_stack(1, Integer) + ms.get_stack(2, Integer) > ms.output.size
           ReturnError.new "return data copy error"
-        when stack.size - OP.input_count(w) + OP.output_count(w) > 1024
-          StackError.new "stack size reach 1024 limit"
+        when stack.size - OP.input_count(w) + OP.output_count(w) > stack_size
+          StackError.new "stack size reach #{stack_size} limit"
           # A condition in yellow paper but I can't understand..: (¬Iw ∧W(w,μ))
-        when instruction.execute_depth > 1024
-          StackError.new "call depth reach 1024 limit"
+        when depth > max_depth
+          StackError.new "call depth reach #{max_depth} limit"
         else
           nil
         end