eth 0.5.9 → 0.5.11

data/lib/eth/client/ipc.rb

@@ -24,7 +24,7 @@ module Eth
     attr_accessor :path
 
     # Constructor for the IPC Client. Should not be used; use
-    # {Client.create} intead.
+    # {Client.create} instead.
     #
     # @param path [String] an URI pointing to an IPC RPC-API.
     def initialize(path)
@@ -36,7 +36,7 @@ module Eth
     #
     # @param payload [Hash] the RPC request parameters.
     # @return [String] a JSON-encoded response.
-    def send(payload)
+    def send_request(payload)
       socket = UNIXSocket.new(@path)
       socket.puts(payload)
       read = socket.recvmsg(nil)[0]

data/lib/eth/client.rb

@@ -34,28 +34,22 @@ module Eth
     # The default transaction max fee per gas in Wei, defaults to {Tx::DEFAULT_GAS_PRICE}.
     attr_accessor :max_fee_per_gas
 
-    # The default gas limit for the transaction, defaults to {Tx::DEFAULT_GAS_LIMIT}.
-    attr_accessor :gas_limit
-
     # A custom error type if a contract interaction fails.
     class ContractExecutionError < StandardError; end
 
     # Creates a new RPC-Client, either by providing an HTTP/S host or
     # an IPC path. Supports basic authentication with username and password.
     #
-    # **Note**, this sets the folling gas defaults: {Tx::DEFAULT_PRIORITY_FEE},
-    # {Tx::DEFAULT_GAS_PRICE}, and {Tx::DEFAULT_GAS_LIMIT}. Use
-    # {#max_priority_fee_per_gas}, {#max_fee_per_gas}, and {#gas_limit} to set
-    # custom values prior to submitting transactions.
+    # **Note**, this sets the folling gas defaults: {Tx::DEFAULT_PRIORITY_FEE}
+    # and {Tx::DEFAULT_GAS_PRICE. Use {#max_priority_fee_per_gas} and
+    # {#max_fee_per_gas} to set custom values prior to submitting transactions.
     #
     # @param host [String] either an HTTP/S host or an IPC path.
     # @return [Eth::Client::Ipc] an IPC client.
-    # @return [Eth::Client::HttpAuth] an HTTP client with basic authentication.
     # @return [Eth::Client::Http] an HTTP client.
     # @raise [ArgumentError] in case it cannot determine the client type.
     def self.create(host)
       return Client::Ipc.new host if host.end_with? ".ipc"
-      return Client::HttpAuth.new host if Regexp.new(":.*@.*:", Regexp::IGNORECASE).match host
       return Client::Http.new host if host.start_with? "http"
       raise ArgumentError, "Unable to detect client type!"
     end
@@ -66,7 +60,6 @@ module Eth
       @id = 0
       @max_priority_fee_per_gas = Tx::DEFAULT_PRIORITY_FEE
       @max_fee_per_gas = Tx::DEFAULT_GAS_PRICE
-      @gas_limit = Tx::DEFAULT_GAS_LIMIT
     end
 
     # Gets the default account (coinbase) of the connected client.
@@ -76,6 +69,7 @@ module Eth
     #
     # @return [Eth::Address] the coinbase account address.
     def default_account
+      raise ArgumentError, "The default account is not available on remote connections!" unless local? || @default_account
       @default_account ||= Address.new eth_coinbase["result"]
     end
 
@@ -102,6 +96,17 @@ module Eth
       eth_get_transaction_count(address, "pending")["result"].to_i 16
     end
 
+    # Resolves an ENS name to an Ethereum address on the connected chain.
+    #
+    # @param ens_name [String] The ENS name, e.g., `fancy.eth`.
+    # @param registry [String] the address for the ENS registry.
+    # @param coin_type [Integer] the coin type as per EIP-2304.
+    # @return [Eth::Address] the Ethereum address resolved from the ENS record.
+    def resolve_ens(ens_name, registry = Ens::DEFAULT_ADDRESS, coin_type = Ens::CoinType::ETHEREUM)
+      ens = Ens::Resolver.new(self, registry)
+      ens.resolve(ens_name, coin_type)
+    end
+
     # Simply transfer Ether to an account and waits for it to be mined.
     # Uses `eth_coinbase` and external signer if no sender key is
     # provided.
@@ -118,7 +123,7 @@ module Eth
     # if no sender key is provided.
     #
     # **Note**, that many remote providers (e.g., Infura) do not provide
-    # any accounts. Provide a `sender_key` if you experience issues.
+    # any accounts. Provide a `sender_key:` if you experience issues.
     #
     # @overload transfer(destination, amount)
     #   @param destination [Eth::Address] the destination address.
@@ -134,38 +139,43 @@ module Eth
       params = {
         value: amount,
         to: destination,
-        gas_limit: gas_limit,
+        gas_limit: Tx::DEFAULT_GAS_LIMIT,
         chain_id: chain_id,
       }
-      if kwargs[:legacy]
-        params.merge!({
-          gas_price: max_fee_per_gas,
-        })
-      else
-        params.merge!({
-          priority_fee: max_priority_fee_per_gas,
-          max_gas_fee: max_fee_per_gas,
-        })
-      end
-      unless kwargs[:sender_key].nil?
+      send_transaction(params, kwargs[:legacy], kwargs[:sender_key], kwargs[:nonce])
+    end
 
-        # use the provided key as sender and signer
-        params.merge!({
-          from: kwargs[:sender_key].address,
-          nonce: kwargs[:nonce] || get_nonce(kwargs[:sender_key].address),
-        })
-        tx = Eth::Tx.new(params)
-        tx.sign kwargs[:sender_key]
-        return eth_send_raw_transaction(tx.hex)["result"]
-      else
+    # Transfers a token that implements the ERC20 `transfer()` interface.
+    #
+    # See {#transfer_erc20} for params and overloads.
+    #
+    # @return [Object] returns the result of the transaction.
+    def transfer_erc20_and_wait(erc20_contract, destination, amount, **kwargs)
+      transact_and_wait(erc20_contract, "transfer", destination, amount, **kwargs)
+    end
 
-        # use the default account as sender and external signer
-        params.merge!({
-          from: default_account,
-          nonce: kwargs[:nonce] || get_nonce(default_account),
-        })
-        return eth_send_transaction(params)["result"]
-      end
+    # Transfers a token that implements the ERC20 `transfer()` interface.
+    #
+    # **Note**, that many remote providers (e.g., Infura) do not provide
+    # any accounts. Provide a `sender_key:` if you experience issues.
+    #
+    # @overload transfer_erc20(erc20_contract, destination, amount)
+    #   @param erc20_contract [Eth::Contract] the ERC20 contract to write to.
+    #   @param destination [Eth::Address] the destination address.
+    #   @param amount [Integer] the transfer amount (mind the `decimals()`).
+    # @overload transfer_erc20(erc20_contract, destination, amount, **kwargs)
+    #   @param erc20_contract [Eth::Contract] the ERC20 contract to write to.
+    #   @param destination [Eth::Address] the destination address.
+    #   @param amount [Integer] the transfer amount (mind the `decimals()`).
+    #   @param **sender_key [Eth::Key] the sender private key.
+    #   @param **legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    #   @param **gas_limit [Integer] optional gas limit override for the transfer.
+    #   @param **nonce [Integer] optional specific nonce for transaction.
+    #   @param **tx_value [Integer] optional transaction value field filling.
+    # @return [Object] returns the result of the transaction.
+    def transfer_erc20(erc20_contract, destination, amount, **kwargs)
+      destination = destination.to_s if destination.instance_of? Eth::Address
+      transact(erc20_contract, "transfer", destination, amount, **kwargs)
     end
 
     # Deploys a contract and waits for it to be mined. Uses
@@ -184,7 +194,7 @@ module Eth
     # if no sender key is provided.
     #
     # **Note**, that many remote providers (e.g., Infura) do not provide
-    # any accounts. Provide a `sender_key` if you experience issues.
+    # any accounts. Provide a `sender_key:` if you experience issues.
     #
     # @overload deploy(contract)
     #   @param contract [Eth::Contract] contracts to deploy.
@@ -218,33 +228,7 @@ module Eth
         chain_id: chain_id,
         data: data,
       }
-      if kwargs[:legacy]
-        params.merge!({
-          gas_price: max_fee_per_gas,
-        })
-      else
-        params.merge!({
-          priority_fee: max_priority_fee_per_gas,
-          max_gas_fee: max_fee_per_gas,
-        })
-      end
-      unless kwargs[:sender_key].nil?
-        # Uses the provided key as sender and signer
-        params.merge!({
-          from: kwargs[:sender_key].address,
-          nonce: kwargs[:nonce] || get_nonce(kwargs[:sender_key].address),
-        })
-        tx = Eth::Tx.new(params)
-        tx.sign kwargs[:sender_key]
-        return eth_send_raw_transaction(tx.hex)["result"]
-      else
-        # Uses the default account as sender and external signer
-        params.merge!({
-          from: default_account,
-          nonce: kwargs[:nonce] || get_nonce(default_account),
-        })
-        return eth_send_transaction(params)["result"]
-      end
+      send_transaction(params, kwargs[:legacy], kwargs[:sender_key], kwargs[:nonce])
     end
 
     # Calls a contract function without executing it
@@ -263,16 +247,21 @@ module Eth
     #   @param *args optional function arguments.
     #   @param **sender_key [Eth::Key] the sender private key.
     #   @param **legacy [Boolean] enables legacy transactions (pre-EIP-1559).
-    #   @param **gas_limit [Integer] optional gas limit override for deploying the contract.
     # @return [Object] returns the result of the call.
     def call(contract, function, *args, **kwargs)
-      func = contract.functions.select { |func| func.name == function }[0]
-      raise ArgumentError, "this function does not exist!" if func.nil?
-      output = call_raw(contract, func, *args, **kwargs)
+      func = contract.functions.select { |func| func.name == function }
+      raise ArgumentError, "this function does not exist!" if func.nil? || func.size === 0
+      selected_func = func.first
+      func.each do |f|
+        if f.inputs.size === args.size
+          selected_func = f
+        end
+      end
+      output = call_raw(contract, selected_func, *args, **kwargs)
       if output&.length == 1
-        return output[0]
+        output[0]
       else
-        return output
+        output
       end
     end
 
@@ -280,7 +269,7 @@ module Eth
     # contract read/write).
     #
     # **Note**, that many remote providers (e.g., Infura) do not provide
-    # any accounts. Provide a `sender_key` if you experience issues.
+    # any accounts. Provide a `sender_key:` if you experience issues.
     #
     # @overload transact(contract, function)
     #   @param contract [Eth::Contract] the subject contract to write to.
@@ -296,7 +285,7 @@ module Eth
     #   @param **sender_key [Eth::Key] the sender private key.
     #   @param **legacy [Boolean] enables legacy transactions (pre-EIP-1559).
     #   @param **address [Eth::Address] contract address.
-    #   @param **gas_limit [Integer] optional gas limit override for deploying the contract.
+    #   @param **gas_limit [Integer] optional gas limit override for transacting with the contract.
     #   @param **nonce [Integer] optional specific nonce for transaction.
     #   @param **tx_value [Integer] optional transaction value field filling.
     # @return [Object] returns the result of the transaction.
@@ -304,7 +293,7 @@ module Eth
       gas_limit = if kwargs[:gas_limit]
           kwargs[:gas_limit]
         else
-          Tx.estimate_intrinsic_gas(contract.bin) + Tx::CREATE_GAS
+          Tx.estimate_intrinsic_gas(contract.bin)
         end
       fun = contract.functions.select { |func| func.name == function }[0]
       params = {
@@ -314,33 +303,7 @@ module Eth
         to: kwargs[:address] || contract.address,
         data: call_payload(fun, args),
       }
-      if kwargs[:legacy]
-        params.merge!({
-          gas_price: max_fee_per_gas,
-        })
-      else
-        params.merge!({
-          priority_fee: max_priority_fee_per_gas,
-          max_gas_fee: max_fee_per_gas,
-        })
-      end
-      unless kwargs[:sender_key].nil?
-        # use the provided key as sender and signer
-        params.merge!({
-          from: kwargs[:sender_key].address,
-          nonce: kwargs[:nonce] || get_nonce(kwargs[:sender_key].address),
-        })
-        tx = Eth::Tx.new(params)
-        tx.sign kwargs[:sender_key]
-        return eth_send_raw_transaction(tx.hex)["result"]
-      else
-        # use the default account as sender and external signer
-        params.merge!({
-          from: default_account,
-          nonce: kwargs[:nonce] || get_nonce(default_account),
-        })
-        return eth_send_transaction(params)["result"]
-      end
+      send_transaction(params, kwargs[:legacy], kwargs[:sender_key], kwargs[:nonce])
     end
 
     # Executes a contract function with a transaction and waits for it
@@ -375,7 +338,7 @@ module Eth
       signature = Util.hex_to_bin signature if Util.hex? signature
       magic = Util.hex_to_bin magic if Util.hex? magic
       result = call(contract, "isValidSignature", hash, signature)
-      return result === magic
+      result === magic
     end
 
     # Gives control over resetting the RPC request ID back to zero.
@@ -431,6 +394,51 @@ module Eth
 
     private
 
+    # Allows to determine if we work with a local connectoin
+    def local?
+      if self.instance_of? Eth::Client::Ipc
+        true
+      elsif self.host === "127.0.0.1" || self.host === "localhost"
+        true
+      else
+        false
+      end
+    end
+
+    # Prepares a transaction to be send for the given params.
+    def send_transaction(params, legacy, key, nonce)
+      if legacy
+        params.merge!({ gas_price: max_fee_per_gas })
+      else
+        params.merge!({
+          priority_fee: max_priority_fee_per_gas,
+          max_gas_fee: max_fee_per_gas,
+        })
+      end
+      unless key.nil?
+
+        # use the provided key as sender and signer
+        params.merge!({
+          from: key.address,
+          nonce: nonce || get_nonce(key.address),
+        })
+        tx = Eth::Tx.new(params)
+        tx.sign key
+        eth_send_raw_transaction(tx.hex)["result"]
+      else
+
+        # do not allow accessing accounts on remote connections
+        raise ArgumentError, "The default account is not available on remote connections, please provide a :sender_key!" unless local?
+
+        # use the default account as sender and external signer
+        params.merge!({
+          from: default_account,
+          nonce: nonce || get_nonce(default_account),
+        })
+        eth_send_transaction(params)["result"]
+      end
+    end
+
     # Non-transactional function call called from call().
     # @see https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_call
     def call_raw(contract, func, *args, **kwargs)
@@ -468,9 +476,9 @@ module Eth
         params: marshal(args),
         id: next_id,
       }
-      output = JSON.parse(send(payload.to_json))
+      output = JSON.parse(send_request(payload.to_json))
       raise IOError, output["error"]["message"] unless output["error"].nil?
-      return output
+      output
     end
 
     # Increments the request id.
@@ -491,18 +499,18 @@ module Eth
     def marshal(params)
       params = params.dup
       if params.is_a? Array
-        return params.map! { |param| marshal(param) }
+        params.map! { |param| marshal(param) }
       elsif params.is_a? Hash
         params = camelize!(params)
-        return params.transform_values! { |param| marshal(param) }
+        params.transform_values! { |param| marshal(param) }
       elsif params.is_a? Numeric
-        return Util.prefix_hex "#{params.to_i.to_s(16)}"
+        Util.prefix_hex "#{params.to_i.to_s(16)}"
       elsif params.is_a? Address
-        return params.to_s
+        params.to_s
       elsif Util.hex? params
-        return Util.prefix_hex params
+        Util.prefix_hex params
       else
-        return params
+        params
       end
     end
   end
@@ -510,5 +518,4 @@ end
 
 # Load the client/* libraries
 require "eth/client/http"
-require "eth/client/http_auth"
 require "eth/client/ipc"

data/lib/eth/contract.rb

@@ -14,6 +14,8 @@
 
 # -*- encoding : ascii-8bit -*-
 
+require "forwardable"
+
 # Provides the {Eth} module.
 module Eth
 
@@ -27,11 +29,19 @@ module Eth
 
     # Constructor of the {Eth::Contract} class.
     #
+    # **Note**, do not use this directly. Use
+    # {from_abi}, {from_bin}, or {from_file}!
+    #
     # @param name [String] contract name.
     # @param bin [String] contract bin string.
     # @param abi [String] contract abi string.
     def initialize(name, bin, abi)
-      @name = name
+
+      # The contract name will be the class name and needs title casing.
+      _name = name.dup
+      _name[0] = name[0].upcase
+
+      @name = _name
       @bin = bin
       @abi = abi
       @constructor_inputs, @functions, @events = parse_abi(abi)

data/lib/eth/ens/coin_type.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Provides the {Eth} module.
+module Eth
+  # Provides ENS specific functionality
+  # ref: https://ens.domains
+  module Ens
+    # Provides EIP-2304 / SLIP-44 cointypes to resolve ENS addresses.
+    # ref: https://eips.ethereum.org/EIPS/eip-2304
+    module CoinType
+      extend self
+
+      # ENS coin type for Bitcoin.
+      BITCOIN = 0.freeze
+
+      # ENS coin type for Litecoin.
+      LITECOIN = 2.freeze
+
+      # ENS coin type for Dogecoin.
+      DOGECOIN = 3.freeze
+
+      # ENS coin type for Ethereum.
+      ETHEREUM = 60.freeze
+
+      # ENS coin type for Ethereum Classic.
+      ETHEREUM_CLASSIC = 61.freeze
+
+      # ENS coin type for Rootstock.
+      ROOTSTOCK = 137.freeze
+
+      # ENS coin type for Bitcoin Cash.
+      BITCOIN_CASH = 145.freeze
+
+      # ENS coin type for Binance.
+      BINANCE = 714.freeze
+    end
+  end
+end

data/lib/eth/ens/resolver.rb

@@ -16,6 +16,7 @@
 
 # Provides the {Eth} module.
 module Eth
+
   # Provides ENS specific functionality
   # ref: https://ens.domains
   module Ens
@@ -23,43 +24,84 @@ module Eth
     # Utility class for resolving ENS names to Ethereum addresses
     class Resolver
 
-      # The default address for ENS, which applies to most chains
-      DEFAULT_ADDRESS = "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e".freeze
+      # The client instance used to resolve the ENS.
+      attr_accessor :client
+
+      # The address of the ENS registry on the given chain.
+      attr_accessor :registry
 
-      # Create an instance of the ENS Resolver
+      # Create an instance of the ENS Resolver.
       #
-      # @param client [Eth::Client] The client instance
-      # @param address [String] The address of the ENS contract
+      # @param client [Eth::Client] The client instance used to resolve the ENS.
+      # @param address [String] The address of the ENS registry on the given chain.
       def initialize(client, address = DEFAULT_ADDRESS)
         @client = client
-        @contract = Eth::Contract.from_abi(
-          name: "ENS",
+        @registry = Eth::Contract.from_abi(
+          name: "ENSRegistryWithFallback",
           address: address,
-          abi: JSON.parse(File.read(File.join(File.dirname(__FILE__), "../../../abis/ens.json"))),
+          abi: JSON.parse(File.read(File.join(File.dirname(__FILE__), "../../../abi/ens_registry.json"))),
         )
       end
 
-      # Resolve an ENS name to an address
+      # Resolve an ENS name owner.
+      #
+      # @param ens_name [String] The ENS name, e.g., `fancy.eth`.
+      # @return [String] The owner address of the name as a hex string.
+      def owner(ens_name)
+        @client.call(@registry, "owner", namehash(ens_name))
+      end
+
+      # Retrieve the public resolver for the given ENS name.
       #
-      # @param ens_name [String] The ENS name, eg: fancy.eth
-      # @return [String] The owner address of the name, as a hex string
-      def resolve(ens_name)
-        @client.call(@contract, "owner", namehash(ens_name))
+      # @param ens_name [String] The ENS name, e.g., `fancy.eth`.
+      # @return [Eth::Contract] The public resolver contract that can be used
+      #   to resolve ENS names.
+      def resolver(ens_name)
+        address = @client.call(@registry, "resolver", namehash(ens_name))
+        Eth::Contract.from_abi(
+          name: "ENSPublicResolver",
+          address: address,
+          abi: JSON.parse(File.read(File.join(File.dirname(__FILE__), "../../../abi/ens_resolver.json"))),
+        )
+      end
+
+      # Resolve an ENS name to an address.
+      #
+      # @param ens_name [String] The ENS name, e.g., `fancy.eth`.
+      # @return [String] The owner address of the name as a hex string.
+      def resolve(ens_name, coin_type = Ens::CoinType::ETHEREUM)
+        if coin_type === Ens::CoinType::ETHEREUM
+          return @client.call(resolver(ens_name), "addr", namehash(ens_name))
+        elsif coin_type === Ens::CoinType::ETHEREUM_CLASSIC
+          data = @client.call(resolver(ens_name), "addr", namehash(ens_name), coin_type)
+          return Util.bin_to_prefixed_hex data
+        else
+          raise NotImplementedError, "Coin type #{coin_type} not implemented!"
+        end
+      end
+
+      # Resolve a text record for a given ENS name.
+      #
+      # @param ens_name [String] The ENS name, e.g., `fancy.eth`.
+      # @param key [String] The key for the text record, e.g., `url`.
+      # @return [String] The text record.
+      def text(ens_name, key = "description")
+        @client.call(resolver(ens_name), "text", namehash(ens_name), key)
       end
 
       # Generate node for the given domain name
       # See: https://docs.ens.domains/contract-api-reference/name-processing
       #
-      # @param ens_name [String] The ENS name, eg: fancy.eth
-      # @return [String] The node as a hex string
+      # @param ens_name [String] The ENS name, e.g., `fancy.eth`.
+      # @return [String] The node as a hex string.
       def namehash(ens_name)
-        node = ("0" * 64)
+        node = Util.hex_to_bin("0" * 64)
         name = normalize(ens_name)
         name.split(".").reverse.each do |label|
-          hash = Digest::Keccak.new(256).hexdigest(label)
-          node = Digest::Keccak.new(256).hexdigest([node + hash].pack("H*"))
+          hash = Util.keccak256(label)
+          node = Util.keccak256(node + hash)
         end
-        "0x#{node}"
+        Util.bin_to_prefixed_hex node
       end
 
       # Normalize a string as specified by http://unicode.org/reports/tr46/
@@ -67,10 +109,12 @@ module Eth
       # @param input [String] The input string
       # @return [String] The normalized output string
       def normalize(input)
-        # TODO: This is fairly complicated, and there doesn't seem to be a ruby
-        # library which can handle it perfectly.
-        # https://www.unicode.org/reports/tr46/tr46-27.html
-        input.downcase
+        name = input.dup
+        if name.gsub!(/[`~!@#$%^&*()_=+\[\]{}<>,;:'"\/\\|?]/, "").nil?
+          return input.downcase
+        else
+          raise ArgumentError, "Provided ENS name contains illegal characters: #{input}"
+        end
       end
     end
   end

data/lib/eth/ens.rb

@@ -0,0 +1,28 @@
+# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "eth/ens/coin_type"
+require "eth/ens/resolver"
+
+# Provides the {Eth} module.
+module Eth
+  # Provides ENS specific functionality
+  # ref: https://ens.domains
+  module Ens
+    extend self
+
+    # The default address for ENS, which applies to most chains
+    DEFAULT_ADDRESS = Address.new("0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e").freeze
+  end
+end

data/lib/eth/solidity.rb

@@ -28,10 +28,12 @@ module Eth
 
     # Instantiates a Solidity `solc` system compiler binding that can be
     # used to compile Solidity contracts.
-    def initialize
+    #
+    # @param path [String] optional override of the solidity compiler path.
+    def initialize(path = nil)
 
-      # Currently only supports `solc`.
-      solc = get_compiler_path
+      # Currently only supports `solc`. Try to override with `path`.
+      solc = path || get_compiler_path
       raise SystemCallError, "Unable to find the solc compiler path!" if solc.nil?
       @compiler = solc
     end
@@ -43,9 +45,10 @@ module Eth
     def compile(contract)
       raise Errno::ENOENT, "Contract file not found: #{contract}" unless File.exist? contract
       flag_opt = "--optimize"
+      flag_ir = "--via-ir"
       flag_json = "--combined-json=bin,abi"
       path = File.realpath contract
-      output, error, status = Open3.capture3 @compiler, flag_opt, flag_json, path
+      output, error, status = Open3.capture3 @compiler, flag_opt, flag_ir, flag_json, path
       raise SystemCallError, "Unable to run solc compiler!" if status.exitstatus === 127
       raise CompilerError, error unless status.success?
       json = JSON.parse output