ciri 0.0.1 → 0.0.2

data/lib/ciri/forks.rb

@@ -26,12 +26,9 @@ require_relative 'forks/frontier'
 module Ciri
   module Forks
 
-    # Fork configure
-    ForkConfig = Struct.new(:cost_of_operation, :cost_of_memory, :intrinsic_gas_of_transaction, keyword_init: true)
-
     def self.detect_fork(header: nil, number: nil)
       number ||= header.number
-      Frontier.fork_config
+      Frontier::Config.new
     end
 
   end

data/lib/ciri/forks/base.rb

@@ -0,0 +1,55 @@
+# 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.
+
+
+module Ciri
+  module Forks
+
+    class Base
+      # gas methods
+      def gas_of_operation(vm)
+        raise NotImplementedError
+      end
+
+      def gas_of_memory(word_count)
+        raise NotImplementedError
+      end
+
+      def intrinsic_gas_of_transaction(transaction)
+        raise NotImplementedError
+      end
+
+      def calculate_deposit_code_gas(code_bytes)
+        raise NotImplementedError
+      end
+
+      def mining_rewards_of_block(block)
+        raise NotImplementedError
+      end
+
+      def calculate_refund_gas(vm)
+        raise NotImplementedError
+      end
+    end
+
+  end
+end

data/lib/ciri/forks/frontier.rb

@@ -21,23 +21,50 @@
 # THE SOFTWARE.
 
 
-require 'ciri/evm/forks/frontier'
+require_relative 'base'
+require_relative 'frontier/cost'
 
 module Ciri
   module Forks
     module Frontier
+      class Config < Base
 
-      class << self
-        def fork_config
-          ForkConfig.new(
-            cost_of_operation: proc {|vm| EVM::Forks::Frontier::Cost.cost_of_operation vm},
-            cost_of_memory: proc {|i| EVM::Forks::Frontier::Cost.cost_of_memory i},
-            intrinsic_gas_of_transaction: proc {|t| EVM::Forks::Frontier::Cost.intrinsic_gas_of_transaction t}
-          # transaction_klass: nil
-          )
+        BLOCK_REWARD = 5 * 10.pow(18) # 5 ether
+
+        # gas methods
+        def gas_of_operation(vm)
+          Cost.cost_of_operation vm
         end
-      end
 
+        def gas_of_memory(word_count)
+          Cost.cost_of_memory word_count
+        end
+
+        def intrinsic_gas_of_transaction(transaction)
+          Cost.intrinsic_gas_of_transaction transaction
+        end
+
+        def calculate_deposit_code_gas(code_bytes)
+          Cost::G_CODEDEPOSIT * (code_bytes || ''.b).size
+        end
+
+        def calculate_refund_gas(vm)
+          vm.sub_state.suicide_accounts.size * Cost::R_SELFDESTRUCT
+        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
+
+      end
     end
   end
 end

data/lib/ciri/forks/frontier/cost.rb

@@ -0,0 +1,186 @@
+# 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/evm/op'
+
+module Ciri
+  module Forks
+    module Frontier
+
+      module Cost
+
+        include Ciri::EVM::OP
+
+        #   fee schedule, start with G
+        G_ZERO = 0
+        G_BASE = 2
+        G_VERYLOW = 3
+        G_LOW = 5
+        G_MID = 8
+        G_HIGH = 10
+        G_EXTCODE = 700
+        G_BALANCE = 400
+        G_SLOAD = 50
+        G_JUMPDEST = 1
+        G_SSET = 20000
+        G_RESET = 5000
+        R_SCLEAR = 15000
+        R_SELFDESTRUCT = 24000
+        G_SELFDESTRUCT = 0
+        G_CREATE = 32000
+        G_CODEDEPOSIT = 200
+        G_CALL = 700
+        G_CALLVALUE = 9000
+        G_CALLSTIPEND = 2300
+        G_NEWACCOUNT = 25000
+        G_EXP = 10
+        G_EXPBYTE = 10
+        G_MEMORY = 3
+        G_TXCREATE = 32000
+        G_TXDATAZERO = 4
+        G_TXDATANONZERO = 68
+        G_TRANSACTION = 21000
+        G_LOG = 375
+        G_LOGDATA = 8
+        G_TOPIC = 375
+        G_SHA3 = 30
+        G_SHA3WORD = 6
+        G_COPY = 3
+        G_BLOCKHASH = 20
+        G_QUADDIVISOR = 100
+
+        # operation code by group, for later calculation
+        W_ZERO = [STOP, RETURN, REVERT]
+        W_BASE = [ADDRESS, ORIGIN, CALLER, CALLVALUE, CALLDATASIZE, CODESIZE, GASPRICE,
+                  COINBASE, TIMESTAMP, NUMBER, DIFFICULTY, GASLIMIT, RETURNDATASIZE,
+                  POP, PC, MSIZE, GAS]
+        W_VERYLOW = [ADD, SUB, NOT, LT, GT, SLT, SGT, EQ, ISZERO, AND, OR,
+                     XOR, BYTE, CALLDATALOAD, MLOAD, MSTORE, MSTORE8,
+                     *(1..32).map {|i| EVM::OP.get(PUSH1 + i - 1).code}, # push1 - push32
+                     *(1..16).map {|i| EVM::OP.get(DUP1 + i - 1).code}, # dup1 - dup16
+                     *(1..16).map {|i| EVM::OP.get(SWAP1 + i - 1).code}] # swap1 - swap16
+        W_LOW = [MUL, DIV, SDIV, MOD, SMOD, SIGNEXTEND]
+        W_MID = [ADDMOD, MULMOD, JUMP]
+        W_HIGH = [JUMPI]
+        W_EXTCODE = [EXTCODESIZE]
+
+
+        class << self
+          include Ciri::EVM::OP
+
+          # C(σ,μ,I)
+          # calculate cost of current operation
+          def cost_of_operation(vm)
+            ms = vm.machine_state
+            instruction = vm.instruction
+            w = instruction.get_op(ms.pc)
+            if w == SSTORE
+              cost_of_sstore(vm)
+            elsif w == EXP && ms.get_stack(1, Integer) == 0
+              G_EXP
+            elsif w == EXP && (x = ms.get_stack(1, Integer)) > 0
+              G_EXP + G_EXPBYTE * Utils.ceil_div(x.bit_length, 8)
+            elsif w == CALLDATACOPY || w == CODECOPY || w == RETURNDATACOPY
+              G_VERYLOW + G_COPY * Utils.ceil_div(ms.get_stack(2, Integer), 32)
+            elsif w == EXTCODECOPY
+              G_EXTCODE + G_COPY * Utils.ceil_div(ms.get_stack(3, Integer), 32)
+            elsif (LOG0..LOG4).include? w
+              G_LOG + G_LOGDATA * ms.get_stack(1, Integer) + (w - LOG0) * G_TOPIC
+            elsif w == CALL || w == CALLCODE || w == DELEGATECALL
+              1 # cost_of_call(state, ms)
+            elsif w == SELFDESTRUCT
+              cost_of_self_destruct(vm)
+            elsif w == CREATE
+              G_CREATE
+            elsif w == SHA3
+              G_SHA3 + G_SHA3WORD * Utils.ceil_div(ms.get_stack(1, Integer), 32)
+            elsif w == JUMPDEST
+              G_JUMPDEST
+            elsif w == SLOAD
+              G_SLOAD
+            elsif W_ZERO.include? w
+              G_ZERO
+            elsif W_BASE.include? w
+              G_BASE
+            elsif W_VERYLOW.include? w
+              G_VERYLOW
+            elsif W_LOW.include? w
+              G_LOW
+            elsif W_MID.include? w
+              G_MID
+            elsif W_HIGH.include? w
+              G_HIGH
+            elsif W_EXTCODE.include? w
+              G_EXTCODE
+            elsif w == BALANCE
+              G_BALANCE
+            elsif w == BLOCKHASH
+              G_BLOCKHASH
+            else
+              raise "can't compute cost for unknown op #{w}"
+            end
+          end
+
+          def cost_of_memory(i)
+            G_MEMORY * i + (i ** 2) / 512
+          end
+
+          def intrinsic_gas_of_transaction(t)
+            gas = (t.data.each_byte || '').reduce(0) {|sum, i| sum + (i.zero? ? G_TXDATAZERO : G_TXDATANONZERO)}
+            # gas + (t.to.empty? ? G_TXCREATE : 0) + G_TRANSACTION
+            gas + G_TRANSACTION
+          end
+
+          private
+
+          def cost_of_self_destruct(vm)
+            G_SELFDESTRUCT
+          end
+
+          def cost_of_call
+
+          end
+
+          def cost_of_sstore(vm)
+            ms = vm.machine_state
+            instruction = vm.instruction
+
+            key = ms.get_stack(0, Integer)
+            value = ms.get_stack(1, Integer)
+
+            stored_is_empty = vm.fetch(instruction.address, key).zero?
+            value_is_non_zero = value && !value.zero?
+
+            if value_is_non_zero && stored_is_empty
+              G_SSET
+            else
+              G_RESET
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/ciri/key.rb

@@ -79,7 +79,7 @@ module Ciri
       privkey = ec_key.private_key.to_s(2)
       # some times below error will occurs, raise error with more detail
       unless privkey.instance_of?(String) && privkey.size == 32
-        raise ArgumentError, "privkey must be composed of 32 bytes, #{bytes}: #{privkey.size} privkey: #{Utils.data_to_hex privkey}"
+        raise ArgumentError, "privkey must be composed of 32 bytes, #{bytes}: #{privkey.size} privkey: #{Utils.to_hex privkey}"
       end
       @secp256k1_key ||= Crypto.ensure_secp256k1_key(privkey: privkey)
     end

data/lib/ciri/pow.rb

@@ -68,7 +68,7 @@ module Ciri
       out_mix_hash, out_result = Ethash.hashimoto_light(block_number, cache, mining_hash, Utils.big_endian_decode(nonce_bytes))
 
       if out_mix_hash != mix_hash
-        raise InvalidError.new("mix hash mismatch; #{Utils.data_to_hex(out_mix_hash)} != #{Utils.data_to_hex(mix_hash)}")
+        raise InvalidError.new("mix hash mismatch; #{Utils.to_hex(out_mix_hash)} != #{Utils.to_hex(mix_hash)}")
       end
 
       result = Utils.big_endian_decode(out_result)

data/lib/ciri/rlp/decode.rb

@@ -68,12 +68,15 @@ module Ciri
           else
             raise InvalidValueError.new "invalid bool value #{item}"
           end
-        elsif type.is_a?(Class) && type < Serializable
-          type.rlp_decode!(s)
+        elsif type.is_a?(Class) && type.respond_to?(:rlp_decode)
+          type.rlp_decode(s)
         elsif type.is_a?(Array)
           decode_list(s) do |list, s2|
+            i = 0
             until s2.eof?
-              list << decode_with_type(s2, type[0])
+              t = type.size > i ? type[i] : type[-1]
+              list << decode_with_type(s2, t)
+              i += 1
             end
           end
         elsif type == Raw

data/lib/ciri/rlp/encode.rb

@@ -28,25 +28,25 @@ module Ciri
       class InputOverflow < StandardError
       end
 
-      # Encode input to rlp encoding, only allow string or array
+      # Encode input to rlp encoding
       #
       # Examples:
       #
       #   Ciri::RLP.encode("hello world")
       #
-      def encode(input, type = Raw)
-        encode_with_type(input, type)
+      def encode(input, type = nil)
+        type ? encode_with_type(input, type) : encode_simple(input)
       end
 
       def encode_simple(input)
         if input.is_a?(Array)
           encode_list(input) {|i| encode_simple(i)}
         elsif input.is_a?(Integer)
-          encode(input, Integer)
-        elsif input.is_a?(Serializable)
-          input.rlp_encode!
+          encode_with_type(input, Integer)
+        elsif input.class.respond_to?(:rlp_encode)
+          input.class.rlp_encode(input)
         else
-          encode(input)
+          encode_with_type(input, Raw)
         end
       end
 
@@ -70,8 +70,8 @@ module Ciri
           end
         elsif type == Bool
           item ? Bool::ENCODED_TRUE : Bool::ENCODED_FALSE
-        elsif type.is_a?(Class) && type < Serializable
-          item.rlp_encode!
+        elsif type.is_a?(Class) && type.respond_to?(:rlp_encode)
+          type.rlp_encode(item)
         elsif type.is_a?(Array)
           if type.size == 1 # array type
             encode_list(item) {|i| encode_with_type(i, type[0])}
@@ -84,7 +84,7 @@ module Ciri
           raise RLP::InvalidValueError.new "unknown type #{type}"
         end
       rescue
-        STDERR.puts "when encoding #{Utils.data_to_hex item.to_s} into #{type}"
+        STDERR.puts "when encoding #{Utils.to_hex item.to_s} into #{type}"
         raise
       end
 

data/lib/ciri/rlp/serializable.rb

@@ -69,8 +69,8 @@ module Ciri
     #   end
     #
     #   msg = AuthMsgV4.new(signature: "\x00", initiator_pubkey: my_pubkey, nonce: [1, 2, 3], version: 4)
-    #   encoded = msg.rlp_encode!
-    #   msg2 = AuthMsgV4.rlp_decode!(encoded)
+    #   encoded = msg.rlp_encode
+    #   msg2 = AuthMsgV4.rlp_decode(encoded)
     #   msg == msg2 # true
     #
     module Serializable
@@ -125,7 +125,7 @@ module Ciri
           end
         end
 
-        def rlp_encode!(data, skip_keys: nil, white_list_keys: nil)
+        def rlp_encode(data, skip_keys: nil, white_list_keys: nil)
           # pre-encode, encode data to rlp compatible format(only string or array)
           used_keys = if white_list_keys
                         white_list_keys
@@ -143,7 +143,7 @@ module Ciri
           encode_list(data_list)
         end
 
-        def rlp_decode!(input)
+        def rlp_decode(input)
           values = decode_list(input) do |list, stream|
             keys.each do |key|
               # decode data by type
@@ -159,7 +159,7 @@ module Ciri
 
         def check_key_type(type)
           return true if TYPES.key?(type)
-          return true if type.is_a?(Class) && type < Serializable
+          return true if type.is_a?(Class) && type.respond_to?(:rlp_decode) && type.respond_to?(:rlp_encode)
 
           if type.is_a?(Array) && type.size == 1
             check_key_type(type[0])
@@ -172,11 +172,14 @@ module Ciri
       module ClassMethods
         # Decode object from input
         def rlp_decode(input)
-          data = schema.rlp_decode!(input)
+          data = schema.rlp_decode(input)
           self.new(data)
         end
 
-        alias rlp_decode! rlp_decode
+        # Encode object to rlp encoding string
+        def rlp_encode(item, skip_keys: nil, white_list_keys: nil)
+          schema.rlp_encode(item.serializable_attributes, skip_keys: skip_keys, white_list_keys: white_list_keys)
+        end
 
         def schema(data_schema = nil)
           @data_schema ||= Schema.new(data_schema).tap do |schema|
@@ -225,8 +228,8 @@ module Ciri
       end
 
       # Encode object to rlp encoding string
-      def rlp_encode!(skip_keys: nil, white_list_keys: nil)
-        self.class.schema.rlp_encode!(serializable_attributes, skip_keys: skip_keys, white_list_keys: white_list_keys)
+      def rlp_encode(skip_keys: nil, white_list_keys: nil)
+        self.class.rlp_encode(self, skip_keys: skip_keys, white_list_keys: white_list_keys)
       end
 
       def ==(other)