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

@spec batch(list(), Keyword.t()) :: [ok: 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]}

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)
  • Any other account or RPC related options

@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_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.)

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

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

@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.

• :to: Indicates recepient address. (Contract address in this case)
• :gas: Gas limit for execution. (If not provided, will get filled using Ethers.Utils.maybe_add_gas_limit/2 function)
• :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.)

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.