flare development using rust
This guide is for developers who want to interact with Flare using Rust. In this guide, using Rust, you will learn how to:
Query a contract on Flare using alloy-rs, an async library for interacting with Ethereum-like chains. Compile a Solidity contract using the CLI interface of solc, the Solidity compiler. Deploy your compiled contract on Flare. TIP All examples in this guide are available at developer-hub/examples.Getting started
Install the Solidity compiler by following the instructions in the Solidity documentation. The main commands are provided here: MacOS via Homebrew Ubuntu via PPAs brew tap ethereum/ethereum brew install solidity Install the following dependencies: cargo add alloy eyre tokio --features alloy/full,tokio/rt,tokio/rt-multi-thread,tokio/macros Usage You need to connect to testnet or mainnet via an RPC, any RPC listed on the Network Configurationpage will work. For this guide, you can use the Public RPC. Flare Testnet Coston2 Flare Mainnet src/bin/chain_id.rs use alloy::providers::{Provider, ProviderBuilder};
use eyre::Result;
#[tokio::main]
async fn main() -> Result<()> {
let provider =
ProviderBuilder::new().on_http("https://coston2-api.flare.network/ext/C/rpc".parse()?);
let chain_id = provider.get_chain_id().await?;
println!("Chain ID: {}", chain_id); // Chain ID: 114
Ok(())
}
cargo run --bin chain_idQuerying a contract To query a contract, two pieces of information are required: Contract address Contract ABI (Application Binary Interface) For this example, you can use the FlareContractRegistry contract which has the same address 0xaD67FE66660Fb8dFE9d6b1b4240d8650e30F6019across both testnet and mainnet. Fetch ABI To fetch a contract's ABI, copy the FlareContractRegistry ABI, and paste it into a file named FlareContractRegistry.json, located in the root of your project, i.e. same level as Cargo.toml. Make query You can now query the FlareContractRegistrycontract to get the addresses of other Flare contracts. For example, querying it for the address of the WNatcontract: Flare Testnet Coston2 Flare Mainnet src/bin/make_query.rs use alloy::{providers::ProviderBuilder, sol}; use eyre::Result; sol!( #[sol(rpc)] FlareContractRegistry, "FlareContractRegistry.json" ); #[tokio::main] async fn main() -> Result<()> { let provider = ProviderBuilder::new().on_http("https://coston2-api.flare.network/ext/C/rpc".parse()?); let registry = FlareContractRegistry::new( "0xaD67FE66660Fb8dFE9d6b1b4240d8650e30F6019".parse()?, provider, ); let FlareContractRegistry::getContractAddressByNameReturn { _0 } = registry .getContractAddressByName("WNat".to_string()) .call() .await?; println!("WNat address: {_0}"); // WNat address: 0xC67DCE33D7A8efA5FfEB961899C73fe01bCe9273 Ok(()) }
cargo run --bin make_query
Compiling a contract>/h5>
For this example, you can use the FtsoV2FeedConsumer contract to query the FTSOv2 feeds. Copy the FtsoV2FeedConsumer sample contract code given below, and save the .sol file in the same folder as your Cargo.toml.
FtsoV2FeedConsumer sample contract
Compile with solc
To compile the contract using the Solidity CLI compiler, create a file named config.json:
config.json
{
"language": "Solidity",
"sources": {
"FtsoV2FeedConsumer.sol": {
"urls": [
"./FtsoV2FeedConsumer.sol"
]
}
},
"settings": {
"outputSelection": {
"FtsoV2FeedConsumer.sol": {
"FtsoV2FeedConsumer": [
"abi",
"metadata",
"evm.bytecode",
"evm.bytecode.sourceMap"
]
}
},
"optimizer": {
"enabled": true,
"runs": 200
},
"evmVersion": "london"
}
}
solc --standard-json config.json > FtsoV2FeedConsumer.json
This will generate a FtsoV2FeedConsumer.json file with the contract's ABI and bytecode.
Modify format
Things get a bit annoying here, as the alloy-rs solc!() macro expects a specific format for the JSON, which is not the same as the output from the Solidity compiler. To fix this, in the generated FtsoV2FeedConsumer.json, remove the top-level JSON fields, after you are done, the JSON should look like:
FtsoV2FeedConsumer.json { "abi": [ ... ], "evm": { ... } "metadata": "..." }Create account
Before deploying a contract, you need to have an account with some testnet or mainnet gas tokens. You can create a new Flare account using create_account.rs: src/bin/create_account.rs use alloy::signers::local::LocalSigner; use eyre::Result; #[tokio::main] async fn main() -> Result<()> { let signer = LocalSigner::random(); println!( "Account: {}, Private key: {}", signer.address(), signer.as_nonzero_scalar() ); Ok(()) } cargo run --bin create_accountThis will output a new private key and an account pair.
DANGER Never share your private keys. Never put your private keys in source code. Never commit private keys to a Git repository. You can save the account and private key into environment variables ACCOUNT and ACCOUNT_PRIVATE_KEY respectively.NOTE
You can also import the raw hex private key to MetaMask and any other wallet - the private key can be shared between your Rust code and any number of wallets. For testnet, you can get free testnet C2FLR on the Coston2 Faucet. For mainnet you will need to fund the account with FLR. You can buy FLR with regular currency in places like centralized exchanges, crypto on-ramps, or swap other tokens for FLR on decentralized exchanges. Deploying with alloy-rs With the account ready, you can now deploy the contract. In a deploy_contract.rs file, you can define the following code to deploy the contract: Flare Testnet Coston2 Flare Mainnet src/bin/deploy_contract.rsYou can now run the deploy_contract.rs script to deploy the contract. The contract address will be printed once the deployment is successful. You can check the contract address on a Flare Blockchain explorer, linked on the Network Configuration page.
cargo run --bin deploy_contract