handy chain init util func

Author: alxiong

.env.example

@@ -0,0 +1,2 @@
+TIMEBOOST_KEY_MANAGER_MNEMONIC="test test test test test test test test test test test junk"
+TIMEBOOST_KEY_MANAGER_ACCOUNT_INDEX=0

Cargo.lock

@@ -29,7 +29,7 @@ rust-version = "1.85.0"
 
 [workspace.dependencies]
 aes-gcm = { version = "0.10.3" }
-alloy = { version = "1.0", features = ["default", "arbitrary", "k256", "serde", "rlp", "node-bindings", "getrandom"] }
+alloy = { version = "1.0", features = ["default", "arbitrary", "k256", "serde", "rlp", "node-bindings", "getrandom", "signer-mnemonic"] }
 alloy-chains = "0.2"
 # derive feature is not exposed via `alloy`, thus has to explicitly declare here
 alloy-rlp = { version = "0.3.12", features = ["derive"] }

Cargo.toml

@@ -7,6 +7,8 @@ rust-version.workspace = true
 
 [dependencies]
 alloy = { workspace = true }
+anyhow = { workspace = true }
+dotenvy = "0.15"
 tracing = { workspace = true }
 tokio = { workspace = true }
 

timeboost-contract/Cargo.toml

@@ -45,16 +45,14 @@ pub async fn deploy_key_manager_contract(
 
 #[cfg(test)]
 mod tests {
-    use crate::{KeyManager, deployer::deploy_key_manager_contract};
-    use alloy::{primitives::Address, providers::ProviderBuilder};
+    use alloy::providers::WalletProvider;
+
+    use crate::KeyManager;
 
     #[tokio::test]
     async fn test_key_manager_deployment() {
-        let provider = ProviderBuilder::new().connect_anvil_with_wallet();
-        let manager = Address::random();
-        let addr = deploy_key_manager_contract(&provider, manager)
-            .await
-            .unwrap();
+        let (provider, addr) = crate::init_test_chain().await.unwrap();
+        let manager = provider.default_signer_address();
         let contract = KeyManager::new(addr, provider);
 
         // try read from the contract storage

timeboost-contract/src/deployer.rs

@@ -2,11 +2,46 @@
 //!
 //! This crate provides Rust bindings and API to interact with smart contracts,
 
+use alloy::{
+    primitives::Address,
+    providers::{ProviderBuilder, WalletProvider},
+    transports::http::reqwest::Url,
+};
+use anyhow::Result;
+
 // Include the generated contract bindings
 // The build script auto-detects contracts and generates bindings in src/bindings/
 pub mod bindings;
 pub mod deployer;
+pub mod provider;
 
 // We manually re-export the type here carefully due to alloy's lack of shared type:
 // tracking issue: https://github.com/foundry-rs/foundry/issues/10153
 pub use bindings::{erc1967proxy::ERC1967Proxy, keymanager::KeyManager};
+use provider::{HttpProviderWithWallet, TestProviderWithWallet, build_provider};
+
+/// Connect to a real blockchain, deploy the KeyManager contract, set the
+/// `TIMEBOOST_KEY_MANAGER_MNEMONIC` as the manager.
+/// Returns the (wallet provider, KeyManager address).
+pub async fn init_chain(chain: Url) -> Result<(HttpProviderWithWallet, Address)> {
+    dotenvy::dotenv()?;
+
+    let mnemonic = dotenvy::var("TIMEBOOST_KEY_MANAGER_MNEMONIC")?;
+    let account_idx = dotenvy::var("TIMEBOOST_KEY_ACCOUNT_INDEX")?.parse::<u32>()?;
+    let provider = build_provider(mnemonic, account_idx, chain);
+
+    let km_addr =
+        deployer::deploy_key_manager_contract(&provider, provider.default_signer_address()).await?;
+
+    Ok((provider, km_addr))
+}
+
+/// Similar to [`init_chain()`] but spawn a local test chain and deploy contracts there instead.
+pub async fn init_test_chain() -> Result<(TestProviderWithWallet, Address)> {
+    // this provider wraps both the test chain instance (exit on drop), and the wallet provider
+    let provider = ProviderBuilder::new().connect_anvil_with_wallet();
+    let km_addr =
+        deployer::deploy_key_manager_contract(&provider, provider.default_signer_address()).await?;
+
+    Ok((provider, km_addr))
+}

timeboost-contract/src/lib.rs

@@ -0,0 +1,48 @@
+//! Helper functions to build Ethereum [providers](https://docs.rs/alloy/latest/alloy/providers/trait.Provider.html)
+//! Partial Credit: <https://github.com/EspressoSystems/espresso-network/tree/main/contracts/rust/deployer>
+
+use alloy::{
+    network::{Ethereum, EthereumWallet},
+    providers::{
+        ProviderBuilder, RootProvider,
+        fillers::{FillProvider, JoinFill, WalletFiller},
+        layers::AnvilProvider,
+        utils::JoinedRecommendedFillers,
+    },
+    signers::local::{MnemonicBuilder, PrivateKeySigner, coins_bip39::English},
+    transports::http::reqwest::Url,
+};
+
+/// Type alias that connects to providers with recommended fillers and wallet
+/// use `<HttpProviderWithWallet as WalletProvider>::wallet()` to access internal wallet
+/// use `<HttpProviderWithWallet as WalletProvider>::default_signer_address(&provider)` to get
+/// wallet address
+pub type HttpProviderWithWallet = FillProvider<
+    JoinFill<JoinedRecommendedFillers, WalletFiller<EthereumWallet>>,
+    RootProvider,
+    Ethereum,
+>;
+
+pub type TestProviderWithWallet = FillProvider<
+    JoinFill<JoinedRecommendedFillers, WalletFiller<EthereumWallet>>,
+    AnvilProvider<RootProvider>,
+    Ethereum,
+>;
+
+/// Build a local signer from wallet mnemonic and account index
+pub fn build_signer(mnemonic: String, account_index: u32) -> PrivateKeySigner {
+    MnemonicBuilder::<English>::default()
+        .phrase(mnemonic)
+        .index(account_index)
+        .expect("wrong mnemonic or index")
+        .build()
+        .expect("fail to build signer")
+}
+
+/// a handy thin wrapper around wallet builder and provider builder that directly
+/// returns an instantiated `Provider` with default fillers with wallet, ready to send tx
+pub fn build_provider(mnemonic: String, account_index: u32, url: Url) -> HttpProviderWithWallet {
+    let signer = build_signer(mnemonic, account_index);
+    let wallet = EthereumWallet::from(signer);
+    ProviderBuilder::new().wallet(wallet).connect_http(url)
+}