evm_client 0.1.0

data/contracts/classic/ParticipantRegistry.sol

@@ -0,0 +1,94 @@
+contract ParticipantRegistry {
+
+  enum ParticipantTypes { Admin, Vendor, Custodian, Auditor }
+  struct ParticipantDatabase {
+    mapping (address => bool) auditors;
+    mapping (address => bool) vendors;
+    mapping (address => bool) custodians;
+    mapping (address => bool) registrars;
+  }
+
+  address owner;
+  ParticipantDatabase participantdb;
+
+  event AddParticipant(address indexed participant, uint indexed participanttype);
+  event RemoveParticipant(address indexed participant, uint indexed participanttype);
+
+  modifier ifowner { if (msg.sender == owner) _ }
+  modifier ifregistrar { if ((participantdb.registrars[tx.origin]) || (tx.origin == owner)) _ }
+  modifier onlyvendor { if (isVendor(tx.origin) == true) _ }
+  modifier onlycustodian { if (isCustodian(tx.origin) == true) _ }
+  modifier onlyauditor { if (isAuditor(tx.origin) == true) _ }
+
+  function ParticipantRegistry() {
+    owner = msg.sender;
+  }
+
+  function getOwner() returns (address oa) {
+    oa = owner;
+  }
+
+  function setOwner(address nown) ifowner {
+    owner = nown;
+  }
+
+  function registerAdmin(address regraddr) ifowner {
+    participantdb.registrars[regraddr] = true;
+    AddParticipant(regraddr, uint(ParticipantTypes.Admin));
+  }
+
+  function unregisterAdmin(address regraddr) ifowner {
+    participantdb.registrars[regraddr] = false;
+    RemoveParticipant(regraddr, uint(ParticipantTypes.Admin));
+  }
+
+  function registerVendor(address vendoraddress) ifregistrar {
+    participantdb.vendors[vendoraddress] = true;
+    AddParticipant(vendoraddress, uint(ParticipantTypes.Vendor));
+  }
+
+  function unregisterVendor(address vendoraddress) ifregistrar {
+    participantdb.vendors[vendoraddress] = false;
+    RemoveParticipant(vendoraddress, uint(ParticipantTypes.Vendor));
+  }
+
+  function registerCustodian(address custodianaddress) ifregistrar {
+    participantdb.custodians[custodianaddress] = true;
+    AddParticipant(custodianaddress, uint(ParticipantTypes.Custodian));
+  }
+
+  function unregisterCustodian(address custodianaddress) ifregistrar {
+    participantdb.custodians[custodianaddress] = false;
+    RemoveParticipant(custodianaddress, uint(ParticipantTypes.Custodian));
+  }
+
+  function registerAuditor(address auditoraddress) ifregistrar {
+    participantdb.auditors[auditoraddress] = true;
+    AddParticipant(auditoraddress, uint(ParticipantTypes.Auditor));
+  }
+
+  function unregisterAuditor(address auditoraddress) ifregistrar {
+    participantdb.auditors[auditoraddress] = false;
+    RemoveParticipant(auditoraddress, uint(ParticipantTypes.Auditor));
+  }
+
+  function isVendor(address vendoraddress) returns (bool) {
+    return participantdb.vendors[vendoraddress];
+  }
+
+  function isCustodian(address custodianaddress) returns (bool) {
+    return participantdb.custodians[custodianaddress];
+  }
+
+  function isAuditor(address auditoraddress) returns (bool) {
+    return participantdb.auditors[auditoraddress];
+  }
+
+  function isRegistrar(address regraddr) returns (bool) {
+    return participantdb.registrars[regraddr];
+  }
+}
+
+
+
+//#include [ParticipantRegistry]

data/contracts/classic/QueueSample.sol

@@ -0,0 +1,54 @@
+////////////////////////////////////////////////////////////
+// This is an example contract hacked together at a meetup.
+// It is by far not complete and only used to show some
+// features of Solidity.
+////////////////////////////////////////////////////////////
+contract QueueContract
+{
+    struct Queue {
+        uint[] data;
+        uint front;
+        uint back;
+    }
+    /// @dev the number of elements stored in the queue.
+    function length(Queue storage q) constant internal returns (uint) {
+        return q.back - q.front;
+    }
+    /// @dev the number of elements this queue can hold
+    function capacity(Queue storage q) constant internal returns (uint) {
+        return q.data.length - 1;
+    }
+    /// @dev push a new element to the back of the queue
+    function push(Queue storage q, uint data) internal
+    {
+        if ((q.back + 1) % q.data.length == q.front)
+            return; // throw;
+        q.data[q.back] = data;
+        q.back = (q.back + 1) % q.data.length;
+    }
+    /// @dev remove and return the element at the front of the queue
+    function pop(Queue storage q) internal returns (uint r)
+    {
+        if (q.back == q.front)
+            return; // throw;
+        r = q.data[q.front];
+        delete q.data[q.front];
+        q.front = (q.front + 1) % q.data.length;
+    }
+}
+
+contract QueueUserMayBeDeliveryDroneCotnrol is QueueContract {
+    Queue requests;
+    function QueueUserMayBeDeliveryDroneCotnrol() {
+        requests.data.length = 200;
+    }
+    function addRequest(uint d) {
+        push(requests, d);
+    }
+    function popRequest() returns (uint) {
+        return pop(requests);
+    }
+    function queueLength() returns (uint) {
+        return length(requests);
+    }
+}

data/evm_client.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'evm_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "evm_client"
+  spec.version       = EvmClient::VERSION
+  spec.authors       = ["shideneyu"]
+  spec.email         = ["shideneyu@gmail.com"]
+
+  spec.summary       = %q{Ruby Ethereum client using the JSON-RPC interface}
+  spec.description   = %q{EvmClient is Ruby Ethereum client using the JSON-RPC interface. Provides interface for sending transactions, creating and interacting with contracts as well as usefull toolkit to work with Ethereum node.}
+  spec.homepage      = "https://github.com/shideneyu/evm_client"
+  spec.license       = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib", "bin"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.5"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "eth", "~> 0.4"
+
+  spec.add_dependency "activesupport", ">= 4.0"
+  spec.add_dependency "digest-sha3", "~> 1.1"
+end

data/lib/evm_client.rb

@@ -0,0 +1,15 @@
+require_relative 'evm_client/version'
+require 'active_support'
+require 'active_support/core_ext'
+require 'digest/sha3'
+require 'pry'
+
+module EvmClient
+  ruby_project_files = Dir[File.join(File.dirname(__FILE__), '**', '*.rb')]
+
+  ruby_project_files.sort_by!{ |file_name| file_name.downcase }.each do |path|
+    require_relative path unless path.match?(/rail/)
+  end
+
+  require_relative 'ethereum/railtie' if defined?(Rails)
+end

data/lib/evm_client/abi.rb

@@ -0,0 +1,32 @@
+module EvmClient
+  class Abi
+
+    def self.parse_abi(abi)
+      constructor = abi.detect {|x| x["type"] == "constructor"}
+      if constructor.present?
+        constructor_inputs = constructor["inputs"].map { |input| EvmClient::FunctionInput.new(input) }
+      else
+        constructor_inputs = []
+      end
+      functions = abi.select {|x| x["type"] == "function" }.map { |fun| EvmClient::Function.new(fun) }
+      events = abi.select {|x| x["type"] == "event" }.map { |evt| EvmClient::ContractEvent.new(evt) }
+      [constructor_inputs, functions, events]
+    end
+
+    def self.parse_type(type)
+      raise NotImplementedError if type.ends_with?("]")
+      match = /(\D+)(\d.*)?/.match(type)
+      [match[1], match[2]]
+    end
+
+    def self.parse_array_type(type)
+      match = /(.+)\[(\d*)\]\z/.match(type)
+      if match
+        [true, match[2].present? ? match[2].to_i : nil, match[1]]
+      else
+        [false, nil, nil]
+      end
+    end
+
+  end
+end

data/lib/evm_client/client.rb

@@ -0,0 +1,146 @@
+module EvmClient
+  class Client
+
+    DEFAULT_GAS_LIMIT    = 4_000_000.freeze
+    DEFAULT_GAS_PRICE    = 22_000_000_000.freeze
+    DEFAULT_BLOCK_NUMBER = 'latest'.freeze
+
+    # https://github.com/ethereum/wiki/wiki/JSON-RPC
+    RPC_COMMANDS = %w(web3_clientVersion web3_sha3 net_version net_peerCount net_listening eth_protocolVersion eth_syncing eth_coinbase eth_mining eth_hashrate eth_gasPrice eth_accounts eth_blockNumber eth_getBalance eth_getStorageAt eth_getTransactionCount eth_getBlockTransactionCountByHash eth_getBlockTransactionCountByNumber eth_getUncleCountByBlockHash eth_getUncleCountByBlockNumber eth_getCode eth_sign eth_sendTransaction eth_sendRawTransaction eth_call eth_estimateGas eth_getBlockByHash eth_getBlockByNumber eth_getTransactionByHash eth_getTransactionByBlockHashAndIndex eth_getTransactionByBlockNumberAndIndex eth_getTransactionReceipt eth_getUncleByBlockHashAndIndex eth_getUncleByBlockNumberAndIndex eth_getCompilers eth_compileLLL eth_compileSolidity eth_compileSerpent eth_newFilter eth_newBlockFilter eth_newPendingTransactionFilter eth_uninstallFilter eth_getFilterChanges eth_getFilterLogs eth_getLogs eth_getWork eth_submitWork eth_submitHashrate db_putString db_getString db_putHex db_getHex shh_post shh_version shh_newIdentity shh_hasIdentity shh_newGroup shh_addToGroup shh_newFilter shh_uninstallFilter shh_getFilterChanges shh_getMessages)
+
+    # https://github.com/ethereum/go-ethereum/wiki/Management-APIs
+    RPC_MANAGEMENT_COMMANDS = %w(admin_addPeer admin_datadir admin_nodeInfo admin_peers admin_setSolc admin_startRPC admin_startWS admin_stopRPC admin_stopWS debug_backtraceAt debug_blockProfile debug_cpuProfile debug_dumpBlock debug_gcStats debug_getBlockRlp debug_goTrace debug_memStats debug_seedHash debug_setHead debug_setBlockProfileRate debug_stacks debug_startCPUProfile debug_startGoTrace debug_stopCPUProfile debug_stopGoTrace debug_traceBlock debug_traceBlockByNumber debug_traceBlockByHash debug_traceBlockFromFile debug_traceTransaction debug_verbosity debug_vmodule debug_writeBlockProfile debug_writeMemProfile miner_hashrate miner_makeDAG miner_setExtra miner_setGasPrice miner_start miner_startAutoDAG miner_stop miner_stopAutoDAG personal_importRawKey personal_listAccounts personal_lockAccount personal_newAccount personal_unlockAccount personal_sendTransaction txpool_content txpool_inspect txpool_status)
+
+    attr_accessor :command, :id, :log, :logger, :default_account, :gas_price, :gas_limit, :block_number
+
+    def initialize(log = false)
+      @id           = 0
+      @log          = log
+      @batch        = nil
+      @formatter    = ::EvmClient::Formatter.new
+      @gas_price    = DEFAULT_GAS_PRICE
+      @gas_limit    = DEFAULT_GAS_LIMIT
+      @block_number = DEFAULT_BLOCK_NUMBER
+
+      if @log == true
+        @logger = Logger.new("/tmp/ethereum_ruby_http.log")
+      end
+    end
+
+    def self.create(host_or_ipcpath, log = false)
+      return IpcClient.new(host_or_ipcpath, log) if host_or_ipcpath.end_with? '.ipc'
+      return HttpClient.new(host_or_ipcpath, log) if host_or_ipcpath.start_with? 'http'
+      raise ArgumentError.new('Unable to detect client type')
+    end
+
+    def batch
+      @batch = []
+
+      yield
+      result = send_batch(@batch)
+
+      @batch = nil
+      reset_id
+
+      return result
+    end
+
+    def get_id
+      @id += 1
+      return @id
+    end
+
+    def reset_id
+      @id = 0
+    end
+
+    def default_account
+      @default_account ||= eth_accounts["result"][0]
+    end
+
+    def int_to_hex(p)
+      p.is_a?(Integer) ? "0x#{p.to_s(16)}" : p 
+    end
+
+    def encode_params(params)
+      params.map(&method(:int_to_hex))
+    end
+
+    def get_balance(address)
+      eth_get_balance(address)["result"].to_i(16)
+    end
+
+    def get_chain
+      @net_version ||= net_version["result"].to_i
+    end
+
+    def get_nonce(address)
+      eth_get_transaction_count(address, "pending")["result"].to_i(16)
+    end
+    
+
+    def transfer_to(address, amount)
+      eth_send_transaction({to: address, value: int_to_hex(amount)})
+    end
+
+    def transfer_to_and_wait(address, amount)
+      wait_for(transfer_to(address, amount)["result"])
+    end
+
+
+    def transfer(key, address, amount)
+      Eth.configure { |c| c.chain_id = net_version["result"].to_i }
+      args = { 
+        from: key.address,
+        to: address,
+        value: amount,
+        data: "",
+        nonce: get_nonce(key.address),
+        gas_limit: gas_limit,
+        gas_price: gas_price
+      }
+      tx = Eth::Tx.new(args)
+      tx.sign key
+      eth_send_raw_transaction(tx.hex)["result"]
+    end
+    
+    def transfer_and_wait(key, address, amount)
+      return wait_for(transfer(key, address, amount))
+    end
+    
+    def wait_for(tx)
+      transaction = EvmClient::Transaction.new(tx, self, "", [])
+      transaction.wait_for_miner
+      return transaction
+    end
+
+    def send_command(command,args)
+      if ["eth_getBalance", "eth_call"].include?(command)
+        args << block_number
+      end
+
+      payload = {jsonrpc: "2.0", method: command, params: encode_params(args), id: get_id}
+      @logger.info("Sending #{payload.to_json}") if @log
+      if @batch
+        @batch << payload
+        return true
+      else
+        output = JSON.parse(send_single(payload.to_json))
+        @logger.info("Received #{output.to_json}") if @log
+        reset_id
+        raise IOError, output["error"]["message"] if output["error"]
+        return output
+      end
+    end
+
+    (RPC_COMMANDS + RPC_MANAGEMENT_COMMANDS).each do |rpc_command|
+      method_name = rpc_command.underscore
+      define_method method_name do |*args|
+        send_command(rpc_command, args)
+      end
+    end
+
+  end
+
+end
+

data/lib/evm_client/contract.rb

@@ -0,0 +1,341 @@
+require 'forwardable'
+module EvmClient
+  class Contract
+
+    attr_reader :address
+    attr_accessor :key
+    attr_accessor :gas_limit, :gas_price, :nonce
+    attr_accessor :code, :name, :abi, :class_object, :sender, :deployment, :client
+    attr_accessor :events, :functions, :constructor_inputs
+    attr_accessor :call_raw_proxy, :call_proxy, :transact_proxy, :transact_and_wait_proxy
+    attr_accessor :new_filter_proxy, :get_filter_logs_proxy, :get_filter_change_proxy
+
+    def initialize(name, code, abi, client = EvmClient::Singleton.instance)
+      @name = name
+      @code = code
+      @abi = abi
+      @constructor_inputs, @functions, @events = EvmClient::Abi.parse_abi(abi)
+      @formatter = EvmClient::Formatter.new
+      @client = client
+      @sender = client.default_account
+      @encoder = Encoder.new
+      @decoder = Decoder.new
+      @gas_limit = @client.gas_limit
+      @gas_price = @client.gas_price
+    end
+
+    # Creates a contract wrapper.
+    # This method attempts to instantiate a contract object from a Solidity source file, from a Truffle
+    # artifacts file, or from explicit API and bytecode.
+    # - If *:file* is present, the method compiles it and looks up the contract factory at *:contract_index*
+    #   (0 if not provided). *:abi* and *:code* are ignored.
+    # - If *:truffle* is present, the method looks up the Truffle artifacts data for *:name* and uses
+    #   those data to build a contract instance.
+    # - Otherwise, the method uses *:name*, *:code*, and *:abi* to build the contract instance.
+    #
+    # @param opts [Hash] Options to the method.
+    # @option opts [String] :file Path to the Solidity source that contains the contract code.
+    # @option opts [EvmClient::Singleton] :client The client to use.
+    # @option opts [String] :code The hex representation of the contract's bytecode.
+    # @option opts [Array,String] :abi The contract's ABI; a string is assumed to contain a JSON representation
+    #  of the ABI.
+    # @option opts [String] :address The contract's address; if not present and +:truffle+ is present,
+    #  the method attempts to determine the address from the artifacts' +networks+ key and the client's
+    #  network id.
+    # @option opts [String] :name The contract name.
+    # @option opts [Integer] :contract_index The index of the contract data in the compiled file.
+    # @option opts [Hash] :truffle If this parameter is present, the method uses Truffle information to
+    #  generate the contract wrapper.
+    #  - *:paths* An array of strings containing the list of paths where to look up Truffle artifacts files.
+    #    See also {#find_truffle_artifacts}.
+    #
+    # @return [EvmClient::Contract] Returns a contract wrapper.
+
+    def self.create(file: nil, client: EvmClient::Singleton.instance, code: nil, abi: nil, address: nil, name: nil, contract_index: nil, truffle: nil)
+      contract = nil
+      if file.present?
+        contracts = EvmClient::Initializer.new(file, client).build_all
+        raise "No contracts compiled" if contracts.empty?
+        if contract_index
+          contract = contracts[contract_index].class_object.new
+        else
+          contract = contracts.first.class_object.new
+        end
+      else
+        if truffle.present? && truffle.is_a?(Hash)
+          artifacts = find_truffle_artifacts(name, (truffle[:paths].is_a?(Array)) ? truffle[:paths] : [])
+          if artifacts
+            abi = artifacts['abi']
+            # The truffle artifacts store bytecodes with a 0x tag, which we need to remove
+            # this may need to be 'deployedBytecode'
+            code_key = artifacts['bytecode'].present? ? 'bytecode' : 'unlinked_binary'
+            code = (artifacts[code_key].start_with?('0x')) ? artifacts[code_key][2, artifacts[code_key].length] : artifacts[code_key]
+            unless address
+              address = if client
+                          network_id = client.net_version['result']
+                          (artifacts['networks'][network_id]) ? artifacts['networks'][network_id]['address'] : nil
+                        else
+                          nil
+                        end
+            end
+          else
+            abi = nil
+            code = nil
+          end
+        else
+          abi = abi.is_a?(String) ? JSON.parse(abi) : abi.map(&:deep_stringify_keys)
+        end
+        contract = EvmClient::Contract.new(name, code, abi, client)
+        contract.build
+        contract = contract.class_object.new
+      end
+      contract.address = address
+      contract
+    end
+
+    def address=(addr)
+      @address = addr
+      @events.each do |event|
+        event.set_address(addr)
+        event.set_client(@client)
+      end
+    end
+
+    def deploy_payload(params)
+      if @constructor_inputs.present?
+        raise ArgumentError, "Wrong number of arguments in a constructor" and return if params.length != @constructor_inputs.length
+      end
+      deploy_arguments = @encoder.encode_arguments(@constructor_inputs, params)
+      "0x" + @code + deploy_arguments
+    end
+
+    def deploy_args(params)
+      add_gas_options_args({from: sender, data: deploy_payload(params)})
+    end
+
+    def send_transaction(tx_args)
+        @client.eth_send_transaction(tx_args)["result"]
+    end
+
+    def send_raw_transaction(payload, to = nil)
+      Eth.configure { |c| c.chain_id = @client.net_version["result"].to_i }
+      @nonce ||= @client.get_nonce(key.address)
+      args = {
+        from: key.address,
+        value: 0,
+        data: payload,
+        nonce: @nonce,
+        gas_limit: gas_limit,
+        gas_price: gas_price
+      }
+      args[:to] = to if to
+      tx = Eth::Tx.new(args)
+      tx.sign key
+      @client.eth_send_raw_transaction(tx.hex)["result"]
+    end
+
+    def deploy(*params)
+      if key
+        tx = send_raw_transaction(deploy_payload(params))
+      else
+        tx = send_transaction(deploy_args(params))
+      end
+      tx_failed = tx.nil? || tx == "0x0000000000000000000000000000000000000000000000000000000000000000"
+      raise IOError, "Failed to deploy, did you unlock #{sender} account? Transaction hash: #{tx}" if tx_failed
+      @deployment = EvmClient::Deployment.new(tx, @client)
+    end
+
+    def deploy_and_wait(*params, **args, &block)
+      deploy(*params)
+      @deployment.wait_for_deployment(**args, &block)
+      self.events.each do |event|
+        event.set_address(@address)
+        event.set_client(@client)
+      end
+      @address = @deployment.contract_address
+    end
+
+    def estimate(*params)
+      result = @client.eth_estimate_gas(deploy_args(params))
+      @decoder.decode_int(result["result"])
+    end
+
+    def call_payload(fun, args)
+      "0x" + fun.minified_signature + (@encoder.encode_arguments(fun.inputs, args))
+    end
+
+    def call_args(fun, args)
+      options = {to: @address, from: @sender, data: call_payload(fun, args)}
+
+      fun.constant ? options : add_gas_options_args(options)
+    end
+
+    def call_raw(fun, *args)
+      raw_result = @client.eth_call(call_args(fun, args))["result"]
+      output = @decoder.decode_arguments(fun.outputs, raw_result)
+      return {data: call_payload(fun, args), raw: raw_result, formatted: output}
+    end
+
+    def call(fun, *args)
+      output = call_raw(fun, *args)[:formatted]
+      if output.length == 1
+        return output[0]
+      else
+        return output
+      end
+    end
+
+    def transact(fun, *args)
+      if key
+        tx = send_raw_transaction(call_payload(fun, args), address)
+      else
+        tx = send_transaction(call_args(fun, args))
+      end
+      return EvmClient::Transaction.new(tx, @client, call_payload(fun, args), args)
+    end
+
+    def transact_and_wait(fun, *args)
+      tx = transact(fun, *args)
+      tx.wait_for_miner
+      return tx
+    end
+
+    def create_filter(evt, **params)
+      params[:to_block] ||= "latest"
+      params[:from_block] ||= "0x0"
+      params[:address] ||= @address
+      params[:topics] = @encoder.ensure_prefix(evt.signature)
+      payload = {topics: [params[:topics]], fromBlock: params[:from_block], toBlock: params[:to_block], address: @encoder.ensure_prefix(params[:address])}
+      filter_id = @client.eth_new_filter(payload)
+      return @decoder.decode_int(filter_id["result"])
+    end
+
+    def parse_filter_data(evt, logs)
+      formatter = EvmClient::Formatter.new
+      collection = []
+      logs["result"].each do |result|
+        inputs = evt.input_types
+        outputs = inputs.zip(result["topics"][1..-1])
+        data = {blockNumber: result["blockNumber"].hex, transactionHash: result["transactionHash"], blockHash: result["blockHash"], transactionIndex: result["transactionIndex"].hex, topics: []}
+        outputs.each do |output|
+          data[:topics] << formatter.from_payload(output)
+        end
+        collection << data
+      end
+      return collection
+    end
+
+    def get_filter_logs(evt, filter_id)
+      parse_filter_data evt, @client.eth_get_filter_logs(filter_id)
+    end
+
+    def get_filter_changes(evt, filter_id)
+      parse_filter_data evt, @client.eth_get_filter_changes(filter_id)
+    end
+
+    def function_name(fun)
+      count = functions.select {|x| x.name == fun.name }.count
+      name = (count == 1) ? "#{fun.name.underscore}" : "#{fun.name.underscore}__#{fun.inputs.collect {|x| x.type}.join("__")}"
+      name.to_sym
+    end
+
+    def build
+      class_name = @name.camelize
+      parent = self
+      create_function_proxies
+      create_event_proxies
+      class_methods = Class.new do
+        extend Forwardable
+        def_delegators :parent, :deploy_payload, :deploy_args, :call_payload, :call_args, :functions
+        def_delegators :parent, :signed_deploy, :key, :key=
+        def_delegators :parent, :gas_limit, :gas_price, :gas_limit=, :gas_price=, :nonce, :nonce=
+        def_delegators :parent, :abi, :deployment, :events, :name
+        def_delegators :parent, :estimate, :deploy, :deploy_and_wait
+        def_delegators :parent, :address, :address=, :sender, :sender=
+        def_delegator :parent, :call_raw_proxy, :call_raw
+        def_delegator :parent, :call_proxy, :call
+        def_delegator :parent, :transact_proxy, :transact
+        def_delegator :parent, :transact_and_wait_proxy, :transact_and_wait
+        def_delegator :parent, :new_filter_proxy, :new_filter
+        def_delegator :parent, :get_filter_logs_proxy, :get_filter_logs
+        def_delegator :parent, :get_filter_change_proxy, :get_filter_changes
+        define_method :parent do
+          parent
+        end
+      end
+      EvmClient::Contract.send(:remove_const, class_name) if EvmClient::Contract.const_defined?(class_name, false)
+      EvmClient::Contract.const_set(class_name, class_methods)
+      @class_object = class_methods
+    end
+
+    # Get the list of paths where to look up Truffle artifacts files.
+    #
+    # @return [Array<String>] Returns the array containing the list of lookup paths.
+
+    def self.truffle_paths()
+      @truffle_paths = [] unless @truffle_paths
+      @truffle_paths
+    end
+
+    # Set the list of paths where to look up Truffle artifacts files.
+    #
+    # @param paths [Array<String>, nil] The array containing the list of lookup paths; a `nil` value is
+    #  converted to the empty array.
+
+    def self.truffle_paths=(paths)
+      @truffle_paths = (paths.is_a?(Array)) ? paths : []
+    end
+
+    # Looks up and loads a Truffle artifacts file.
+    # This method iterates over the `truffle_path` elements, looking for an artifact file in the
+    # `build/contracts` subdirectory.
+    #
+    # @param name [String] The name of the contract whose artifacts to look up.
+    # @param paths [Array<String>] An additional list of paths to look up; this list, if present, is
+    #  prepended to the `truffle_path`.
+    #
+    # @return [Hash,nil] Returns a hash containing the parsed JSON from the artifacts file; if no file
+    #  was found, returns `nil`.
+
+    def self.find_truffle_artifacts(name, paths = [])
+      subpath = File.join('build', 'contracts', "#{name}.json")
+
+      found = paths.concat(truffle_paths).find { |p| File.file?(File.join(p, subpath)) }
+      if (found)
+        JSON.parse(IO.read(File.join(found, subpath)))
+      else
+        nil
+      end
+    end
+
+    private
+      def add_gas_options_args(args)
+        args[:gas] = @client.int_to_hex(gas_limit) if gas_limit.present?
+        args[:gasPrice] = @client.int_to_hex(gas_price) if gas_price.present?
+        args
+      end
+
+      def create_function_proxies
+        parent = self
+        call_raw_proxy, call_proxy, transact_proxy, transact_and_wait_proxy = Class.new, Class.new, Class.new, Class.new
+        @functions.each do |fun|
+          call_raw_proxy.send(:define_method, parent.function_name(fun)) { |*args| parent.call_raw(fun, *args) }
+          call_proxy.send(:define_method, parent.function_name(fun)) { |*args| parent.call(fun, *args) }
+          transact_proxy.send(:define_method, parent.function_name(fun)) { |*args| parent.transact(fun, *args) }
+          transact_and_wait_proxy.send(:define_method, parent.function_name(fun)) { |*args| parent.transact_and_wait(fun, *args) }
+        end
+        @call_raw_proxy, @call_proxy, @transact_proxy, @transact_and_wait_proxy =  call_raw_proxy.allocate, call_proxy.allocate, transact_proxy.allocate, transact_and_wait_proxy.allocate
+      end
+
+      def create_event_proxies
+        parent = self
+        new_filter_proxy, get_filter_logs_proxy, get_filter_change_proxy = Class.new, Class.new, Class.new
+        events.each do |evt|
+          new_filter_proxy.send(:define_method, evt.name.underscore) { |*args| parent.create_filter(evt, *args) }
+          get_filter_logs_proxy.send(:define_method, evt.name.underscore) { |*args| parent.get_filter_logs(evt, *args) }
+          get_filter_change_proxy.send(:define_method, evt.name.underscore) { |*args| parent.get_filter_changes(evt, *args) }
+        end
+        @new_filter_proxy, @get_filter_logs_proxy, @get_filter_change_proxy = new_filter_proxy.allocate, get_filter_logs_proxy.allocate, get_filter_change_proxy.allocate
+      end
+  end
+end