reth 0.1.0

data/lib/reth/genesisdata/genesis_morden.json

@@ -0,0 +1,27 @@
+{
+  "nonce": "0x00006d6f7264656e",
+  "difficulty": "0x20000",
+  "mixhash": "0x00000000000000000000000000000000000000647572616c65787365646c6578",
+  "coinbase": "0x0000000000000000000000000000000000000000",
+  "timestamp": "0x00",
+  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "extraData": "0x",
+  "gasLimit": "0x2FEFD8",
+  "alloc": {
+    "0000000000000000000000000000000000000001": {
+      "balance": "1"
+    },
+    "0000000000000000000000000000000000000002": {
+      "balance": "1"
+    },
+    "0000000000000000000000000000000000000003": {
+      "balance": "1"
+    },
+    "0000000000000000000000000000000000000004": {
+      "balance": "1"
+    },
+    "102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c": {
+      "balance": "1606938044258990275541962092341162602522202993782792835301376"
+    }
+  }
+}

data/lib/reth/genesisdata/genesis_olympic.json

@@ -0,0 +1,48 @@
+{
+  "nonce": "0x0000000000000042",
+  "difficulty": "0x20000",
+  "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "coinbase": "0x0000000000000000000000000000000000000000",
+  "timestamp": "0x00",
+  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "extraData": "",
+  "gasLimit": "0x2fefd8",
+  "alloc": {
+    "dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6": {
+      "balance": "1606938044258990275541962092341162602522202993782792835301376"
+    },
+    "e6716f9544a56c530d868e4bfbacb172315bdead": {
+      "balance": "1606938044258990275541962092341162602522202993782792835301376"
+    },
+    "b9c015918bdaba24b4ff057a92a3873d6eb201be": {
+      "balance": "1606938044258990275541962092341162602522202993782792835301376"
+    },
+    "1a26338f0d905e295fccb71fa9ea849ffa12aaf4": {
+      "balance": "1606938044258990275541962092341162602522202993782792835301376"
+    },
+    "2ef47100e0787b915105fd5e3f4ff6752079d5cb": {
+      "balance": "1606938044258990275541962092341162602522202993782792835301376"
+    },
+    "cd2a3d9f938e13cd947ec05abc7fe734df8dd826": {
+      "balance": "1606938044258990275541962092341162602522202993782792835301376"
+    },
+    "6c386a4b26f73c802f34673f7248bb118f97424a": {
+      "balance": "1606938044258990275541962092341162602522202993782792835301376"
+    },
+    "e4157b34ea9615cfbde6b4fda419828124b70c78": {
+      "balance": "1606938044258990275541962092341162602522202993782792835301376"
+    },
+    "0000000000000000000000000000000000000001": {
+      "balance": "1"
+    },
+    "0000000000000000000000000000000000000002": {
+      "balance": "1"
+    },
+    "0000000000000000000000000000000000000003": {
+      "balance": "1"
+    },
+    "0000000000000000000000000000000000000004": {
+      "balance": "1"
+    }
+  }
+}

data/lib/reth/jsonrpc.rb

@@ -0,0 +1,13 @@
+require 'json'
+require 'rack'
+require 'sinatra/base'
+require 'sinatra/json'
+
+require 'ethereum'
+
+require 'reth/jsonrpc/helper'
+require 'reth/jsonrpc/filter'
+require 'reth/jsonrpc/handler'
+require 'reth/jsonrpc/server'
+require 'reth/jsonrpc/service'
+require 'reth/jsonrpc/app'

data/lib/reth/jsonrpc/app.rb

@@ -0,0 +1,79 @@
+module Reth
+module JSONRPC
+
+  class App < Sinatra::Base
+
+    configure do
+      enable :logging
+    end
+
+    CORS_ORIGIN = "http://localhost:8080"
+
+    options "*" do
+      response.headers["Allow"] = "POST,OPTIONS"
+      response.headers["Access-Control-Allow-Headers"] = "X-Requested-With, X-HTTP-Method-Override, Content-Type, Cache-Control, Accept"
+      response.headers["Access-Control-Allow-Origin"] = "http://localhost:8080"
+      response.headers["Access-Control-Allow-Methods"] = "POST"
+
+      200
+    end
+
+    post '/' do
+      response.headers["Access-Control-Allow-Origin"] = CORS_ORIGIN
+
+      begin
+        data = JSON.parse request.body.read
+        puts "Params: #{data.inspect}"
+
+        result = if data.instance_of?(Array)
+                   data.map {|d| dispatch d }
+                 else
+                   dispatch data
+                 end
+
+        json result
+      rescue JSON::ParserError
+        puts $!
+        puts $!.backtrace[0,10].join("\n")
+        json jsonrpc: '2.0', error: $!
+      end
+    end
+
+    def initialize(node)
+      @node = node
+
+      @default_block = 'latest'
+      @default_address = Account.test_accounts.keys.first
+      @default_startgas = 500 * 1000
+      @default_gas_price = 60.shannon
+
+      super()
+    end
+
+    private
+
+    include Handler
+
+    def dispatch(data)
+      # TODO: filter injection, validate method names
+      result = send :"handle_#{data['method']}", *data['params']
+
+      {jsonrpc: data['jsonrpc'], id: data['id'], result: result}
+    rescue NoMethodError
+      if $!.message =~ /handle_([a-zA-Z_]+)/
+        {jsonrpc: '2.0', id: data['id'], error: "jsonrpc method not defined: #{$1}"}
+      else
+        puts $!
+        puts $!.backtrace[0,10].join("\n")
+        {jsonrpc: data['jsonrpc'], id: data['id'], error: $!}
+      end
+    rescue
+      puts $!
+      puts $!.backtrace[0,10].join("\n")
+      {jsonrpc: data['jsonrpc'], id: data['id'], error: $!}
+    end
+
+  end
+
+end
+end

data/lib/reth/jsonrpc/filter.rb

@@ -0,0 +1,288 @@
+module Reth
+module JSONRPC
+
+  class Filter
+    class <<self
+      def next_id
+        @next_id ||= 0
+        @next_id += 1
+      end
+
+      def map
+        @map ||= {}
+      end
+
+      def find(id)
+        map[id]
+      end
+
+      def delete(id)
+        map.delete id
+      end
+
+      def include?(id)
+        map.include?(id)
+      end
+    end
+  end
+
+  class LogFilter
+
+    class <<self
+      def create(obj, chain)
+        f = new obj, chain
+        id = Filter.next_id
+        Filter.map[id] = f
+        id
+      end
+    end
+
+    include Helper
+
+    def initialize(obj, chain)
+      @chain = chain
+      @first_block, @last_block, @addresses, @topics = parse_obj obj
+
+      @last_head = @chain.head
+      @last_block_checked = nil
+
+      @log_dict = {}
+    end
+
+    def check
+      first, last = get_from_to @first_block, @last_block
+      first = [@last_head.number + 1, first].min if @first_block.is_a?(String)
+      raise "first must not be greater than last" unless first <= last
+
+      if @last_block_checked
+        first = [@last_block_checked.number + 1, first].max
+        return {} if first > last
+      end
+
+      blocks_to_check = []
+      (first...last).each do |n|
+        blocks_to_check.push @chain.index.get_block_by_number(n)
+      end
+
+      head = @chain.head
+      head_candidate = @chain.head_candidate
+
+      if last == head_candidate.number
+        blocks_to_check.push head_candidate
+      else
+        blocks_to_check.push @chain.get(@chain.index.get_block_by_number(last))
+      end
+
+      int32 = RLP::Sedes::BigEndianInt.new 32
+
+      new_logs = {}
+      blocks_to_check.each_with_index do |block, i|
+        unless [Ethereum::Block, Ethereum::CachedBlock].include?(block.class)
+          # must be blockhash
+          bloom = @chain.get_bloom block
+
+          if @addresses
+            pass_address_check = @addresses.any? {|addr| Ethereum::Bloom.query(bloom, addr) }
+            next unless pass_address_check
+          end
+
+          topics = (@topics || []).map {|t| int32.serialize(t) }
+          topic_bloom = Ethereum::Bloom.from_array topics
+          next if Ethereum::Bloom.combine(bloom, topic_bloom) != bloom
+
+          block = @chain.get block
+        end
+
+        r_idx = nil
+        l_idx = nil
+        log = nil
+        block.get_receipts.each_with_index do |receipt, ri|
+          r_idx = ri
+
+          receipt.logs.each_with_index do |_log, li|
+            log = _log
+            l_idx = li
+
+            next if @addresses && !@addresses.include?(log.address)
+
+            if @topics
+              topic_match = log.topics.size >= @topics.size
+              next unless topic_match
+
+              @topics.zip(log.topics).each do |filter_topic, log_topic|
+                if filter_topic && filter_topic != log_topic
+                  topic_match = false
+                  break
+                end
+              end
+              next unless topic_match
+            end
+
+            tx = block.get_transaction r_idx
+            id = Ethereum::Utils.keccak256 "#{tx.full_hash}#{l_idx}"
+            pending = block == head_candidate
+            new_logs[id] = {
+              log: log,
+              log_idx: l_idx,
+              block: block,
+              txhash: tx.full_hash,
+              tx_idx: r_idx
+            }
+          end
+        end
+      end
+
+      @last_block_checked = if blocks_to_check.last != head_candidate
+                              blocks_to_check.last
+                            else
+                              blocks_to_check.size >= 2 ? blocks_to_check[-2] : nil
+                            end
+
+      if @last_block_checked && ![Ethereum::Block, Ethereum::CachedBlock].include?(@last_block_checked.class)
+        @last_block_checked = @chain.get @last_block_checked
+      end
+
+      actually_new_ids = new_logs.keys - @log_dict.keys
+      @log_dict.merge! new_logs
+
+      actually_new_ids.map {|id| [id, new_logs[id]] }.to_h
+    end
+
+    def logs
+      check
+      @log_dict.values
+    end
+
+    def new_logs
+      check.values
+    end
+
+    def to_s
+      "<Filter(addressed=#{@addresses}, topics=#{@topics}, first=#{@first_block}, last=#{@last_block})>"
+    end
+
+    private
+
+    def parse_obj(obj)
+      raise ArgumentError, 'obj must be a Hash' unless obj.instance_of?(Hash)
+
+      addresses = case obj['address']
+                  when String
+                    [hex_to_bytes(obj['address'])]
+                  when Array
+                    obj['address'].map {|addr| hex_to_bytes(addr) }
+                  when NilClass
+                    nil
+                  else
+                    raise ArgumentError, "address must be String or Array of Strings"
+                  end
+
+      topics = nil
+      if obj.has_key?('topics')
+        topics = []
+        obj['topics'].each do |t|
+          if t
+            topics.push(Ethereum::Utils.big_endian_to_int hex_to_bytes(t))
+          else
+            topics.push(nil)
+          end
+        end
+      end
+
+      from_block = decode_block_tag(obj['fromBlock'] || 'latest')
+      to_block = decode_block_tag(obj['toBlock'] || 'latest')
+
+      from, to = get_from_to from_block, to_block
+      raise ArgumentError, 'fromBlock must not be newer than toBlock' if from > to
+
+      return from_block, to_block, addresses, topics
+    end
+
+    def get_from_to(from_block, to_block)
+      block_tags = {
+        'earliest' => 0,
+        'latest' => @chain.head.number,
+        'pending' => @chain.head_candidate.number
+      }
+      from = from_block.is_a?(Integer) ? from_block : block_tags[from_block]
+      to = to_block.is_a?(Integer) ? to_block : block_tags[to_block]
+
+      return from, to
+    end
+
+  end
+
+  class BlockFilter
+
+    class <<self
+      def create(chain)
+        f = new chain
+        id = Filter.next_id
+        Filter.map[id] = f
+        id
+      end
+    end
+
+    def initialize(chain)
+      @chain = chain
+      @latest_block = chain.head
+    end
+
+    def check
+      new_blocks = []
+      block = @chain.head
+
+      while block.number > @latest_block.number
+        new_blocks.push block
+        block = block.get_parent
+      end
+
+      puts "previous latest block not in current chain!" if block != @latest_block
+      @latest_block = new_blocks.first if new_blocks.size > 0
+
+      new_blocks.reverse
+    end
+
+  end
+
+  class PendingTransactionFilter
+
+    class <<self
+      def create(chain)
+        f = new chain
+        id = Filter.next_id
+        Filter.map[id] = f
+        id
+      end
+    end
+
+    def initialize(chain)
+      @chain = chain
+      @latest_block = @chain.head_candidate
+      @reported_txs = []
+    end
+
+    def check
+      head_candidate = @chain.head_candidate
+      pending_txs = head_candidate.get_transactions
+      new_txs = pending_txs.select {|tx| !@reported_txs.include?(tx.full_hash) }
+
+      block = head_candidate.get_parent
+      while block.number >= @latest_block.number
+        block.get_transactions.reverse.each do |tx|
+          new_txs.push(tx) unless @reported_txs.include?(tx.full_hash)
+        end
+
+        block = block.get_parent
+      end
+
+      @latest_block = head_candidate
+      @reported_txs = pending_txs.map(&:full_hash)
+
+      new_txs.reverse
+    end
+
+  end
+
+end
+end