ruby-ethereum 0.9.0

data/lib/ethereum/env.rb

@@ -0,0 +1,64 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class Env
+
+    DEFAULT_CONFIG = {
+      # Genesis constants
+      genesis_difficulty: 131072,
+      genesis_gas_limit: 3141592,
+      genesis_prevhash: Constant::HASH_ZERO,
+      genesis_coinbase: Address::ZERO,
+      genesis_nonce: Utils.zpad_int(42, 8),
+      genesis_mixhash: Constant::HASH_ZERO,
+      genesis_timestamp: 0,
+      genesis_extra_data: Constant::BYTE_EMPTY,
+      genesis_initial_alloc: {},
+
+      # Gas limit adjustment algo:
+      #
+      # block.gas_limit = block.parent.gas_limit * 1023/1024 +
+      #                     (block.gas.used * 6/5) / 1024
+      min_gas_limit: 5000,
+      gaslimit_ema_factor: 1024,
+      gaslimit_adjmax_factor: 1024,
+      blklim_factor_nom: 3,
+      blklim_factor_den: 2,
+
+      block_reward:  5000.finney,
+      nephew_reward: 5000.finney/32, # block_reward/32
+
+      # GHOST constants
+      uncle_depth_penalty_factor: 8,
+      max_uncle_depth: 6, # max (block.number - uncle.number)
+      max_uncles: 2,
+
+      diff_adjustment_cutoff: 13,
+      block_diff_factor: 2048,
+      min_diff: 131072,
+
+      pow_epoch_length: 30000,
+
+      max_extradata_length: 32,
+
+      expdiff_period: 100000,
+      expdiff_free_periods: 2,
+
+      account_initial_nonce: 0,
+
+      homestead_fork_blknum: 1150000,
+      homestead_diff_adjustment_cutoff: 10
+    }.freeze
+
+    attr :db, :config, :global_config
+
+    def initialize(db, config: nil, global_config: {})
+      @db = db
+      @config = config || DEFAULT_CONFIG
+      @global_config = global_config
+
+      raise "invalid nephew/block reward config" unless @config[:nephew_reward] == @config[:block_reward]/32
+    end
+
+  end
+end

data/lib/ethereum/ethash.rb

@@ -0,0 +1,78 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'ethash'
+require 'ethereum/ethash_ruby'
+
+module Ethereum
+  module Ethash
+
+    EPOCH_LENGTH = ::Ethash::EPOCH_LENGTH
+
+    CACHE_BY_SEED_MAX = 32
+
+    class <<self
+      def seeds
+        @seeds ||= ["\x00"*32]
+      end
+
+      def get_seed(block_number)
+        epoch_no = block_number / EPOCH_LENGTH
+        while seeds.size <= epoch_no
+          seeds.push Ethereum::Utils.keccak256(seeds.last)
+        end
+
+        seeds[epoch_no]
+      end
+
+      def cache_by_seed
+        @cache_by_seed ||= {} # ordered hash
+      end
+
+      def cache_by_file(block_number, data=nil)
+        path = "/tmp/ruby_ethereum_hashimoto_cache_#{block_number}"
+        if data
+          File.open(path, 'wb') {|f| f.write Marshal.dump(data) }
+        else
+          if File.exist?(path)
+            File.open(path, 'rb') {|f| Marshal.load f.read }
+          else
+            nil
+          end
+        end
+      end
+
+      def get_cache(blknum)
+        seed = get_seed blknum
+
+        if cache_by_seed.has_key?(seed)
+          c = cache_by_seed.delete seed # pop
+          cache_by_seed[seed] = c # and append at end
+          return c
+        end
+
+        if c = cache_by_file(Utils.encode_hex(seed))
+          cache_by_seed[seed] = c
+          return c
+        end
+
+        # Use c++ implementation or ethash_ruby
+        c = ::Ethash.mkcache_bytes blknum
+        #c = EthashRuby::Cache.new(blknum).to_a
+
+        cache_by_seed[seed] = c
+        cache_by_file Utils.encode_hex(seed), c
+        if cache_by_seed.size > CACHE_BY_SEED_MAX
+          cache_by_seed.delete cache_by_seed.keys.first # remove last recently accessed
+        end
+
+        c
+      end
+
+      def hashimoto_light(blknum, cache, mining_hash, bin_nonce)
+        nonce = Utils.big_endian_to_int(bin_nonce)
+        ::Ethash.hashimoto_light blknum, cache, mining_hash, nonce
+      end
+    end
+
+  end
+end

data/lib/ethereum/ethash_ruby.rb

@@ -0,0 +1,38 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'ethereum/ethash_ruby/utils'
+require 'ethereum/ethash_ruby/cache'
+require 'ethereum/ethash_ruby/hashimoto'
+
+module Ethereum
+  module EthashRuby
+
+    EPOCH_LENGTH = 30000         # blocks per epoch
+    ACCESSES = 64                # number of accesses in hashimoto loop
+
+    DATASET_BYTES_INIT = 2**30   # bytes in dataset at genesis
+    DATASET_BYTES_GROWTH = 2**23 # growth per epoch (~ 7GB per year)
+    DATASET_PARENTS = 256        # number of parents of each dataset element
+
+    CACHE_BYTES_INIT = 2**24     # size of the dataset relative to the cache
+    CACHE_BYTES_GROWTH = 2**17   # size of the dataset relative to the cache
+    CACHE_ROUNDS = 3             # number of rounds in cache production
+
+    WORD_BYTES = 4               # bytes in word
+    MIX_BYTES = 128              # width of mix
+    HASH_BYTES = 64              # hash length in bytes
+
+    FNV_PRIME = 0x01000193
+
+    class <<self
+      def hashimoto_light(*args)
+        ::Ethereum::Ethash::Hashimoto.new.light(*args)
+      end
+
+      def get_cache(*args)
+        ::Ethereum::Ethash::Cache.get(*args)
+      end
+    end
+
+  end
+end

data/lib/ethereum/ethash_ruby/cache.rb

@@ -0,0 +1,47 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'prime'
+
+module Ethereum
+  module EthashRuby
+
+    class Cache
+      include Utils
+
+      def initialize(block_number)
+        @block_number = block_number
+      end
+
+      def to_a
+        n = size / HASH_BYTES
+
+        o = [keccak512(seed)]
+        (1...n).each {|i| o.push keccak512(o.last) }
+
+        CACHE_ROUNDS.times do
+          n.times do |i|
+            v = o[i][0] % n
+            xor = o[(i-1+n) % n].zip(o[v]).map {|(a,b)| a^b }
+            o[i] = keccak512 xor
+          end
+        end
+
+        o
+      end
+
+      def seed
+        @seed ||= self.class.get_seed(@block_number)
+      end
+
+      def size
+        sz = CACHE_BYTES_INIT + CACHE_BYTES_GROWTH * (@block_number / EPOCH_LENGTH)
+        sz -= HASH_BYTES
+
+        sz -= 2 * HASH_BYTES while !Prime.prime?(sz / HASH_BYTES)
+        sz
+      end
+
+    end
+
+  end
+end

data/lib/ethereum/ethash_ruby/hashimoto.rb

@@ -0,0 +1,75 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'prime'
+
+module Ethereum
+  module EthashRuby
+
+    class Hashimoto
+      include Utils
+
+      def light(block_number, cache, header, nonce)
+        run header, nonce, get_full_size(block_number) do |x|
+          calc_dataset_item(cache, x)
+        end
+      end
+
+      def run(header, nonce, full_size, &dataset_lookup)
+        n = full_size / HASH_BYTES
+        w = MIX_BYTES / WORD_BYTES
+        mixhashes = MIX_BYTES / HASH_BYTES
+
+        s = keccak512(header + nonce.reverse)
+
+        mix = []
+        mixhashes.times { mix.concat s }
+
+        ACCESSES.times do |i|
+          p = fnv(i ^ s[0], mix[i % w]) % (n / mixhashes) * mixhashes
+
+          newdata = []
+          mixhashes.times {|j| newdata.concat dataset_lookup.call(p + j) }
+          mix = mix.zip(newdata).map {|(a,b)| fnv(a, b) }
+        end
+
+        cmix = []
+        (mix.size / WORD_BYTES).times do |i|
+          i *= WORD_BYTES
+          cmix.push fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3])
+        end
+
+        { mixhash: serialize_hash(cmix),
+          result: serialize_hash(keccak256(s + cmix)) }
+      end
+
+      def calc_dataset_item(cache, i)
+        n = cache.size
+        r = HASH_BYTES / WORD_BYTES
+
+        mix = cache[i % n].dup
+        mix[0] ^= i
+        mix = keccak512 mix
+
+        DATASET_PARENTS.times do |j|
+          cache_index = fnv(i ^ j, mix[j % r])
+          mix = mix.zip(cache[cache_index % n]).map {|(v1,v2)| fnv(v1, v2) }
+        end
+
+        keccak512(mix)
+      end
+
+      def fnv(v1, v2)
+        (v1 * FNV_PRIME ^ v2) % Constant::TT32
+      end
+
+      def get_full_size(block_number)
+        sz = DATASET_BYTES_INIT + DATASET_BYTES_GROWTH * (block_number / EPOCH_LENGTH)
+        sz -= MIX_BYTES
+        sz -= 2 * MIX_BYTES while !Prime.prime?(sz / MIX_BYTES)
+        sz
+      end
+
+    end
+
+  end
+end

data/lib/ethereum/ethash_ruby/utils.rb

@@ -0,0 +1,53 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module EthashRuby
+    module Utils
+
+      # sha3 hash function, outputs 64 bytes
+      def keccak512(x)
+        hash_words(x) do |v|
+          Ethereum::Utils.keccak512(v)
+        end
+      end
+
+      def keccak256(x)
+        hash_words(x) do |v|
+          Ethereum::Utils.keccak256(v)
+        end
+      end
+
+      def hash_words(x, &block)
+        x = serialize_hash(x) if x.instance_of?(Array)
+        y = block.call(x)
+        deserialize_hash(y)
+      end
+
+      def serialize_hash(h)
+        h.map {|x| zpad(encode_int(x), WORD_BYTES) }.join
+      end
+
+      def deserialize_hash(h)
+        (h.size / WORD_BYTES).times.map do |i|
+          i *= WORD_BYTES
+          decode_int h[i, WORD_BYTES]
+        end
+      end
+
+      def encode_int(i)
+        # `pack('L<`) will introduce leading zeros
+        Ethereum::Utils.int_to_big_endian(i).reverse
+      end
+
+      # Assumes little endian bit ordering (same as Intel architectures)
+      def decode_int(s)
+        s && !s.empty? ? s.unpack('L<').first : 0
+      end
+
+      def zpad(s, len)
+        s + "\x00" * [0, len - s.size].max
+      end
+
+    end
+  end
+end

data/lib/ethereum/exceptions.rb

@@ -0,0 +1,28 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+
+  class DeprecatedError < StandardError; end
+  class ChecksumError < StandardError; end
+  class FormatError < StandardError; end
+  class ValidationError < StandardError; end
+  class ValueError < StandardError; end
+  class AssertError < StandardError; end
+
+  class UnknownParentError < StandardError; end
+  class InvalidBlock < ValidationError; end
+  class InvalidUncles < ValidationError; end
+
+  class InvalidTransaction < ValidationError; end
+  class UnsignedTransactionError < InvalidTransaction; end
+  class InvalidNonce < InvalidTransaction; end
+  class InsufficientStartGas < InvalidTransaction; end
+  class InsufficientBalance < InvalidTransaction; end
+  class BlockGasLimitReached < InvalidTransaction; end
+
+  class InvalidSPVProof < ValidationError; end
+
+  class ContractCreationFailed < StandardError; end
+  class TransactionFailed < StandardError; end
+
+end

data/lib/ethereum/external_call.rb

@@ -0,0 +1,173 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'forwardable'
+
+module Ethereum
+
+  ##
+  # External calls that can be made from inside the VM. To use the EVM with a
+  # different blockchain system, database, set parameters for testing, just
+  # swap out the functions here.
+  #
+  class ExternalCall
+
+    extend Forwardable
+    def_delegators :@block, :get_code, :get_balance, :set_balance, :get_storage_data, :set_storage_data, :add_refund, :account_exists
+
+    def initialize(block, tx)
+      @block = block
+      @tx = tx
+    end
+
+    def log_storage(x)
+      @block.account_to_dict(x)[:storage]
+    end
+
+    def add_suicide(x)
+      @block.suicides.push x
+    end
+
+    def block_hash(x)
+      d = @block.number - x
+      if d > 0 && d <= 256
+        @block.get_ancestor_hash d
+      else
+        Constant::BYTE_EMPTY
+      end
+    end
+
+    def block_coinbase
+      @block.coinbase
+    end
+
+    def block_timestamp
+      @block.timestamp
+    end
+
+    def block_number
+      @block.number
+    end
+
+    def block_difficulty
+      @block.difficulty
+    end
+
+    def block_gas_limit
+      @block.gas_limit
+    end
+
+    def log(addr, topics, data)
+      @block.add_log Log.new(addr, topics, data)
+    end
+
+    def tx_origin
+      @tx.sender
+    end
+
+    def tx_gasprice
+      @tx.gasprice
+    end
+
+    def post_homestead_hardfork
+      @block.number >= @block.config[:homestead_fork_blknum]
+    end
+
+    def create(msg)
+      log_msg.debug 'CONTRACT CREATION'
+
+      sender = Utils.normalize_address(msg.sender, allow_blank: true)
+
+      @block.increment_nonce msg.sender if tx_origin != msg.sender
+
+      nonce = Utils.encode_int(@block.get_nonce(msg.sender) - 1)
+      msg.to = Utils.mk_contract_address sender, nonce
+
+      balance = get_balance(msg.to)
+      if balance > 0
+        set_balance msg.to, balance
+        @block.set_nonce msg.to, 0
+        @block.set_code msg.to, Constant::BYTE_EMPTY
+        @block.reset_storage msg.to
+      end
+
+      msg.is_create = true
+
+      code = msg.data.extract_all
+      msg.data = VM::CallData.new [], 0, 0
+      snapshot = @block.snapshot
+
+      res, gas, dat = apply_msg msg, code
+
+      if res.true?
+        return 1, gas, msg.to if dat.empty?
+
+        gcost = dat.size * Opcodes::GCONTRACTBYTE
+        if gas >= gcost
+          gas -= gcost
+        else
+          dat = []
+          log_msg.debug "CONTRACT CREATION OOG", have: gas, want: gcost, block_number: @block.number
+
+          if @block.number >= @block.config[:homestead_fork_blknum]
+            @block.revert snapshot
+            return 0, 0, Constant::BYTE_EMPTY
+          end
+        end
+
+        @block.set_code msg.to, Utils.int_array_to_bytes(dat)
+        return 1, gas, msg.to
+      else
+        return 0, gas, Constant::BYTE_EMPTY
+      end
+    end
+
+    def apply_msg(msg, code=nil)
+      code ||= get_code msg.code_address
+
+      log_msg.debug "MSG APPLY",  sender: Utils.encode_hex(msg.sender), to: Utils.encode_hex(msg.to), gas: msg.gas, value: msg.value, data: Utils.encode_hex(msg.data.extract_all)
+      log_state.trace "MSG PRE STATE SENDER", account: Utils.encode_hex(msg.sender), balance: get_balance(msg.sender), state: log_storage(msg.sender)
+      log_state.trace "MSG PRE STATE RECIPIENT", account: Utils.encode_hex(msg.to), balance: get_balance(msg.to), state: log_storage(msg.to)
+
+      # snapshot before execution
+      snapshot = @block.snapshot
+
+      # transfer value
+      if msg.transfers_value
+        unless @block.transfer_value(msg.sender, msg.to, msg.value)
+          log_msg.debug "MSG TRANSFER FAILED", have: get_balance(msg.to), want: msg.value
+          return [1, msg.gas, []]
+        end
+      end
+
+      # main loop
+      if SpecialContract[msg.code_address]
+        res, gas, dat = SpecialContract[msg.code_address].call(self, msg)
+      else
+        res, gas, dat = VM.execute self, msg, code
+      end
+
+      log_msg.trace "MSG APPLIED", gas_remained: gas, sender: msg.sender, to: msg.to, data: dat
+      log_state.trace "MSG POST STATE SENDER", account: Utils.encode_hex(msg.sender), balance: get_balance(msg.sender), state: log_storage(msg.sender)
+      log_state.trace "MSG POST STATE RECIPIENT", account: Utils.encode_hex(msg.to), balance: get_balance(msg.to), state: log_storage(msg.to)
+
+      if res == 0
+        log_msg.debug 'REVERTING'
+        @block.revert snapshot
+      end
+
+      return res, gas, dat
+    end
+
+    private
+
+    def log_msg
+      @log_msg ||= Logger.new 'eth.external_call.msg'
+    end
+
+    def log_state
+      @log_state ||= Logger.new 'eth.external_call.state'
+    end
+
+  end
+
+end