Struct ethers::contract::Contract

pub struct Contract<M> { /* fields omitted */ }

A Contract is an abstraction of an executable program on the Ethereum Blockchain. It has code (called byte code) as well as allocated long-term memory (called storage). Every deployed Contract has an address, which is used to connect to it so that it may be sent messages to call its methods.

A Contract can emit Events, which can be efficiently observed by applications to be notified when a contract has performed specific operation.

There are two types of methods that can be called on a Contract:

1. A Constant method may not add, remove or change any data in the storage, nor log any events, and may only call Constant methods on other contracts. These methods are free (no Ether is required) to call. The result from them may also be returned to the caller. Constant methods are marked as pure and view in Solidity.

2. A Non-Constant method requires a fee (in Ether) to be paid, but may perform any state-changing operation desired, log events, send ether and call Non-Constant methods on other Contracts. These methods cannot return their result to the caller. These methods must be triggered by a transaction, sent by an Externally Owned Account (EOA) either directly or indirectly (i.e. called from another contract), and are required to be mined before the effects are present. Therefore, the duration required for these operations can vary widely, and depend on the transaction gas price, network congestion and miner priority heuristics.

The Contract API provides simple way to connect to a Contract and call its methods, as functions on a Rust struct, handling all the binary protocol conversion, internal name mangling and topic construction. This allows a Contract object to be used like any standard Rust struct, without having to worry about the low-level details of the Ethereum Virtual Machine or Blockchain.

The Contract definition (called an Application Binary Interface, or ABI) must be provided to instantiate a contract and the available methods and events will be made available to call by providing their name as a str via the method and event methods. If non-existing names are given, the function/event call will fail.

Alternatively, you can and should use the abigen macro, or the Abigen builder to generate type-safe bindings to your contracts.

Example

Assuming we already have our contract deployed at address, we’ll proceed to interact with its methods and retrieve raw logs it has emitted.

use ethers_core::{
    abi::Abi,
    types::{Address, H256},
};
use ethers_contract::Contract;
use ethers_providers::{Provider, Http};
use ethers_signers::Wallet;
use std::convert::TryFrom;

// this is a fake address used just for this example
let address = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee".parse::<Address>()?;

// (ugly way to write the ABI inline, you can otherwise read it from a file)
let abi: Abi = serde_json::from_str(r#"[{"inputs":[{"internalType":"string","name":"value","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"author","type":"address"},{"indexed":true,"internalType":"address","name":"oldAuthor","type":"address"},{"indexed":false,"internalType":"string","name":"oldValue","type":"string"},{"indexed":false,"internalType":"string","name":"newValue","type":"string"}],"name":"ValueChanged","type":"event"},{"inputs":[],"name":"getValue","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastSender","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"value","type":"string"}],"name":"setValue","outputs":[],"stateMutability":"nonpayable","type":"function"}]"#)?;

// connect to the network
let client = Provider::<Http>::try_from("http://localhost:8545").unwrap();

// create the contract object at the address
let contract = Contract::new(address, abi, client);

// Calling constant methods is done by calling `call()` on the method builder.
// (if the function takes no arguments, then you must use `()` as the argument)
let init_value: String = contract
    .method::<_, String>("getValue", ())?
    .call()
    .await?;

// Non-constant methods are executed via the `send()` call on the method builder.
let call = contract
    .method::<_, H256>("setValue", "hi".to_owned())?;
let pending_tx = call.send().await?;

// `await`ing on the pending transaction resolves to a transaction receipt
let receipt = pending_tx.confirmations(6).await?;

Event Logging

Querying structured logs requires you to have defined a struct with the expected datatypes and to have implemented Detokenize for it. This boilerplate code is generated for you via the abigen and Abigen builder utilities.

use ethers_core::{abi::Abi, types::Address};
use ethers_contract::{Contract, EthEvent};
use ethers_providers::{Provider, Http, Middleware};
use ethers_signers::Wallet;
use std::convert::TryFrom;
use ethers_core::abi::{Detokenize, Token, InvalidOutputType};

#[derive(Clone, Debug, EthEvent)]
struct ValueChanged {
    old_author: Address,
    new_author: Address,
    old_value: String,
    new_value: String,
}

let logs: Vec<ValueChanged> = contract
    .event()
    .from_block(0u64)
    .query()
    .await?;

println!("{:?}", logs);

Disclaimer: these above docs have been adapted from the corresponding ethers.js page

Implementations

impl<M> Contract<M> where
    M: Middleware, 

pub fn new(
    address: H160,
    abi: impl Into<BaseContract>,
    client: impl Into<Arc<M>>
) -> Contract<M>

Creates a new contract from the provided client, abi and address

pub fn event<D>(&self) -> Event<'_, M, D> where
    D: EthEvent, 

Returns an Event builder for the provided event.

pub fn event_with_filter<D>(&self, filter: Filter) -> Event<'_, M, D> where
    D: EthLogDecode, 

Returns an Event builder with the provided filter.

pub fn event_for_name<D>(&self, name: &str) -> Result<Event<'_, M, D>, Error> where
    D: EthLogDecode, 

Returns an Event builder with the provided name.

pub fn method<T, D>(
    &self,
    name: &str,
    args: T
) -> Result<ContractCall<M, D>, AbiError> where
    T: Tokenize,
    D: Detokenize, 

Returns a transaction builder for the provided function name. If there are multiple functions with the same name due to overloading, consider using the method_hash method instead, since this will use the first match.

pub fn method_hash<T, D>(
    &self,
    signature: [u8; 4],
    args: T
) -> Result<ContractCall<M, D>, AbiError> where
    T: Tokenize,
    D: Detokenize, 

Returns a transaction builder for the selected function signature. This should be preferred if there are overloaded functions in your smart contract

pub fn at<T>(&self, address: T) -> Contract<M> where
    T: Into<H160>,
    M: Clone, 

Returns a new contract instance at address.

Clones self internally

pub fn connect(&self, client: Arc<M>) -> Contract<M> where
    M: Clone, 

Returns a new contract instance using the provided client

Clones self internally

pub fn address(&self) -> H160

Returns the contract’s address

pub fn abi(&self) -> &Contract

Returns a reference to the contract’s ABI

pub fn client(&self) -> &M

Returns a reference to the contract’s client

Methods from Deref<Target = BaseContract>

pub fn encode<T>(&self, name: &str, args: T) -> Result<Bytes, AbiError> where
    T: Tokenize, 

Returns the ABI encoded data for the provided function and arguments

If the function exists multiple times and you want to use one of the overloaded versions, consider using encode_with_selector

pub fn encode_with_selector<T>(
    &self,
    signature: [u8; 4],
    args: T
) -> Result<Bytes, AbiError> where
    T: Tokenize, 

Returns the ABI encoded data for the provided function selector and arguments

pub fn decode<D, T>(&self, name: &str, bytes: T) -> Result<D, AbiError> where
    D: Detokenize,
    T: AsRef<[u8]>, 

Decodes the provided ABI encoded function arguments with the selected function name.

If the function exists multiple times and you want to use one of the overloaded versions, consider using decode_with_selector

pub fn decode_event<D>(
    &self,
    name: &str,
    topics: Vec<H256, Global>,
    data: Bytes
) -> Result<D, AbiError> where
    D: Detokenize, 

Decodes for a given event name, given the log.topics and log.data fields from the transaction receipt

pub fn decode_with_selector<D, T>(
    &self,
    signature: [u8; 4],
    bytes: T
) -> Result<D, AbiError> where
    D: Detokenize,
    T: AsRef<[u8]>, 

Decodes the provided ABI encoded bytes with the selected function selector

pub fn abi(&self) -> &Contract

Returns a reference to the contract’s ABI

Trait Implementations

impl<M> Clone for Contract<M> where
    M: Clone, 

pub fn clone(&self) -> Contract<M>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<M> Debug for Contract<M> where
    M: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<M> Deref for Contract<M> where
    M: Middleware, 

type Target = BaseContract

The resulting type after dereferencing.

pub fn deref(&self) -> &<Contract<M> as Deref>::Target

Dereferences the value.