evm_client 0.1.0

data/lib/evm_client/contract_event.rb

@@ -0,0 +1,32 @@
+module EvmClient
+  class ContractEvent
+
+    attr_accessor :name, :signature, :input_types, :inputs,
+                  :event_string, :address, :client,
+                  :indexed_inputs, :indexed_outputs,
+                  :non_indexed_inputs, :non_indexed_outputs
+
+    def initialize(data)
+      @name           = data['name']
+      @input_types    = data['inputs'].map {|x| x['type']}
+      @inputs         = data['inputs'].map {|x| x['name']}
+      @event_string   = "#{@name}(#{@input_types.join(",")})"
+      @signature      = Digest::SHA3.hexdigest(@event_string, 256)
+
+      @indexed_inputs     = Array(data['inputs']).select { |input| input['indexed'] == true  }
+      @non_indexed_inputs = Array(data['inputs']).select { |input| input['indexed'] == false }
+
+      @indexed_outputs     = Array(data['outputs']).select { |output| output['indexed'] == true  }
+      @non_indexed_outputs = Array(data['outputs']).select { |output| output['indexed'] == false }
+    end
+
+    def set_address(address)
+      @address = address
+    end
+
+    def set_client(client)
+      @client = client
+    end
+  end
+end
+

data/lib/evm_client/contract_initializer.rb

@@ -0,0 +1,54 @@
+module EvmClient
+
+  class ContractInitializer
+
+    attr_accessor :abi, :binary, :name, :libraries, :needs_linking, :project_initializer, :contract
+
+    def initialize(contract_name, contract, project_initializer)
+      @abi = JSON.parse(contract["abi"]) unless contract.nil?
+      @binary = contract["bin"] unless contract.nil?
+      @name = contract_name
+      @project_initializer = project_initializer
+      matchdata = @binary.scan(/_+[a-zA-Z]+_+/).uniq
+      @needs_linking = matchdata.present?
+      if @needs_linking
+        @libraries = matchdata.collect do |libname|
+          {name: libname.gsub(/_+/,''), sigil: libname}
+        end
+      end
+    end
+
+    def link_libraries
+      if @needs_linking
+        @libraries.each do |library|
+          name = library[:name]
+          if @project_initializer.libraries[name].nil?
+            ENV['ETHEREUM_DEPLOYER_WAIT_TIME'] ||= "120"
+            wait_time = ENV['ETHEREUM_DEPLOYER_WAIT_TIME'].to_i
+            library_instance = library[:name].constantize.new
+            puts "Deploying library #{name}"
+            library_instance.deploy_and_wait(wait_time)
+            puts "Library deployed at #{library_instance.address}"
+            @project_initializer.libraries[name] = library_instance.address
+            @binary.gsub!(library[:sigil], library_instance.address.gsub(/^0x/,''))
+          else
+            address = @project_initializer.libraries[name]
+            @binary.gsub!(library[:sigil], address.gsub(/^0x/,''))
+          end
+        end
+      end
+    end
+
+    def build(connection)
+      @contract = EvmClient::Contract.new(@name, @binary, @abi, client)
+      @contract.build(connection)
+    end
+
+    def generate_javascripts(path)
+      data = {name: @name, abi: @abi, binary: @binary}
+      File.open(File.join(path, "#{@name}.json"), 'w') {|f| f.puts data.to_json}
+    end
+
+  end
+
+end

data/lib/evm_client/decoder.rb

@@ -0,0 +1,99 @@
+module EvmClient
+  class Decoder
+
+    def decode(type, value, start = 0)
+      is_array, arity, array_subtype = Abi::parse_array_type(type)
+      if is_array && arity
+        decode_static_array(arity, array_subtype, value, start)
+      elsif is_array
+        decode_dynamic_array(array_subtype, value, start)
+      else
+        value = value.gsub(/^0x/,'')
+        core, subtype = Abi::parse_type(type)
+        method_name = "decode_#{core}".to_sym
+        self.send(method_name, value, subtype, start)
+      end
+    end
+
+    def decode_static_array(arity, array_subtype, value, start)
+      (0..arity-1).map { |i| decode(array_subtype, value, start + i * 64) }
+    end
+
+    def decode_dynamic_array(array_subtype, value, start)
+      location = decode_uint(value[start..(start+63)]) * 2
+      size = decode_uint(value[location..location+63])
+      (0..size-1).map { |i| decode(array_subtype, value, location + (i+1) * 64) }
+    end
+
+    def decode_fixed(value, subtype = "128x128", start = 0)
+      decode_int(trim(value, start, fixed_bitsize(subtype))).to_f / 2**exponent(subtype)
+    end
+
+    def decode_uint(value, subtype = "256", start = 0)
+      trim(value, start, bitsize(subtype)).hex
+    end
+
+    def decode_int(value, subtype = "256", start = 0)
+      raise ArgumentError if value.nil?
+      size = bitsize(subtype)
+      value = trim(value, start, size)
+      (value[0..1] == "ff") ? (value.hex - (2 ** size)) : value.hex
+    end
+
+    def decode_bool(value, _, start)
+      value = trim(value, start, 4)
+      return true if value == "1"
+      return false if value == "0"
+      raise ArgumentError
+    end
+
+    def decode_address(value, _ = nil, start)
+      raise ArgumentError if value.size-start < 64
+      value[start+24..start+63]
+    end
+
+    def decode_bytes(value, subtype, start)
+      subtype.present? ? decode_static_bytes(value, subtype, start) : decode_dynamic_bytes(value, start)
+    end
+
+    def decode_static_bytes(value, subtype = nil, start = 0)
+      trim(value, start, subtype.to_i*8).scan(/.{2}/).collect {|x| x.hex}.pack('C*').strip
+    end
+
+    def decode_dynamic_bytes(value, start = 0)
+      location = decode_uint(value[start..(start+63)]) * 2
+      size = decode_uint(value[location..location+63]) * 2
+      value[location+64..location+63+size].scan(/.{2}/).collect {|x| x.hex}.pack('C*')
+    end
+
+    def decode_string(value, _ = nil, start = 0)
+      decode_dynamic_bytes(value, start).force_encoding('utf-8')
+    end
+
+    def decode_arguments(arguments, data)
+      data = data.gsub(/^0x/,'')
+      types = arguments.map { |o| o.type }
+      types.each.with_index.map { |t , i| decode(t, data, i*64) }
+    end
+
+    private 
+      def trim(value, start, bitsize = 256)
+        value[start+63-(bitsize/4-1)..start+63]
+      end
+
+      def bitsize(subtype, default = 256)
+        subtype.present? ? subtype.to_i : default
+      end
+
+      def fixed_bitsize(subtype = nil)
+        subtype ||= "128x128"
+        _, x, n = /(\d+)x(\d+)/.match(subtype).to_a
+        x.to_i + n.to_i
+      end
+
+      def exponent(subtype, default = 128)
+        subtype.nil? ? default : /(\d+)x(\d+)/.match(subtype)[2].to_i
+      end
+
+  end
+end

data/lib/evm_client/deployment.rb

@@ -0,0 +1,49 @@
+module EvmClient
+
+  class Deployment
+
+    DEFAULT_TIMEOUT = 300.seconds
+    DEFAULT_STEP = 5.seconds
+
+    attr_accessor :id, :contract_address, :connection, :deployed, :mined
+    attr_reader :valid_deployment
+
+    def initialize(txid, connection)
+      @id = txid
+      @connection = connection
+      @deployed = false
+      @contract_address = nil
+      @valid_deployment = false
+    end
+
+    def mined?
+      return true if @mined
+      @mined = @connection.eth_get_transaction_by_hash(@id)["result"]["blockNumber"].present?
+      @mined ||= false
+    end
+
+    def check_deployed
+      return false unless @id
+      contract_receipt = @connection.eth_get_transaction_receipt(@id)
+      result = contract_receipt["result"]
+      has_contract_address = result && result["contractAddress"]
+      @contract_address ||= result["contractAddress"] if has_contract_address
+      has_contract_address && result["blockNumber"]
+    end
+
+    def deployed?
+      @valid_deployment ||= check_deployed
+    end
+
+    def wait_for_deployment(timeout: DEFAULT_TIMEOUT, step: DEFAULT_STEP)
+      start_time = Time.now
+      loop do
+        raise "Transaction #{@id} timed out." if ((Time.now - start_time) > timeout) 
+        yield if block_given?
+        return true if deployed?
+        sleep step
+      end
+    end
+
+  end
+end

data/lib/evm_client/encoder.rb

@@ -0,0 +1,118 @@
+module EvmClient
+
+  class Encoder
+
+    def encode(type, value)
+      is_array, arity, array_subtype = Abi::parse_array_type(type)
+      if is_array && arity
+        encode_static_array(arity, array_subtype, value)
+      elsif is_array
+        encode_dynamic_array(array_subtype, value)
+      else
+        core, subtype = Abi::parse_type(type)
+        method_name = "encode_#{core}".to_sym
+        self.send(method_name, value, subtype)
+      end
+    end
+
+    def encode_static_array(arity, array_subtype, array)
+      raise "Wrong number of arguments" if arity != array.size
+      array.inject("") { |a, e| a << encode(array_subtype, e) }
+    end
+
+    def encode_dynamic_array(array_subtype, array)
+      location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
+      size = encode_uint(array.size)
+      data = array.inject("") { |a, e| a << encode(array_subtype, e) }
+      [location, size + data]
+    end
+
+    def encode_int(value, _ = nil)
+      to_twos_complement(value).to_s(16).rjust(64, '0')
+    end
+
+    def encode_uint(value, _ = nil)
+      raise ArgumentError if value < 0
+      encode_int(value)
+    end
+
+    def encode_bool(value, _)
+      (value ? "1" : "0").rjust(64, '0')
+    end
+
+    def encode_fixed(value, subtype)
+      n = subtype.nil? ? 128 : /(\d+)x(\d+)/.match(subtype)[2].to_i
+      do_encode_fixed(value, n)
+    end
+
+    def do_encode_fixed(value, n)
+      encode_uint((value * 2**n).to_i)
+    end
+
+    def encode_ufixed(_value, _)
+      raise NotImplementedError
+    end
+
+    def encode_bytes(value, subtype)
+      subtype.nil? ? encode_dynamic_bytes(value) : encode_static_bytes(value)
+    end
+
+    def encode_static_bytes(value)
+      value.bytes.map {|x| x.to_s(16).rjust(2, '0')}.join("").ljust(64, '0')
+    end
+
+    def encode_dynamic_bytes(value)
+      location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
+      size = encode_uint(value.size)
+      content = encode_static_bytes(value)
+      [location, size + content]
+    end
+
+    def encode_string(value, _)
+      location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
+      size = encode_uint(value.bytes.size)
+      content = value.bytes.map {|x| x.to_s(16).rjust(2, '0')}.join("").ljust(64, '0')
+      [location, size + content]
+    end
+
+    def encode_address(value, _)
+      value = "0" * 24 + value.gsub(/^0x/,'')
+      raise ArgumentError if value.size != 64
+      value
+    end
+
+    def ensure_prefix(value)
+      value.start_with?("0x") ? value : ("0x" + value)
+    end
+
+    def encode_arguments(inputs, args)
+      raise "Wrong number of arguments" if inputs.length != args.length
+      @head = ""
+      @tail = ""
+      @inputs = inputs
+      inputs.each.with_index do |input, index|
+        encoded = encode(input.type, args[index])
+        if encoded.is_a? Array
+          @head << encoded[0]
+          @tail << encoded[1]
+        else
+          @head << encoded
+        end
+      end
+      @head + @tail
+    end
+
+    private
+      def to_twos_complement(number)
+        (number & ((1 << 256) - 1))
+      end
+
+      def size_of_inputs(inputs)
+        inputs.map do |input|
+          _, arity, _ = Abi::parse_array_type(input.type)
+          arity.nil? ? 32 : arity * 32
+        end.inject(:+)
+      end
+  end
+
+end

data/lib/evm_client/event_log.rb

@@ -0,0 +1,88 @@
+module EvmClient
+  class EventLog
+    attr_reader :address, :block_hash, :block_number, :data, :log_index, :removed,
+    :topics, :transaction_hash, :transaction_index, :signature, :contract, :event
+
+    def self.build(raw_response:, contract:)
+      signature = raw_response['topics'][0]
+      event     = contract.events.find { |event| signature.match(event.signature) }
+
+      new(
+        address:           raw_response['address'],
+        block_hash:        raw_response['blockHash'],
+        block_number:      raw_response['blockNumber'].to_i(16),
+        data:              raw_response['data'],
+        log_index:         raw_response['logIndex'],
+        removed:           raw_response['removed'],
+        topics:            raw_response['topics'],
+        transaction_hash:  raw_response['transactionHash'],
+        transaction_index: raw_response['transactionIndex'],
+        signature:         signature,
+        contract:          contract,
+        event:             event
+      )
+    end
+
+    def initialize( address:, block_hash:, block_number:, data:, log_index:, removed:,
+                    topics:, transaction_hash:, transaction_index:, signature:, contract:, event:)
+      @address            = address
+      @block_hash         = block_hash
+      @block_number       = block_number
+      @data               = data
+      @log_index          = log_index
+      @removed            = removed
+      @topics             = topics
+      @transaction_hash   = transaction_hash
+      @transaction_index  = transaction_index
+      @signature          = signature
+      @contract           = contract
+      @event              = event
+    end
+
+    def name
+      event.name
+    end
+
+    def return_values
+      return_values = {}
+
+      indexed_params.each_with_index do |param, index|
+        return_values[param.name] = topics[index+1]
+      end
+
+      non_indexed_params.each_with_index do |param, index|
+        return_values[param.name]  = Decoder.new.decode_arguments(non_indexed_params, data)[index]
+      end
+
+      return_values
+    end
+
+    def to_h
+      {
+        address:            address,
+        block_hash:         block_hash,
+        block_number:       block_number,
+        data:               data,
+        log_index:          log_index,
+        removed:            removed,
+        topics:             topics,
+        transaction_hash:   transaction_hash,
+        transaction_index:  transaction_index,
+        signature:          signature,
+        name:               name,
+        contract_name:      contract.name,
+        return_values:      return_values
+      }
+    end
+
+    private
+
+    def indexed_params
+      [event.indexed_inputs, event.indexed_outputs].flatten.map { |input| OpenStruct.new(input) }
+    end
+
+    def non_indexed_params
+      [event.non_indexed_inputs, event.non_indexed_outputs].flatten.map { |output| OpenStruct.new(output) }
+    end
+  end
+end