Crate ethcontract[−][src]
Generate bindings for Ethereum smart contracts. Internally, the generated
types use web3
crate to interact with the Ethereum network and uses a
custom Instance
runtime that can be
used directly without code generation.
This crate is using std::future::Future
for futures by wrapping web3
futures
0.1 with futures
0.3 compatibility layer. This means that this
crate is ready for async
/await
!
Here is an example of interacing with a smart contract MyContract
. The
builder pattern is used for configuring transactions.
pragma solidity ^0.6.0;
contract MyContract {
function my_view_function(uint64 some_val) public view returns (string) {
// ...
}
function my_function(bool some_bool, string some_str) public returns (uint256) {
// ...
}
function my_other_function() public {
// ...
}
}
Once this contract is built and deployed with truffle the following example demonstrates how to interact with it from Rust.
use ethcontract::transaction::Account; use std::time::Duration; use web3::api::Web3; use web3::types::*; // this proc macro generates a `MyContract` type with type-safe bindings to // contract functions ethcontract::contract!("path/to/MyContract.json"); // create a web3 instance as usual let transport = ...; let web3 = Web3::new(transport); // now create an instance of an interface to the contract let instance = MyContract::deployed(web3).await?; let addr: Address = "0x000102030405060708090a0b0c0d0e0f10111213".parse()?; let some_uint: U256 = U256::from_dec_str("1000000000000000000")?; let some_bool = true; let some_val = u64; // call instance view functions with type-safe bindings! will only compile // if contract function accepts a single `u64` value parameter and returns // a concrete type based on the contract function's return type let value = instance .my_view_function(some_val) .from(addr) .execute() .await?; // contract functions also have type-safe bindings and return the tx hash // of the submitted transaction; allows for multiple ways of signing txs let tx = instance .my_function(some_bool, value) .from(Account::Locked(addr, "password".into(), None)) .value(some_uint) .gas_price(1_000_000.into()) .execute() .await?; // wait for confirmations when needed let receipt = instance .my_important_function() .poll_interval(Duration::from_secs(5)) .confirmations(2) .execute_confirm() .await?;
See contract!
proc macro documentation for more
information on usage and parameters as well on how to use contract ABI
directly from Etherscan.
Re-exports
pub use crate::contract::Instance; |
pub use crate::prelude::*; |
pub use ethcontract_common as common; |
pub use futures; |
pub use jsonrpc_core as jsonrpc; |
pub use serde_json as json; |
pub use web3; |
Modules
batch | Module containing components to batch multiple contract calls into a single request to the Node. |
contract | Abtraction for interacting with ethereum smart contracts. Provides methods for sending transactions to contracts as well as querying current contract state. |
dyns | Type aliases to various runtime types that use an underlying
|
errors | Module with common error types. |
log | This module implements event builders and streams for retrieving events emitted by a contract. |
prelude | A prelude module for importing commonly used types when interacting with generated contracts. |
secret | This module implements secrets in the form of protected memory. |
transaction | Implementation for setting up, signing, estimating gas and sending transactions on the Ethereum network. |
transport | Module containing additional transports used by the |
Macros
contract | Proc macro to generate type-safe bindings to a contract. This macro accepts
a path to a Truffle artifact JSON file. Note that this path is rooted in
the crate’s root |
Structs
Artifact | Represents a truffle artifact. |