ciri 0.0.1 → 0.0.2

data/lib/ciri/chain.rb

@@ -22,9 +22,13 @@
 
 
 require 'forwardable'
+require 'ciri/evm'
+require 'ciri/utils/logger'
+require_relative 'chain/header_chain'
 require_relative 'chain/block'
 require_relative 'chain/header'
 require_relative 'chain/transaction'
+require_relative 'types/receipt'
 require_relative 'pow'
 
 module Ciri
@@ -32,6 +36,7 @@ module Ciri
   # Chain manipulate logic
   # store via rocksdb
   class Chain
+    include Utils::Logger
 
     class Error < StandardError
     end
@@ -42,151 +47,75 @@ module Ciri
     class InvalidBlockError < Error
     end
 
-    # HeaderChain
-    # store headers
-    class HeaderChain
-      HEAD = 'head'
-      GENESIS = 'genesis'
-      HEADER_PREFIX = 'h'
-      TD_SUFFIX = 't'
-      NUM_SUFFIX = 'n'
-
-      attr_reader :store, :byzantium_block, :homestead_block
-
-      def initialize(store, byzantium_block: nil, homestead_block: nil)
-        @store = store
-        @byzantium_block = byzantium_block
-        @homestead_block = homestead_block
-      end
-
-      def head
-        encoded = store[HEAD]
-        encoded && Header.rlp_decode!(encoded)
-      end
+    extend Forwardable
 
-      def head=(header)
-        store[HEAD] = header.rlp_encode!
-      end
+    BODY_PREFIX = 'b'
 
-      def get_header(hash)
-        encoded = store[HEADER_PREFIX + hash]
-        encoded && Header.rlp_decode!(encoded)
-      end
+    def_delegators :@header_chain, :head, :total_difficulty, :get_header_by_number, :get_header
 
-      def get_header_by_number(number)
-        hash = get_header_hash_by_number(number)
-        hash && get_header(hash)
-      end
+    attr_reader :genesis, :network_id, :store, :header_chain
 
-      def valid?(header)
-        # ignore genesis header if there not exist one
-        return true if header.number == 0 && get_header_by_number(0).nil?
-
-        parent_header = get_header(header.parent_hash)
-        return false unless parent_header
-        # check height
-        return false unless parent_header.number + 1 == header.number
-        # check timestamp
-        return false unless parent_header.timestamp < header.timestamp
-
-        # check gas limit range
-        parent_gas_limit = parent_header.gas_limit
-        gas_limit_max = parent_gas_limit + parent_gas_limit / 1024
-        gas_limit_min = parent_gas_limit - parent_gas_limit / 1024
-        gas_limit = header.gas_limit
-        return false unless gas_limit >= 5000 && gas_limit > gas_limit_min && gas_limit < gas_limit_max
-        return false unless calculate_difficulty(header, parent_header) == header.difficulty
-
-        # check pow
-        begin
-          POW.check_pow(header.number, header.mining_hash, header.mix_hash, header.nonce, header.difficulty)
-        rescue POW::InvalidError
-          return false
-        end
+    def initialize(store, genesis:, network_id:, evm: nil, byzantium_block: nil, homestead_block: nil)
+      @store = store
+      @header_chain = HeaderChain.new(store, byzantium_block: byzantium_block, homestead_block: homestead_block)
+      @genesis = genesis
+      @network_id = network_id
+      @evm = evm
+      load_or_init_store
+    end
 
-        true
-      end
+    # run block
+    def import_block(block)
+      validate_block(block)
+      write_block(block)
 
-      # calculate header difficulty
-      # you can find explain in Ethereum yellow paper: Block Header Validity section.
-      def calculate_difficulty(header, parent_header)
-        return header.difficulty if header.number == 0
-
-        x = parent_header.difficulty / 2048
-        y = header.ommers_hash == Utils::BLANK_SHA3 ? 1 : 2
-
-        # handle byzantium fork
-        # https://github.com/ethereum/EIPs/blob/181867ae830df5419eb9982d2a24797b2dcad28f/EIPS/eip-609.md
-        # https://github.com/ethereum/EIPs/blob/984cf5de90bbf5fbe7e49be227b0c2f9567e661e/EIPS/eip-100.md
-        byzantium_fork = byzantium_block && header.number > byzantium_block
-        # https://github.com/ethereum/EIPs/blob/984cf5de90bbf5fbe7e49be227b0c2f9567e661e/EIPS/eip-2.md
-        homestead_fork = homestead_block && header.number > homestead_block
-
-        time_factor = if byzantium_fork
-                        [y - (header.timestamp - parent_header.timestamp) / 9, -99].max
-                      elsif homestead_fork
-                        [1 - (header.timestamp - parent_header.timestamp) / 10, -99].max
-                      else
-                        (header.timestamp - parent_header.timestamp) < 13 ? 1 : -1
-                      end
-
-        # difficulty bomb
-        height = byzantium_fork ? [(header.number - 3000000), 0].max : header.number
-        height_factor = 2 ** (height / 100000 - 2)
-
-        difficulty = (parent_header.difficulty + x * time_factor + height_factor).to_i
-        [header.difficulty, difficulty].max
-      end
+      # update state
+      # apply_changes
+    end
 
-      # write header
-      def write(header)
-        hash = header.get_hash
-        # get total difficulty
-        td = if header.number == 0
-               header.difficulty
-             else
-               parent_header = get_header(header.parent_hash)
-               raise "can't find parent from db" unless parent_header
-               parent_td = total_difficulty(parent_header.get_hash)
-               parent_td + header.difficulty
-             end
-        # write header and td
-        store.batch do |b|
-          b.put(HEADER_PREFIX + hash, header.rlp_encode!)
-          b.put(HEADER_PREFIX + hash + TD_SUFFIX, RLP.encode(td, Integer))
+    # validate block, effect current state
+    def validate_block(block)
+      raise InvalidBlockError.new('invalid header') unless @header_chain.valid?(block.header)
+      # valid ommers
+      raise InvalidBlockError.new('ommers blocks can not more than 2') if block.ommers.size > 2
+      block.ommers.each do |ommer|
+        unless is_kin?(ommer, get_block(block.header.parent_hash), 6)
+          raise InvalidBlockError.new("invalid ommer relation")
         end
       end
 
-      def write_header_hash_number(header_hash, number)
-        enc_number = Utils.big_endian_encode number
-        store[HEADER_PREFIX + enc_number + NUM_SUFFIX] = header_hash
+      # valid transactions and gas
+      begin
+        receipts = @evm.transition(block)
+      rescue EVM::InvalidTransition => e
+        raise InvalidBlockError.new(e.message)
       end
 
-      def get_header_hash_by_number(number)
-        enc_number = Utils.big_endian_encode number
-        store[HEADER_PREFIX + enc_number + NUM_SUFFIX]
+      # verify state root
+      if @evm.state_root != block.header.state_root
+        error("incorrect state_root, evm: #{Utils.to_hex @evm.state_root}, header: #{Utils.to_hex block.header.state_root} height: #{block.header.number}")
+        raise InvalidBlockError.new("incorrect state_root")
       end
 
-      def total_difficulty(header_hash = head.nil? ? nil : head.get_hash)
-        return 0 if header_hash.nil?
-        RLP.decode(store[HEADER_PREFIX + header_hash + TD_SUFFIX], Integer)
+      # verify receipts root
+      trie = Trie.new
+      receipts.each_with_index do |r, i|
+        trie[RLP.encode(i)] = RLP.encode(r)
       end
-    end
-
-    extend Forwardable
 
-    BODY_PREFIX = 'b'
-
-    def_delegators :@header_chain, :head, :total_difficulty, :get_header_by_number, :get_header
+      if trie.root_hash != block.header.receipts_root
+        raise InvalidBlockError.new("incorrect receipts_root")
+      end
 
-    attr_reader :genesis, :network_id, :store, :header_chain
+      # verify state root
+      trie = Trie.new
+      block.transactions.each_with_index do |t, i|
+        trie[RLP.encode(i)] = RLP.encode(t)
+      end
 
-    def initialize(store, genesis:, network_id:, byzantium_block: nil, homestead_block: nil)
-      @store = store
-      @header_chain = HeaderChain.new(store, byzantium_block: byzantium_block, homestead_block: homestead_block)
-      @genesis = genesis
-      @network_id = network_id
-      load_or_init_store
+      if trie.root_hash != block.header.transactions_root
+        raise InvalidBlockError.new("incorrect transactions_root")
+      end
     end
 
     def genesis_hash
@@ -223,17 +152,17 @@ module Ciri
 
     def get_block(hash)
       encoded = store[BODY_PREFIX + hash]
-      encoded && Block.rlp_decode!(encoded)
+      encoded && Block.rlp_decode(encoded)
     end
 
     def write_block(block)
       # write header
       header = block.header
-      raise InvalidHeaderError.new("invalid header: #{header.number}") unless @header_chain.valid?(header)
+      # raise InvalidHeaderError.new("invalid header: #{header.number}") unless @header_chain.valid?(header)
       @header_chain.write(header)
 
       # write body
-      store[BODY_PREFIX + header.get_hash] = block.rlp_encode!
+      store[BODY_PREFIX + header.get_hash] = block.rlp_encode
 
       td = total_difficulty(header.get_hash)
 
@@ -251,6 +180,14 @@ module Ciri
 
     private
 
+    def is_kin?(ommer, parent, n)
+      return false if n == 0
+      return true if get_header(ommer.parent_hash) == get_header(parent.header.parent_hash) &&
+        ommer != parent.header &&
+        !parent.ommers.include?(ommer)
+      is_kin?(ommer, get_block(parent.header.parent_hash), n - 1)
+    end
+
     # reorg chain
     def reorg_chain(new_block, old_block)
       new_chain = []

data/lib/ciri/chain/header.rb

@@ -48,12 +48,12 @@ module Ciri
 
       # header hash
       def get_hash
-        Utils.sha3(rlp_encode!)
+        Utils.sha3(rlp_encode)
       end
 
       # mining_hash, used for mining
       def mining_hash
-        Utils.sha3(rlp_encode! skip_keys: [:mix_hash, :nonce])
+        Utils.sha3(rlp_encode skip_keys: [:mix_hash, :nonce])
       end
 
     end

data/lib/ciri/chain/header_chain.rb

@@ -0,0 +1,136 @@
+# HeaderChain
+# store headers
+
+module Ciri
+  class Chain
+    class HeaderChain
+      HEAD = 'head'
+      GENESIS = 'genesis'
+      HEADER_PREFIX = 'h'
+      TD_SUFFIX = 't'
+      NUM_SUFFIX = 'n'
+
+      attr_reader :store, :byzantium_block, :homestead_block
+
+      def initialize(store, byzantium_block: nil, homestead_block: nil)
+        @store = store
+        @byzantium_block = byzantium_block
+        @homestead_block = homestead_block
+      end
+
+      def head
+        encoded = store[HEAD]
+        encoded && Header.rlp_decode(encoded)
+      end
+
+      def head=(header)
+        store[HEAD] = header.rlp_encode
+      end
+
+      def get_header(hash)
+        encoded = store[HEADER_PREFIX + hash]
+        encoded && Header.rlp_decode(encoded)
+      end
+
+      def get_header_by_number(number)
+        hash = get_header_hash_by_number(number)
+        hash && get_header(hash)
+      end
+
+      def valid?(header)
+        # ignore genesis header if there not exist one
+        return true if header.number == 0 && get_header_by_number(0).nil?
+
+        parent_header = get_header(header.parent_hash)
+        return false unless parent_header
+        # check height
+        return false unless parent_header.number + 1 == header.number
+        # check timestamp
+        return false unless parent_header.timestamp < header.timestamp
+
+        # check gas limit range
+        parent_gas_limit = parent_header.gas_limit
+        gas_limit_max = parent_gas_limit + parent_gas_limit / 1024
+        gas_limit_min = parent_gas_limit - parent_gas_limit / 1024
+        gas_limit = header.gas_limit
+        return false unless gas_limit >= 5000 && gas_limit > gas_limit_min && gas_limit < gas_limit_max
+        return false unless calculate_difficulty(header, parent_header) == header.difficulty
+
+        # check pow
+        begin
+          POW.check_pow(header.number, header.mining_hash, header.mix_hash, header.nonce, header.difficulty)
+        rescue POW::InvalidError
+          return false
+        end
+
+        true
+      end
+
+      # calculate header difficulty
+      # you can find explain in Ethereum yellow paper: Block Header Validity section.
+      def calculate_difficulty(header, parent_header)
+        return header.difficulty if header.number == 0
+
+        x = parent_header.difficulty / 2048
+        y = header.ommers_hash == Utils::BLANK_SHA3 ? 1 : 2
+
+        # handle byzantium fork
+        # https://github.com/ethereum/EIPs/blob/181867ae830df5419eb9982d2a24797b2dcad28f/EIPS/eip-609.md
+        # https://github.com/ethereum/EIPs/blob/984cf5de90bbf5fbe7e49be227b0c2f9567e661e/EIPS/eip-100.md
+        byzantium_fork = byzantium_block && header.number > byzantium_block
+        # https://github.com/ethereum/EIPs/blob/984cf5de90bbf5fbe7e49be227b0c2f9567e661e/EIPS/eip-2.md
+        homestead_fork = homestead_block && header.number > homestead_block
+
+        time_factor = if byzantium_fork
+                        [y - (header.timestamp - parent_header.timestamp) / 9, -99].max
+                      elsif homestead_fork
+                        [1 - (header.timestamp - parent_header.timestamp) / 10, -99].max
+                      else
+                        (header.timestamp - parent_header.timestamp) < 13 ? 1 : -1
+                      end
+
+        # difficulty bomb
+        height = byzantium_fork ? [(header.number - 3000000), 0].max : header.number
+        height_factor = 2 ** (height / 100000 - 2)
+
+        difficulty = (parent_header.difficulty + x * time_factor + height_factor).to_i
+        [header.difficulty, difficulty].max
+      end
+
+      # write header
+      def write(header)
+        hash = header.get_hash
+        # get total difficulty
+        td = if header.number == 0
+               header.difficulty
+             else
+               parent_header = get_header(header.parent_hash)
+               raise "can't find parent from db" unless parent_header
+               parent_td = total_difficulty(parent_header.get_hash)
+               parent_td + header.difficulty
+             end
+        # write header and td
+        store.batch do |b|
+          b.put(HEADER_PREFIX + hash, header.rlp_encode)
+          b.put(HEADER_PREFIX + hash + TD_SUFFIX, RLP.encode(td, Integer))
+        end
+      end
+
+      def write_header_hash_number(header_hash, number)
+        enc_number = Utils.big_endian_encode number
+        store[HEADER_PREFIX + enc_number + NUM_SUFFIX] = header_hash
+      end
+
+      def get_header_hash_by_number(number)
+        enc_number = Utils.big_endian_encode number
+        store[HEADER_PREFIX + enc_number + NUM_SUFFIX]
+      end
+
+      def total_difficulty(header_hash = head.nil? ? nil : head.get_hash)
+        return 0 if header_hash.nil?
+        RLP.decode(store[HEADER_PREFIX + header_hash + TD_SUFFIX], Integer)
+      end
+
+    end
+  end
+end

data/lib/ciri/chain/transaction.rb

@@ -97,7 +97,7 @@ module Ciri
       end
 
       def get_hash
-        Utils.sha3 rlp_encode!
+        Utils.sha3 rlp_encode
       end
 
       # validate transaction

data/lib/ciri/crypto.rb

@@ -67,8 +67,8 @@ module Ciri
       end
 
       def signature
-        @signature ||= Utils.big_endian_encode_to_size(@r, "\x00".b, size: 32) +
-          Utils.big_endian_encode_to_size(@s, "\x00".b, size: 32) +
+        @signature ||= Utils.big_endian_encode(@r, "\x00".b, size: 32) +
+          Utils.big_endian_encode(@s, "\x00".b, size: 32) +
           Utils.big_endian_encode(@v, "\x00".b)
       end
 

data/lib/ciri/db/account_db.rb

@@ -0,0 +1,145 @@
+# 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 'ciri/trie'
+require 'ciri/types/account'
+require 'ciri/serialize'
+require 'ciri/utils/logger'
+
+module Ciri
+  module DB
+    class AccountDB
+
+      include Serialize
+      include Utils::Logger
+
+      attr_reader :db
+
+      def initialize(db, root_hash: nil)
+        @db = db
+        root_hash ||= Trie::BLANK_NODE_HASH
+        @trie = Trie.new(db: @db, root_hash: root_hash, prune: true)
+      end
+
+      def root_hash
+        @trie.root_hash
+      end
+
+      def store(address, key, value)
+        account = find_account address
+        trie = Trie.new(db: @db, root_hash: account.storage_root)
+
+        converted_key = convert_key Utils.big_endian_encode(key, size: 32)
+
+        if value && value != 0
+          trie[converted_key] = RLP.encode(value)
+        else
+          trie.delete(converted_key)
+        end
+        account.storage_root = trie.root_hash
+        update_account(address, account)
+      end
+
+      def fetch(address, key)
+        # remove unnecessary null byte from key
+        converted_key = convert_key Utils.big_endian_encode(key, size: 32)
+        account = find_account address
+        trie = Trie.new(db: @db, root_hash: account.storage_root)
+        value = trie[converted_key]
+        value.empty? ? 0 : RLP.decode(value, Integer)
+      end
+
+      def set_nonce(address, nonce)
+        account = find_account(address)
+        account.nonce = nonce
+        update_account(address, account)
+      end
+
+      def increment_nonce(address, value = 1)
+        account = find_account(address)
+        account.nonce += value
+        update_account(address, account)
+      end
+
+      def set_balance(address, balance)
+        account = find_account(address)
+        account.balance = balance
+        update_account(address, account)
+      end
+
+      def add_balance(address, value)
+        account = find_account(address)
+        account.balance += value
+        raise "value can't be negative" if account.balance < 0
+        update_account(address, account)
+      end
+
+      def set_account_code(address, code)
+        code ||= ''.b
+        account = find_account(address)
+        account.code_hash = Utils.sha3(code)
+        update_account(address, account)
+        db[account.code_hash] = code
+      end
+
+      def get_account_code(address)
+        db[find_account(address).code_hash] || ''.b
+      end
+
+      def touch_account(address)
+        update_account(address, find_account(address))
+      end
+
+      def find_account(address)
+        rlp_encoded_account = @trie[convert_key address]
+        if rlp_encoded_account.nil? || rlp_encoded_account.size == 0
+          Types::Account.new_empty
+        else
+          Types::Account.rlp_decode(rlp_encoded_account)
+        end
+      end
+
+      def delete_account(address)
+        @trie.delete(convert_key address)
+      end
+
+      def account_dead?(address)
+        find_account(address).empty?
+      end
+
+      private
+
+      def update_account(address, account)
+        debug 'update account'
+        debug Utils.to_hex(address)
+        debug account.serializable_attributes
+        @trie[convert_key address] = Types::Account.rlp_encode account
+      end
+
+      def convert_key(key)
+        Utils.sha3 key.to_s
+      end
+
+    end
+  end
+end