etherlite 0.1.0

data/lib/etherlite/client.rb

@@ -0,0 +1,11 @@
+module Etherlite
+  class Client
+    include Api::Node
+
+    attr_reader :connection
+
+    def initialize
+      @connection = Connection.new
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Etherlite::Abi
+  class LoadContract < PowerTypes::Command.new(:json)
+    def perform
+      klass = Class.new(Etherlite::Contract::Base)
+
+      abi_definitions.each do |definition|
+        case definition['type']
+        when 'function'
+          define_function klass, definition
+        when 'event'
+          define_event klass, definition
+        end
+      end
+
+      klass.functions.freeze
+      klass.events.freeze
+      klass
+    end
+
+    private
+
+    def abi_definitions
+      @json['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']
+      )
+
+      _class.functions << function
+      _class.class_eval do
+        define_method(_definition['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?
+          account.call address, function, *params
+        end
+      end
+    end
+
+    def define_event(_class, _definition)
+      event_inputs = _definition['inputs'].map do |input|
+        Etherlite::Contract::EventInput.new(
+          input['name'], LoadType.for(signature: input['type']), input['indexed']
+        )
+      end
+
+      event_class = Class.new(Etherlite::Contract::EventBase) do
+        event_inputs.each do |input|
+          define_method(input.name) { attributes[input.name] }
+        end
+      end
+
+      event_class.instance_variable_set(:@original_name, _definition['name'])
+      event_class.instance_variable_set(:@inputs, event_inputs)
+
+      _class.events << event_class
+      _class.const_set(_definition['name'], event_class)
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Etherlite::Abi
+  class LoadFunction < PowerTypes::Command.new(:signature)
+    MATCHER = /^(payable|onchain|\w[\w\d]*) (\w[\w\d]*)\((.*?)\)$/
+
+    def perform
+      parts = MATCHER.match @signature
+      raise ArgumentError, 'invalid method signature' if parts.nil?
+
+      args = parts[3].split(',').map { |a| LoadType.for(signature: a.strip) }
+
+      case parts[1]
+      when 'payable'
+        build parts[2], args, payable: true
+      when 'onchain'
+        build parts[2], args
+      else
+        return_type = parts[1] == 'void' ? nil : LoadType.for(signature: parts[1])
+        build parts[2], args, constant: true, returns: return_type
+      end
+    end
+
+    private
+
+    def build(*_args)
+      Etherlite::Contract::Function.new *_args
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Etherlite::Abi
+  class LoadType < PowerTypes::Command.new(:signature)
+    MATCHER = /^(?:(?:(?<ty>uint|int|bytes)(?<b1>\d+)|(?<ty>uint|int|bytes)(?<b1>\d+)|(?<ty>fixed|ufixed)(?<b1>\d+)x(?<b2>\d+)|(?<ty>address|bool|uint|int|fixed|ufixed))(?:\[(?<dim>\d*)\]|)|(?<ty>bytes|string))$/
+
+    def perform
+      parts = MATCHER.match @signature
+      raise ArgumentError, "Invalid argument type #{@signature}" if parts.nil?
+
+      type = build_base_type parts
+      build_array_type type, parts
+    end
+
+    private
+
+    def build_base_type(_parts) # rubocop:disable Metrics/CyclomaticComplexity
+      case _parts[:ty]
+      when 'uint'     then Etherlite::Types::Integer.new(false, b1_256(_parts))
+      when 'int'      then Etherlite::Types::Integer.new(true, b1_256(_parts))
+      when 'ufixed'   then Etherlite::Types::Fixed.new(false, b1_128(_parts), b2_128(_parts))
+      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 'bytes'
+        if _parts[:b1].present?
+          Etherlite::Types::Bytes.new(_parts[:b1].to_i)
+        else
+          Etherlite::Types::ByteString.new
+        end
+      end
+    end
+
+    def build_array_type(_base_type, _parts)
+      return _base_type if _parts[:dim].nil?
+
+      if _parts[:dim].empty?
+        Etherlite::Types::ArrayDynamic.new _base_type
+      else
+        Etherlite::Types::ArrayFixed.new _base_type, _parts[:dim].to_i
+      end
+    end
+
+    def b1_256(_parts)
+      _parts[:b1].nil? ? 256 : _parts[:b1].to_i
+    end
+
+    def b1_128(_parts)
+      _parts[:b1].nil? ? 128 : _parts[:b1].to_i
+    end
+
+    def b2_128(_parts)
+      _parts[:b2].nil? ? 128 : _parts[:b2].to_i
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+class Etherlite::Contract::EventBase
+  class DecodeLogInputs < PowerTypes::Command.new(:connection, :inputs, :json)
+    def perform
+      indexed = []
+      non_indexed = []
+      attributes = {}
+
+      @inputs.each { |i| (i.indexed? ? indexed : non_indexed) << i }
+
+      @json['data'][2..-1].scan(/.{64}/).each_with_index do |data, i|
+        attributes[non_indexed[i].name] = non_indexed[i].type.decode(@connection, data)
+      end
+
+      @json['topics'][1..-1].each_with_index do |topic, i|
+        attributes[indexed[i].name] = indexed[i].type.decode(@connection, topic[2..-1])
+      end
+
+      attributes
+    end
+  end
+end

data/lib/etherlite/commands/contract/function/encode_arguments.rb

@@ -0,0 +1,32 @@
+class Etherlite::Contract::Function
+  class EncodeArguments < PowerTypes::Command.new(:subtypes, :values)
+    def perform # rubocop:disable Metrics/MethodLength
+      if @values.length != @subtypes.count
+        raise ArgumentError, "Expected #{@subtypes.count} arguments, got #{@values.length} "
+      end
+
+      head = []
+      tail = []
+      tail_offset = calculate_head_offset
+
+      @subtypes.each_with_index do |type, i|
+        content = type.encode @values[i]
+        if type.dynamic?
+          head << Etherlite::Utils.uint_to_hex(tail_offset)
+          tail << content
+          tail_offset += content.length / 2 # hex string, 2 characters per byte
+        else
+          head << content
+        end
+      end
+
+      head.join + tail.join
+    end
+
+    private
+
+    def calculate_head_offset
+      @subtypes.inject(0) { |r, type| r + (type.dynamic? ? 32 : type.size) }
+    end
+  end
+end

data/lib/etherlite/commands/utils/validate_address.rb

@@ -0,0 +1,25 @@
+module Etherlite::Utils
+  class ValidateAddress < PowerTypes::Command.new(:address)
+    MATCHER = /^(0x)?[0-9a-fA-F]{40}$/
+
+    def perform
+      return false unless MATCHER === @address
+      return false if /[A-F]/ === @address && !valid_checksum?
+      true
+    end
+
+    private
+
+    def valid_checksum?
+      trimmed_address = @address.gsub(/^0x/, '')
+      address_hash = Etherlite::Utils.sha3 trimmed_address.downcase
+
+      trimmed_address.chars.each_with_index do |c, i|
+        hash_byte = address_hash[i].to_i(16)
+        return false if (hash_byte > 7 && c.upcase != c) || (hash_byte <= 7 && c.downcase != c)
+      end
+
+      true
+    end
+  end
+end

data/lib/etherlite/configuration.rb

@@ -0,0 +1,33 @@
+module Etherlite
+  class Configuration
+    DEFAULTS = {
+      url: 'http://127.0.0.1:8545',
+      logger: nil # set by method
+    }
+
+    attr_accessor :url, :logger
+
+    def initialize
+      assign_attributes DEFAULTS
+    end
+
+    def reset
+      assign_attributes DEFAULTS
+    end
+
+    def assign_attributes(_options)
+      _options.each { |k, v| public_send("#{k}=", v) }
+      self
+    end
+
+    def logger
+      @logger || default_logger
+    end
+
+    private
+
+    def default_logger
+      @default_logger ||= Logger.new(STDOUT)
+    end
+  end
+end

data/lib/etherlite/connection.rb

@@ -0,0 +1,39 @@
+module Etherlite
+  class Connection
+    def initialize(_uri)
+      @uri = _uri
+    end
+
+    def ipc_call(_method, *_params)
+      id = new_unique_id
+      payload = { jsonrpc: "2.0", method: _method, params: _params, id: id }
+
+      # TODO: support ipc
+      Net::HTTP.start(@uri.hostname, @uri.port) do |http|
+        return handle_response http.post(
+          @uri.path.empty? ? '/' : @uri.path,
+          payload.to_json,
+          "Content-Type" => "application/json"
+        ), id
+      end
+    end
+
+    private
+
+    def new_unique_id
+      (Time.now.to_f * 1000.0).to_i
+    end
+
+    def handle_response(_response, _id)
+      case _response
+      when Net::HTTPSuccess
+        # puts _response.body
+        json_body = JSON.parse _response.body
+        # TODO: check id
+        json_body['result']
+      else
+        raise _response
+      end
+    end
+  end
+end

data/lib/etherlite/contract/base.rb

@@ -0,0 +1,58 @@
+module Etherlite::Contract
+  class Base
+    include Etherlite::Api::Address
+
+    def self.functions
+      @functions ||= []
+    end
+
+    def self.events
+      @events ||= []
+    end
+
+    def self.at(_address, client: nil, as: nil)
+      client ||= ::Etherlite # use default client if no client is provided
+
+      new(
+        client.connection,
+        Etherlite::Utils.normalize_address_param(_address),
+        as || client.first_account
+      )
+    end
+
+    attr_reader :connection
+
+    def initialize(_connection, _normalized_address, _default_account)
+      @connection = _connection
+      @normalized_address = _normalized_address
+      @default_account = _default_account
+    end
+
+    def get_logs(events: nil, from_block: :earliest, to_block: :latest)
+      params = {
+        address: '0x' + @normalized_address,
+        fromBlock: Etherlite::Utils.encode_block_param(from_block),
+        toBlock: Etherlite::Utils.encode_block_param(to_block)
+      }
+
+      params[:topics] = [events.map { |e| event_topic e }] unless events.nil?
+
+      event_map = Hash[(events || self.class.events).map { |e| [event_topic(e), e] }]
+
+      logs = @connection.ipc_call(:eth_getLogs, params)
+      logs.map do |log|
+        event = event_map[log["topics"].first]
+        # TODO: support anonymous events!
+        event.decode(@connection, log) unless event.nil?
+      end
+    end
+
+    private
+
+    attr_reader :default_account, :normalized_address
+
+    def event_topic(_event)
+      '0x' + Etherlite::Utils.sha3(_event.signature)
+    end
+  end
+end

data/lib/etherlite/contract/event_base.rb

@@ -0,0 +1,36 @@
+require 'etherlite/commands/contract/event_base/decode_log_inputs'
+
+module Etherlite::Contract
+  class EventBase
+    def self.inputs
+      @inputs
+    end
+
+    def self.original_name
+      @original_name
+    end
+
+    def self.signature
+      @signature ||= begin
+        input_sig = @inputs.map { |i| i.type.signature }
+        "#{@original_name}(#{input_sig.join(',')})"
+      end
+    end
+
+    def self.decode(_connection, _json)
+      new(
+        _json['blockNumber'].nil? ? nil : Etherlite::Utils.hex_to_uint(_json['blockNumber']),
+        _json['transactionHash'],
+        DecodeLogInputs.for(connection: _connection, inputs: inputs, json: _json)
+      )
+    end
+
+    attr_reader :block_number, :tx_hash, :attributes
+
+    def initialize(_block_number, _tx_hash, _attributes)
+      @block_number = _block_number
+      @tx_hash = _tx_hash
+      @attributes = _attributes
+    end
+  end
+end

data/lib/etherlite/contract/event_input.rb

@@ -0,0 +1,19 @@
+module Etherlite::Contract
+  class EventInput
+    attr_reader :original_name, :type
+
+    def initialize(_original_name, _type, _indexed)
+      @original_name = _original_name
+      @type = _type
+      @indexed = _indexed
+    end
+
+    def name
+      @name ||= @original_name.underscore
+    end
+
+    def indexed?
+      @indexed
+    end
+  end
+end

data/lib/etherlite/contract/function.rb

@@ -0,0 +1,43 @@
+require 'etherlite/commands/contract/function/encode_arguments'
+
+module Etherlite::Contract
+  class Function
+    attr_reader :name, :args
+
+    def initialize(_name, _args, returns: nil, payable: false, constant: false)
+      @name = _name
+      @args = _args
+
+      @returns = returns
+      @payable = payable
+      @constant = constant
+    end
+
+    def constant?
+      @constant
+    end
+
+    def payable?
+      @payable
+    end
+
+    def signature
+      @signature ||= begin
+        arg_signatures = @args.map &:signature
+        "#{@name}(#{arg_signatures.join(',')})"
+      end
+    end
+
+    def encode(_values)
+      signature_hash = Etherlite::Utils.sha3 signature
+      encoded_args = EncodeArguments.for subtypes: @args, values: _values
+
+      '0x' + signature_hash[0..7] + encoded_args
+    end
+
+    def decode(_connection, _values)
+      # TODO: decode return values
+      _values
+    end
+  end
+end