reth 0.1.0

data/lib/reth/account_service.rb

@@ -0,0 +1,361 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'fileutils'
+
+module Reth
+
+  class AccountService < ::DEVp2p::Service
+
+    name 'accounts'
+
+    default_config(
+      accounts: {
+        keystore_dir: 'keystore',
+        must_include_coinbase: true
+      }
+    )
+
+    attr :accounts
+
+    DEFAULT_COINBASE = Utils.decode_hex('de0b295669a9fd93d5f28d9ec85e40f4cb697bae')
+
+    def initialize(app)
+      super(app)
+
+      if app.config[:accounts][:keystore_dir][0] == '/'
+        @keystore_dir = app.config[:accounts][:keystore_dir]
+      else # relative path
+        @keystore_dir = File.join app.config[:data_dir], app.config[:accounts][:keystore_dir]
+      end
+
+      @accounts = []
+
+      if !File.exist?(@keystore_dir)
+        logger.warn "keystore directory does not exist", directory: @keystore_dir
+      elsif !File.directory?(@keystore_dir)
+        logger.error "configured keystore directory is a file, not a directory", directory: @keystore_dir
+      else
+        logger.info "searching for key files", directory: @keystore_dir
+
+        ignore = %w(. ..)
+        Dir.foreach(@keystore_dir) do |filename|
+          next if ignore.include?(filename)
+
+          begin
+            @accounts.push Account.load(File.join(@keystore_dir, filename))
+          rescue ValueError
+            logger.warn "invalid file skipped in keystore directory", path: filename
+          end
+        end
+      end
+      @accounts.sort_by! {|acct| acct.path.to_s }
+
+      if @accounts.empty?
+        logger.warn "no accounts found"
+      else
+        logger.info "found account(s)", accounts: @accounts
+      end
+    end
+
+    def start
+      # do nothing
+    end
+
+    def stop
+      # do nothing
+    end
+
+    ##
+    # Return the address that should be used as coinbase for new blocks.
+    #
+    # The coinbase address is given by the config field pow.coinbase_hex. If
+    # this does not exist, the address of the first account is used instead.
+    # If there are no accounts, the coinbase is `DEFAULT_COINBASE`.
+    #
+    # @raise [ValueError] if the coinbase is invalid (no string, wrong
+    #   length) or there is no account for it and the config flag
+    #   `accounts.check_coinbase` is set (does not apply to the default
+    #   coinbase).
+    #
+    def coinbase
+      cb_hex = (app.config[:pow] || {})[:coinbase_hex]
+      if cb_hex
+        raise ValueError, 'coinbase must be String' unless cb_hex.is_a?(String)
+        begin
+          cb = Utils.decode_hex Utils.remove_0x_head(cb_hex)
+        rescue TypeError
+          raise ValueError, 'invalid coinbase'
+        end
+      else
+        accts = accounts_with_address
+        return DEFAULT_COINBASE if accts.empty?
+        cb = accts[0].address
+      end
+
+      raise ValueError, 'wrong coinbase length' if cb.size != 20
+
+      if config[:accounts][:must_include_coinbase]
+        raise ValueError, 'no account for coinbase' if !@accounts.map(&:address).include?(cb)
+      end
+
+      cb
+    end
+
+    ##
+    # Add an account.
+    #
+    # If `store` is true the account will be stored as a key file at the
+    # location given by `account.path`. If this is `nil` a `ValueError` is
+    # raised. `include_address` and `include_id` determine if address and id
+    # should be removed for storage or not.
+    #
+    # This method will raise a `ValueError` if the new account has the same
+    # UUID as an account already known to the service. Note that address
+    # collisions do not result in an exception as those may slip through
+    # anyway for locked accounts with hidden addresses.
+    #
+    def add_account(account, store=true, include_address=true, include_id=true)
+      logger.info "adding account", account: account
+
+      if account.uuid && @accounts.any? {|acct| acct.uuid == account.uuid }
+        logger.error 'could not add account (UUID collision)', uuid: account.uuid
+        raise ValueError, 'Could not add account (UUID collision)'
+      end
+
+      if store
+        raise ValueError, 'Cannot store account without path' if account.path.nil?
+        if File.exist?(account.path)
+          logger.error 'File does already exist', path: account.path
+          raise IOError, 'File does already exist'
+        end
+
+        raise AssertError if @accounts.any? {|acct| acct.path == account.path }
+
+        begin
+          directory = File.dirname account.path
+          FileUtils.mkdir_p(directory) unless File.exist?(directory)
+
+          File.open(account.path, 'w') do |f|
+            f.write account.dump(include_address, include_id)
+          end
+        rescue IOError => e
+          logger.error "Could not write to file", path: account.path, message: e.to_s
+          raise e
+        end
+      end
+
+      @accounts.push account
+      @accounts.sort_by! {|acct| acct.path.to_s }
+    end
+
+    ##
+    # Replace the password of an account.
+    #
+    # The update is carried out in three steps:
+    #
+    # 1. the old keystore file is renamed
+    # 2. the new keystore file is created at the previous location of the old
+    #   keystore file
+    # 3. the old keystore file is removed
+    #
+    # In this way, at least one of the keystore files exists on disk at any
+    # time and can be recovered if the process is interrupted.
+    #
+    # @param account [Account] which must be unlocked, stored on disk and
+    #   included in `@accounts`
+    # @param include_address [Bool] forwarded to `add_account` during step 2
+    # @param include_id [Bool] forwarded to `add_account` during step 2
+    #
+    # @raise [ValueError] if the account is locked, if it is not added to the
+    #   account manager, or if it is not stored
+    #
+    def update_account(account, new_password, include_address=true, include_id=true)
+      raise ValueError, "Account not managed by account service" unless @accounts.include?(account)
+      raise ValueError, "Cannot update locked account" if account.locked?
+      raise ValueError, 'Account not stored on disk' unless account.path
+
+      logger.debug "creating new account"
+      new_account = Account.create new_password, account.privkey, account.uuid, account.path
+
+      backup_path = account.path + '~'
+      i = 1
+      while File.exist?(backup_path)
+        backup_path = backup_path[0, backup_path.rindex('~')+1] + i.to_s
+        i += 1
+      end
+      raise AssertError if File.exist?(backup_path)
+
+      logger.info 'moving old keystore file to backup location', from: account.path, to: backup_path
+      begin
+        FileUtils.mv account.path, backup_path
+      rescue
+        logger.error "could not backup keystore, stopping account update", from: account.path, to: backup_path
+        raise $!
+      end
+      raise AssertError unless File.exist?(backup_path)
+      raise AssertError if File.exist?(new_account.path)
+      account.path = backup_path
+
+      @accounts.delete account
+      begin
+        add_account new_account, include_address, include_id
+      rescue
+        logger.error 'adding new account failed, recovering from backup'
+        FileUtils.mv backup_path, new_account.path
+        account.path = new_account.path
+        @accounts.push account
+        @accounts.sort_by! {|acct| acct.path.to_s }
+        raise $!
+      end
+      raise AssertError unless File.exist?(new_account.path)
+
+      logger.info "deleting backup of old keystore", path: backup_path
+      begin
+        FileUtils.rm backup_path
+      rescue
+        logger.error 'failed to delete no longer needed backup of old keystore', path: account.path
+        raise $!
+      end
+
+      account.keystore = new_account.keystore
+      account.path = new_account.path
+
+      @accounts.push account
+      @accounts.delete new_account
+      @accounts.sort_by! {|acct| acct.path.to_s }
+
+      logger.debug "account update successful"
+    end
+
+    def accounts_with_address
+      @accounts.select {|acct| acct.address }
+    end
+
+    def unlocked_accounts
+      @accounts.select {|acct| !acct.locked? }
+    end
+
+    ##
+    # Find an account by either its address, its id, or its index as string.
+    #
+    # Example identifiers:
+    #
+    # - '9c0e0240776cfbe6fa1eb37e57721e1a88a563d1' (address)
+    # - '0x9c0e0240776cfbe6fa1eb37e57721e1a88a563d1' (address with 0x prefix)
+    # - '01dd527b-f4a5-4b3c-9abb-6a8e7cd6722f' (UUID)
+    # - '3' (index)
+    #
+    # @param identifier [String] the accounts hex encoded, case insensitive
+    #   address (with optional 0x prefix), its UUID or its index (as string,
+    #   >= 1)
+    #
+    # @raise [ValueError] if the identifier could not be interpreted
+    # @raise [KeyError] if the identified account is not known to the account
+    #   service
+    #
+    def find(identifier)
+      identifier = identifier.downcase
+
+      if identifier =~ /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/ # uuid
+        return get_by_id(identifier)
+      end
+
+      begin
+        address = Address.new(identifier).to_bytes
+        raise AssertError unless address.size == 20
+        return self[address]
+      rescue
+        # do nothing
+      end
+
+      index = identifier.to_i
+      raise ValueError, 'Index must be 1 or greater' if index <= 0
+      raise KeyError if index > @accounts.size
+      @accounts[index-1]
+    end
+
+    ##
+    # Return the account with a given id.
+    #
+    # Note that accounts are not required to have an id.
+    #
+    # @raise [KeyError] if no matching account can be found
+    #
+    def get_by_id(id)
+      accts = @accounts.select {|acct| acct.uuid == id }
+
+      if accts.size == 0
+        raise KeyError, "account with id #{id} unknown"
+      elsif accts.size > 1
+        logger.warn "multiple accounts with same UUID found", uuid: id
+      end
+
+      accts[0]
+    end
+
+    ##
+    # Get an account by its address.
+    #
+    # Note that even if an account with the given address exists, it might
+    # not be found if it is locked. Also, multiple accounts with the same
+    # address may exist, in which case the first one is returned (and a
+    # warning is logged).
+    #
+    # @raise [KeyError] if no matching account can be found
+    #
+    def get_by_address(address)
+      raise ArgumentError, 'address must be 20 bytes' unless address.size == 20
+
+      accts = @accounts.select {|acct| acct.address == address }
+
+      if accts.size == 0
+        raise KeyError, "account not found by address #{Utils.encode_hex(address)}"
+      elsif accts.size > 1
+        logger.warn "multiple accounts with same address found", address: Utils.encode_hex(address)
+      end
+
+      accts[0]
+    end
+
+    def sign_tx(address, tx)
+      get_by_address(address).sign_tx(tx)
+    end
+
+    def propose_path(address)
+      File.join @keystore_dir, Utils.encode_hex(address)
+    end
+
+    def include?(address)
+      raise ArgumentError, 'address must be 20 bytes' unless address.size == 20
+      @accounts.any? {|acct| acct.address == address }
+    end
+
+    def [](address_or_idx)
+      if address_or_idx.instance_of?(String)
+        raise ArgumentError, 'address must be 20 bytes' unless address_or_idx.size == 20
+        acct = @accounts.find {|acct| acct.address == address_or_idx }
+        acct or raise KeyError
+      else
+        raise ArgumentError, 'address_or_idx must be String or Integer' unless address_or_idx.is_a?(Integer)
+        @accounts[address_or_idx]
+      end
+    end
+
+    include Enumerable
+    def each(&block)
+      @accounts.each(&block)
+    end
+
+    def size
+      @accounts.size
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.new('accounts')
+    end
+
+  end
+
+end

data/lib/reth/app.rb

@@ -0,0 +1,15 @@
+# -*- encoding : ascii-8bit -*-
+
+module Reth
+
+  class App < ::DEVp2p::App
+
+    default_config(
+      client_version_string: CLIENT_VERSION_STRING,
+      deactivated_services: [],
+      post_app_start_callback: nil
+    )
+
+  end
+
+end

data/lib/reth/chain_service.rb

@@ -0,0 +1,500 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'thread'
+
+module Reth
+
+  class ChainService < ::DEVp2p::WiredService
+    name 'chain'
+
+    default_config(
+      eth: {
+        network_id: 0,
+        genesis: '',
+        pruning: -1
+      },
+      block: Env::DEFAULT_CONFIG
+    )
+
+    BLOCK_QUEUE_SIZE = 512
+    TRANSACTION_QUEUE_SIZE = 512
+
+    MAX_NEWBLOCK_PROCESSING_TIME_STATS = 1000
+
+    attr :chain, :block_queue, :transaction_queue, :synchronizer
+
+    def initialize(app)
+      setup_db(app)
+      super(app)
+
+      logger.info 'initializing chain'
+      coinbase = app.services.accounts.coinbase
+      env = Env.new @db, config: config[:eth][:block]
+      @chain = Chain.new env, new_head_cb: method(:on_new_head), coinbase: coinbase
+
+      logger.info 'chain at', number: @chain.head.number
+      if config[:eth][:genesis_hash]
+        raise AssertError, "Genesis hash mismatch. Expected: #{config[:eth][:genesis_hash]}, Got: #{@chain.genesis.full_hash_hex}" unless config[:eth][:genesis_hash] == @chain.genesis.full_hash_hex
+      end
+
+      @synchronizer = Synchronizer.new(self, nil)
+
+      @block_queue = SyncQueue.new BLOCK_QUEUE_SIZE
+      @transaction_queue = SyncQueue.new TRANSACTION_QUEUE_SIZE
+      @add_blocks_lock = false
+      @add_transaction_lock = Mutex.new # TODO: should be semaphore
+
+      @broadcast_filter = DuplicatesFilter.new
+      @on_new_head_cbs = []
+      @on_new_head_candidate_cbs = []
+      @newblock_processing_times = []
+
+      @processed_gas = 0
+      @processed_elapsed = 0
+
+      @wire_protocol = ETHProtocol
+    end
+
+    def start
+      # do nothing
+    end
+
+    def stop
+      # do nothing
+    end
+
+    def syncing?
+      @synchronizer.syncing?
+    end
+
+    def mining?
+      app.services.include?('pow') && app.services.pow.active?
+    end
+
+    def add_transaction(tx, origin=nil, force_broadcast=false)
+      if syncing?
+        if force_broadcast
+          raise AssertError, 'only allowed for local txs' if origin
+          logger.debug 'force broadcasting unvalidated tx'
+          broadcast_transaction tx, origin
+        end
+
+        return
+      end
+
+      logger.debug 'add_transaction', locked: !@add_transaction_lock.locked?, tx: tx
+      raise ArgumentError, 'tx must be Transaction' unless tx.instance_of?(Transaction)
+      raise ArgumentError, 'origin must be nil or DEVp2p::Protocol' unless origin.nil? || origin.is_a?(DEVp2p::Protocol)
+
+      if @broadcast_filter.include?(tx.full_hash)
+        logger.debug 'discarding known tx'
+        return
+      end
+
+      begin
+        @chain.head_candidate.validate_transaction tx
+        logger.debug 'valid tx, broadcasting'
+        broadcast_transaction tx, origin
+      rescue InvalidTransaction => e
+        logger.debug 'invalid tx', error: e
+        return
+      end
+
+      if origin # not locally added via jsonrpc
+        if !mining? || syncing?
+          logger.debug 'discarding tx', syncing: syncing?, mining: mining?
+          return
+        end
+      end
+
+      @add_transaction_lock.lock
+      success = @chain.add_transaction tx
+      @add_transaction_lock.unlock
+
+      on_new_head_candidate if success
+      success
+    end
+
+    def add_block(t_block, proto)
+      @block_queue.enq [t_block, proto] # blocks if full
+      if !@add_blocks_lock
+        @add_blocks_lock = true
+        Thread.new { add_blocks }
+      end
+    end
+
+    def add_blocks
+      logger.debug 'add_blocks', qsize: @block_queue.size, add_tx_lock: @add_transaction_lock.locked?
+      raise AssertError unless @add_blocks_lock
+      @add_transaction_lock.lock
+
+      while !@block_queue.empty?
+        t_block, proto = @block_queue.peek
+
+        if @chain.include?(t_block.header.full_hash)
+          logger.warn 'known block', block: t_block
+          @block_queue.deq
+          next
+        end
+
+        if !@chain.include?(t_block.header.prevhash)
+          logger.warn 'missing parent', block: t_block, head: @chain.head
+          @block_queue.deq
+          next
+        end
+
+        block = nil
+        begin # deserialize
+          t = Time.now
+          block = t_block.to_block @chain.env
+          elapsed = Time.now - t
+          logger.debug 'deserialized', elapsed: elapsed, gas_used: block.gas_used, gpsec: gpsec(block.gas_used, elapsed)
+        rescue InvalidTransaction => e
+          logger.warn 'invalid transaction', block: t_block, error: e
+          errtype = case e
+                    when InvalidNonce then 'InvalidNonce'
+                    when InsufficientBalance then 'NotEnoughCash'
+                    when InsufficientStartGas then 'OutOfGasBase'
+                    else 'other_transaction_error'
+                    end
+          warn_invalid t_block, errtype
+          @block_queue.deq
+          next
+        rescue ValidationError => e
+          logger.warn 'verification failed', error: e
+          warn_invalid t_block, 'other_block_error'
+          @block_queue.deq
+          next
+        end
+
+        # all check passed
+        logger.debug 'adding', block: block
+        t = Time.now
+        if @chain.add_block(block, mining?)
+          logger.info 'added', block: block, txs: block.transaction_count, gas_used: block.gas_used, time: (Time.now-t)
+
+          now = Time.now.to_i
+          if t_block.newblock_timestamp && t_block.newblock_timestamp > 0
+            total = now - t_block.newblock_timestamp
+            @newblock_processing_times.push total
+            @newblock_processing_times.shift if @newblock_processing_times.size > MAX_NEWBLOCK_AGE
+
+            avg = @newblock_processing_times.reduce(0.0, &:+) / @newblock_processing_times.size
+            max = @newblock_processing_times.max
+            min = @newblock_processing_times.min
+            logger.info 'processing time', last: total, avg: avg, max: max, min: min
+          end
+        else
+          logger.warn 'could not add', block: block
+        end
+
+        @block_queue.deq
+        sleep 0.001
+      end
+    rescue
+      logger.error $!
+      logger.error $!.backtrace[0,10].join("\n")
+    ensure
+      @add_blocks_lock = false
+      @add_transaction_lock.unlock
+    end
+
+    def add_mined_block(block)
+      logger.debug 'adding mined block', block: block
+      raise ArgumentError, 'block must be Block' unless block.is_a?(Block)
+      raise AssertError, 'invalid pow' unless block.header.check_pow
+
+      if @chain.add_block(block)
+        logger.debug 'added', block: block
+        raise AssertError, 'block is not head' unless block == @chain.head
+        broadcast_newblock block, block.chain_difficulty
+      end
+    end
+
+    ##
+    # if block is in chain or in queue
+    #
+    def knows_block(blockhash)
+      return true if @chain.include?(blockhash)
+      @block_queue.queue.any? {|(block, proto)| block.header.full_hash == blockhash }
+    end
+
+    def broadcast_newblock(block, chain_difficulty=nil, origin=nil)
+      unless chain_difficulty
+        raise AssertError, 'block not in chain' unless @chain.include?(block.full_hash)
+        chain_difficulty = block.chain_difficulty
+      end
+
+      raise ArgumentError, 'block must be Block or TransientBlock' unless block.is_a?(Block) or block.instance_of?(TransientBlock)
+
+      if @broadcast_filter.update(block.header.full_hash)
+        logger.debug 'broadcasting newblock', origin: origin
+        exclude_peers = origin ? [origin.peer] : []
+        app.services.peermanager.broadcast(ETHProtocol, 'newblock', [block, chain_difficulty], {}, nil, exclude_peers)
+      else
+        logger.debug 'already broadcasted block'
+      end
+    end
+
+    def broadcast_transaction(tx, origin=nil)
+      raise ArgumentError, 'tx must be Transaction' unless tx.instance_of?(Transaction)
+
+      if @broadcast_filter.update(tx.full_hash)
+        logger.debug 'broadcasting tx', origin: origin
+        exclude_peers = origin ? [origin.peer] : []
+        app.services.peermanager.broadcast ETHProtocol, 'transactions', [tx], {}, nil, exclude_peers
+      else
+        logger.debug 'already broadcasted tx'
+      end
+    end
+
+    def on_wire_protocol_start(proto)
+      logger.debug 'on_wire_protocol_start', proto: proto
+      raise AssertError, 'incompatible protocol' unless proto.instance_of?(@wire_protocol)
+
+      # register callbacks
+      %i(status newblockhashes transactions getblockhashes blockhashes getblocks blocks newblock getblockhashesfromnumber).each do |cmd|
+        proto.send(:"receive_#{cmd}_callbacks").push method(:"on_receive_#{cmd}")
+      end
+
+      head = @chain.head
+      proto.send_status head.chain_difficulty, head.full_hash, @chain.genesis.full_hash
+    end
+
+    def on_wire_protocol_stop(proto)
+      raise AssertError, 'incompatible protocol' unless proto.instance_of?(@wire_protocol)
+      logger.debug 'on_wire_protocol_stop', proto: proto
+    end
+
+    def on_receive_status(proto, options)
+      eth_version = options[:eth_version]
+      network_id = options[:network_id]
+      chain_difficulty = options[:chain_difficulty]
+      chain_head_hash = options[:chain_head_hash]
+      genesis_hash = options[:genesis_hash]
+
+      logger.debug 'status received', proto: proto, eth_version: eth_version
+      raise ETHProtocolError, 'eth version mismatch' unless eth_version == proto.version
+
+      if network_id != config[:eth].fetch(:network_id, proto.network_id)
+        logger.warn 'invalid network id', remote_network_id: network_id, expected_network_id: config[:eth].fetch(:network_id, proto.network_id)
+        raise ETHProtocolError, 'wrong network id'
+      end
+
+      # check genesis
+      if genesis_hash != @chain.genesis.full_hash
+        logger.warn 'invalid genesis hash', remote_id: proto, genesis: Utils.encode_hex(genesis_hash)
+        raise ETHProtocolError, 'wrong genesis block'
+      end
+
+      # request chain
+      @synchronizer.receive_status proto, chain_head_hash, chain_difficulty
+
+      # send transactions
+      transactions = @chain.get_transactions
+      unless transactions.empty?
+        logger.debug 'sending transactions', remote_id: proto
+        proto.send_transactions *transactions
+      end
+    rescue ETHProtocolError
+      app.services.peermanager.exclude proto.peer
+    rescue
+      logger.error $!
+      logger.error $!.backtrace[0,10].join("\n")
+    end
+
+    def on_receive_transactions(proto, transactions)
+      logger.debug 'remote transactions received', count: transactions.size, remote_id: proto
+      transactions.each do |tx|
+        add_transaction tx, proto
+      end
+    rescue
+      logger.debug $!
+      logger.debug $!.backtrace[0,10].join("\n")
+    end
+
+    def on_receive_newblockhashes(proto, newblockhashes)
+      logger.debug 'recv newblockhashes', num: newblockhashes.size, remote_id: proto
+      raise AssertError, 'cannot handle more than 32 block hashes at one time' unless newblockhashes.size <= 32
+
+      @synchronizer.receive_newblockhashes(proto, newblockhashes)
+    end
+
+    def on_receive_getblockhashes(proto, options)
+      child_block_hash = options[:child_block_hash]
+      count = options[:count]
+
+      logger.debug 'handle getblockhashes', count: count, block_hash: Utils.encode_hex(child_block_hash)
+
+      max_hashes = [count, @wire_protocol::MAX_GETBLOCKHASHES_COUNT].min
+      found = []
+
+      unless @chain.include?(child_block_hash)
+        logger.debug 'unknown block'
+        proto.send_blockhashes
+        return
+      end
+
+      last = child_block_hash
+      while found.size < max_hashes
+        begin
+          last = RLP.decode_lazy(@chain.db.get(last))[0][0] # [head][prevhash]
+        rescue KeyError
+          # this can happen if we started a chain download, which did not complete
+          # should not happen if the hash is part of the canonical chain
+          logger.warn 'KeyError in getblockhashes', hash: last
+          break
+        end
+
+        if last
+          found.push(last)
+        else
+          break
+        end
+      end
+
+      logger.debug 'sending: found block_hashes', count: found.size
+      proto.send_blockhashes *found
+    end
+
+    def on_receive_blockhashes(proto, blockhashes)
+      if blockhashes.empty?
+        logger.debug 'recv 0 remote block hashes, signifying genesis block'
+      else
+        logger.debug 'on receive blockhashes', count: blockhashes.size, remote_id: proto, first: Utils.encode_hex(blockhashes.first), last: Utils.encode_hex(blockhashes.last)
+      end
+
+      @synchronizer.receive_blockhashes proto, blockhashes
+    end
+
+    def on_receive_getblocks(proto, blockhashes)
+      logger.debug 'on receive getblocks', count: blockhashes.size
+
+      found = []
+      blockhashes[0, @wire_protocol::MAX_GETBLOCKS_COUNT].each do |bh|
+        begin
+          found.push @chain.db.get(bh)
+        rescue KeyError
+          logger.debug 'unknown block requested', block_hash: Utils.encode_hex(bh)
+        end
+      end
+
+      unless found.empty?
+        logger.debug 'found', count: found.dize
+        proto.send_blocks *found
+      end
+    end
+
+    def on_receive_blocks(proto, transient_blocks)
+      blk_number = transient_blocks.empty? ? 0 : transient_blocks.map {|blk| blk.header.number }.max
+      logger.debug 'recv blocks', count: transient_blocks.size, remote_id: proto, highest_number: blk_number
+
+      unless transient_blocks.empty?
+        @synchronizer.receive_blocks proto, transient_blocks
+      end
+    end
+
+    def on_receive_newblock(proto, options)
+      block = options[:block]
+      chain_difficulty = options[:chain_difficulty]
+
+      logger.debug 'recv newblock', block: block, remote_id: proto
+      @synchronizer.receive_newblock proto, block, chain_difficulty
+    rescue
+      logger.debug $!
+      logger.debug $!.backtrace[0,10].join("\n")
+    end
+
+    def on_receive_getblockhashesfromnumber(proto, options)
+      number = options[:number]
+      count = options[:count]
+
+      logger.debug 'recv getblockhashesfromnumber', number: number, count: count, remote_id: proto
+
+      found = []
+      count = [count, @wire_protocol::MAX_GETBLOCKHASHES_COUNT].min
+
+      for i in (number...(number+count))
+        begin
+          h = @chain.index.get_block_by_number(i)
+          found.push h
+        rescue KeyError
+          logger.debug 'unknown block requested', number: number
+        end
+      end
+
+      logger.debug 'sending: found block_hashes', count: found.size
+      proto.send_blockhashes *found
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.new('eth.chainservice')
+    end
+
+    def on_new_head(block)
+      logger.debug 'new head cbs', num: @on_new_head_cbs.size
+      @on_new_head_cbs.each {|cb| cb.call block }
+      on_new_head_candidate # we implicitly have a new head_candidate
+    end
+
+    def on_new_head_candidate
+      @on_new_head_candidate_cbs.each {|cb| cb.call @chain.head_candidate }
+    end
+
+    def gpsec(gas_spent=0, elapsed=0)
+      if gas_spent != 0
+        @processed_gas += gas_spent
+        @processed_elapsed += elapsed
+      end
+
+      (@processed_gas / (0.001 + @processed_elapsed)).to_i
+    end
+
+    def warn_invalid(block, errortype='other')
+      # TODO: send to badblocks.ethereum.org
+    end
+
+    def setup_db(app)
+      data_dir = app.config[:data_dir]
+      eth_config = app.config[:eth] || {}
+
+      if eth_config[:pruning].to_i >= 0
+        @db = DB::RefcountDB.new app.services.db
+
+        if @db.db.include?("I am not pruning")
+          raise "The database in '#{data_dir}' was initialized as non-pruning. Can not enable pruning now."
+        end
+
+        @db.ttl = eth_config[:pruning].to_i
+        @db.db.put "I am pruning", "1"
+        @db.commit
+      else
+        @db = app.services.db
+
+        if @db.include?("I am pruning")
+          raise "The database in '#{data_dir}' was initialized as pruning. Can not disable pruning now."
+        end
+
+        @db.put "I am not pruning", "1"
+        @db.commit
+      end
+
+      if @db.include?('network_id')
+        db_network_id = @db.get 'network_id'
+
+        if db_network_id != eth_config[:network_id].to_s
+          raise "The database in '#{data_dir}' was initialized with network id #{db_network_id} and can not be used when connecting to network id #{eth_config[:network_id]}. Please choose a different data directory."
+        end
+      else
+        @db.put 'network_id', eth_config[:network_id].to_s
+        @db.commit
+      end
+
+      raise AssertError, 'failed to setup db' if @db.nil?
+    end
+
+  end
+
+end