reth 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 81f3646dda45ea703ebdd86931afa3ca03560838
+  data.tar.gz: f5d710770445a550aca6fade8a7f268845a085fd
+SHA512:
+  metadata.gz: 5d8366c448058a052bccc36b0226361e5d9bb56c23797df2217a4926e06ca44e6bc5f2b856e45c5345f4751b1aff76c0ca607906c551ceabbb7847db9bdb9f3b
+  data.tar.gz: d2ce932b075f7895a6db74628050cc10aace81c689a4edbc21b3f861af5917eda2ca882d1617a28ee69102f52f6d5b07aeb82a99ad8d7e3ba60ae03c7de71c8d

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jan Xie
+
+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.

data/README.md

@@ -0,0 +1,6 @@
+# reth
+
+
+## License
+
+[MIT License](LICENSE)

data/bin/reth

@@ -0,0 +1,208 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'slop'
+require 'reth'
+
+class RethControl
+
+  Services = [
+    Reth::DBService,
+    Reth::AccountService,
+    DEVp2p::Discovery::Service,
+    DEVp2p::PeerManager,
+    Reth::ChainService,
+    Reth::JSONRPC::Service
+  ].freeze
+
+  attr :app, :config
+
+  def initialize(options={})
+    load_config(options)
+    @app = Reth::App.new(@config)
+  end
+
+  def load_config(options)
+    datadir = options[:data_dir] or raise ArgumentError.new('missing datadir')
+    profile = if options[:network_id]
+                Reth::Profile.private(options[:network_id])
+              else
+                Reth::Profile.public(options[:profile].to_sym)
+              end
+
+    Reth::Config.setup(datadir)
+    @config = profile.deep_merge Reth::Config.load(datadir)
+
+    # TODO: allow bootstrap_node to be Array, merge with defaults
+    if options[:bootstrap_node]
+      @config.discovery.bootstrap_nodes = [ options[:bootstrap_node] ]
+    end
+
+    update_config_with_defaults @config, Reth::Config.get_default_config([Reth::App] + Services)
+    update_config_with_defaults @config, {eth: {block: Reth::Env::DEFAULT_CONFIG}}
+
+    genesis_from_config_file = @config.fetch(:eth, {})[:genesis]
+    if genesis_from_config_file
+      # Fixed genesis_hash take from profile must be deleted as custom genesis loaded
+      @config[:eth].delete :genesis_hash
+      @config[:eth][:genesis] = genesis_from_config_file
+    end
+
+    update_config_from_genesis_json @config[:eth][:genesis]
+
+    # TODO: bootstrap_nodes_from_config_file
+
+    @config = @config.deep_merge options
+
+    dump_config
+  end
+
+  def dump_config
+    puts_header 'CONFIGURATION'
+
+    cfg = @config.to_hash
+    alloc = cfg.fetch('eth', {}).fetch('block', {}).fetch('genesis_initial_alloc', {})
+    if alloc.size > 100
+      puts "omitting reporting of #{alloc.size} accounts in genesis"
+      cfg['eth']['block'].delete('genesis_initial_alloc')
+    end
+
+    puts cfg
+  end
+
+  def register_services
+    exclude_services = @app.config[:deactivated_services]
+    Services.each do |service|
+      raise ArgumentError, 'service must be DEVp2p::Service' unless service.instance_of?(Class) && service < DEVp2p::Service
+
+      next if exclude_services.include?(service.name)
+      service.register_with_app @app
+    end
+  end
+
+  def start
+    register_services
+
+    puts_header "starting"
+    @app.start
+
+    #trap("INT")  { @app.stop }
+    #trap("TERM") { @app.stop }
+    #trap("QUIT") { @app.stop }
+
+    #10000.times do |i|
+    #  sleep 2
+    #  @app.services.db.put i.to_s, Time.now.to_s
+    #  @app.services.db.commit
+    #end
+
+    evt_exit = Concurrent::Event.new
+    do_exit = proc do
+      @app.stop
+      evt_exit.set
+      puts "\nexit."
+    end
+
+    Signal.trap("INT", &do_exit)
+    Signal.trap("TERM", &do_exit)
+    Signal.trap("QUIT", &do_exit)
+
+    Thread.new { evt_exit.wait }.join
+  end
+
+  private
+
+  def puts_header(text)
+    puts "\n>>>>> #{text}"
+  end
+
+  def update_config_with_defaults(config, default_config)
+    DEVp2p::Utils.update_config_with_defaults config, default_config
+  end
+
+  def update_config_from_genesis_json(genesis_json_filename_or_hash)
+    genesis = genesis_json_filename_or_hash.instance_of?(String) ?
+      JSON.parse(File.read(genesis_json_filename_or_hash)) :
+      genesis_json_filename_or_hash
+
+    @config[:eth] ||= {}
+    @config[:eth][:block] ||= {}
+
+    id = ->(x) { x }
+    parse_int_or_hex = ->(x) { Reth::Utils.parse_int_or_hex(x) }
+    dec = ->(x) { Reth::Utils.decode_hex Reth::Utils.remove_0x_head(x) }
+
+    m = {
+      'alloc' => [:genesis_initial_alloc, id],
+      'difficulty' => [:genesis_difficulty, parse_int_or_hex],
+      'timestamp' => [:genesis_timestamp, parse_int_or_hex],
+      'extraData' => [:genesis_extra_data, dec],
+      'gasLimit' => [:genesis_gas_limit, parse_int_or_hex],
+      'mixhash' => [:genesis_mixhash, dec],
+      'parentHash' => [:genesis_prevhash, dec],
+      'coinbase' => [:genesis_coinbase, dec],
+      'nonce' => [:genesis_nonce, dec]
+    }
+
+    genesis.each do |k, v|
+      target_key, trans = m[k]
+      @config[:eth][:block][target_key] = trans.call v
+    end
+  end
+end
+
+format = "    %s                   %s"
+result = Slop.parse do |o|
+  o.separator ''
+  o.separator 'Commands:'
+  o.separator(format % ['run', 'Start the client (--dev to stop on error).'])
+
+  o.separator ''
+  o.separator 'Options:'
+
+  o.string '--profile', 'Configuration profile, livenet or testnet. [default: livenet]', default: 'livenet'
+  o.string '-c', '--config', 'Alternative configuration file.'
+  o.string '-C', 'Single configuration parameters (<param>=<value>).'
+  o.string '-d', '--data-dir', "Data directory. [default: #{Reth::Config::DEFAULT_DATA_DIR}]", default: Reth::Config::DEFAULT_DATA_DIR
+
+  o.string '-l', '--log-config', 'Logger configuration. [default: info]', default: 'info'
+  o.string '--log-file', 'Log to file instead of standard outputs.'
+
+  o.int '-n', '--network-id', 'Network id. Any number greater than 2 will create a private network. If specified predefined profile (by --profile) will not be used.'
+  o.string '-b', '--bootstrap-node', 'Single bootstrap node as enode://pubkey@host:port.'
+
+  o.bool '-m', '--mine', 'Enable miner. [default: disabled]', defalut: false
+  o.int '--mining-pct', 'CPU percentage used for mining.'
+
+  o.string '--unlock', 'Unlock an account (prompts for password).'
+  o.string '--password', 'Path to a password file.'
+
+  o.separator ''
+  o.separator 'Misc:'
+
+  o.on '-v', '--version' do
+    puts "version: #{Reth::CLIENT_VERSION_STRING}"
+    exit
+  end
+
+  o.on '-h', '--help' do
+    puts o
+    exit
+  end
+end
+opts = result.to_hash
+command = ARGV[0]
+
+Reth::Logger.level = opts[:log_config]
+
+# frontier genesis:
+# d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3
+
+case command
+when 'run'
+  RethControl.new(opts).start
+else
+  puts result
+end
+

data/lib/reth.rb

@@ -0,0 +1,44 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'devp2p'
+require 'ethereum'
+
+module Reth
+
+  CLIENT_NAME = 'reth'
+  CLIENT_VERSION = "#{VERSION}/#{RUBY_PLATFORM}/#{RUBY_ENGINE}-#{RUBY_VERSION}"
+  CLIENT_VERSION_STRING = "#{CLIENT_NAME}-v#{CLIENT_VERSION}"
+
+  Env         = Ethereum::Env
+  DB          = Ethereum::DB
+  BlockHeader = Ethereum::BlockHeader
+  Block       = Ethereum::Block
+  Transaction = Ethereum::Transaction
+  Chain       = Ethereum::Chain
+
+  Logger = BlockLogger
+
+end
+
+require 'reth/utils'
+require 'reth/config'
+require 'reth/profile'
+
+require 'reth/keystore'
+require 'reth/account'
+
+require 'reth/duplicates_filter'
+require 'reth/sync_task'
+require 'reth/synchronizer'
+
+require 'reth/transient_block'
+require 'reth/eth_protocol'
+
+require 'reth/account_service'
+require 'reth/db_service'
+require 'reth/leveldb_service'
+require 'reth/chain_service'
+
+require 'reth/jsonrpc'
+require 'reth/app'
+

data/lib/reth/account.rb

@@ -0,0 +1,195 @@
+# -*- encoding : ascii-8bit -*-
+
+module Reth
+
+  class Account
+
+    class <<self
+      def test_accounts
+        return @test_accounts if @test_accounts
+
+        @test_accounts = 9.times.map do |i|
+          privkey = (i+1).chr * 32
+          address = Ethereum::PrivateKey.new(privkey).to_address
+          ["0x#{Ethereum::Utils.encode_hex(address)}", privkey]
+        end.to_h
+
+        @test_accounts
+      end
+
+      def test_addresses
+        @test_addresses ||= test_accounts.keys.map {|k| Ethereum::Utils.normalize_address(k) }
+      end
+
+      ##
+      # Create a new account.
+      #
+      # Note that this creates the account in memory and does not store it on
+      # disk.
+      #
+      # @param password [String] used to encrypt the private key
+      # @param key [String] the private key, or `nil` to generate a random one
+      # @param uuid [String] an optional id
+      #
+      def create(password, key=nil, uuid=nil, path=nil)
+        key ||= Utils.mk_random_privkey
+
+        json = Keystore.make_json key, password
+        json[:id] = uuid
+
+        new json, password, path
+      end
+
+      ##
+      # Load an account from a keystore file.
+      #
+      # @param path [String] full path to the keyfile
+      # @param password [String] the password to decrypt the key file or
+      #   `nil` to leave it encrypted
+      #
+      def load(path, password=nil)
+        json = JSON.load File.read(path)
+        raise ValidationError, 'Invalid keystore file' unless Keystore.validate(json)
+        new json, password, path
+      end
+    end
+
+    attr_accessor :path, :address, :keystore
+
+    def initialize(keystore, password=nil, path=nil)
+      @keystore = Hashie.symbolize_keys keystore
+      @address = keystore[:address] ? Utils.decode_hex(keystore[:address]) : nil
+
+      @path = path
+      @locked = true
+
+      unlock(password) if password
+    end
+
+    ##
+    # Dump the keystore for later disk storage.
+    #
+    # The result inherits the entries `crypto` and `version` from `Keystore`,
+    # and adds `address` and `id` in accordance with the parameters
+    # `include_address` and `include_id`.
+    #
+    # If address or id are not known, they are not added, even if requested.
+    #
+    # @param include_address [Bool] flag denoting if the address should be
+    #   included or not
+    # @param include_id [Bool] flag denoting if the id should be included or
+    #   not
+    #
+    def dump(include_address=true, include_id=true)
+      h = {}
+      h[:crypto] = @keystore[:crypto]
+      h[:version] = @keystore[:version]
+
+      h[:address] = Utils.encode_hex address if include_address && address
+      h[:id] = uuid if include_id && uuid
+
+      JSON.dump(h)
+    end
+
+    ##
+    # Unlock the account with a password.
+    #
+    # If the account is already unlocked, nothing happens, even if the
+    # password is wrong.
+    #
+    # @raise [ValueError] (originating from `Keystore.decode_json`) if the
+    # password is wrong and the account is locked
+    #
+    def unlock(password)
+      if @locked
+        @privkey = Keystore.decode_json @keystore, password
+        @locked = false
+        address # get address such that it stays accessible after a subsequent lock
+      end
+    end
+
+    ##
+    # Relock an unlocked account.
+    #
+    # This method sets `privkey` to `nil` (unlike `address` which is
+    # preserved).
+    #
+    def lock
+      @privkey = nil
+      @locked = true
+    end
+
+    def privkey
+      @locked ? nil : @privkey
+    end
+
+    def pubkey
+      @locked ? nil : PrivateKey.new(@privkey).to_pubkey
+    end
+
+    def address
+      unless @address
+        if @keystore[:address]
+          @address = Utils.decode_hex(@keystore[:address])
+        elsif !@locked
+          @address = PrivateKey.new(@privkey).to_address
+        else
+          return nil
+        end
+      end
+
+      @address
+    end
+
+    ##
+    # An optional unique identifier, formatted according to UUID version 4,
+    # or `nil` if the account does not have an id.
+    #
+    def uuid
+      @keystore[:id]
+    end
+
+    def uuid=(id)
+      if id
+        @keystore[:id] = id
+      else
+        @keystore.delete :id
+      end
+    end
+
+    ##
+    # Sign a Transaction with the private key of this account.
+    #
+    # If the account is unlocked, this is equivalent to
+    # `tx.sign(account.privkey)`.
+    #
+    # @param tx [Transaction] the transaction to sign
+    # @raise [ValueError] if the account is locked
+    #
+    def sign_tx(tx)
+      if privkey
+        logger.info "signing tx", tx: tx, account: self
+        tx.sign privkey
+      else
+        raise ValueError, "Locked account cannot sign tx"
+      end
+    end
+
+    def locked?
+      @locked
+    end
+
+    def to_s
+      addr = address ? Utils.encode_hex(address) : '?'
+      "<Account(address=#{addr}, id=#{uuid})>"
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.new('accounts')
+    end
+
+  end
+
+end