@spec batch([t_batch_request()], Keyword.t()) ::
  {:ok, ok: term(), error: term()} | {:error, term()}

Combines multiple requests and make a batch json RPC request.

It returns {:ok, results} in case of success or {:error, reason} in case of RPC failure.

Each action will have an entry in the results. Each entry is again a tuple and either {:ok, result} or {:error, reason} in case of action failure.

Checkout Batching Requests sections in Ethers module for more examples.

Parameters

• requests: A list of requests to execute.
• opts: RPC related options. (No account and block options are accepted in batch)

Action

An action can be in either of the following formats.

• {action_name_atom, action_data, action_overrides}
• {action_name_atom, action_data}
• action_name_atom

Examples

Ethers.batch([
  {:call, WETH.name()},
  {:call, WETH.symbol(), to: "[WETH ADDRESS]"},
  {:send, WETH.transfer("[RECEIVER]", 1000), from: "[SENDER]"},
  :current_block_number
])
{:ok, [ok: "Weapped Ethereum", ok: "WETH", ok: "0xhash...", ok: 182394532]}

@spec batch!([t_batch_request()], Keyword.t()) :: [ok: term(), error: term()]

Same as Ethers.batch/2 but raises on error.

@spec call(Ethers.TxData.t(), Keyword.t()) ::
  {:ok, [term()]} | {:ok, term()} | {:error, term()}

Makes an eth_call to with the given Ethers.TxData struct and overrides. It then parses the response using the selector in the TxData struct.

Overrides and Options

Other than what stated below, any other option given in the overrides keyword list will be merged with the map that the RPC client will receive.

• :to: Indicates recepient address. (Contract address in this case)
• :block: The block number or block alias. Defaults to latest
• :rpc_client: The RPC Client to use. It should implement ethereum jsonRPC API. default: Ethereumex.HttpClient
• :rpc_opts: Extra options to pass to rpc_client. (Like timeout, Server URL, etc.)

Return structure

For contract functions which return a single value (e.g. function test() returns (uint)) this returns {:ok, value} and for the functions which return multiple values it will return {:ok, [value0, value1]} (A list).

Examples

Ethers.Contract.ERC20.total_supply() |> Ethers.call(to: "0xa0b...ef6")
{:ok, 100000000000000}

@spec call!(Ethers.TxData.t(), Keyword.t()) :: term() | no_return()

Same as Ethers.call/2 but raises on error.

@spec current_block_number(Keyword.t()) :: {:ok, non_neg_integer()} | {:error, term()}

Returns the current block number of the blockchain.

@spec current_gas_price(Keyword.t()) :: {:ok, non_neg_integer()}

Returns the current gas price from the RPC API

@spec deploy(atom() | binary(), Keyword.t()) ::
  {:ok, Ethers.Types.t_hash()} | {:error, term()}

Deploys a contract to the blockchain.

This will return the transaction hash for the deployment transaction. To get the address of your deployed contract, use Ethers.deployed_address/2.

To deploy a cotract you must have the binary related to it. It can either be a part of the ABI File you have or as a separate file.

Parameters

• contract_module_or_binary: Either the contract module which was already loaded or the compiled binary of the contract. The binary MUST be hex encoded.
• overrides: A keyword list containing options and overrides.
  • :encoded_constructor: Hex encoded value for constructor parameters. (See constructor function of the contract module)
  • All other options from Ethers.send/2

@spec deployed_address(binary(), Keyword.t()) ::
  {:ok, Ethers.Types.t_address()}
  | {:error, :no_contract_address | :transaction_not_found | term()}

Returns the address of the deployed contract if the deployment is finished and successful

Parameters

• tx_hash: Hash of the Transaction which created a contract.
• opts: RPC and account options.

@spec estimate_gas(map(), Keyword.t()) :: {:ok, non_neg_integer()} | {:error, term()}

Makes an eth_estimate_gas rpc call with the given parameters and overrides.

Overrides and Options

• :to: Indicates recepient address. (Contract address in this case)
• :rpc_client: The RPC Client to use. It should implement ethereum jsonRPC API. default: Ethereumex.HttpClient
• :rpc_opts: Extra options to pass to rpc_client. (Like timeout, Server URL, etc.)

Ethers.Contract.ERC20.transfer("0xff0...ea2", 1000) |> Ethers.estimate_gas(to: "0xa0b...ef6")
{:ok, 12345}

@spec estimate_gas!(map(), Keyword.t()) :: non_neg_integer() | no_return()

Same as Ethers.estimate_gas/2 but raises on error.

@spec get_balance(Ethers.Types.t_address(), Keyword.t()) ::
  {:ok, non_neg_integer()} | {:error, term()}

Returns the native token (ETH) balance of an account in wei.

Parameters

• account: Account which the balance is queried for.
• overrides:
  • block: The block you want to query the balance of account in (defaults to latest).
  • rpc_client: The RPC module to use for this request (overrides default).
  • rpc_opts: Specific RPC options to specify for this request.

@spec get_logs(map(), Keyword.t()) :: {:ok, [Ethers.Event.t()]} | {:error, atom()}

Fetches the event logs with the given filter.

Overrides and Options

• :address: Indicates event emitter contract address. (nil means all contracts)
• :rpc_client: The RPC Client to use. It should implement ethereum jsonRPC API. default: Ethereumex.HttpClient
• :rpc_opts: Extra options to pass to rpc_client. (Like timeout, Server URL, etc.)
• :fromBlock: Minimum block number of logs to filter.
• :toBlock: Maximum block number of logs to filter.

@spec get_logs!(map(), Keyword.t()) :: [Ethers.Event.t()] | no_return()

Same as Ethers.get_logs/2 but raises on error.

@spec get_transaction(Ethers.Types.t_hash(), Keyword.t()) ::
  {:ok, Ethers.Transaction.t()} | {:error, term()}

Returns the native transaction (ETH) by transaction hash.

Parameters

• tx_hash: Transaction hash which the transaction is queried for.
• overrides:
  • rpc_client: The RPC module to use for this request (overrides default).
  • rpc_opts: Specific RPC options to specify for this request.

@spec get_transaction_count(Ethers.Types.t_address(), Keyword.t()) ::
  {:ok, non_neg_integer()} | {:error, term()}

Returns the transaction count of an address.

Parameters

• account: Account which the transaction count is queried for.
• overrides:
  • block: The block you want to query the transaction count in (defaults to latest).
  • rpc_client: The RPC module to use for this request (overrides default).
  • rpc_opts: Specific RPC options to specify for this request.

@spec get_transaction_receipt(Ethers.Types.t_hash(), Keyword.t()) ::
  {:ok, map()} | {:error, term()}

Returns the receipt of a transaction by it's hash.

Parameters

• tx_hash: Transaction hash which the transaction receipt is queried for.
• overrides:
  • rpc_client: The RPC module to use for this request (overrides default).
  • rpc_opts: Specific RPC options to specify for this request.

@spec max_priority_fee_per_gas(Keyword.t()) :: {:ok, non_neg_integer()}

Returns the current max priority fee per gas from the RPC API

@spec send(map() | Ethers.TxData.t(), Keyword.t()) ::
  {:ok, String.t()} | {:error, term()}

Makes an eth_send rpc call to with the given data and overrides, Then returns the transaction hash.

Overrides and Options

Other than what stated below, any other option given in the overrides keyword list will be merged with the map that the RPC client will receive.

Required Options

• :from: The address of the account to sign the transaction with.

Optional Options

• :access_list: List of storage slots that this transaction accesses (optional)
• :chain_id: Chain id for the transaction (defaults to chain id from RPC server).
• :gas_price: (legacy only) max price willing to pay for each gas.
• :gas: Gas limit for execution of this transaction.
• :max_fee_per_gas: (EIP-1559 only) max fee per gas (defaults to 120% current gas price estimate).
• :max_priority_fee_per_gas: (EIP-1559 only) max priority fee per gas or validator tip. (defaults to zero)
• :nonce: Nonce of the transaction. (defaults to number of transactions of from address)
• :rpc_client: The RPC Client to use. It should implement ethereum jsonRPC API. default: Ethereumex.HttpClient
• :rpc_opts: Extra options to pass to rpc_client. (Like timeout, Server URL, etc.)
• :signer: The signer module to use for signing transaction. Default is nil and will rely on the RPC server for signing.
• :signer_opts: Options for signer module. See your signer docs for more details.
• :tx_type: Transaction type. Either :eip1559 (default) or :legacy.
• :to: Address of the contract or a receiver of this transaction. (required if TxData does not have default_address)
• :value: Ether value to send with the transaction to the receiver (from => to).

Examples

Ethers.Contract.ERC20.transfer("0xff0...ea2", 1000) |> Ethers.send(to: "0xa0b...ef6")
{:ok, _tx_hash}

@spec send!(map() | Ethers.TxData.t(), Keyword.t()) :: String.t() | no_return()

Same as Ethers.send/2 but raises on error.

@spec sign_transaction(map(), Keyword.t()) :: {:ok, binary()} | {:error, term()}

Signs a transaction and returns the encoded signed transaction hex.

Parameters

Accepts same parameters as Ethers.send/2.

@spec sign_transaction!(map(), Keyword.t()) :: binary() | no_return()

Same as Ethers.sign_transaction/2 but raises on error.