platon 0.2.7

data/lib/bech32.rb

@@ -0,0 +1,82 @@
+module Bech32
+
+  module Encoding
+    BECH32 = 1
+    BECH32M = 2
+  end
+
+  SEPARATOR = '1'
+
+  CHARSET = %w(q p z r y 9 x 8 g f 2 t v d w 0 s 3 j n 5 4 k h c e 6 m u a 7 l)
+
+  BECH32M_CONST = 0x2bc830a3
+
+  module_function
+
+  # Returns the encoded Bech32 string.
+  def encode(hrp, data, spec)
+    checksummed = data + create_checksum(hrp, data, spec)
+    hrp + SEPARATOR + checksummed.map{|i|CHARSET[i]}.join
+  end
+
+  # Returns the Bech32 decoded hrp and data.
+  def decode(bech, max_length = 90)
+    # check uppercase/lowercase
+    return nil if bech.bytes.index{|x| x < 33 || x > 126}
+    return nil if (bech.downcase != bech && bech.upcase != bech)
+    bech = bech.downcase
+    # check data length
+    pos = bech.rindex(SEPARATOR)
+    return nil if pos.nil? || pos + 7 > bech.length || bech.length > max_length
+    # check valid charset
+    bech[pos+1..-1].each_char{|c|return nil unless CHARSET.include?(c)}
+    # split hrp and data
+    hrp = bech[0..pos-1]
+    data = bech[pos+1..-1].each_char.map{|c|CHARSET.index(c)}
+    # check checksum
+    spec = verify_checksum(hrp, data)
+    spec ? [hrp, data[0..-7], spec] : nil
+  end
+
+  # Returns computed checksum values of +hrp+ and +data+
+  def create_checksum(hrp, data, spec)
+    values = expand_hrp(hrp) + data
+    const = (spec == Bech32::Encoding::BECH32M ? Bech32::BECH32M_CONST : 1)
+    polymod = polymod(values + [0, 0, 0, 0, 0, 0]) ^ const
+    (0..5).map{|i|(polymod >> 5 * (5 - i)) & 31}
+  end
+
+  # Verify a checksum given Bech32 string
+  # @param [String] hrp hrp part.
+  # @param [Array[Integer]] data data array.
+  # @return [Integer] spec
+  def verify_checksum(hrp, data)
+    const = polymod(expand_hrp(hrp) + data)
+    case const
+    when 1
+      Encoding::BECH32
+    when BECH32M_CONST
+      Encoding::BECH32M
+    end
+  end
+
+  # Expand the hrp into values for checksum computation.
+  def expand_hrp(hrp)
+    hrp.each_char.map{|c|c.ord >> 5} + [0] + hrp.each_char.map{|c|c.ord & 31}
+  end
+
+  # Compute Bech32 checksum
+  def polymod(values)
+    generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+    chk = 1
+    values.each do |v|
+      top = chk >> 25
+      chk = (chk & 0x1ffffff) << 5 ^ v
+      (0..4).each{|i|chk ^= ((top >> i) & 1) == 0 ? 0 : generator[i]}
+    end
+    chk
+  end
+
+  private_class_method :polymod, :expand_hrp
+
+end

data/lib/platon.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "platon/version"
+require 'active_support'
+require 'active_support/core_ext'
+require 'digest/sha3'
+
+require 'ffi'
+require 'money-tree'
+require 'rlp'
+
+require 'bech32'
+
+module Platon
+
+  BYTE_ZERO = "\x00".freeze
+  UINT_MAX = 2**256 - 1
+
+  class << self
+
+    def replayable_chain_id
+      27
+    end
+
+    def v_base
+      replayable_chain_id
+    end
+
+    def replayable_v?(v)
+      [replayable_chain_id, replayable_chain_id + 1].include? v
+    end
+
+    def chain_id_from_signature(signature)
+      return nil if Platon.replayable_v?(signature[:v])
+
+      cid = (signature[:v] - 35) / 2
+      (cid < 1) ? nil : cid
+    end
+  end
+
+  require 'platon/abi'
+  require 'platon/client'
+  require 'platon/ipc_client'
+  require 'platon/http_client'
+  require 'platon/singleton'
+  require 'platon/solidity'
+  require 'platon/initializer'
+  require 'platon/contract'
+  require 'platon/explorer_url_helper'
+  require 'platon/function'
+  require 'platon/function_input'
+  require 'platon/function_output'
+  require 'platon/contract_event'
+  require 'platon/encoder'
+  require 'platon/decoder'
+  require 'platon/formatter'
+  require 'platon/transaction'
+  require 'platon/deployment'
+  require 'platon/contract_initializer'
+  require 'platon/railtie' if defined?(Rails)
+
+  require 'platon/ppos'
+
+  autoload :Address, 'platon/address'
+  autoload :Gas, 'platon/gas'
+  autoload :Key, 'platon/key'
+  autoload :OpenSsl, 'platon/open_ssl'
+  autoload :Secp256k1, 'platon/secp256k1'
+  autoload :Sedes, 'platon/sedes'
+  autoload :Tx, 'platon/tx'
+  autoload :Utils, 'platon/utils'
+
+  autoload :SegwitAddr, 'platon/segwit_addr'
+
+  class ValidationError < StandardError; end
+  class InvalidTransaction < ValidationError; end
+end

data/lib/platon/abi.rb

@@ -0,0 +1,32 @@
+module Platon
+  class Abi
+
+    def self.parse_abi(abi)
+      constructor = abi.detect {|x| x["type"] == "constructor"}
+      if constructor.present?
+        constructor_inputs = constructor["inputs"].map { |input| Platon::FunctionInput.new(input) }
+      else
+        constructor_inputs = []
+      end
+      functions = abi.select {|x| x["type"] == "function" }.map { |fun| Platon::Function.new(fun) }
+      events = abi.select {|x| x["type"] == "event" }.map { |evt| Platon::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/platon/address.rb

@@ -0,0 +1,62 @@
+module Platon
+  class Address
+
+    def initialize(address)
+      @address = Utils.prefix_hex(address)
+    end
+
+    def valid?
+      if !matches_any_format?
+        false
+      elsif not_checksummed?
+        true
+      else
+        checksum_matches?
+      end
+    end
+
+    def checksummed
+      raise "Invalid address: #{address}" unless matches_any_format?
+
+      cased = unprefixed.chars.zip(checksum.chars).map do |char, check|
+        check.match(/[0-7]/) ? char.downcase : char.upcase
+      end
+
+      Utils.prefix_hex(cased.join)
+    end
+
+
+    private
+
+    attr_reader :address
+
+    def checksum_matches?
+      address == checksummed
+    end
+
+    def not_checksummed?
+      all_uppercase? || all_lowercase?
+    end
+
+    def all_uppercase?
+      address.match(/(?:0[xX])[A-F0-9]{40}/)
+    end
+
+    def all_lowercase?
+      address.match(/(?:0[xX])[a-f0-9]{40}/)
+    end
+
+    def matches_any_format?
+      address.match(/\A(?:0[xX])[a-fA-F0-9]{40}\z/)
+    end
+
+    def checksum
+      Utils.bin_to_hex(Utils.keccak256 unprefixed.downcase)
+    end
+
+    def unprefixed
+      Utils.remove_hex_prefix address
+    end
+
+  end
+end

data/lib/platon/client.rb

@@ -0,0 +1,175 @@
+module Platon
+  class Client
+
+    DEFAULT_GAS_LIMIT = 400_000 
+
+    DEFAULT_GAS_PRICE = 1_000_000_000  #1 GVON
+
+    RPC_COMMANDS = %w(web3_clientVersion web3_sha3 net_version net_peerCount net_listening platon_protocolVersion platon_syncing platon_gasPrice platon_accounts platon_blockNumber platon_getBalance platon_getStorageAt platon_getTransactionCount platon_getBlockTransactionCountByHash platon_getBlockTransactionCountByNumber platon_getCode platon_sign platon_sendTransaction platon_sendRawTransaction platon_call platon_estimateGas platon_getBlockByHash platon_getBlockByNumber platon_getTransactionByHash platon_getTransactionByBlockHashAndIndex platon_getTransactionByBlockNumberAndIndex platon_getTransactionReceipt platon_getUncleByBlockHashAndIndex platon_newFilter platon_newBlockFilter platon_newPendingTransactionFilter platon_uninstallFilter platon_getFilterChanges platon_getFilterLogs platon_getLogs platon_getWork platon_submitWork platon_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)
+    #PLATON_UNSUPPORT_COMMANDS =  %w(platon_coinbase ,plton_mining,platon_hashrate,platon_getUncleCountByBlockHash,platon_getUncleCountByBlockNumber,platon_getUncleByBlockNumberAndIndex platon_getCompilers platon_compileLLL platon_compileSolidity platon_compileSerpent)
+    PLATON_RPC_COMMANDS = %w(platon_evidences admin_getProgramVersion admin_getSchnorrNIZKProve)
+    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, :ppos, :hrp,:chain_id
+
+    def initialize(chain_name=nil,log = false)
+      @id = 0
+      @log = log
+      @batch = nil
+      # @formatter = Platon::Formatter.new
+      @gas_price = DEFAULT_GAS_PRICE 
+      @gas_limit = DEFAULT_GAS_LIMIT
+      if @log == true
+        @logger = Logger.new("/tmp/platon_ruby_http.log")
+      end
+
+      @ppos = Platon::Ppos.new self
+
+      set_network(chain_name.downcase.to_sym)
+
+    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 set_network(network) 
+      config = {
+        platondev: {hrp: "lat", chain_id: 210309},
+        alaya:{hrp:"atp",chain_id:201018} ,
+        alayadev:{hrp:"atp",chain_id: 201030}
+      }
+      if config[network]
+        @hrp = config[network][:hrp]  
+        @chain_id = config[network][:chain_id]
+
+        puts "Using Network: #{network}: hrp->#{hrp} , chain_id->#{chain_id}"
+      else
+        puts "Warning: Network:#{network} not found. You can use 'update_setting' to set hrp & chain_id"
+      end
+
+    end
+
+    def update_setting(params)
+      @hrp = params[:hrp]
+      @chain_id = params[:chain_id]
+    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 ||= platon_accounts[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_nonce(address)
+      platon_get_transaction_count(address, "pending")
+    end
+    
+    def transfer_to(address, amount)
+      platon_send_transaction({to: address, value: int_to_hex(amount)})
+    end
+
+    def transfer_to_and_wait(address, amount)
+      wait_for(transfer_to(address, amount))
+    end
+
+
+    def transfer(key, bech32_address, amount,other=nil)
+      raise ArgumentError.new("#{bech32_address} not match current network hrp :#{hrp}") unless Bech32.decode(bech32_address)[0] == hrp
+      args = { 
+        from: key.address,
+        to: Utils.decode_bech32_address(bech32_address),
+        value: amount.to_i,
+        data: "",
+        nonce: get_nonce(key.bech32_address(hrp:hrp)),
+        gas_limit: (other && other[:gas_limit])|| gas_limit,
+        gas_price: (other && other[:gas_price]) || gas_price,
+        chain_id: chain_id
+      }
+
+      tx = Platon::Tx.new(args)
+      tx.sign key
+      platon_send_raw_transaction(tx.hex)
+    end
+    
+    def transfer_and_wait(key, address, amount,other=nil)
+      return wait_for(transfer(key, address, amount,other))
+    end
+    
+    def wait_for(tx)
+      transaction = Platon::Transaction.new(tx, self, "", [])
+      transaction.wait_for_miner
+      return transaction
+    end
+
+    def send_command(command,args)
+
+      # if ["platon_call"].include?(command)
+      #   args << "latest"
+      # end
+      
+      payload = {jsonrpc: "2.0", method: command, params: encode_params(args), id: get_id}
+      # puts payload
+      @logger.info("Sending #{payload.to_json}") if @log
+      if @batch
+        @batch << payload
+        return true
+      else
+        # tmp = send_single(payload.to_json)
+        # output = JSON.parse(tmp)
+        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"]
+        
+        if %W(net_peerCount platon_protocolVersion platon_gasPrice platon_blockNumber platon_getBalance platon_getTransactionCount platon_getBlockTransactionCountByHash platon_getBlockTransactionCountByNumber platon_estimateGas).include?(command)
+          return output["result"].to_i(16)
+        end
+
+        return output["result"]
+      end
+    end
+
+    (RPC_COMMANDS + RPC_MANAGEMENT_COMMANDS + PLATON_RPC_COMMANDS).each do |rpc_command|
+      method_name = rpc_command.underscore
+
+      define_method method_name do |*args|
+        # puts "res： #{method_name}"
+        send_command(rpc_command, args)
+      end
+    end
+
+
+  end
+
+end
+

data/lib/platon/contract.rb

@@ -0,0 +1,351 @@
+require 'forwardable'
+
+module Platon
+  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 self.hello
+      puts 111
+    end
+
+    def initialize(name, code, abi, client = Platon::Singleton.instance)
+      @name = name
+      @code = code
+      @abi = abi
+      @constructor_inputs, @functions, @events = Platon::Abi.parse_abi(abi)
+      @formatter = Platon::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 [Platon::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 [Platon::Contract] Returns a contract wrapper.
+
+    def self.create(file: nil, client: Platon::Singleton.instance, code: nil, abi: nil, address: nil, name: nil, contract_index: nil, truffle: nil)
+      contract = nil
+      if file.present?
+        contracts = Platon::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
+                          (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 = Platon::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.platon_send_transaction(tx_args)
+    end
+
+    def send_raw_transaction(payload, to = nil)
+      # Platon.configure { |c| c.chain_id = @client.net_version.to_i }
+      @nonce = @client.get_nonce(key.bech32_address)
+      args = {
+        from: key.address,
+        value: 0,
+        data: payload,
+        nonce: @nonce,
+        gas_limit: gas_limit,
+        gas_price: gas_price,
+        chain_id: @client.chain_id
+      }
+      args[:to] = Utils.decode_bech32_address(to) if to
+
+      puts args
+
+      tx = Platon::Tx.new(args)
+      tx.sign key
+      @client.platon_send_raw_transaction(tx.hex)
+    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 = Platon::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.platon_estimate_gas(deploy_args(params))
+      @decoder.decode_int(result.to_s(16))  ## TODO
+    end
+
+    def call_payload(fun, args)
+      "0x" + fun.signature + (@encoder.encode_arguments(fun.inputs, args).presence || "0"*64)
+    end
+
+    def call_args(fun, args)
+      # add_gas_options_args({to: @address, from: @sender, data: call_payload(fun, args)})
+      {to: @address, from: @sender, data: call_payload(fun, args)}
+      ## TODO[from js SDK] :missing "from" should give error on deploy and send, call ?
+    end
+
+    def call_raw(fun, *args)
+      raw_result = @client.platon_call(call_args(fun, args),"latest")
+      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 Platon::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.platon_new_filter(payload)
+      return @decoder.decode_int(filter_id)
+    end
+
+    def parse_filter_data(evt, logs)
+      formatter = Platon::Formatter.new
+      collection = []
+      logs.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.platon_get_filter_logs(filter_id)
+    end
+
+    def get_filter_changes(evt, filter_id)
+      parse_filter_data evt, @client.platon_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
+        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
+        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
+      Platon::Contract.send(:remove_const, class_name) if Platon::Contract.const_defined?(class_name, false)
+      Platon::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?
+        puts args
+        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.new, call_proxy.new, transact_proxy.new, transact_and_wait_proxy.new
+      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.new, get_filter_logs_proxy.new, get_filter_change_proxy.new
+      end
+  end
+end