Struct ethers::contract::ContractFactory

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

To deploy a contract to the Ethereum network, a ContractFactory can be created which manages the Contract bytecode and Application Binary Interface (ABI), usually generated from the Solidity compiler.

Once the factory’s deployment transaction is mined with sufficient confirmations, the Contract object is returned.

Example

use ethers_solc::Solc;
use ethers_contract::ContractFactory;
use ethers_providers::{Provider, Http};
use ethers_signers::Wallet;
use std::convert::TryFrom;

// first we'll compile the contract (you can alternatively compile it yourself
// and pass the ABI/Bytecode
let compiled = Solc::default().compile_source("./tests/contract.sol").unwrap();
let contract = compiled
    .get("./tests/contract.sol", "SimpleStorage")
    .expect("could not find contract");

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

// create a factory which will be used to deploy instances of the contract
let factory = ContractFactory::new(contract.abi.unwrap().clone(), contract.bin.unwrap().clone(), client);

// The deployer created by the `deploy` call exposes a builder which gets consumed
// by the async `send` call
let contract = factory
    .deploy("initial value".to_string())?
    .confirmations(0usize)
    .send()
    .await?;
println!("{}", contract.address());

Implementations

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

pub fn new(abi: Contract, bytecode: Bytes, client: Arc<M>) -> ContractFactory<M>

Creates a factory for deployment of the Contract with bytecode, and the constructor defined in the abi. The client will be used to send any deployment transaction.

pub fn deploy<T>(
    self,
    constructor_args: T
) -> Result<Deployer<M>, ContractError<M>> where
    T: Tokenize, 

Constructs the deployment transaction based on the provided constructor arguments and returns a Deployer instance. You must call send() in order to actually deploy the contract.

Notes:

1. If there are no constructor arguments, you should pass () as the argument.
2. The default poll duration is 7 seconds.
3. The default number of confirmations is 1 block.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.