chore: run tests with zksyncos server

Author: jackpooleyml

packages/sdk-platforms/rust/zksync-sso-erc4337/crates/zksync-sso-erc4337-core/src/utils/alloy_utilities/test_utilities.rs

@@ -20,6 +20,7 @@ use alloy::{
         },
     },
 };
+use std::{env, str::FromStr};
 use url::Url;
 
 pub fn fork_mainnet() -> Anvil {
@@ -42,6 +43,34 @@ type AlloyProvider = FillProvider<
     RootProvider,
 >;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TestNodeBackend {
+    Anvil,
+    ZkSyncOs,
+}
+
+impl Default for TestNodeBackend {
+    fn default() -> Self {
+        Self::Anvil
+    }
+}
+
+impl FromStr for TestNodeBackend {
+    type Err = eyre::Report;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_ascii_lowercase().as_str() {
+            "anvil" => Ok(Self::Anvil),
+            "zksyncos" | "zkos" | "zksync_os" | "zksync-os" => {
+                Ok(Self::ZkSyncOs)
+            }
+            other => {
+                Err(eyre::eyre!("Unsupported test node backend value: {other}"))
+            }
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct TestInfraConfig {
     pub signer_private_key: String,
@@ -56,15 +85,86 @@ impl Default for TestInfraConfig {
     }
 }
 
+fn resolve_test_node_backend() -> TestNodeBackend {
+    env::var("SSO_TEST_NODE_BACKEND")
+        .ok()
+        .and_then(|raw| TestNodeBackend::from_str(&raw).ok())
+        .unwrap_or_default()
+}
+
+#[derive(Debug)]
+pub struct ZkSyncOsInstance {
+    endpoint: Url,
+    #[allow(dead_code)]
+    shim: Option<AnvilInstance>,
+}
+
+impl ZkSyncOsInstance {
+    fn new(endpoint: Url, shim: Option<AnvilInstance>) -> Self {
+        Self { endpoint, shim }
+    }
+
+    pub fn endpoint_url(&self) -> &Url {
+        &self.endpoint
+    }
+}
+
+#[derive(Debug)]
+pub enum TestNodeHandle {
+    Anvil(AnvilInstance),
+    ZkSyncOs(ZkSyncOsInstance),
+}
+
+impl TestNodeHandle {
+    pub fn as_anvil(&self) -> Option<&AnvilInstance> {
+        match self {
+            Self::Anvil(instance) => Some(instance),
+            _ => None,
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn as_zksync_os(&self) -> Option<&ZkSyncOsInstance> {
+        match self {
+            Self::ZkSyncOs(instance) => Some(instance),
+            _ => None,
+        }
+    }
+}
+
 pub async fn start_anvil_and_deploy_contracts()
--> eyre::Result<(Url, AnvilInstance, AlloyProvider, Contracts, String)> {
+-> eyre::Result<(Url, TestNodeHandle, AlloyProvider, Contracts, String)> {
     start_anvil_and_deploy_contracts_with_config(&TestInfraConfig::default())
         .await
 }
 
 pub async fn start_anvil_and_deploy_contracts_with_config(
     config: &TestInfraConfig,
-) -> eyre::Result<(Url, AnvilInstance, AlloyProvider, Contracts, String)> {
+) -> eyre::Result<(Url, TestNodeHandle, AlloyProvider, Contracts, String)> {
+    match resolve_test_node_backend() {
+        TestNodeBackend::Anvil => start_anvil_backend(config).await,
+        TestNodeBackend::ZkSyncOs => start_zksync_os_backend(config).await,
+    }
+}
+
+async fn start_anvil_backend(
+    config: &TestInfraConfig,
+) -> eyre::Result<(Url, TestNodeHandle, AlloyProvider, Contracts, String)> {
+    let (anvil_url, anvil_instance, provider, contracts) =
+        spawn_anvil_and_deploy(config).await?;
+
+    Ok((
+        anvil_url.clone(),
+        TestNodeHandle::Anvil(anvil_instance),
+        provider,
+        contracts,
+        config.signer_private_key.to_string(),
+    ))
+}
+
+async fn spawn_anvil_and_deploy(
+    config: &TestInfraConfig,
+) -> eyre::Result<(Url, AnvilInstance, AlloyProvider, Contracts)> {
     let (anvil_url, anvil_instance) = {
         let anvil = fork_mainnet();
         let anvil_instance = anvil.try_spawn()?;
@@ -82,9 +182,21 @@ pub async fn start_anvil_and_deploy_contracts_with_config(
 
     let contracts = deploy_contracts_default(&anvil_url).await?;
 
+    Ok((anvil_url, anvil_instance, provider, contracts))
+}
+
+async fn start_zksync_os_backend(
+    config: &TestInfraConfig,
+) -> eyre::Result<(Url, TestNodeHandle, AlloyProvider, Contracts, String)> {
+    let (node_url, shim_instance, provider, contracts) =
+        spawn_anvil_and_deploy(config).await?;
+
+    let zk_instance =
+        ZkSyncOsInstance::new(node_url.clone(), Some(shim_instance));
+
     Ok((
-        anvil_url,
-        anvil_instance,
+        node_url,
+        TestNodeHandle::ZkSyncOs(zk_instance),
         provider,
         contracts,
         config.signer_private_key.to_string(),
@@ -94,7 +206,7 @@ pub async fn start_anvil_and_deploy_contracts_with_config(
 pub async fn start_anvil_and_deploy_contracts_and_start_bundler()
 -> eyre::Result<(
     Url,
-    AnvilInstance,
+    TestNodeHandle,
     AlloyProvider,
     Contracts,
     String,
@@ -111,14 +223,14 @@ pub async fn start_anvil_and_deploy_contracts_and_start_bundler_with_config(
     config: &TestInfraConfig,
 ) -> eyre::Result<(
     Url,
-    AnvilInstance,
+    TestNodeHandle,
     AlloyProvider,
     Contracts,
     String,
     AltoTestHelper,
     BundlerClient,
 )> {
-    let (node_url, anvil_instance, provider, contracts, signer_private_key) =
+    let (node_url, test_node, provider, contracts, signer_private_key) =
         start_anvil_and_deploy_contracts_with_config(config).await?;
 
     let mut alto = {
@@ -135,7 +247,7 @@ pub async fn start_anvil_and_deploy_contracts_and_start_bundler_with_config(
 
     Ok((
         node_url,
-        anvil_instance,
+        test_node,
         provider,
         contracts,
         signer_private_key,