feat: account signer utilities (#218)

Author: jackpooleyml

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

@@ -4,6 +4,7 @@ pub mod nonce;
 pub mod send;
 pub mod session;
 pub mod signers;
+pub mod utils;
 
 #[cfg(test)]
 pub mod test_utilities;

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

@@ -1,13 +1,19 @@
 use crate::{
     config::contracts::Contracts,
-    erc4337::account::modular_smart_account::session::{
-        SessionKeyValidator, session_lib::session_spec::SessionSpec,
+    erc4337::account::modular_smart_account::{
+        session::{
+            SessionKeyValidator, session_lib::session_spec::SessionSpec,
+        },
+        utils::{
+            calculate_from_block, create_logs_filter_with_range,
+            parse_add_remove_events,
+        },
     },
 };
 use alloy::{
     primitives::{Address, FixedBytes},
     providers::Provider,
-    rpc::types::{BlockNumberOrTag, Filter, FilterSet, Log},
+    rpc::types::{Filter, Log},
     sol_types::SolEvent,
 };
 use serde::{Deserialize, Serialize};
@@ -19,8 +25,6 @@ pub struct ActiveSession {
     pub session_spec: SessionSpec,
 }
 
-const MAX_BLOCK_RANGE: u64 = 100_000;
-
 pub async fn get_active_sessions<P>(
     account_address: Address,
     provider: P,
@@ -52,27 +56,11 @@ where
     Ok(active_sessions)
 }
 
-fn calculate_from_block(current_block: u64) -> u64 {
-    current_block.saturating_sub(MAX_BLOCK_RANGE)
-}
-
 fn create_session_logs_filter_with_range(
     session_key_validator_address: Address,
     from_block: u64,
 ) -> Filter {
-    Filter {
-        address: session_key_validator_address.into(),
-        topics: [
-            FilterSet::default(),
-            FilterSet::default(),
-            FilterSet::default(),
-            FilterSet::default(),
-        ],
-        block_option: alloy::rpc::types::FilterBlockOption::Range {
-            from_block: Some(BlockNumberOrTag::Number(from_block)),
-            to_block: None,
-        },
-    }
+    create_logs_filter_with_range(session_key_validator_address, from_block)
 }
 
 fn parse_session_events(
@@ -84,33 +72,27 @@ fn parse_session_events(
     let session_revoked_topic =
         SessionKeyValidator::SessionRevoked::SIGNATURE_HASH;
 
-    let mut created_sessions: Vec<(FixedBytes<32>, SessionSpec)> = Vec::new();
-    let mut revoked_hashes: HashSet<FixedBytes<32>> = HashSet::new();
-
-    for log in logs {
-        if let Some(topic0) = log.inner.topics().first() {
-            if *topic0 == session_created_topic
-                && let Ok(decoded) =
-                    log.log_decode::<SessionKeyValidator::SessionCreated>()
-            {
-                let event = decoded.inner.data;
-                if event.account == account_address {
-                    let session_spec: SessionSpec = event.sessionSpec.into();
-                    created_sessions.push((event.sessionHash, session_spec));
-                }
-            } else if *topic0 == session_revoked_topic
-                && let Ok(decoded) =
-                    log.log_decode::<SessionKeyValidator::SessionRevoked>()
-            {
-                let event = decoded.inner.data;
-                if event.account == account_address {
-                    revoked_hashes.insert(event.sessionHash);
-                }
+    parse_add_remove_events(
+        logs,
+        account_address,
+        session_created_topic,
+        session_revoked_topic,
+        |event: SessionKeyValidator::SessionCreated, account_address| {
+            if event.account == account_address {
+                let session_spec: SessionSpec = event.sessionSpec.into();
+                Some((event.sessionHash, session_spec))
+            } else {
+                None
             }
-        }
-    }
-
-    (created_sessions, revoked_hashes)
+        },
+        |event: SessionKeyValidator::SessionRevoked, account_address| {
+            if event.account == account_address {
+                Some(event.sessionHash)
+            } else {
+                None
+            }
+        },
+    )
 }
 
 pub fn filter_active_sessions(
@@ -162,7 +144,7 @@ mod tests {
     };
     use alloy::{
         primitives::{FixedBytes, U256, Uint, address},
-        rpc::types::FilterBlockOption,
+        rpc::types::{BlockNumberOrTag, FilterBlockOption, FilterSet},
     };
     use std::{collections::HashSet, sync::Arc};
 

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

@@ -1,10 +1,23 @@
+pub mod active;
+pub mod add;
+pub mod remove;
+
 use crate::erc4337::account::modular_smart_account::signers::STUB_PRIVATE_KEY;
 use alloy::{
     primitives::{Address, Bytes, FixedBytes},
     signers::{SignerSync, local::PrivateKeySigner},
+    sol,
 };
 use std::str::FromStr;
 
+sol!(
+    #[sol(rpc)]
+    #[derive(Debug, Default)]
+    #[allow(missing_docs)]
+    EOAKeyValidator,
+    "../../../../../../packages/erc4337-contracts/out/EOAKeyValidator.sol/EOAKeyValidator.json"
+);
+
 pub fn stub_signature_eoa(eoa_validator: Address) -> eyre::Result<Bytes> {
     let hash = FixedBytes::default();
     let private_key_hex = STUB_PRIVATE_KEY;

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

@@ -0,0 +1,82 @@
+use crate::{
+    config::contracts::Contracts,
+    erc4337::account::modular_smart_account::{
+        signers::eoa::EOAKeyValidator,
+        utils::{
+            calculate_from_block, create_logs_filter_with_range,
+            parse_add_remove_events,
+        },
+    },
+};
+use alloy::{
+    primitives::Address, providers::Provider, rpc::types::Log,
+    sol_types::SolEvent,
+};
+use std::collections::HashSet;
+
+pub async fn get_active_owners<P>(
+    account_address: Address,
+    provider: P,
+    contracts: Contracts,
+) -> eyre::Result<Vec<Address>>
+where
+    P: Provider + Send + Sync + Clone,
+{
+    let eoa_validator_address = contracts.eoa_validator;
+
+    let from_block = {
+        let current_block = provider.get_block_number().await?;
+        calculate_from_block(current_block)
+    };
+
+    let filter =
+        create_logs_filter_with_range(eoa_validator_address, from_block);
+
+    let all_logs = provider.get_logs(&filter).await?;
+
+    let (added_signers, removed_signers) =
+        parse_eoa_events(all_logs, account_address);
+
+    let active_signers = filter_active_signers(added_signers, removed_signers);
+
+    Ok(active_signers)
+}
+
+fn parse_eoa_events(
+    logs: Vec<Log>,
+    account_address: Address,
+) -> (Vec<Address>, HashSet<Address>) {
+    let owner_added_topic = EOAKeyValidator::OwnerAdded::SIGNATURE_HASH;
+    let owner_removed_topic = EOAKeyValidator::OwnerRemoved::SIGNATURE_HASH;
+
+    parse_add_remove_events(
+        logs,
+        account_address,
+        owner_added_topic,
+        owner_removed_topic,
+        |event: EOAKeyValidator::OwnerAdded, account_address| {
+            if event.smartAccount == account_address {
+                Some(event.owner)
+            } else {
+                None
+            }
+        },
+        |event: EOAKeyValidator::OwnerRemoved, account_address| {
+            if event.smartAccount == account_address {
+                Some(event.owner)
+            } else {
+                None
+            }
+        },
+    )
+}
+
+fn filter_active_signers(
+    added_signers: Vec<Address>,
+    removed_signers: HashSet<Address>,
+) -> Vec<Address> {
+    added_signers
+        .into_iter()
+        .filter(|signer| !removed_signers.contains(signer))
+        .collect()
+}

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

@@ -0,0 +1,64 @@
+use crate::erc4337::{
+    account::{
+        erc7579::{Execution, calls::encode_calls},
+        modular_smart_account::{
+            send::{SendParams, send_transaction},
+            signers::eoa::EOAKeyValidator,
+        },
+    },
+    bundler::pimlico::client::BundlerClient,
+    signer::Signer,
+};
+use alloy::{
+    primitives::{Address, Bytes, U256},
+    providers::Provider,
+    sol_types::SolCall,
+};
+
+pub async fn add_owner<P>(
+    account_address: Address,
+    new_owner: Address,
+    entry_point_address: Address,
+    eoa_validator_address: Address,
+    bundler_client: BundlerClient,
+    provider: P,
+    signer: Signer,
+) -> eyre::Result<()>
+where
+    P: Provider + Send + Sync + Clone,
+{
+    let call_data = add_owner_call_data(new_owner, eoa_validator_address);
+
+    send_transaction(SendParams {
+        account: account_address,
+        entry_point: entry_point_address,
+        factory_payload: None,
+        call_data,
+        nonce_key: None,
+        paymaster: None,
+        bundler_client,
+        provider,
+        signer,
+    })
+    .await?;
+
+    Ok(())
+}
+
+fn add_owner_call_data(
+    new_owner: Address,
+    eoa_validator_address: Address,
+) -> Bytes {
+    let add_owner_calldata =
+        EOAKeyValidator::addOwnerCall { owner: new_owner }.abi_encode().into();
+
+    let call = {
+        let target = eoa_validator_address;
+        let value = U256::from(0);
+        let data = add_owner_calldata;
+        Execution { target, value, data }
+    };
+
+    let calls = vec![call];
+    encode_calls(calls).into()
+}