ruby-ethereum 0.9.0

data/lib/ethereum/constant.rb

@@ -0,0 +1,26 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module Constant
+
+    BYTE_EMPTY = "".freeze
+    BYTE_ZERO = "\x00".freeze
+    BYTE_ONE  = "\x01".freeze
+
+    TT32  = 2**32
+    TT256 = 2**256
+    TT64M1 = 2**64 - 1
+
+    UINT_MAX = 2**256 - 1
+    UINT_MIN = 0
+    INT_MAX = 2**255 - 1
+    INT_MIN = -2**255
+
+    HASH_ZERO = ("\x00"*32).freeze
+
+    PUBKEY_ZERO = ("\x00"*32).freeze
+    PRIVKEY_ZERO = ("\x00"*32).freeze
+    PRIVKEY_ZERO_HEX = ('0'*64).freeze
+
+  end
+end

data/lib/ethereum/core_ext/array/safe_slice.rb

@@ -0,0 +1,18 @@
+# -*- encoding : ascii-8bit -*-
+
+class Array
+  def safe_slice(*args)
+    if args.size == 2
+      return [] if args[1] == 0
+      slice(args[0], args[1]) || []
+    elsif args.size == 1
+      if args[0].instance_of?(Range)
+        slice(args[0]) || []
+      else
+        slice(args[0])
+      end
+    else
+      slice(*args)
+    end
+  end
+end

data/lib/ethereum/core_ext/module/lru_cache.rb

@@ -0,0 +1,20 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'lru_redux'
+
+class Module
+
+  def lru_cache(meth, n)
+    @_lru_caches ||= {}
+    @_lru_caches[meth] ||= LruRedux::Cache.new n
+    cache = @_lru_caches[meth]
+
+    origin_meth = "#{meth}_without_cache"
+    self.send :alias_method, origin_meth, meth
+
+    self.send(:define_method, meth) do |*args|
+      cache[args] ||= send(origin_meth, *args)
+    end
+  end
+
+end

data/lib/ethereum/core_ext/numeric/denominations.rb

@@ -0,0 +1,45 @@
+# -*- encoding : ascii-8bit -*-
+
+class Numeric
+
+  BABBAGE  = 10**3
+  LOVELACE = 10**6
+  SHANNON  = 10**9
+  SZABO    = 10**12
+  FINNEY   = 10**15
+  ETHER    = 10**18
+  TURING   = 2**256
+
+  def wei
+    self
+  end
+
+  def babbage
+    self * BABBAGE
+  end
+
+  def lovelace
+    self * LOVELACE
+  end
+
+  def shannon
+    self * SHANNON
+  end
+
+  def szabo
+    self * SZABO
+  end
+
+  def finney
+    self * FINNEY
+  end
+
+  def ether
+    self * ETHER
+  end
+
+  def turing
+    self * TURING
+  end
+
+end

data/lib/ethereum/core_ext/object/truth.rb

@@ -0,0 +1,47 @@
+# -*- encoding : ascii-8bit -*-
+
+class Object
+  def true?
+    !false?
+  end
+
+  def false?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end
+
+class Array
+  def false?
+    empty?
+  end
+end
+
+class String
+  def false?
+    empty?
+  end
+end
+
+class NilClass
+  def false?
+    true
+  end
+end
+
+class TrueClass
+  def false?
+    false
+  end
+end
+
+class FalseClass
+  def false?
+    true
+  end
+end
+
+class Numeric
+  def false?
+    self == 0
+  end
+end

data/lib/ethereum/db.rb

@@ -0,0 +1,6 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'ethereum/db/base_db'
+require 'ethereum/db/ephem_db'
+require 'ethereum/db/overlay_db'
+require 'ethereum/db/refcount_db'

data/lib/ethereum/db/base_db.rb

@@ -0,0 +1,9 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module DB
+    class BaseDB
+      attr :db
+    end
+  end
+end

data/lib/ethereum/db/ephem_db.rb

@@ -0,0 +1,63 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module DB
+    class EphemDB < BaseDB
+
+      def initialize
+        @db = {}
+      end
+
+      def get(k)
+        @db[k] or raise KeyError, k.inspect
+      end
+
+      def put(k, v)
+        @db[k] = v
+      end
+
+      def delete(k)
+        @db.delete(k)
+      end
+
+      def commit
+        # do nothing
+      end
+
+      def has_key?(k)
+        @db.has_key?(k)
+      end
+      alias :include? :has_key?
+
+      def ==(other)
+        other.instance_of?(self.class) && db == other.db
+      end
+
+      def inc_refcount(k, v)
+        put k, v
+      end
+
+      def dec_refcount(k)
+        # do nothing
+      end
+
+      def revert_refcount_changes(epoch)
+        # do nothing
+      end
+
+      def commit_refcount_changes(epoch)
+        # do nothing
+      end
+
+      def cleanup(epoch)
+        # do nothing
+      end
+
+      def put_temporarily(k, v)
+        inc_refcount(k, v)
+        dec_refcount(k)
+      end
+
+    end
+  end
+end

data/lib/ethereum/db/overlay_db.rb

@@ -0,0 +1,72 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module DB
+    ##
+    # Used for making temporary objects.
+    #
+    class OverlayDB < BaseDB
+
+      def initialize(db)
+        @db = db
+        @overlay = {}
+      end
+
+      def get(k)
+        if @overlay.has_key?(k)
+          raise KeyError, k.inspect if @overlay[k].nil?
+          return @overlay[k]
+        end
+
+        db.get k
+      end
+
+      def put(k, v)
+        @overlay[k] = v
+      end
+
+      def put_temporarily(k, v)
+        inc_refcount k, v
+        dec_refcount k
+      end
+
+      def delete(k)
+        @overlay[k] = nil
+      end
+
+      def commit
+        # do nothing
+      end
+
+      def has_key?(k)
+        @overlay.has_key?(k) ? !@overlay[k].nil? : db.has_key?(k)
+      end
+      alias :include? :has_key?
+
+      def ==(other)
+        other.instance_of?(self.class) && db = other.db
+      end
+
+      def inc_refcount(k, v)
+        put k, v
+      end
+
+      def dec_refcount(k)
+        # do nothing
+      end
+
+      def revert_refcount_changes(epoch)
+        # do nothing
+      end
+
+      def commit_refcount_changes(epoch)
+        # do nothing
+      end
+
+      def cleanup(epoch)
+        # do nothing
+      end
+
+    end
+  end
+end

data/lib/ethereum/db/refcount_db.rb

@@ -0,0 +1,188 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module DB
+    class RefcountDB < BaseDB
+
+      DEATH_ROW_OFFSET = 2**62
+
+      ZERO_ENCODED = Utils.encode_int(0)
+      ONE_ENCODED = Utils.encode_int(1)
+
+      def initialize(db)
+        @db = db
+        @journal = []
+        @death_row = []
+        @kv = @db.respond_to?(:kv) ? @db.kv : nil
+        @ttl = 500
+      end
+
+      ##
+      # Increase the reference count associated with a key.
+      #
+      def inc_refcount(k, v)
+        node_object = RLP.decode ref_get(k)
+        refcount = Utils.decode_int node_object[0]
+
+        @journal.push [node_object[0], k]
+        refcount = 0 if refcount >= DEATH_ROW_OFFSET
+
+        new_refcount = Utils.encode_int(refcount+1)
+        ref_put k, RLP.encode([new_refcount, v])
+
+        if Logger.trace?(logger.name)
+          logger.trace "increasing #{Utils.encode_hex(k)}=#{v} to #{refcount+1}"
+        end
+      rescue
+        ref_put k, RLP.encode([ONE_ENCODED, v])
+        @journal.push [ZERO_ENCODED, k]
+
+        if Logger.trace?(logger.name)
+          logger.trace "increasing #{Utils.encode_hex(k)}=#{v} to 1"
+        end
+      end
+      alias :put :inc_refcount
+
+      ##
+      # Decrease the reference count associated with a key.
+      #
+      def dec_refcount(k)
+        node_object = RLP.decode ref_get(k)
+        refcount = Utils.decode_int node_object[0]
+
+        if Logger.trace?(logger.name)
+          logger.trace "decreasing #{Utils.encode_hex(k)} to #{refcount-1}"
+        end
+
+        raise AssertError, "refcount must be greater than zero!" unless refcount > 0
+
+        @journal.push [node_object[0], k]
+        new_refcount = Utils.encode(refcount-1)
+        ref_put k, RLP.encode([new_refcount, node_object[1]])
+
+        @death_row.push k if new_refcount == ZERO_ENCODED
+      end
+      alias :delete :dec_refcount
+
+      def get_refcount(k)
+        o = Utils.decode_int RLP.decode(ref_get(k))[0]
+        o >= DEATH_ROW_OFFSET ? 0 : o
+      rescue
+        0
+      end
+
+      def get(k)
+        RLP.decode(ref_get(k))[1]
+      end
+
+      ##
+      # Kill nodes that are eligible to be killed, and remove the associated
+      # deathrow record. Also delete old journals.
+      #
+      def cleanup(epoch)
+        rlp_nodes = @db.get("deathrow:#{epoch}") rescue RLP.encode([])
+        death_row_nodes = RLP.decode rlp_nodes
+
+        pruned = 0
+        offset = DEATH_ROW_OFFSET + epoch
+
+        death_row_nodes.each do |node_key|
+          begin
+            refcount, val = RLP.decode ref_get(node_key)
+            if Utils.decode_int(refcount) == offset
+              @db.delete ref_key(node_key)
+              pruned += 1
+            end
+          rescue
+            logger.debug "in cleanup: #{$!}"
+          end
+        end
+        logger.debug "#{pruned} nodes successfully pruned"
+
+        @db.delete "deathrow:#{epoch}" rescue nil
+        @db.delete "journal:#{epoch-@ttl}" rescue nil
+      end
+
+      ##
+      # Commit changes to the journal and death row to the database.
+      #
+      def commit_refcount_changes(epoch)
+        timeout_epoch = epoch + @ttl
+        death_row_nodes = RLP.decode(@db.get("deathrow:#{timeout_epoch}")) rescue []
+
+        @death_row.each do |node_key|
+          refcount, val = RLP.decode ref_get(node_key)
+          if refcount == ZERO_ENCODED
+            new_refcount = Utils.encode_int(DEATH_ROW_OFFSET + timeout_epoch)
+            ref_put node_key, RLP.encode([new_refcount, val])
+          end
+        end
+
+        unless @death_row.empty?
+          logger.debug "#{@death_row.size} nodes marked for pruning during block #{timeout_epoch}"
+        end
+
+        death_row_nodes.concat @death_row
+        @death_row = []
+        @db.put "deathrow:#{timeout_epoch}", RLP.encode(death_row_nodes)
+
+        journal = RLP.decode(@db.get("journal:#{epoch}")) rescue []
+        journal.extend @journal
+        @journal = []
+        @db.put "journal:#{epoch}", RLP.encode(journal)
+      end
+
+      ##
+      # Revert changes made during an epoch
+      #
+      def revert_refcount_changes(epoch)
+        timeout_epoch = epoch + @ttl
+
+        @db.delete("deathrow:#{timeout_epoch}") rescue nil
+
+        begin
+          journal = RLP.decode @db.get("journal:#{epoch}")
+          journal.reverse.each do |(new_refcount, key)|
+            node_object = RLP.decode ref_get(key)
+            ref_put key, RLP.encode([new_refcount, node_object[1]])
+          end
+        rescue
+          # do nothing
+        end
+      end
+
+      def has_key?(k)
+        @db.has_key? ref_key(k)
+      end
+      alias :include? :has_key?
+
+      def put_temporarily(k, v)
+        inc_refcount k, v
+        dec_refcount k
+      end
+
+      def commit
+        @db.commit
+      end
+
+      def ref_get(k)
+        @db.get ref_key(k)
+      end
+
+      def ref_put(k, v)
+        @db.put ref_key(k), v
+      end
+
+      def ref_key(k)
+        "r:#{k}"
+      end
+
+      private
+
+      def logger
+        @logger ||= Logger.new 'eth.db.refcount'
+      end
+
+    end
+  end
+end