Struct ethers_contract::DeploymentTxFactory

pub struct DeploymentTxFactory<B, M> { /* private fields */ }

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 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.bytecode().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<B, M> DeploymentTxFactory<B, M>where B: Borrow<M> + Clone, M: Middleware,

pub fn new(abi: Abi, bytecode: Bytes, client: B) -> Self

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_tokens( self, params: Vec<Token> ) -> Result<Deployer<B, M>, ContractError<M>>where B: Clone,

Create a deployment tx using the provided tokens as constructor arguments

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

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<B, M> Clone for DeploymentTxFactory<B, M>where B: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug, M: Debug> Debug for DeploymentTxFactory<B, M>

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

Formats the value using the given formatter.