[−][src]Crate ethcontract
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.5.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?;
Re-exports
pub use crate::contract::Instance; |
pub use crate::transaction::Account; |
pub use crate::transport::DynTransport; |
pub use ethsign; |
pub use serde_json as json; |
pub use web3; |
Modules
contract | Abtraction for interacting with ethereum smart contracts. Provides methods for sending transactions to contracts as well as querying current contract state. |
errors | Module with common error types. |
sign | Utility for signing transactions and generating RLP encoded raw transactions.
Hopefully we can move this functionailly upstream to the |
transaction | Implementation for setting up, signing, estimating gas and sending transactions on the Ethereum network. |
transport | Module containing additional transports used by the |
truffle | Module for reading and examining data produced by truffle. |
Macros
contract | Proc macro to generate type-safe bindings to a contract. See
|
Structs
Artifact | Represents a truffle artifact. |
H256 | Fixed-size uninterpreted hash type with 32 bytes (256 bits) size. |
Protected | A protected set of bytes. |
SecretKey | Represents the private part of the Ethereum key |
U256 | Little-endian large integer type |
Enums
BlockNumber | Block Number |
TransactionCondition | Represents condition on minimum block number or block timestamp. |
Type Definitions
Address | Address |
DynDeployBuilder | Type alias for a |
DynInstance | Type alias for a contract |
DynMethodBuilder | Type alias for a |
DynViewMethodBuilder | Type alias for a |