feat: guardian typescript bindings

Author: jackpooleyml

packages/sdk-platforms/rust/zksync-sso-erc4337/crates/zksync-sso-erc4337-core/src/erc4337/account/modular_smart_account/guardian/remove.rs

@@ -20,14 +20,14 @@ use alloy::{
 
 #[derive(Clone)]
 pub struct RemoveGuardianParams<P: Provider + Send + Sync + Clone> {
-    guardian_executor: Address,
-    guardian_to_remove: Address,
-    account_address: Address,
-    entry_point_address: Address,
-    paymaster: Option<PaymasterParams>,
-    provider: P,
-    bundler_client: BundlerClient,
-    signer: Signer,
+    pub guardian_executor: Address,
+    pub guardian_to_remove: Address,
+    pub account_address: Address,
+    pub entry_point_address: Address,
+    pub paymaster: Option<PaymasterParams>,
+    pub provider: P,
+    pub bundler_client: BundlerClient,
+    pub signer: Signer,
 }
 
 pub async fn remove_guardian<P>(

packages/sdk-platforms/rust/zksync-sso-erc4337/crates/zksync-sso-erc4337-core/src/erc4337/account/modular_smart_account/session.rs

@@ -11,4 +11,4 @@ pub mod signature_wasm;
 pub mod state;
 pub mod status;
 
-pub mod contract;
+pub(crate) mod contract;

packages/sdk-platforms/rust/zksync-sso-erc4337/crates/zksync-sso-erc4337-ffi-web/src/account.rs

@@ -0,0 +1 @@
+pub mod modular_smart_account;

packages/sdk-platforms/rust/zksync-sso-erc4337/crates/zksync-sso-erc4337-ffi-web/src/account/modular_smart_account.rs

@@ -0,0 +1 @@
+pub mod guardian;

packages/sdk-platforms/rust/zksync-sso-erc4337/crates/zksync-sso-erc4337-ffi-web/src/account/modular_smart_account/guardian.rs

@@ -0,0 +1,6 @@
+pub mod accept;
+pub mod list;
+pub mod propose;
+pub mod recovery;
+pub mod remove;
+pub mod status;

packages/sdk-platforms/rust/zksync-sso-erc4337/crates/zksync-sso-erc4337-ffi-web/src/account/modular_smart_account/guardian/accept.rs

@@ -0,0 +1,99 @@
+use crate::wasm_transport::WasmHttpTransport;
+use alloy::{
+    network::EthereumWallet,
+    primitives::Address,
+    providers::ProviderBuilder,
+    signers::local::PrivateKeySigner,
+};
+use alloy_rpc_client::RpcClient;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::future_to_promise;
+use zksync_sso_erc4337_core::erc4337::account::modular_smart_account::guardian::accept::{
+    accept_guardian, AcceptGuardianParams,
+};
+
+/// Accept a proposed guardian for a smart account
+///
+/// This function allows a guardian to accept their proposed role for a smart account.
+/// The guardian must sign the transaction using their private key.
+///
+/// # Parameters
+/// * `rpc_url` - RPC URL for the blockchain network
+/// * `guardian_executor` - Address of the GuardianExecutor contract
+/// * `account` - Address of the smart account
+/// * `guardian_private_key` - Private key of the guardian (0x-prefixed hex string)
+///
+/// # Returns
+/// Promise that resolves to the transaction receipt hash as a hex string
+#[wasm_bindgen]
+pub fn accept_guardian_wasm(
+    rpc_url: String,
+    guardian_executor: String,
+    account: String,
+    guardian_private_key: String,
+) -> js_sys::Promise {
+    future_to_promise(async move {
+        // Parse addresses
+        let guardian_executor_addr = match guardian_executor.parse::<Address>()
+        {
+            Ok(addr) => addr,
+            Err(e) => {
+                return Err(JsValue::from_str(&format!(
+                    "Invalid guardian executor address: {}",
+                    e
+                )));
+            }
+        };
+
+        let account_addr = match account.parse::<Address>() {
+            Ok(addr) => addr,
+            Err(e) => {
+                return Err(JsValue::from_str(&format!(
+                    "Invalid account address: {}",
+                    e
+                )));
+            }
+        };
+
+        // Parse guardian private key
+        let guardian_key = match guardian_private_key
+            .trim_start_matches("0x")
+            .parse::<PrivateKeySigner>()
+        {
+            Ok(signer) => signer,
+            Err(e) => {
+                return Err(JsValue::from_str(&format!(
+                    "Invalid guardian private key: {}",
+                    e
+                )));
+            }
+        };
+
+        let guardian_wallet = EthereumWallet::from(guardian_key);
+
+        // Create transport and provider with wallet
+        let transport = WasmHttpTransport::new(rpc_url);
+        let client = RpcClient::new(transport.clone(), false);
+        let guardian_provider = ProviderBuilder::new()
+            .wallet(guardian_wallet)
+            .connect_client(client);
+
+        // Call the core function
+        match accept_guardian(AcceptGuardianParams {
+            guardian_executor: guardian_executor_addr,
+            account: account_addr,
+            guardian_provider,
+        })
+        .await
+        {
+            Ok(receipt) => {
+                let tx_hash = receipt.transaction_hash;
+                Ok(JsValue::from_str(&format!("0x{:x}", tx_hash)))
+            }
+            Err(e) => Err(JsValue::from_str(&format!(
+                "Failed to accept guardian: {}",
+                e
+            ))),
+        }
+    })
+}

packages/sdk-platforms/rust/zksync-sso-erc4337/crates/zksync-sso-erc4337-ffi-web/src/account/modular_smart_account/guardian/list.rs

@@ -0,0 +1,237 @@
+use crate::wasm_transport::WasmHttpTransport;
+use alloy::primitives::Address;
+use alloy::providers::ProviderBuilder;
+use alloy_rpc_client::RpcClient;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::future_to_promise;
+use zksync_sso_erc4337_core::erc4337::account::modular_smart_account::guardian::list::get_guardians_list;
+
+/// Get the list of guardians for a smart account
+///
+/// # Parameters
+/// * `rpc_url` - RPC URL for the blockchain network
+/// * `account_address` - Address of the smart account
+/// * `guardian_executor_address` - Address of the GuardianExecutor contract
+///
+/// # Returns
+/// Promise that resolves to a JSON array of guardian addresses (hex strings)
+#[wasm_bindgen]
+pub fn get_guardians_list_wasm(
+    rpc_url: String,
+    account_address: String,
+    guardian_executor_address: String,
+) -> js_sys::Promise {
+    future_to_promise(async move {
+        // Parse addresses
+        let account_addr = match account_address.parse::<Address>() {
+            Ok(addr) => addr,
+            Err(e) => {
+                return Err(JsValue::from_str(&format!(
+                    "Invalid account address: {}",
+                    e
+                )));
+            }
+        };
+
+        let guardian_executor_addr =
+            match guardian_executor_address.parse::<Address>() {
+                Ok(addr) => addr,
+                Err(e) => {
+                    return Err(JsValue::from_str(&format!(
+                        "Invalid guardian executor address: {}",
+                        e
+                    )));
+                }
+            };
+
+        // Create transport and provider
+        let transport = WasmHttpTransport::new(rpc_url);
+        let client = RpcClient::new(transport.clone(), false);
+        let provider = ProviderBuilder::new().connect_client(client);
+
+        // Call the core function
+        match get_guardians_list(account_addr, guardian_executor_addr, provider)
+            .await
+        {
+            Ok(guardians) => {
+                let addresses: Vec<String> = guardians
+                    .iter()
+                    .map(|addr| format!("0x{:x}", addr))
+                    .collect();
+                let json = serde_json::to_string(&addresses).map_err(|e| {
+                    JsValue::from_str(&format!(
+                        "Failed to serialize guardians list: {}",
+                        e
+                    ))
+                })?;
+                Ok(JsValue::from_str(&json))
+            }
+            Err(e) => Err(JsValue::from_str(&format!(
+                "Failed to get guardians list: {}",
+                e
+            ))),
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy::primitives::address;
+    use serde_json;
+    use wasm_bindgen_futures::JsFuture;
+    use zksync_sso_erc4337_core::{
+        erc4337::{
+            account::{
+                erc7579::module::add::{
+                    AddModuleParams, AddModulePayload, add_module,
+                },
+                modular_smart_account::{
+                    deploy::{DeployAccountParams, EOASigners, deploy_account},
+                    guardian::propose::{
+                        ProposeGuardianParams, propose_guardian,
+                    },
+                    test_utilities::fund_account_with_default_amount,
+                },
+            },
+            signer::create_eoa_signer,
+        },
+        utils::alloy_utilities::test_utilities::{
+            TestInfraConfig,
+            start_anvil_and_deploy_contracts_and_start_bundler_with_config,
+        },
+    };
+
+    #[tokio::test]
+    #[cfg(not(target_arch = "wasm32"))]
+    async fn test_get_guardians_list_wasm() -> eyre::Result<()> {
+        let (
+            _node_url,
+            anvil_instance,
+            provider,
+            contracts,
+            signer_private_key,
+            bundler,
+            bundler_client,
+        ) = {
+            let signer_private_key = "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6".to_string();
+            let config = TestInfraConfig {
+                signer_private_key: signer_private_key.clone(),
+            };
+            start_anvil_and_deploy_contracts_and_start_bundler_with_config(
+                &config,
+            )
+            .await?
+        };
+
+        let entry_point_address =
+            address!("0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108");
+
+        let factory_address = contracts.account_factory;
+        let eoa_validator_address = contracts.eoa_validator;
+
+        let signer_address =
+            address!("0xa0Ee7A142d267C1f36714E4a8F75612F20a79720");
+        let signers = vec![signer_address];
+
+        let eoa_signers = EOASigners {
+            addresses: signers,
+            validator_address: eoa_validator_address,
+        };
+
+        let account_address = deploy_account(DeployAccountParams {
+            factory_address,
+            eoa_signers: Some(eoa_signers),
+            webauthn_signer: None,
+            session_validator: None,
+            id: None,
+            provider: provider.clone(),
+        })
+        .await?;
+
+        println!("Account deployed");
+
+        fund_account_with_default_amount(account_address, provider.clone())
+            .await?;
+
+        let signer = create_eoa_signer(
+            signer_private_key.clone(),
+            eoa_validator_address,
+        )?;
+
+        // Install WebAuthn module
+        {
+            let webauthn_module = contracts.webauthn_validator;
+            add_module(AddModuleParams {
+                account_address,
+                module: AddModulePayload::webauthn(webauthn_module),
+                entry_point_address,
+                paymaster: None,
+                provider: provider.clone(),
+                bundler_client: bundler_client.clone(),
+                signer: signer.clone(),
+            })
+            .await?;
+        }
+
+        let guardian_module = contracts.guardian_executor;
+
+        // Install Guardian module
+        add_module(AddModuleParams {
+            account_address,
+            module: AddModulePayload::guardian(guardian_module),
+            entry_point_address,
+            paymaster: None,
+            provider: provider.clone(),
+            bundler_client: bundler_client.clone(),
+            signer: signer.clone(),
+        })
+        .await?;
+
+        // Use a different address for the guardian (not the account owner)
+        let new_guardian =
+            address!("0x70997970C51812dc3A010C7d01b50e0d17dc79C8");
+
+        // Propose guardian using core function
+        propose_guardian(ProposeGuardianParams {
+            guardian_executor: guardian_module,
+            new_guardian,
+            account: account_address,
+            entry_point: entry_point_address,
+            paymaster: None,
+            provider: provider.clone(),
+            bundler_client: bundler_client.clone(),
+            signer: signer.clone(),
+        })
+        .await?;
+
+        // Get guardians list using WASM wrapper
+        let promise = get_guardians_list_wasm(
+            "http://127.0.0.1:8545".to_string(), // Use default anvil URL
+            format!("0x{:x}", account_address),
+            format!("0x{:x}", guardian_module),
+        );
+
+        let result = JsFuture::from(promise)
+            .await
+            .map_err(|e| eyre::eyre!("Failed to await promise: {:?}", e))?;
+        let json_str =
+            result.as_string().ok_or(eyre::eyre!("Expected string result"))?;
+        let guardians: Vec<String> = serde_json::from_str(&json_str)?;
+
+        eyre::ensure!(
+            guardians.len() == 1,
+            "Expected exactly one guardian in the list"
+        );
+        eyre::ensure!(
+            guardians[0].to_lowercase()
+                == format!("0x{:x}", new_guardian).to_lowercase(),
+            "Guardian address mismatch"
+        );
+
+        drop(anvil_instance);
+        drop(bundler);
+
+        Ok(())
+    }
+}