ciri 0.0.2 → 0.0.3

data/lib/ciri/evm/machine_state.rb

@@ -1,26 +1,21 @@
 # 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/serialize'
 require 'ciri/evm/errors'
 
@@ -29,23 +24,13 @@ module Ciri
 
     # represent current vm status, include stack, memory..
     class MachineState
+      include Utils::Logger
 
-      attr_reader :remain_gas, :memory, :stack
-      attr_accessor :pc, :output, :memory_item
+      attr_reader :memory, :stack
 
-      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
+      def initialize(memory: ''.b, stack: [])
         @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
@@ -72,7 +57,7 @@ module Ciri
 
       # store data to memory
       def memory_store(start, size, data)
-        if start < memory.size && start + size - 1 < memory.size
+        if size > 0 && start < memory.size && start + size - 1 < memory.size
           memory[start..(start + size - 1)] = Serialize.serialize(data).rjust(size, "\x00".b)
         end
       end
@@ -87,10 +72,20 @@ module Ciri
         end
       end
 
+      def memory_item
+        Utils.ceil_div(memory.size, 32)
+      end
+
       # extend vm memory, used for memory_gas calculation
-      def extend_memory(pos, size)
-        if size != 0 && (i = Utils.ceil_div(pos + size, 32)) > memory_item
-          self.memory_item = i
+      def extend_memory(context, pos, size)
+        if size != 0 && (new_item = Utils.ceil_div(pos + size, 32)) > memory_item
+          debug("extend memory: from #{memory_item} -> #{new_item}")
+          old_cost_gas = context.fork_schema.gas_of_memory memory_item
+          new_cost_gas = context.fork_schema.gas_of_memory new_item
+          context.consume_gas(new_cost_gas - old_cost_gas)
+
+          extend_size = (new_item - memory_item) * 32
+          self.memory << "\x00".b * extend_size
         end
       end
 

data/lib/ciri/evm/op.rb

@@ -1,29 +1,24 @@
 # 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'
 require 'ciri/utils/number'
 require 'ciri/types/address'
+require_relative 'op_call'
 
 module Ciri
   class EVM
@@ -206,7 +201,8 @@ module Ciri
       # 20s: sha3
       def_op :SHA3, 0x20, 2, 1 do |vm|
         pos, size = vm.pop_list(2, Integer)
-        hashed = Ciri::Utils.sha3 vm.memory_fetch(pos, size)
+        vm.extend_memory(pos, size)
+        hashed = Ciri::Utils.keccak vm.memory_fetch(pos, size)
         vm.extend_memory(pos, size)
         vm.push hashed
       end
@@ -246,8 +242,8 @@ module Ciri
       def_op :CALLDATACOPY, 0x37, 3, 0 do |vm|
         mem_pos, data_pos, size = vm.pop_list(3, Integer)
         data = vm.get_data(data_pos, size)
-        vm.memory_store(mem_pos, size, data)
         vm.extend_memory(mem_pos, size)
+        vm.memory_store(mem_pos, size, data)
       end
 
       def_op :CODESIZE, 0x38, 0, 1 do |vm|
@@ -257,6 +253,7 @@ module Ciri
       def_op :CODECOPY, 0x39, 3, 0 do |vm|
         mem_pos, code_pos, size = vm.pop_list(3, Integer)
         data = vm.get_code(code_pos, size)
+        vm.extend_memory(mem_pos, size)
         vm.memory_store(mem_pos, size, data)
       end
 
@@ -283,6 +280,7 @@ module Ciri
                else
                  code[data_pos..data_end_pos]
                end
+        vm.extend_memory(mem_pos, size)
         vm.memory_store(mem_pos, size, data)
       end
 
@@ -290,7 +288,14 @@ module Ciri
       RETURNDATACOPY = 0x3e
 
       # 40s: block information
-      BLOCKHASH = 0x40
+      def_op :BLOCKHASH, 0x40, 1, 1 do |vm|
+        height = vm.pop(Integer)
+        # cause current block hash do not exists in chain
+        # here we compute distance of parent height and ancestor height
+        # and use parent_hash to find ancestor hash
+        distance = vm.block_info.number - height - 1
+        vm.push vm.state.get_ancestor_hash(vm.block_info.parent_hash, distance)
+      end
 
       def_op :COINBASE, 0x41, 0, 1 do |vm|
         vm.push vm.block_info.coinbase
@@ -319,22 +324,22 @@ module Ciri
 
       def_op :MLOAD, 0x51, 1, 1 do |vm|
         index = vm.pop(Integer)
-        vm.push vm.memory_fetch(index, 32)
         vm.extend_memory(index, 32)
+        vm.push vm.memory_fetch(index, 32)
       end
 
       def_op :MSTORE, 0x52, 2, 0 do |vm|
         index = vm.pop(Integer)
         data = vm.pop
-        vm.memory_store(index, 32, data)
         vm.extend_memory(index, 32)
+        vm.memory_store(index, 32, data)
       end
 
       def_op :MSTORE8, 0x53, 2, 0 do |vm|
         index = vm.pop(Integer)
         data = vm.pop(Integer)
-        vm.memory_store(index, 1, data % 256)
         vm.extend_memory(index, 8)
+        vm.memory_store(index, 1, data % 256)
       end
 
       def_op :SLOAD, 0x54, 1, 1 do |vm|
@@ -356,10 +361,12 @@ module Ciri
 
       def_op :JUMPI, 0x57, 2, 0 do |vm|
         dest, cond = vm.pop_list(2, Integer)
+        # if cond is non zero jump to dest, else just goto next pc
         if cond != 0
           vm.jump_to(dest)
         else
-          vm.jump_to(vm.pc + 1)
+          # clear jump_to
+          vm.jump_to(nil)
         end
       end
 
@@ -372,7 +379,7 @@ module Ciri
       end
 
       def_op :GAS, 0x5a, 0, 1 do |vm|
-        vm.push vm.machine_state.remain_gas
+        vm.push vm.remain_gas
       end
 
       def_op :JUMPDEST, 0x5b, 0, 0
@@ -417,8 +424,8 @@ module Ciri
         def_op name, 0xa0 + i, i + 2, 0, &(proc do |i|
           proc do |vm|
             pos, size = vm.pop_list(2, Integer)
-            log_data = vm.memory_fetch(pos, size)
             vm.extend_memory(pos, size)
+            log_data = vm.memory_fetch(pos, size)
             topics = vm.pop_list(i, Integer)
             vm.add_log_entry(topics, log_data)
           end
@@ -430,75 +437,39 @@ module Ciri
         value = vm.pop(Integer)
         mem_pos, size = vm.pop_list(2, Integer)
 
-        init = vm.memory_fetch(mem_pos, size)
         vm.extend_memory(mem_pos, size)
 
-        contract_address, _ = vm.create_contract(value: value, init: init)
-        vm.push contract_address
+        # have not enough money
+        if vm.find_account(vm.instruction.address).balance < value
+          vm.push(0)
+        else
+          init = vm.memory_fetch(mem_pos, size)
+          create_gas = vm.remain_gas
+          vm.consume_gas(create_gas)
+          child_context = vm.execution_context.child_context(gas_limit: create_gas)
+          contract_address, _ = vm.create_contract(value: value, init: init, touch_nonce: true, context: child_context)
+          vm.execution_context.return_gas(child_context.remain_gas)
+
+          vm.push contract_address
+        end
       end
 
       def_op :CALL, 0xf1, 7, 1 do |vm|
-        vm.pop
-        target = vm.pop(Address)
-        value = vm.pop(Integer)
-        input_mem_pos, input_size = vm.pop_list(2, Integer)
-        output_mem_pos, output_mem_size = vm.pop_list(2, Integer)
-
-        data = vm.memory_fetch(input_mem_pos, input_size)
-        vm.extend_memory(input_mem_pos, input_size)
-
-        status, output = vm.call_message(sender: vm.instruction.address, value: value,
-                                         data: data, receipt: target, code_address: target)
-
-        output_size = [output_mem_size, output.size].min
-        vm.memory_store(output_mem_pos, output_size, output)
-        vm.extend_memory(output_mem_pos, output_size)
-        vm.push status
+        OPCall::Call.new.call(vm)
       end
 
       def_op :CALLCODE, 0xf2, 7, 1 do |vm|
-        # this method consume 7 items from stack, but seems not all of them are used
-        # skip item
-        vm.pop
-        target = vm.pop(Address)
-        value = vm.pop(Integer)
-        input_mem_pos, input_size = vm.pop_list(2, Integer)
-        output_mem_pos, output_mem_size = vm.pop_list(2, Integer)
-
-        data = vm.memory_fetch(input_mem_pos, input_size)
-        vm.extend_memory(input_mem_pos, input_size)
-
-        status, output = vm.call_message(sender: vm.instruction.address, value: value,
-                                         data: data, receipt: vm.instruction.address, code_address: target)
-
-        output_size = [output_mem_size, output.size].min
-        vm.memory_store(output_mem_pos, output_size, output)
-        vm.extend_memory(output_mem_pos, output_size)
-        vm.push status
+        OPCall::CallCode.new.call(vm)
       end
 
       def_op :RETURN, 0xf3, 2, 0 do |vm|
         index, size = vm.pop_list(2, Integer)
-        vm.output = vm.memory_fetch(index, size)
         vm.extend_memory(index, size)
+        vm.set_output vm.memory_fetch(index, size)
       end
 
-      def_op :DELEGATECALL, 0xf4, 6, 1 do |vm|
-        vm.pop
-        target = vm.pop(Address)
-        input_mem_pos, input_size = vm.pop_list(2, Integer)
-        output_mem_pos, output_mem_size = vm.pop_list(2, Integer)
-
-        data = vm.memory_fetch(input_mem_pos, input_size)
-        vm.extend_memory(input_mem_pos, input_size)
-
-        status, output = vm.call_message(sender: vm.instruction.sender, value: vm.instruction.value,
-                                         data: data, receipt: vm.instruction.address, code_address: target)
-
-        output_size = [output_mem_size, output.size].min
-        vm.memory_store(output_mem_pos, output_size, output)
-        vm.extend_memory(output_mem_pos, output_size)
-        vm.push status
+      def_op :DELEGATECALL, -0xf4, 6, 1 do |vm|
+        OPCall::DelegateCall.new.call(vm)
       end
 
       STATICCALL = 0xfa
@@ -516,18 +487,10 @@ module Ciri
 
       def_op :SELFDESTRUCT, 0xff, 1, 0 do |vm|
         refund_address = vm.pop(Address)
-        refund_account = vm.find_account(refund_address)
-
         contract_account = vm.find_account vm.instruction.address
 
-        if refund_address != vm.instruction.address
-          refund_account.balance += contract_account.balance
-        end
-
-        contract_account.balance = 0
-
-        vm.state.set_balance(refund_address, refund_account.balance)
-        vm.state.set_balance(vm.instruction.address, contract_account.balance)
+        vm.state.add_balance(refund_address, contract_account.balance)
+        vm.state.set_balance(vm.instruction.address, 0)
 
         # register changed accounts
         vm.add_refund_account(refund_address)

data/lib/ciri/evm/op_call.rb

@@ -0,0 +1,114 @@
+# 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/types/address'
+
+module Ciri
+  class EVM
+    # handle EVM call operations
+    module OPCall
+      class Base
+
+        include Types
+
+        def call(vm)
+          raise NotImplementedError
+        end
+
+        def extract_call_argument(vm)
+          gas = vm.pop(Integer)
+          to = vm.pop(Address)
+          value = vm.pop(Integer)
+          input_mem_pos, input_size = vm.pop_list(2, Integer)
+          output_mem_pos, output_mem_size = vm.pop_list(2, Integer)
+
+          # extend input output memory
+          vm.extend_memory(input_mem_pos, input_size)
+          vm.extend_memory(output_mem_pos, output_mem_size)
+
+          data = vm.memory_fetch(input_mem_pos, input_size)
+          [gas, to, value, data, output_mem_pos, output_mem_size]
+        end
+
+        def call_message(vm:, gas:, sender:, value:, data:, to:, code_address: to, output_mem_pos:, output_mem_size:)
+          context = vm.execution_context
+          child_gas_limit, child_gas_fee = context.fork_schema.gas_of_call(vm: vm,
+                                                                           gas: gas, to: to, value: value)
+          context.consume_gas(child_gas_fee)
+          if context.depth + 1 > 1024
+            context.return_gas(child_gas_limit)
+            vm.push 0
+            return
+          end
+          child_context = context.child_context(gas_limit: child_gas_limit)
+          child_context.instruction.sender = sender
+          child_context.instruction.value = value
+          child_context.instruction.data = data
+          child_context.instruction.address = to
+          child_context.instruction.bytes_code = vm.state.get_account_code(code_address)
+          status, output = vm.call_message(code_address: code_address, context: child_context)
+
+          context.return_gas(child_context.remain_gas)
+          output_size = [output_mem_size, output.size].min
+          vm.extend_memory(output_mem_pos, output_size)
+          vm.memory_store(output_mem_pos, output_size, output)
+          vm.push status
+        end
+      end
+
+      class Call < Base
+        def call(vm)
+          gas, to, value, data, output_mem_pos, output_mem_size = extract_call_argument(vm)
+          call_message(vm: vm, sender: vm.instruction.address, value: value, gas: gas, to: to,
+                       data: data, code_address: to, output_mem_pos: output_mem_pos, output_mem_size: output_mem_size)
+        end
+      end
+
+      class CallCode < Base
+        def call(vm)
+          gas, to, value, data, output_mem_pos, output_mem_size = extract_call_argument(vm)
+          call_message(vm: vm, sender: vm.instruction.address, value: value, gas: gas, to: vm.instruction.address,
+                       data: data, code_address: to, output_mem_pos: output_mem_pos, output_mem_size: output_mem_size)
+        end
+      end
+
+      class DelegateCall < Base
+        def call(vm)
+          gas, to, data, output_mem_pos, output_mem_size = extract_call_argument(vm)
+          call_message(vm: vm, sender: vm.instruction.sender, value: vm.instruction.value, gas: gas,
+                       to: vm.instruction.address, data: data, code_address: to,
+                       output_mem_pos: output_mem_pos, output_mem_size: output_mem_size)
+        end
+
+        def extract_call_argument(vm)
+          gas = vm.pop(Integer)
+          to = vm.pop(Address)
+          input_mem_pos, input_size = vm.pop_list(2, Integer)
+          output_mem_pos, output_mem_size = vm.pop_list(2, Integer)
+
+          # extend input output memory
+          vm.extend_memory(input_mem_pos, input_size)
+          vm.extend_memory(output_mem_pos, output_mem_size)
+
+          data = vm.memory_fetch(input_mem_pos, input_size)
+          [gas, to, data, output_mem_pos, output_mem_size]
+        end
+      end
+
+    end
+  end
+end

data/lib/ciri/evm/precompile_contract.rb

@@ -0,0 +1,102 @@
+# 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/core_ext'
+require 'ciri/crypto'
+require 'digest'
+
+using Ciri::CoreExt
+
+module Ciri
+  class EVM
+    module PrecompileContract
+
+      class ECRecover
+        GAS_ECRECOVER = 3000
+
+        def call(vm)
+          vm.consume_gas(GAS_ECRECOVER)
+          message_hash = vm.instruction.data[0...32].pad_zero(32)
+
+          v = vm.instruction.data[32...64].decode_big_endian
+          r = vm.instruction.data[64...96].decode_big_endian
+          s = vm.instruction.data[96...128].decode_big_endian
+          unless valid_vrs?(v, r, s)
+            return vm.set_exception(Error.new("invalid vrs"))
+          end
+          raw_v = v - 27
+          begin
+            signature = Ciri::Crypto::Signature.new(vrs: [raw_v, r, s])
+            key = Ciri::Key.ecdsa_recover(message_hash, signature)
+          rescue StandardError => e
+            return vm.set_exception(e)
+          end
+
+          vm.set_output(key.to_address.to_s)
+        end
+
+        def valid_vrs?(v, r, s)
+          return false unless r < Ciri::Crypto::SECP256K1N
+          return false unless s < Ciri::Crypto::SECP256K1N
+          return false unless v == 28 || v == 27
+          true
+        end
+      end
+
+      class SHA256
+        GAS_SHA256 = 60
+        GAS_SHA256WORD = 12
+
+        def call(vm)
+          input_bytes = vm.instruction.data
+          word_count = input_bytes.size.ceil_div(32) / 32
+          gas_fee = GAS_SHA256 + word_count * GAS_SHA256WORD
+          vm.consume_gas(gas_fee)
+          vm.set_output input_bytes.keccak
+        end
+      end
+
+      class RIPEMD160
+        GAS_RIPEMD160 = 600
+        GAS_RIPEMD160WORD = 120
+
+        def call(vm)
+          input_bytes = vm.instruction.data
+          word_count = input_bytes.size.ceil_div(32) / 32
+          gas_fee = GAS_RIPEMD160 + word_count * GAS_RIPEMD160WORD
+          vm.consume_gas(gas_fee)
+          vm.set_output Digest::RMD160.digest(input_bytes).pad_zero(32)
+        end
+      end
+
+      class Identity
+        GAS_IDENTITY = 15
+        GAS_IDENTITYWORD = 3
+
+        def call(vm)
+          input_bytes = vm.instruction.data
+          word_count = input_bytes.size.ceil_div(32) / 32
+          gas_fee = GAS_IDENTITY + word_count * GAS_IDENTITYWORD
+          vm.consume_gas(gas_fee)
+          computation.output = input_bytes
+        end
+      end
+
+
+    end
+  end
+end

data/lib/ciri/evm/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.
 
 
 require 'forwardable'
@@ -31,11 +25,25 @@ module Ciri
       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
+                     :find_account, :delete_account, :account_dead?, :store, :fetch,
+                     :set_account_code, :get_account_code, :account_exist?
 
-      def initialize(db, state_root: nil)
+      def initialize(db, state_root: nil, chain: nil)
         @db = db
         @account_db = DB::AccountDB.new(db, root_hash: state_root)
+        @chain = chain
+      end
+
+      # get ancestor hash
+      def get_ancestor_hash(current_hash, ancestor_distance)
+        if ancestor_distance > 256 || ancestor_distance < 0
+          ''.b
+        elsif ancestor_distance == 0
+          current_hash
+        else
+          parent_hash = @chain.get_header(current_hash).parent_hash
+          get_ancestor_hash(parent_hash, ancestor_distance - 1)
+        end
       end
 
       def snapshot
@@ -43,9 +51,8 @@ module Ciri
       end
 
       def revert(snapshot)
-        state_root, db = snapshot
-        @db = db
-        @account_db = DB::AccountDB.new(db, root_hash: state_root)
+        state_root, _db = snapshot
+        @account_db = DB::AccountDB.new(@db, root_hash: state_root)
       end
 
       def commit(snapshot)