ciri 0.0.1 → 0.0.2

data/lib/ciri/db/backend/memory.rb

@@ -31,6 +31,18 @@ module Ciri
       # implement kvstore
       class Memory
 
+        class Batch
+          attr_reader :value
+
+          def initialize
+            @value = Hash.new
+          end
+
+          def put(k, v)
+            @value[k] = v
+          end
+        end
+
         class InvalidError < StandardError
         end
 
@@ -40,7 +52,12 @@ module Ciri
           @db = {}
         end
 
-        def_delegators :@db, :[], :[]=
+        def initialize_copy(orig)
+          super
+          @db = orig.instance_variable_get(:@db).dup
+        end
+
+        def_delegators :@db, :[], :[]=, :fetch, :delete, :include?
 
         def get(key)
           @db[key]
@@ -54,6 +71,12 @@ module Ciri
           keys.each(&blk)
         end
 
+        def batch
+          b = Batch.new
+          yield(b)
+          @db.merge! b.value
+        end
+
         def close
           @db = nil
         end

data/lib/ciri/devp2p/peer.rb

@@ -52,7 +52,7 @@ module Ciri
 
       def to_s
         @display_name ||= begin
-          Utils.data_to_hex(node_id.id)[0..8]
+          Utils.to_hex(node_id.id)[0..8]
         end
       end
 

data/lib/ciri/devp2p/rlpx/connection.rb

@@ -67,7 +67,7 @@ module Ciri
 
         # protocol handshake
         def protocol_handshake!(our_hs)
-          @frame_io.send_data(MESSAGES[:handshake], our_hs.rlp_encode!)
+          @frame_io.send_data(MESSAGES[:handshake], our_hs.rlp_encode)
           remote_hs = read_protocol_handshake
           # enable snappy compress if remote peer support
           @frame_io.snappy = remote_hs.version >= SNAPPY_PROTOCOL_VERSION
@@ -81,7 +81,7 @@ module Ciri
           receiver.handle_auth_msg(auth_msg)
 
           auth_ack_msg = receiver.auth_ack_msg
-          auth_ack_msg_plain_text = auth_ack_msg.rlp_encode!
+          auth_ack_msg_plain_text = auth_ack_msg.rlp_encode
           auth_ack_packet = if auth_msg.got_plain
                               raise NotImplementedError.new('not support pre eip8 plain text seal')
                             else
@@ -94,13 +94,13 @@ module Ciri
 
         def initiator_enc_handshake(initiator)
           initiator_auth_msg = initiator.auth_msg
-          auth_msg_plain_text = initiator_auth_msg.rlp_encode!
+          auth_msg_plain_text = initiator_auth_msg.rlp_encode
           # seal eip8
           auth_packet = seal_eip8(auth_msg_plain_text, initiator)
           @io.write(auth_packet)
 
           auth_ack_mgs_binary, auth_ack_packet = read_enc_handshake_msg(ENC_AUTH_RESP_MSG_LENGTH, initiator.private_key)
-          auth_ack_msg = AuthRespV4.rlp_decode! auth_ack_mgs_binary
+          auth_ack_msg = AuthRespV4.rlp_decode auth_ack_mgs_binary
           initiator.handle_auth_ack_msg(auth_ack_msg)
 
           initiator.extract_secrets(auth_packet, auth_ack_packet, initiator: true)
@@ -142,7 +142,7 @@ module Ciri
           if msg.code != MESSAGES[:handshake]
             raise UnexpectedMessageError.new("expected handshake, get #{msg.code}")
           end
-          ProtocolHandshake.rlp_decode!(msg.payload)
+          ProtocolHandshake.rlp_decode(msg.payload)
         end
 
         def set_timeout(io)

data/lib/ciri/eth/peer.rb

@@ -47,16 +47,16 @@ module Ciri
       def handshake(network_id, total_difficulty, head_hash, genesis_hash)
         status = Status.new(protocol_version: 63, network_id: network_id,
                             total_difficulty: total_difficulty, current_block: head_hash, genesis_block: genesis_hash)
-        io.send_data(Status::CODE, status.rlp_encode!)
+        io.send_data(Status::CODE, status.rlp_encode)
         msg = io.read_msg
-        @status = Status.rlp_decode!(msg.payload)
+        @status = Status.rlp_decode(msg.payload)
         @total_difficulty = @status.total_difficulty
         @status
       end
 
       def send_msg(msg_class, **data)
         msg = msg_class.new(data)
-        io.send_data(msg_class::CODE, msg.rlp_encode!)
+        io.send_data(msg_class::CODE, msg.rlp_encode)
       end
     end
 

data/lib/ciri/eth/protocol_manage.rb

@@ -104,13 +104,13 @@ module Ciri
             header.reverse! if get_header_msg.reverse
           end
 
-          headers_msg = BlockHeaders.new(headers: headers).rlp_encode!
+          headers_msg = BlockHeaders.new(headers: headers).rlp_encode
           peer.io.send_data(BlockHeaders::CODE, headers_msg)
         when BlockHeaders::CODE
-          headers = BlockHeaders.rlp_decode!(msg.payload).headers
+          headers = BlockHeaders.rlp_decode(msg.payload).headers
           synchronizer << [:receive_headers, peer, headers] unless headers.empty?
         when BlockBodies::CODE
-          bodies = BlockBodies.rlp_decode!(msg.payload).bodies
+          bodies = BlockBodies.rlp_decode(msg.payload).bodies
           synchronizer << [:receive_bodies, peer, bodies] unless bodies.empty?
         else
           raise StandardError, "unknown code #{msg.code}, #{msg}"

data/lib/ciri/eth/protocol_messages.rb

@@ -30,32 +30,33 @@ module Ciri
 
     # represent a hash or a number
     class HashOrNumber
-      include Ciri::RLP::Serializable
-
       attr_reader :value
 
-      def initialize(value)
-        @value = value
-      end
+      class << self
+        def rlp_encode(item)
+          value = item.value
+          if value.is_a? Integer
+            RLP.encode(value, Integer)
+          else
+            RLP.encode(value)
+          end
+        end
 
-      def rlp_encode!
-        if value.is_a? Integer
-          RLP.encode(value, Integer)
-        else
-          RLP.encode(value)
+        def rlp_decode(s)
+          s = StringIO.new(s) if s.is_a?(String)
+          # start with 0xA0, represent s is a 32 length hash bytes
+          c = s.getc
+          s.ungetc(c)
+          if c.ord == 0xa0
+            RLP.decode(s)
+          else
+            RLP.decode(s, Integer)
+          end
         end
       end
 
-      def self.rlp_decode!(s)
-        s = StringIO.new(s) if s.is_a?(String)
-        # start with 0xA0, represent s is a 32 length hash bytes
-        c = s.getc
-        s.ungetc(c)
-        if c.ord == 0xa0
-          RLP.decode(s)
-        else
-          RLP.decode(s, Integer)
-        end
+      def initialize(value)
+        @value = value
       end
     end
 
@@ -100,11 +101,11 @@ module Ciri
         @headers = headers
       end
 
-      def rlp_encode!
+      def rlp_encode
         Ciri::RLP.encode(@headers, [Chain::Header])
       end
 
-      def self.rlp_decode!(payload)
+      def self.rlp_decode(payload)
         new headers: Ciri::RLP.decode(payload, [Chain::Header])
       end
     end
@@ -118,11 +119,11 @@ module Ciri
         @hashes = hashes
       end
 
-      def rlp_encode!
+      def rlp_encode
         Ciri::RLP.encode(@hashes)
       end
 
-      def self.rlp_decode!(payload)
+      def self.rlp_decode(payload)
         new hashes: Ciri::RLP.decode(payload)
       end
     end
@@ -145,11 +146,11 @@ module Ciri
         @bodies = bodies
       end
 
-      def rlp_encode!
+      def rlp_encode
         Ciri::RLP.encode(@bodies, [Bodies])
       end
 
-      def self.rlp_decode!(bodies)
+      def self.rlp_decode(bodies)
         new bodies: Ciri::RLP.decode(bodies, [Bodies])
       end
     end

data/lib/ciri/ethash.rb

@@ -22,7 +22,6 @@
 
 
 require 'ffi'
-require 'ciri/utils/lib_c'
 
 module Ciri
 
@@ -30,6 +29,22 @@ module Ciri
   # from https://github.com/ethereum/ethash/blob/master/src/python/core.c
   module Ethash
 
+    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
+    end
+
     module Lib
       extend FFI::Library
       ffi_lib 'libethash'
@@ -88,7 +103,7 @@ module Ciri
       cache_size = cache_bytes.size
       raise Error.new("seed must be 32 bytes long, (was #{header_size})") if header_size != 32
 
-      cache_ptr = Utils::LibC.malloc(cache_size)
+      cache_ptr = LibC.malloc(cache_size)
       cache_ptr.write_string_length(cache_bytes, cache_size)
 
       light = Lib::Light.new
@@ -105,7 +120,7 @@ module Ciri
       result = [value[:mix_hash].get_bytes, value[:result].get_bytes]
 
       # release memory *_*
-      Utils::LibC.free cache_ptr
+      LibC.free cache_ptr
 
       result
     end

data/lib/ciri/evm.rb

@@ -21,15 +21,21 @@
 # THE SOFTWARE.
 
 
+require 'forwardable'
+require 'ciri/forks'
 require_relative 'evm/op'
 require_relative 'evm/vm'
-require_relative 'evm/account'
-require 'ciri/forks'
+require_relative 'evm/errors'
+require_relative 'types/account'
+require_relative 'types/receipt'
 
 module Ciri
   class EVM
+    extend Forwardable
+
+    ExecutionResult = Struct.new(:status, :state_root, :logs, :gas_used, :gas_price, :exception, keyword_init: true)
 
-    BLOCK_REWARD = 3 * 10.pow(18) # 3 ether
+    def_delegators :@state, :find_account, :account_dead?, :get_account_code, :state_root
 
     attr_reader :state
 
@@ -37,45 +43,69 @@ module Ciri
       @state = state
     end
 
-    # run block
-    def finalize_block(block)
-      # validate block
-      # transition
-      # apply_changes
-    end
-
-    def validate_block(block)
-      # valid ommers
-      # valid transactions(block.gas_used == transactions...gas)
-      # Reward miner, ommers(reward == block reward + ommers reward)
-      # apply changes
-      # verify state and block nonce
-      # 1. parent header root == trie(state[i]) 当前状态的 root 相等, 返回 state[i] otherwise state[0]
-    end
-
     # transition block
-    # block -> new block(mining)
-    # return new_block and status change
-    def transition(block)
+    def transition(block, check_gas_limit: true, check_gas_used: true)
+      receipts = []
+
+      total_gas_used = 0
       # execute transactions, we don't need to valid transactions, it should be done before evm(in Chain module).
       block.transactions.each do |transaction|
-        execute_transaction(transaction, header: block.header)
+        result = execute_transaction(transaction, header: block.header, ignore_exception: true)
+
+        total_gas_used += result.gas_used
+        if check_gas_limit && total_gas_used > block.header.gas_limit
+          raise InvalidTransition.new('reach block gas_limit')
+        end
+        if check_gas_used && total_gas_used > block.header.gas_used
+          raise InvalidTransition.new("incorrect gas_used, total_gas_used: #{total_gas_used}, block gas_used: #{block.header.gas_used}")
+        end
+
+        # calculate fee
+        fee = result.gas_used * result.gas_price
+
+        miner_account = find_account(block.header.beneficiary)
+        miner_account.balance += fee
+        state.set_balance(block.header.beneficiary, miner_account.balance)
+
+        # update actually state_root(after calculate fee)
+        result.state_root = state.state_root
+
+        receipts << Types::Receipt.new(state_root: result.state_root, gas_used: total_gas_used, logs: result.logs)
+      end
+
+      if check_gas_used && total_gas_used != block.header.gas_used
+        raise InvalidTransition.new("incorrect gas_used, actual used: #{total_gas_used} header: #{block.header.gas_used}")
       end
-      # status transfer
-      # state[c].balance += mining reward
-      # ommers: state[u.c].balance += uncle reward
-      #
-      # block.nonce
-      # block.mix
-      # R[i].gas_used = gas_used(state[i - 1], block.transactions[i]) + R[i - 1].gas_used
-      # R[i].logs = logs(state[i - 1], block.transactions[i])
-      # R[i].z = z(state[i - 1], block.transactions[i])
+
+      fork_config = Ciri::Forks.detect_fork(header: block.header, number: block.header.number)
+      rewards = fork_config.mining_rewards_of_block(block)
+
+      # apply rewards
+      rewards.each do |address, value|
+        if value > 0
+          account = find_account(address)
+          account.balance += value
+          state.set_balance(address, account.balance)
+        end
+      end
+
+      receipts
     end
 
     # execute transaction
     # @param t Transaction
     # @param header Chain::Header
     def execute_transaction(t, header: nil, block_info: nil, ignore_exception: false)
+      unless state.find_account(t.sender).balance >= t.gas_price * t.gas_limit + t.value
+        raise InvalidTransaction.new('account balance not enough')
+      end
+
+      # remove gas fee from account balance
+      state.add_balance(t.sender, -1 * t.gas_limit * t.gas_price)
+      fork_config = Ciri::Forks.detect_fork(header: header, number: block_info&.number)
+
+      gas_limit = t.gas_limit - fork_config.intrinsic_gas_of_transaction(t)
+
       instruction = Instruction.new(
         origin: t.sender,
         price: t.gas_price,
@@ -89,51 +119,66 @@ module Ciri
         instruction.bytes_code = t.data
         instruction.address = t.sender
       else
-        if (account = find_account t.to)
-          instruction.bytes_code = account.code
-          instruction.address = account.address
-        end
+        instruction.bytes_code = get_account_code(t.to)
+        instruction.address = t.to
         instruction.data = t.data
       end
 
       @vm = VM.spawn(
         state: state,
-        gas_limit: t.gas_limit,
+        gas_limit: gas_limit,
         instruction: instruction,
         header: header,
         block_info: block_info,
-        fork_config: Ciri::Forks.detect_fork(header: header, number: block_info&.number)
+        fork_config: fork_config
       )
 
+      # transact ether
+      exception = nil
+      # begin
       if t.contract_creation?
         # contract creation
-        @vm.create_contract(value: instruction.value, init: instruction.bytes_code)
+        _, exception = @vm.create_contract(value: instruction.value, init: instruction.bytes_code)
       else
-        # transact ether
-        begin
-          @vm.transact(sender: t.sender, value: t.value, to: t.to)
-        rescue VM::VMError
-          raise unless ignore_exception
-          return nil
-        end
-        @vm.run(ignore_exception: ignore_exception)
+        _, _, exception = @vm.call_message(sender: t.sender, value: t.value, receipt: t.to, data: t.data)
       end
-      nil
+      # rescue ArgumentError => e
+      #   raise unless ignore_exception
+      #   exception = e
+      # end
+      raise exception if !ignore_exception && exception
+
+      # refund gas
+      refund_gas = fork_config.calculate_refund_gas(@vm)
+      gas_used = t.gas_limit - @vm.remain_gas
+      refund_gas = [refund_gas, gas_used / 2].min
+      state.add_balance(t.sender, (refund_gas + @vm.remain_gas) * t.gas_price)
+
+      # destroy accounts
+      @vm.sub_state.suicide_accounts.each do |address|
+        state.set_balance(address, 0)
+        state.delete_account(address)
+      end
+
+      ExecutionResult.new(status: @vm.status, state_root: state_root, logs: @vm.sub_state.log_series, gas_used: gas_used - refund_gas,
+                          gas_price: t.gas_price, exception: @vm.exception)
     end
 
     def logs_hash
-      return nil unless @vm
-      Utils.sha3(RLP.encode_simple(@vm.sub_state.log_series))
+      # return nil unless @vm
+      Utils.sha3(RLP.encode_simple(vm.sub_state.log_series))
     end
 
     private
 
-    def account_dead?(address)
-      Account.account_dead?(state, address)
-    end
-
-    def find_account(address)
-      Account.find_account(state, address)
+    def vm
+      @vm ||= VM.spawn(
+        state: state,
+        gas_limit: 0,
+        instruction: nil,
+        block_info: BlockInfo.new,
+        fork_config: nil
+      )
     end
 
   end