etherlite 0.1.4 → 0.1.5

data/lib/etherlite/api/rpc.rb

@@ -0,0 +1,55 @@
+module Etherlite
+  module Api
+    module Rpc
+      def eth_block_number
+        Etherlite::Utils.hex_to_uint ipc_call(:eth_blockNumber)
+      end
+
+      def eth_gas_price
+        Etherlite::Utils.hex_to_uint ipc_call(:eth_gasPrice)
+      end
+
+      def eth_get_transaction_receipt(_tx_hash)
+        ipc_call(:eth_getTransactionReceipt, _tx_hash)
+      end
+
+      def eth_get_transaction_count(_address, _block = 'latest')
+        Etherlite::Utils.hex_to_uint ipc_call(:eth_getTransactionCount, _address, _block)
+      end
+
+      def eth_call(_params, _block = 'latest')
+        ipc_call(:eth_call, _params, _block)
+      end
+
+      def eth_send_raw_transaction(_hex_data)
+        ipc_call(:eth_sendRawTransaction, _hex_data)
+      end
+
+      def eth_send_transaction(_params)
+        ipc_call(:eth_sendTransaction, _params)
+      end
+
+      def personal_send_transaction(_params, _passphrase)
+        ipc_call(:personal_sendTransaction, _params, _passphrase)
+      end
+
+      # TestRPC support
+
+      def evm_snapshot
+        ipc_call(:evm_snapshot)
+      end
+
+      def evm_revert(_snapshot_id)
+        ipc_call(:evm_revert, _snapshot_id)
+      end
+
+      def evm_increase_time(_seconds)
+        Etherlite::Utils.hex_to_uint ipc_call(:evm_increase_time, _seconds)
+      end
+
+      def evm_mine
+        ipc_call(:evm_mine)
+      end
+    end
+  end
+end

data/lib/etherlite/commands/abi/load_contract.rb

@@ -1,8 +1,10 @@
 module Etherlite::Abi
-  class LoadContract < PowerTypes::Command.new(:json)
+  class LoadContract < PowerTypes::Command.new(:artifact)
     def perform
       klass = Class.new(Etherlite::Contract::Base)
 
+      define_class_methods klass
+
       abi_definitions.each do |definition|
         case definition['type']
         when 'function'
@@ -20,21 +22,15 @@ module Etherlite::Abi
     private
 
     def abi_definitions
-      @json['abi'] || []
+      @artifact['abi'] || []
     end
 
     def define_function(_class, _definition)
-      function_args = _definition['inputs'].map { |input| LoadType.for signature: input['type'] }
-      function = Etherlite::Contract::Function.new(
-        _definition['name'],
-        function_args,
-        payable: _definition['payable'],
-        constant: _definition['constant']
-      )
+      function = build_function_from_definition _definition
 
       _class.functions << function
       _class.class_eval do
-        define_method(_definition['name'].underscore) do |*params|
+        define_method(function.name.underscore) do |*params|
           account = (params.last.is_a?(Hash) && params.last[:as]) || default_account
 
           raise ArgumentError, 'must provide a source account' if account.nil?
@@ -62,5 +58,23 @@ module Etherlite::Abi
       _class.events << event_class
       _class.const_set(_definition['name'], event_class)
     end
+
+    def define_class_methods(_class)
+      unlinked_binary = @artifact['unlinked_binary'] || ''
+
+      _class.class_eval do
+        define_singleton_method('unlinked_binary') { unlinked_binary }
+      end
+    end
+
+    def build_function_from_definition(_definition)
+      Etherlite::Contract::Function.new(
+        _definition['name'],
+        _definition['inputs'].map { |input| LoadType.for signature: input['type'] },
+        _definition['outputs'].map { |input| LoadType.for signature: input['type'] },
+        _definition['payable'],
+        _definition['constant']
+      )
+    end
   end
 end

data/lib/etherlite/commands/abi/load_function.rb

@@ -6,16 +6,16 @@ module Etherlite::Abi
       parts = MATCHER.match @signature
       raise ArgumentError, 'invalid method signature' if parts.nil?
 
-      args = parts[3].split(',').map { |a| LoadType.for(signature: a.strip) }
+      inputs = parts[3].split(',').map { |a| LoadType.for(signature: a.strip) }
 
       case parts[1]
       when 'payable'
-        build parts[2], args, payable: true
+        build parts[2], inputs, [], true, false
       when 'onchain'
-        build parts[2], args
+        build parts[2], inputs, [], false, false
       else
-        return_type = parts[1] == 'void' ? nil : LoadType.for(signature: parts[1])
-        build parts[2], args, constant: true, returns: return_type
+        ouputs = parts[1] == 'void' ? [] : [LoadType.for(signature: parts[1])]
+        build parts[2], inputs, ouputs, false, true
       end
     end
 

data/lib/etherlite/commands/abi/load_type.rb

@@ -20,7 +20,7 @@ module Etherlite::Abi
       when 'fixed'    then Etherlite::Types::Fixed.new(true, b1_128(_parts), b2_128(_parts))
       when 'string'   then Etherlite::Types::String.new
       when 'address'  then Etherlite::Types::Address.new
-      when 'bool'     then Etherlite::Types::Bool.new
+      when 'bool'     then Etherlite::Types::Boolean.new
       when 'bytes'
         if _parts[:b1].present?
           Etherlite::Types::Bytes.new(_parts[:b1].to_i)

data/lib/etherlite/commands/contract/event_base/decode_log_inputs.rb

@@ -1,21 +1,41 @@
 class Etherlite::Contract::EventBase
   class DecodeLogInputs < PowerTypes::Command.new(:connection, :inputs, :json)
     def perform
-      indexed = []
-      non_indexed = []
-      attributes = {}
+      store_by_name non_indexed_inputs, non_indexed_values
+      store_by_name indexed_inputs, indexed_values
+      attributes
+    end
 
-      @inputs.each { |i| (i.indexed? ? indexed : non_indexed) << i }
+    private
 
-      @json['data'][2..-1].scan(/.{64}/).each_with_index do |data, i|
-        attributes[non_indexed[i].original_name] = non_indexed[i].type.decode(@connection, data)
-      end
+    def attributes
+      @attributes ||= {}
+    end
+
+    def non_indexed_inputs
+      @non_indexed_inputs ||= @inputs.select { |i| !i.indexed? }
+    end
 
-      @json['topics'][1..-1].each_with_index do |topic, i|
-        attributes[indexed[i].original_name] = indexed[i].type.decode(@connection, topic[2..-1])
+    def non_indexed_values
+      Etherlite::Support::Array.decode(
+        @connection, non_indexed_inputs.map(&:type), @json['data'][2..-1]
+      )
+    end
+
+    def indexed_inputs
+      @indexed_inputs ||= @inputs.select(&:indexed?)
+    end
+
+    def indexed_values
+      topics = @json['topics'][1..-1]
+      indexed_inputs.each_with_index.map do |input, i|
+        # dynamic indexed inputs cannot be retrieved (only the hash is stored)
+        input.type.dynamic? ? topics[i] : input.type.decode(@connection, topics[i])
       end
+    end
 
-      attributes
+    def store_by_name(_inputs, _values)
+      _inputs.each_with_index { |input, i| attributes[input.original_name] = _values[i] }
     end
   end
 end

data/lib/etherlite/configuration.rb

@@ -2,10 +2,11 @@ module Etherlite
   class Configuration
     DEFAULTS = {
       url: 'http://127.0.0.1:8545',
+      chain_id: nil, # any chain
       logger: nil # set by method
     }
 
-    attr_accessor :url, :logger
+    attr_accessor :url, :chain_id, :logger
 
     def initialize
       assign_attributes DEFAULTS

data/lib/etherlite/connection.rb

@@ -1,7 +1,12 @@
 module Etherlite
   class Connection
-    def initialize(_uri)
+    include Api::Rpc
+
+    attr_reader :chain_id
+
+    def initialize(_uri, _chain_id = nil)
       @uri = _uri
+      @chain_id = _chain_id
     end
 
     def ipc_call(_method, *_params)
@@ -31,12 +36,11 @@ module Etherlite
     def handle_response(_response, _id)
       case _response
       when Net::HTTPSuccess
-        # puts _response.body
         json_body = JSON.parse _response.body
-        # TODO: check id
+        raise NodeError.new json_body['error'] if json_body['error']
         json_body['result']
       else
-        raise _response
+        raise RPCError.new _response.code, _response.body
       end
     end
   end

data/lib/etherlite/contract/base.rb

@@ -1,15 +1,62 @@
 module Etherlite::Contract
+  ##
+  # The base class for etherlite contract classes
+  #
   class Base
     include Etherlite::Api::Address
 
+    # The contract's registered functions
     def self.functions
       @functions ||= []
     end
 
+    # The contract's registered events
     def self.events
       @events ||= []
     end
 
+    # The contract's compiled bytecode in binary format (stored as hex)
+    def self.binary
+      @binary ||= begin
+        if /__[^_]+_+/ === unlinked_binary
+          raise UnlinkedContractError, 'compiled contract contains unresolved library references'
+        end
+
+        unlinked_binary
+      end
+    end
+
+    ##
+    # Deploys the contract and waits for the creation transaction to be mined.
+    #
+    # This method can be given a source account or client. If an account is given, the it will be
+    # used to send the creation transaction. If instead a client is given, the client
+    # `default_account` will be used to send the transaction. If no account nor client is given,
+    # then the default_account from the default client will be used (if configured).
+    #
+    # @param as (Object) The source account
+    # @param client (Object) The source client (no effect if :as is given)
+    # @param timeout (Integer) The transaction mining timeout in seconds, defaults to 120 seconds.
+    #
+    # This method also takes any parameters the underlying account.send_transaction accepts, like
+    # :gas, :gas_price, etc.
+    #
+    # @return [Object] instance of the contract class pointing the newly deployed contract address.
+    #
+    def self.deploy(_options = {})
+      as = _options[:as] || _options[:client].try(:default_account) || Etherlite.default_account
+
+      tx = as.send_transaction({ data: binary }.merge(_options))
+      if tx.wait_for_block(timeout: _options.fetch(:timeout, 120))
+        at tx.contract_address, as: as
+      end
+    end
+
+    ##
+    # Creates a new instance of the contract class that points to a given address.
+    #
+    #
+    #
     def self.at(_address, client: nil, as: nil)
       _address = Etherlite::Utils.normalize_address_param _address
 
@@ -17,7 +64,7 @@ module Etherlite::Contract
         new(as.connection, _address, as)
       else
         client ||= ::Etherlite
-        new(client.connection, _address, client.first_account)
+        new(client.connection, _address, client.default_account)
       end
     end
 
@@ -29,6 +76,11 @@ module Etherlite::Contract
       @default_account = _default_account
     end
 
+    ##
+    # Searches for event logs emitted by this contract
+    #
+    #
+    #
     def get_logs(events: nil, from_block: :earliest, to_block: :latest)
       params = {
         address: json_encoded_address,

data/lib/etherlite/contract/function.rb

@@ -1,16 +1,14 @@
-require 'etherlite/commands/contract/function/encode_arguments'
-
 module Etherlite::Contract
   class Function
-    attr_reader :name, :args
+    attr_reader :name, :inputs, :outputs
 
-    def initialize(_name, _args, returns: nil, payable: false, constant: false)
+    def initialize(_name, _inputs, _outputs, _payable, _constant)
       @name = _name
-      @args = _args
+      @inputs = _inputs
+      @outputs = _outputs
 
-      @returns = returns
-      @payable = payable
-      @constant = constant
+      @payable = _payable
+      @constant = _constant
     end
 
     def constant?
@@ -23,21 +21,27 @@ module Etherlite::Contract
 
     def signature
       @signature ||= begin
-        arg_signatures = @args.map &:signature
+        arg_signatures = @inputs.map &:signature
         "#{@name}(#{arg_signatures.join(',')})"
       end
     end
 
     def encode(_values)
+      if _values.length != @inputs.count
+        raise ArgumentError, "Expected #{@inputs.count} arguments, got #{_values.length} "
+      end
+
       signature_hash = Etherlite::Utils.sha3 signature
-      encoded_args = EncodeArguments.for subtypes: @args, values: _values
+      encoded_inputs = Etherlite::Support::Array.encode(@inputs, _values)
 
-      '0x' + signature_hash[0..7] + encoded_args
+      '0x' + signature_hash[0..7] + encoded_inputs
     end
 
-    def decode(_connection, _values)
-      # TODO: decode return values
-      _values
+    def decode(_connection, _data)
+      return nil if @outputs.empty?
+
+      result = Etherlite::Support::Array.decode(_connection, @outputs, _data[2..-1])
+      result.length > 1 ? result : result[0]
     end
   end
 end

data/lib/etherlite/errors.rb

@@ -0,0 +1,27 @@
+module Etherlite
+  class Error < StandardError; end
+
+  class RPCError < Error
+    attr_reader :http_status, :http_body
+
+    def initialize(_status, _body)
+      super("Request returned status code #{_status}")
+      @http_status = _status
+      @http_body = _body
+    end
+  end
+
+  class NodeError < Error
+    attr_reader :rpc_error_code, :rpc_error_message
+
+    def initialize(_error)
+      super("#{_error['code']}: #{_error['message']}")
+      @rpc_error_code =  _error['code']
+      @rpc_error_message = _error['message']
+    end
+  end
+
+  class NotSupportedError < Error; end
+
+  class UnlinkedContractError < Error; end
+end

data/lib/etherlite/nonce_manager.rb

@@ -3,30 +3,31 @@ module Etherlite
     @@nonce_cache = {}
     @@nonce_mutex = Mutex.new
 
+    def self.clear_cache
+      @@nonce_cache = {}
+    end
+
     def initialize(_connection)
       @connection = _connection
     end
 
-    def last_nonce_for(_address)
-      _address = Utils.encode_address_param _address
-      last_nonce = @@nonce_cache[_address]
-      last_nonce = last_observed_nonce_for(_address) if last_nonce.nil?
+    def last_nonce_for(_normalized_address)
+      last_nonce = @@nonce_cache[_normalized_address]
+      last_nonce = last_observed_nonce_for(_normalized_address) if last_nonce.nil?
       last_nonce
     end
 
-    def with_next_nonce_for(_address)
-      _address = Utils.encode_address_param _address
-
+    def with_next_nonce_for(_normalized_address)
       @@nonce_mutex.synchronize do
-        next_nonce = last_nonce_for(_address) + 1
+        next_nonce = last_nonce_for(_normalized_address) + 1
 
         begin
           result = yield next_nonce
-          @@nonce_cache[_address] = next_nonce
+          @@nonce_cache[_normalized_address] = next_nonce
           return result
         rescue
           # if yield fails, cant be sure about transaction status so must rely again on observing.
-          @@nonce_cache.delete _address
+          @@nonce_cache.delete _normalized_address
           raise
         end
       end
@@ -34,12 +35,10 @@ module Etherlite
 
     private
 
-    def last_observed_nonce_for(_address)
+    def last_observed_nonce_for(_normalized_address)
       # TODO: support using tx_pool API to improve this:
       # http://qnimate.com/calculating-nonce-for-raw-transactions-in-geth/
-      Etherlite::Utils.hex_to_uint(
-        @connection.ipc_call(:eth_getTransactionCount, _address, 'pending')
-      ) - 1
+      @connection.eth_get_transaction_count('0x' + _normalized_address, 'pending') - 1
     end
   end
 end