ciri 0.0.3 → 0.0.4

data/lib/ciri/evm/state.rb

@@ -24,7 +24,7 @@ module Ciri
 
       extend Forwardable
 
-      def_delegators :@account_db, :set_nonce, :increment_nonce, :set_balance, :add_balance, :touch_account,
+      def_delegators :@account_db, :set_nonce, :increment_nonce, :set_balance, :add_balance,
                      :find_account, :delete_account, :account_dead?, :store, :fetch,
                      :set_account_code, :get_account_code, :account_exist?
 

data/lib/ciri/evm/sub_state.rb

@@ -41,16 +41,16 @@ module Ciri
         @refunds = orig.refunds.dup
       end
 
-      def add_refund_account(account)
-        @refunds << account
+      def add_refund_account(address)
+        @refunds << address
       end
 
-      def add_touched_account(account)
-        @touched_accounts << account
+      def add_touched_account(address)
+        @touched_accounts << address
       end
 
-      def add_suicide_account(account)
-        @suicide_accounts << account
+      def add_suicide_account(address)
+        @suicide_accounts << address
       end
     end
 

data/lib/ciri/evm/vm.rb

@@ -24,6 +24,7 @@ require_relative 'instruction'
 require_relative 'sub_state'
 require_relative 'block_info'
 require_relative 'log_entry'
+require_relative 'op/errors'
 
 using Ciri::CoreExt
 module Ciri
@@ -101,26 +102,34 @@ module Ciri
           end
 
           deposit_code_gas = fork_schema.calculate_deposit_code_gas(output)
+          gas_is_not_enough = deposit_code_gas > remain_gas
+          deposit_code_reach_limit = output.size > fork_schema.contract_code_size_limit
 
-          if deposit_code_gas > remain_gas
-            # deposit_code_gas not enough
+          # check deposit_code_gas
+          if gas_is_not_enough || deposit_code_reach_limit
             contract_address = 0
+            if fork_schema.exception_on_deposit_code_gas_not_enough
+              if deposit_code_reach_limit
+                set_exception GasNotEnoughError.new("deposit_code size reach limit, code size: #{output.size}, limit size: #{fork_schema.contract_code_size_limit}")
+              else
+                set_exception GasNotEnoughError.new("deposit_code_gas not enough, deposit_code_gas: #{deposit_code_gas}, remain_gas: #{remain_gas}")
+              end
+            else
+              set_output ''.b
+            end
           elsif exception
-            # 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)
+            if fork_schema.contract_init_nonce != 0
+              state.set_nonce(contract_address, fork_schema.contract_init_nonce)
+            end
             # minus deposit_code_fee
             consume_gas deposit_code_gas
-            state.commit(snapshot)
           end
+
+          finalize_message(snapshot)
           [contract_address, exception]
         end
       end
@@ -148,18 +157,7 @@ module Ciri
             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)
-          end
-
+          finalize_message(snapshot)
           [status, output || ''.b, exception]
         end
       end
@@ -172,6 +170,8 @@ module Ciri
       def transact(sender:, value:, to:)
         sender_account = find_account(sender)
         raise VMError.new("balance not enough") if sender_account.balance < value
+        add_touched_account(sender)
+        add_touched_account(to)
         state.add_balance(sender, -value)
         state.add_balance(to, value)
       end
@@ -207,12 +207,21 @@ module Ciri
         machine_state.extend_memory(execution_context, pos, size)
       end
 
+      def delete_empty_accounts
+        return unless fork_schema.clean_empty_accounts?
+        sub_state.touched_accounts.to_set.select do |address|
+          account_dead?(address)
+        end.each do |address|
+          state.delete_account(address)
+        end
+      end
+
       private
 
       # O(σ, μ, A, I) ≡ (σ′, μ′, A′, I)
       def operate
         w = get_op(pc)
-        operation = OP.get(w)
+        operation = fork_schema.get_operation(w)
 
         raise "can't find operation #{w}, pc #{pc}" unless operation
 
@@ -230,12 +239,6 @@ module Ciri
           set_exception(e)
         end
 
-        # revert sub_state and return if exception occur
-        if exception
-          execution_context.revert
-          return
-        end
-
         set_pc case
                when w == OP::JUMP
                  jump_pc
@@ -254,8 +257,6 @@ module Ciri
           output
         elsif w == OP::STOP || w == OP::SELFDESTRUCT
           operate
-          # return empty sequence: nil
-          # debug("#{pc} #{OP.get(w).name} gas: 0 stack: #{stack.size}")
           nil
         else
           EMPTY_SET
@@ -266,7 +267,7 @@ module Ciri
       def check_exception(state, ms, instruction)
         w = instruction.get_op(pc)
         case
-        when w == OP::INVALID || OP.input_count(w).nil?
+        when w == OP::INVALID || fork_schema.get_operation(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}"
@@ -280,7 +281,6 @@ module Ciri
           ReturnError.new "return data copy error"
         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 depth > max_depth
           StackError.new "call depth reach #{max_depth} limit"
         else
@@ -288,6 +288,26 @@ module Ciri
         end
       end
 
+      def finalize_message(snapshot)
+        # check exception and commit/revert state
+        if exception.is_a?(OP::RevertError)
+          execution_context.revert_sub_state
+          state.revert(snapshot)
+          # cleanup exception
+          set_exception(nil)
+        elsif 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_sub_state
+          state.revert(snapshot)
+        else
+          delete_empty_accounts
+          state.commit(snapshot)
+        end
+      end
+
     end
   end
 end

data/lib/ciri/forks.rb

@@ -18,6 +18,10 @@
 require_relative 'forks/config'
 require_relative 'forks/frontier'
 require_relative 'forks/homestead'
+require_relative 'forks/tangerine_whistle'
+require_relative 'forks/spurious_dragon'
+require_relative 'forks/byzantium'
+require_relative 'forks/constantinople'
 
 module Ciri
   module Forks

data/lib/ciri/forks/base.rb

@@ -61,6 +61,34 @@ module Ciri
       def find_precompile_contract(address)
         raise NotImplementedError
       end
+
+      def transaction_class
+        raise NotImplementedError
+      end
+
+      def get_operation(op_code)
+        raise NotImplementedError
+      end
+
+      def exception_on_deposit_code_gas_not_enough
+        raise NotImplementedError
+      end
+
+      def contract_code_size_limit
+        raise NotImplementedError
+      end
+
+      def contract_init_nonce
+        raise NotImplementedError
+      end
+
+      def clean_empty_accounts?
+        raise NotImplementedError
+      end
+
+      def make_receipt(execution_result:, gas_used:)
+        raise NotImplementedError
+      end
     end
 
   end

data/lib/ciri/forks/byzantium.rb

@@ -16,25 +16,59 @@
 
 
 require_relative 'base'
-require_relative 'homestead'
+require_relative 'spurious_dragon'
+require_relative 'byzantium/opcodes'
+require 'ciri/types/receipt'
+require 'ciri/utils'
+require 'ciri/rlp'
 
 module Ciri
   module Forks
+    # https://github.com/ethereum/EIPs/blob/181867ae830df5419eb9982d2a24797b2dcad28f/EIPS/eip-609.md
     module Byzantium
-      class Schema < Forks::Frontier::Schema
+      class Schema < Forks::SpuriousDragon::Schema
 
-        include Forks::Frontier::Cost
+        BLOCK_REWARD = 3 * 10.pow(18) # 3 ether
 
-        # chain difficulty method
-        # https://github.com/ethereum/EIPs/blob/181867ae830df5419eb9982d2a24797b2dcad28f/EIPS/eip-609.md
-        # https://github.com/ethereum/EIPs/blob/984cf5de90bbf5fbe7e49be227b0c2f9567e661e/EIPS/eip-100.md
-        def difficulty_time_factor(header, parent_header)
-          y = header.ommers_hash == Utils::BLANK_SHA3 ? 1 : 2
-          [y - (header.timestamp - parent_header.timestamp) / 9, -99].max
+        TRANSACTION_STATUS_FAILURE = ''.b
+        TRANSACTION_STATUS_SUCCESS = "\x01".b
+
+        BLANK_OMMERS_HASH = Utils.keccak(RLP.encode([])).freeze
+
+        def calculate_difficulty(header, parent_header)
+          # https://github.com/ethereum/EIPs/blob/984cf5de90bbf5fbe7e49be227b0c2f9567e661e/EIPS/eip-100.md
+          y = parent_header.ommers_hash == BLANK_OMMERS_HASH ? 1 : 2
+          difficulty_time_factor = [y - (header.timestamp - parent_header.timestamp) / 9, -99].max
+          x = parent_header.difficulty / 2048
+
+          # difficulty bomb
+          height = [(header.number - 3000000), 0].max
+          height_factor = 2 ** (height / 100000 - 2)
+
+          difficulty = (parent_header.difficulty + x * difficulty_time_factor + height_factor).to_i
+          [header.difficulty, difficulty].max
+        end
+
+        def get_operation(op)
+          OPCODES[op]
+        end
+
+        def mining_rewards_of_block(block)
+          rewards = Hash.new(0)
+          # reward miner
+          rewards[block.header.beneficiary] += ((1 + block.ommers.count.to_f / 32) * BLOCK_REWARD).to_i
+
+          # reward ommer(uncle) block miners
+          block.ommers.each do |ommer|
+            rewards[ommer.beneficiary] += ((1 + (ommer.number - block.header.number).to_f / 8) * BLOCK_REWARD).to_i
+          end
+          rewards
         end
 
-        def difficulty_virtual_height(height)
-          [(height - 3000000), 0].max
+        # https://github.com/ethereum/EIPs/blob/181867ae830df5419eb9982d2a24797b2dcad28f/EIPS/eip-658.md
+        def make_receipt(execution_result:, gas_used:)
+          status = execution_result.status == 1 ? TRANSACTION_STATUS_SUCCESS : TRANSACTION_STATUS_FAILURE
+          Types::Receipt.new(state_root: status, gas_used: gas_used, logs: execution_result.logs)
         end
 
       end

data/lib/ciri/forks/byzantium/opcodes.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Jiang Jinyang <https://justjjy.com>
+#
+# 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
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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/evm/op'
+require 'ciri/forks/homestead/opcodes'
+
+module Ciri
+  module Forks
+    module Byzantium
+
+      include Ciri::EVM::OP
+
+      UPDATE_OPCODES = [
+          REVERT,
+      ].map do |op|
+        [op, Ciri::EVM::OP.get(op)]
+      end.to_h.freeze
+
+      OPCODES = Homestead::OPCODES.merge(UPDATE_OPCODES).freeze
+
+    end
+  end
+end

data/lib/ciri/forks/constantinople.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Jiang Jinyang <https://justjjy.com>
+#
+# 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
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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_relative 'base'
+require_relative 'byzantium'
+
+module Ciri
+  module Forks
+    module Constantinople
+      class Schema < Forks::Byzantium::Schema
+
+      end
+    end
+  end
+end

data/lib/ciri/forks/frontier.rb

@@ -17,8 +17,12 @@
 
 require_relative 'base'
 require_relative 'frontier/cost'
+require_relative 'frontier/transaction'
+require_relative 'frontier/opcodes'
+require 'ciri/types/receipt'
 require 'ciri/core_ext'
 require 'ciri/evm/precompile_contract'
+require 'forwardable'
 
 using Ciri::CoreExt
 
@@ -27,24 +31,15 @@ module Ciri
     module Frontier
       class Schema < Base
 
-        BLOCK_REWARD = 5 * 10.pow(18) # 5 ether
-
-        # gas methods
-        def gas_of_operation(vm)
-          Cost.cost_of_operation vm
-        end
+        extend Forwardable
 
-        def gas_of_memory(word_count)
-          Cost.cost_of_memory word_count
-        end
+        BLOCK_REWARD = 5 * 10.pow(18) # 5 ether
 
-        def gas_of_call(vm:, gas:, to:, value:)
-          Cost.gas_of_call(vm: vm, gas: gas, to: to, value: value)
+        def initialize
+          @cost = Cost.new
         end
 
-        def intrinsic_gas_of_transaction(transaction)
-          Cost.intrinsic_gas_of_transaction transaction
-        end
+        def_delegators :@cost, :gas_of_operation, :gas_of_memory, :gas_of_call, :intrinsic_gas_of_transaction
 
         def calculate_deposit_code_gas(code_bytes)
           Cost::G_CODEDEPOSIT * (code_bytes || ''.b).size
@@ -66,26 +61,23 @@ module Ciri
           rewards
         end
 
-        def validate_transaction(transaction)
-          unless transaction.v >= 27 && transaction.v <= 28
-            "v can be only 27 or 28 in frontier schema, found: #{transaction.v}"
-          end
-        end
+        def calculate_difficulty(header, parent_header)
+          difficulty_time_factor = (header.timestamp - parent_header.timestamp) < 13 ? 1 : -1
+          x = parent_header.difficulty / 2048
 
-        # chain difficulty method
-        def difficulty_time_factor(header, parent_header)
-          (header.timestamp - parent_header.timestamp) < 13 ? 1 : -1
-        end
+          # difficulty bomb
+          height = header.number
+          height_factor = 2 ** (height / 100000 - 2)
 
-        def difficulty_virtual_height(height)
-          height
+          difficulty = (parent_header.difficulty + x * difficulty_time_factor + height_factor).to_i
+          [header.difficulty, difficulty].max
         end
 
         PRECOMPILE_CONTRACTS = {
-          "\x01".pad_zero(20).b => EVM::PrecompileContract::ECRecover.new,
-          "\x02".pad_zero(20).b => EVM::PrecompileContract::SHA256.new,
-          "\x03".pad_zero(20).b => EVM::PrecompileContract::RIPEMD160.new,
-          "\x04".pad_zero(20).b => EVM::PrecompileContract::Identity.new,
+            "\x01".pad_zero(20).b => EVM::PrecompileContract::ECRecover.new,
+            "\x02".pad_zero(20).b => EVM::PrecompileContract::SHA256.new,
+            "\x03".pad_zero(20).b => EVM::PrecompileContract::RIPEMD160.new,
+            "\x04".pad_zero(20).b => EVM::PrecompileContract::Identity.new,
         }.freeze
 
         # EVM op code and contract
@@ -93,6 +85,34 @@ module Ciri
           PRECOMPILE_CONTRACTS[address.to_s]
         end
 
+        def transaction_class
+          Transaction
+        end
+
+        def get_operation(op)
+          OPCODES[op]
+        end
+
+        def exception_on_deposit_code_gas_not_enough
+          false
+        end
+
+        def contract_code_size_limit
+          Float::INFINITY
+        end
+
+        def contract_init_nonce
+          0
+        end
+
+        def clean_empty_accounts?
+          false
+        end
+
+        def make_receipt(execution_result:, gas_used:)
+          Types::Receipt.new(state_root: execution_result.state_root, gas_used: gas_used, logs: execution_result.logs)
+        end
+
       end
     end
   end