feat: sessions

Author: jackpooleyml

packages/sdk-platforms/react-native/react-native-zksync-sso/example/src/config.json

@@ -8,6 +8,6 @@
   },
   "nodeUrl": "http://localhost:8011/",
   "deployWallet": {
-    "privateKeyHex": "2544c43e10c09cd9bc1ecd30b931545eaf08b01811156714cae8062cbaaa0186"
+    "privateKeyHex": "f1010e4119b26f6ceccb5a42b8dc6b2a10650d4f5943e4eb8285951aba264b6c"
   }
 }

packages/sdk-platforms/rust/zksync-sso/Cargo.toml

@@ -5,7 +5,7 @@ resolver = "2"
 [workspace.package]
 version = "0.0.1"
 edition = "2024"
-rust-version = "1.86"
+rust-version = "1.87"
 license = "Apache-2.0"
 
 [profile.release]
@@ -33,6 +33,9 @@ alloy-zksync = { version = "0.12.5" }
 openssl = "0.10.71"
 openssl-sys = "0.9.106"
 
+# Signer
+k256 = { version = "0.13", default-features = false, features = ["ecdsa"] }
+
 # Passkey support
 passkey-types = { git = "https://github.com/jackpooleyml/passkey-rs", branch = "validate-credential", features = [
     "testable",
@@ -59,8 +62,7 @@ async-trait = "0.1"
 futures = "0.3"
 
 # Uniffi
-# uniffi = { version = "0.29" }
-uniffi = { git = "https://github.com/mozilla/uniffi-rs", rev = "6c3f9b2376cb4b622247e4ae94eabe8d426cc5c5" }
+uniffi = { version = "0.29" }
 
 # Error handling
 eyre = "0.6"
@@ -69,13 +71,26 @@ thiserror = "2.0.11"
 # Randomness
 rand = "0.9"
 
-# Hex
-hex = "0.4"
+# Hashing
+sha2 = "0.10"
+sha3 = "0.10.8"
+
+# passkey support
+coset = "0.3"
+
+# CBOR
+serde_cbor = "0.11"
+ciborium = { version = "^0.2.1", default-features = false }
+ciborium-io = { version = "^0.2.0", features = ["alloc"] }
 
 # Base64
 base64-url = "3.0.0"
 base64 = "0.21"
 
+# DER
+der = { version = "0.7", features = ["alloc"] }
+der_derive = "0.7"
+
 # i18n
 icu = { version = "1.5.0", features = ["default", "serde", "std"] }
 icu_decimal = { version = "1.5.0", features = ["default"] }
@@ -89,3 +104,7 @@ log = "0.4"
 android_logger = { version = "0.15" }
 # Logging for Apple platforms
 oslog = "0.2"
+
+# Mocking
+mockall = { version = "0.13.1" }
+scopeguard = { version = "1.2.0" }

packages/sdk-platforms/rust/zksync-sso/TODO.md

@@ -1,5 +1,3 @@
 # TODOs
 
 [ ] Move `fund` method to seperate module
-[ ] Consider using the `log` crate for debug logging
-[ ] Change passkey attestation to `direct`

packages/sdk-platforms/rust/zksync-sso/crates/cli/src/deploy_contracts.rs

@@ -3,14 +3,14 @@ use sdk::{
     api::utils::deploy_contracts,
     config::{Config, deploy_wallet::DeployWallet},
 };
-use std::{fs, path::PathBuf};
+use std::{fs, path::PathBuf, process::Command};
 use url::Url;
 
 pub async fn deploy_contracts_and_update_example_configs(
     node_url: Url,
     config_paths: Vec<PathBuf>,
 ) -> Result<()> {
-    println!("Deploying contracts to node: {}", node_url);
+    println!("Deploying contracts to node: {node_url}");
 
     let contracts = deploy_contracts(node_url.clone()).await?;
     println!("Contracts deployed successfully:");
@@ -20,9 +20,8 @@ pub async fn deploy_contracts_and_update_example_configs(
     println!("  ExampleAuthServerPaymaster: {}", contracts.account_paymaster);
     println!("  Recovery: {}", contracts.recovery);
 
-    let deploy_wallet = DeployWallet::random();
-    let config =
-        Config::new(contracts.clone(), node_url.clone(), deploy_wallet);
+    let deploy_wallet = Some(DeployWallet::random());
+    let config = Config::new(contracts, node_url.clone(), deploy_wallet);
 
     for path in config_paths {
         let platform_name = path
@@ -40,15 +39,15 @@ fn write_and_verify_config(
     config_path: &PathBuf,
     platform_name: &str,
 ) -> Result<()> {
-    println!("\nWriting {} config to path: {:?}", platform_name, config_path);
+    println!("\nWriting {platform_name} config to path: {config_path:?}");
     config.write_json(config_path)?;
 
-    println!("\nVerifying written {} config:", platform_name);
+    println!("\nVerifying written {platform_name} config:");
     let written_json = fs::read_to_string(config_path)?;
-    println!("Written {} JSON content:\n{}", platform_name, written_json);
+    println!("Written {platform_name} JSON content:\n{written_json}");
 
     let written_config: Config = serde_json::from_str(&written_json)?;
-    println!("\nParsed {} config verification:", platform_name);
+    println!("\nParsed {platform_name} config verification:");
     println!("  Node URL: {}", written_config.node_url);
     println!("  AAFactory: {}", written_config.contracts.account_factory);
     println!("  WebAuthValidator: {}", written_config.contracts.passkey);
@@ -59,8 +58,46 @@ fn write_and_verify_config(
     );
     println!("  Recovery: {}", written_config.contracts.recovery);
     println!(
-        "\nSuccessfully updated and verified {} config values",
-        platform_name
+        "\nSuccessfully updated and verified {platform_name} config values"
     );
     Ok(())
 }
+
+pub async fn build_and_deploy_contracts_and_update_example_configs(
+    node_url: Url,
+    config_paths: Option<Vec<PathBuf>>,
+) -> Result<()> {
+    println!("Building contracts...");
+
+    let contracts_dir = std::env::current_dir()?
+        .parent()
+        .and_then(|p| p.parent())
+        .and_then(|p| p.parent())
+        .and_then(|p| p.parent())
+        .map(|p| p.join("packages").join("contracts"))
+        .ok_or_else(|| eyre::eyre!("Could not find contracts directory"))?;
+
+    let output = Command::new("pnpm")
+        .arg("build")
+        .current_dir(&contracts_dir)
+        .output()?;
+
+    if !output.status.success() {
+        return Err(eyre::eyre!(
+            "Failed to build contracts: {}",
+            String::from_utf8_lossy(&output.stderr)
+        ));
+    }
+
+    println!("Contracts built successfully!");
+
+    let paths_to_write = match config_paths {
+        Some(paths) if !paths.is_empty() => paths,
+        _ => vec![
+            Config::get_default_swift_config_path(),
+            Config::get_default_react_native_config_path(),
+        ],
+    };
+
+    deploy_contracts_and_update_example_configs(node_url, paths_to_write).await
+}

packages/sdk-platforms/rust/zksync-sso/crates/cli/src/handle_cli.rs

@@ -1,4 +1,4 @@
-use crate::handle_cli::Commands::DeployContracts;
+use crate::handle_cli::Commands::{BuildAndDeployContracts, DeployContracts};
 use clap::{Parser, Subcommand};
 use sdk::config::Config;
 use std::path::PathBuf;
@@ -19,6 +19,16 @@ enum Commands {
         #[arg(long, default_value = "http://localhost:8011/")]
         node_url: Url,
 
+        /// Paths to write the config files to. If not provided or if empty, defaults to Swift and React Native example paths.
+        #[arg(long)]
+        config_paths: Option<Vec<PathBuf>>,
+    },
+    /// Build contracts and then deploy them with config updates
+    BuildAndDeployContracts {
+        /// The URL of the zkSync node (defaults to http://localhost:8011/)
+        #[arg(long, default_value = "http://localhost:8011/")]
+        node_url: Url,
+
         /// Paths to write the config files to. If not provided or if empty, defaults to Swift and React Native example paths.
         #[arg(long)]
         config_paths: Option<Vec<PathBuf>>,
@@ -43,6 +53,13 @@ pub async fn handle_cli() -> eyre::Result<()> {
             )
             .await?;
         }
+        BuildAndDeployContracts { node_url, config_paths } => {
+            super::deploy_contracts::build_and_deploy_contracts_and_update_example_configs(
+                node_url,
+                config_paths,
+            )
+            .await?;
+        }
     }
 
     Ok(())

packages/sdk-platforms/rust/zksync-sso/crates/ffi/Cargo.toml

@@ -32,9 +32,6 @@ log.workspace = true
 rand.workspace = true
 base64.workspace = true
 
-# Hex encoding/decoding
-hex.workspace = true
-
 # Target-specific dependencies - Android
 [target.'cfg(target_os = "android")'.dependencies]
 android_logger.workspace = true

packages/sdk-platforms/rust/zksync-sso/crates/ffi/build-swift-framework-ios-ci.sh

@@ -130,6 +130,6 @@ sed -i '' 's/filenonisolated(unsafe) private let uniffiContinuationHandleMap = U
 cat <<EOT >> "$WRAPPER_PATH/$FRAMEWORK_LIBRARY_NAME.swift"
 
 extension Config: Codable {}
-extension PasskeyContracts: Codable {}
+extension SsoContracts: Codable {}
 extension DeployWallet: Codable {}
 EOT

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

@@ -3,6 +3,8 @@ mod deployment;
 mod fetch;
 mod fund;
 mod send;
+mod session;
+mod transaction;
 
 #[derive(Debug, Clone, uniffi::Record)]
 pub struct Account {

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

@@ -1,22 +1,14 @@
 use crate::{
+    account::transaction::Transaction,
     config,
     native_apis::{PasskeyAuthenticator, PasskeyAuthenticatorAsync},
 };
 use futures::future::BoxFuture;
 use log::debug;
-use sdk::api::utils::parse_address;
 use std::sync::Arc;
 
 pub mod prepare;
 
-#[derive(Debug, uniffi::Record)]
-pub struct Transaction {
-    pub from: String,
-    pub to: Option<String>,
-    pub value: Option<String>,
-    pub input: Option<String>,
-}
-
 #[derive(Debug, uniffi::Record)]
 pub struct SendTransactionResult {
     pub tx_hash: String,
@@ -31,27 +23,6 @@ pub enum SendTransactionError {
     InvalidAddress(String),
 }
 
-impl TryFrom<Transaction> for sdk::api::account::transaction::Transaction {
-    type Error = SendTransactionError;
-
-    fn try_from(tx: Transaction) -> Result<Self, Self::Error> {
-        Ok(Self {
-            from: parse_address(&tx.from).map_err(|e| {
-                SendTransactionError::InvalidAddress(e.to_string())
-            })?,
-            to: tx.to.and_then(|to| {
-                parse_address(&to)
-                    .map_err(|e| {
-                        SendTransactionError::InvalidAddress(e.to_string())
-                    })
-                    .ok()
-            }),
-            value: tx.value,
-            input: tx.input,
-        })
-    }
-}
-
 impl From<sdk::api::account::send::SendTransactionResult>
     for SendTransactionResult
 {
@@ -73,20 +44,23 @@ pub async fn send_transaction(
     authenticator: Arc<dyn PasskeyAuthenticator + 'static>,
     config: config::Config,
 ) -> Result<SendTransactionResult, SendTransactionError> {
-    debug!("XDB send_transaction - transaction: {:?}", transaction);
+    debug!("XDB send_transaction - transaction: {transaction:?}");
     let tx: sdk::api::account::transaction::Transaction =
-        transaction.try_into()?;
+        transaction.try_into().map_err(
+            |e: crate::account::transaction::TransactionConversionError| {
+                SendTransactionError::SendTransaction(e.to_string())
+            },
+        )?;
 
-    debug!("XDB send_transaction - tx: {:?}", tx);
+    debug!("XDB send_transaction - tx: {tx:?}");
 
     let authenticator = authenticator.clone();
     let sign_message: SignFn = Box::new(
         move |message: &[u8]| -> BoxFuture<'static, Result<Vec<u8>, String>> {
             let message_owned = message.to_vec();
             let auth = authenticator.clone();
             debug!(
-                "XDB send_transaction - sign_message - message_owned: {:?}",
-                message_owned
+                "XDB send_transaction - sign_message - message_owned: {message_owned:?}"
             );
             Box::pin(async move {
                 debug!(
@@ -117,14 +91,15 @@ pub async fn send_transaction_async_signer(
     authenticator: Arc<dyn PasskeyAuthenticatorAsync + 'static>,
     config: config::Config,
 ) -> Result<SendTransactionResult, SendTransactionError> {
-    debug!(
-        "XDB send_transaction_async_signer - transaction: {:?}",
-        transaction
-    );
+    debug!("XDB send_transaction_async_signer - transaction: {transaction:?}");
     let tx: sdk::api::account::transaction::Transaction =
-        transaction.try_into()?;
+        transaction.try_into().map_err(
+            |e: crate::account::transaction::TransactionConversionError| {
+                SendTransactionError::SendTransaction(e.to_string())
+            },
+        )?;
 
-    debug!("XDB send_transaction_async_signer - tx: {:?}", tx);
+    debug!("XDB send_transaction_async_signer - tx: {tx:?}");
 
     let authenticator = authenticator.clone();
     let sign_message: SignFn = Box::new(

packages/sdk-platforms/rust/zksync-sso/crates/ffi/src/account/send/prepare.rs

@@ -1,10 +1,9 @@
-use super::SendTransactionError::{
-    InvalidAddress as SendInvalidAddress,
-    SendTransaction as SendSendTransaction,
-};
 use crate::{
-    account::send::prepare::PrepareTransactionError::{
-        InvalidAddress, PrepareTransaction,
+    account::{
+        send::prepare::PrepareTransactionError::{
+            InvalidAddress, PrepareTransaction,
+        },
+        transaction::Transaction,
     },
     config,
 };
@@ -54,14 +53,13 @@ pub enum PrepareTransactionError {
 
 #[uniffi::export(async_runtime = "tokio")]
 pub async fn prepare_send_transaction(
-    transaction: super::Transaction,
+    transaction: Transaction,
     config: config::Config,
 ) -> Result<PreparedTransaction, PrepareTransactionError> {
     let transaction: sdk::api::account::transaction::Transaction =
-        transaction.try_into().map_err(|e| -> PrepareTransactionError {
+        transaction.try_into().map_err(|e: crate::account::transaction::TransactionConversionError| -> PrepareTransactionError {
             match e {
-                SendInvalidAddress(e) => InvalidAddress(e),
-                SendSendTransaction(e) => PrepareTransaction(e),
+                crate::account::transaction::TransactionConversionError::InvalidAddress(e) => InvalidAddress(e),
             }
         })?;