feat: sessions swift demo

Author: jackpooleyml

.github/workflows/ci-swift.yml

@@ -99,6 +99,7 @@ jobs:
           fi
           echo "Simulator UDID: $UDID"
           echo "SIMULATOR_UDID=$UDID" >> $GITHUB_ENV
+        
       - name: Install swiftformat
         run: brew install swiftformat
 

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

@@ -1,13 +1,13 @@
 {
   "contracts": {
-    "accountFactory": "0xda635aa336e8f5c1c3c19e6a0db6d601fa1e3e05",
+    "accountFactory": "0x7452d866cdbf84762b77a99849f00c26daaf2da8",
     "passkey": "0xa472581ea2aca6e6bd8ea6cca95d3e1297aa5ae3",
-    "session": "0x6e2eef457e8a4dc33f6259ff0a933a2f94d64a8e",
-    "accountPaymaster": "0x18d0069ac0e0431f2af792ec425950427b775f1d",
-    "recovery": "0xe72da237538a1854535e9565dbee0b414f382698"
+    "session": "0x11f853c85e282a542d8ee8f9cdd8fe6ce61badf1",
+    "accountPaymaster": "0x3ec8307648f31c494caeab625e5f2c99bfbaa560",
+    "recovery": "0x3a34dab058fd71b2fb0d9d9e7d3dd205f9072fc3"
   },
   "nodeUrl": "http://localhost:8011/",
   "deployWallet": {
-    "privateKeyHex": "f1010e4119b26f6ceccb5a42b8dc6b2a10650d4f5943e4eb8285951aba264b6c"
+    "privateKeyHex": "4efff3175ef36dbca4d150b0ad168b4c7aef57f1631f4d25f7abc626d2fe9f89"
   }
 }

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

@@ -1,4 +1,6 @@
 use crate::config;
+use sdk::api::account::session::decode_session_config;
+use sdk::api::utils::parse_address;
 
 #[derive(Debug, uniffi::Record)]
 pub struct AndroidRpId {
@@ -103,15 +105,44 @@ pub enum DeployAccountError {
 
     #[error("Account already deployed")]
     AccountAlreadyDeployed,
+
+    #[error("Invalid session config: {0}")]
+    InvalidSessionConfig(String),
+
+    #[error("Invalid K1 owners: {0}")]
+    InvalidK1Owners(String),
 }
 
 #[uniffi::export(async_runtime = "tokio")]
 pub async fn deploy_account(
     passkey_parameters: PasskeyParameters,
+    initial_k1_owners: Option<Vec<String>>,
+    initial_session_config_json: Option<String>,
     config: config::Config,
 ) -> Result<super::Account, DeployAccountError> {
+    let initial_k1_owners = initial_k1_owners
+        .map(|k1_owners| {
+            k1_owners
+                .into_iter()
+                .map(|k1_owner| parse_address(&k1_owner))
+                .collect::<Result<Vec<_>, _>>()
+        })
+        .transpose()
+        .map_err(|e| DeployAccountError::InvalidK1Owners(e.to_string()))?;
+
+    let initial_session = initial_session_config_json
+        .map(|session_config| {
+            decode_session_config(&session_config).map_err(|e| {
+                DeployAccountError::InvalidSessionConfig(e.to_string())
+            })
+        })
+        .transpose()
+        .map_err(|e| DeployAccountError::InvalidSessionConfig(e.to_string()))?;
+
     sdk::api::account::deployment::deploy_account(
         passkey_parameters.into(),
+        initial_k1_owners,
+        initial_session,
         &(config.try_into()
             as Result<sdk::config::Config, config::ConfigError>)
             .map_err(|e: config::ConfigError| {
@@ -127,11 +158,34 @@ pub async fn deploy_account(
 pub async fn deploy_account_with_unique_id(
     passkey_parameters: PasskeyParameters,
     unique_account_id: String,
+    initial_k1_owners: Option<Vec<String>>,
+    initial_session_config_json: Option<String>,
     config: config::Config,
 ) -> Result<super::Account, DeployAccountError> {
+    let initial_k1_owners = initial_k1_owners
+        .map(|k1_owners| {
+            k1_owners
+                .into_iter()
+                .map(|k1_owner| parse_address(&k1_owner))
+                .collect::<Result<Vec<_>, _>>()
+        })
+        .transpose()
+        .map_err(|e| DeployAccountError::InvalidK1Owners(e.to_string()))?;
+
+    let initial_session = initial_session_config_json
+        .map(|session_config| {
+            decode_session_config(&session_config).map_err(|e| {
+                DeployAccountError::InvalidSessionConfig(e.to_string())
+            })
+        })
+        .transpose()
+        .map_err(|e| DeployAccountError::InvalidSessionConfig(e.to_string()))?;
+
     sdk::api::account::deployment::deploy_account_with_unique_id(
         passkey_parameters.into(),
         unique_account_id,
+        initial_k1_owners,
+        initial_session,
         &(config.try_into()
             as Result<sdk::config::Config, config::ConfigError>)
             .map_err(|e: config::ConfigError| {

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

@@ -1,2 +1,5 @@
 pub mod client;
 pub mod create;
+pub mod hash;
+pub mod revoke;
+pub mod state;

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

@@ -41,8 +41,10 @@ pub enum CreateSessionError {
     InvalidAddress(String),
     #[error("Invalid session config: {0}")]
     InvalidSessionConfig(String),
-    #[error("Invalid session key: {0}")]
-    InvalidSessionKey(String),
+    #[error("Invalid config: {0}")]
+    InvalidConfig(String),
+    #[error("Invalid private key: {0}")]
+    InvalidPrivateKey(String),
     #[error("Invalid paymaster: {0}")]
     InvalidPaymaster(String),
 }
@@ -68,15 +70,15 @@ pub async fn create_session(
     let args = SdkCreateSessionArgs { account, session_config, paymaster };
 
     let sign_fn = sign_fn_from_private_key_hex(owner_private_key)
-        .map_err(|e| CreateSessionError::CreateSession(e.to_string()))?;
+        .map_err(|e| CreateSessionError::InvalidPrivateKey(e.to_string()))?;
 
     let result = sdk::api::account::session::create::create_session(
         args,
         sign_fn,
         &(config.try_into()
             as Result<sdk::config::Config, config::ConfigError>)
             .map_err(|e: config::ConfigError| {
-                CreateSessionError::CreateSession(e.to_string())
+                CreateSessionError::InvalidConfig(e.to_string())
             })?,
     )
     .await

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

@@ -0,0 +1,26 @@
+use sdk::api::account::session::{
+    decode_session_config, hash::get_session_hash as sdk_get_session_hash,
+};
+
+#[derive(Debug, thiserror::Error, uniffi::Error)]
+pub enum GetSessionHashError {
+    #[error("{0}")]
+    GetSessionHash(String),
+    #[error("Invalid session config: {0}")]
+    InvalidSessionConfig(String),
+}
+
+#[uniffi::export]
+pub fn get_session_hash(
+    session_config_json: String,
+) -> Result<String, GetSessionHashError> {
+    let session_config =
+        decode_session_config(&session_config_json).map_err(|e| {
+            GetSessionHashError::InvalidSessionConfig(e.to_string())
+        })?;
+
+    let hash = sdk_get_session_hash(session_config)
+        .map_err(|e| GetSessionHashError::GetSessionHash(e.to_string()))?;
+
+    Ok(format!("{:#x}", hash.fixed_bytes()))
+}

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

@@ -0,0 +1,67 @@
+use crate::config;
+use sdk::api::{
+    account::session::revoke::RevokeSessionArgs as SdkRevokeSessionArgs,
+    utils::{parse_address, sign_fn_from_private_key_hex},
+};
+
+#[derive(Debug, uniffi::Record)]
+pub struct RevokeSessionArgs {
+    pub account: String,
+    pub session_id: String,
+    pub owner_private_key: String,
+}
+
+#[derive(Debug, uniffi::Record)]
+pub struct RevokeSessionReturnType {
+    pub transaction_receipt_json: String,
+}
+
+impl From<RevokeSessionReturnType>
+    for sdk::api::account::session::revoke::RevokeSessionReturnType
+{
+    fn from(revoke_session_return_type: RevokeSessionReturnType) -> Self {
+        sdk::api::account::session::revoke::RevokeSessionReturnType {
+            transaction_receipt_json: revoke_session_return_type
+                .transaction_receipt_json,
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error, uniffi::Error)]
+pub enum RevokeSessionError {
+    #[error("{0}")]
+    RevokeSession(String),
+    #[error("Invalid address: {0}")]
+    InvalidAddress(String),
+}
+
+#[uniffi::export(async_runtime = "tokio")]
+pub async fn revoke_session(
+    args: RevokeSessionArgs,
+    config: config::Config,
+) -> Result<RevokeSessionReturnType, RevokeSessionError> {
+    let account_address = parse_address(&args.account)
+        .map_err(|e| RevokeSessionError::InvalidAddress(e.to_string()))?;
+
+    let sign_fn = sign_fn_from_private_key_hex(&args.owner_private_key)
+        .map_err(|e| RevokeSessionError::RevokeSession(e.to_string()))?;
+
+    let sdk_args = SdkRevokeSessionArgs { session_id: args.session_id };
+
+    let result = sdk::api::account::session::revoke::revoke_session(
+        sdk_args,
+        account_address,
+        sign_fn,
+        &(config.try_into()
+            as Result<sdk::config::Config, config::ConfigError>)
+            .map_err(|e: config::ConfigError| {
+                RevokeSessionError::RevokeSession(e.to_string())
+            })?,
+    )
+    .await
+    .map_err(|e| RevokeSessionError::RevokeSession(e.to_string()))?;
+
+    Ok(RevokeSessionReturnType {
+        transaction_receipt_json: result.transaction_receipt_json,
+    })
+}

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

@@ -0,0 +1,60 @@
+use crate::config;
+use sdk::api::{
+    account::session::{
+        decode_session_config,
+        state::GetSessionStateArgs as SdkGetSessionStateArgs,
+    },
+    utils::parse_address,
+};
+
+#[derive(Debug, uniffi::Record)]
+pub struct GetSessionStateArgs {
+    pub account: String,
+    pub session_config: String,
+}
+
+#[derive(Debug, uniffi::Record)]
+pub struct GetSessionStateReturnType {
+    pub session_state_json: String,
+}
+
+#[derive(Debug, thiserror::Error, uniffi::Error)]
+pub enum GetSessionStateError {
+    #[error("{0}")]
+    GetSessionState(String),
+    #[error("Invalid address: {0}")]
+    InvalidAddress(String),
+    #[error("Invalid session config: {0}")]
+    InvalidSessionConfig(String),
+}
+
+#[uniffi::export(async_runtime = "tokio")]
+pub async fn get_session_state(
+    args: GetSessionStateArgs,
+    config: config::Config,
+) -> Result<GetSessionStateReturnType, GetSessionStateError> {
+    let session_config =
+        decode_session_config(&args.session_config).map_err(|e| {
+            GetSessionStateError::InvalidSessionConfig(e.to_string())
+        })?;
+    let account = parse_address(&args.account)
+        .map_err(|e| GetSessionStateError::InvalidAddress(e.to_string()))?;
+
+    let sdk_args = SdkGetSessionStateArgs { account, session_config };
+
+    let result = sdk::api::account::session::state::get_session_state(
+        sdk_args,
+        &(config.try_into()
+            as Result<sdk::config::Config, config::ConfigError>)
+            .map_err(|e: config::ConfigError| {
+                GetSessionStateError::GetSessionState(e.to_string())
+            })?,
+    )
+    .await
+    .map_err(|e| GetSessionStateError::GetSessionState(e.to_string()))?;
+
+    let session_state_json = serde_json::to_string(&result.session_state)
+        .map_err(|e| GetSessionStateError::GetSessionState(e.to_string()))?;
+
+    Ok(GetSessionStateReturnType { session_state_json })
+}

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

@@ -1,3 +1,4 @@
+use crate::utils::session::session_lib::session_spec::SessionSpec;
 use crate::{
     client::passkey::{
         account_factory::{AccountParams, create_account},
@@ -56,6 +57,8 @@ pub struct DeployedAccountDetails {
 
 pub async fn deploy_account(
     passkey_parameters: PasskeyParameters,
+    initial_k1_owners: Option<Vec<Address>>,
+    initial_session: Option<SessionSpec>,
     config: &Config,
 ) -> eyre::Result<DeployedAccountDetails> {
     debug!("XDB deploy_account - passkey_parameters: {passkey_parameters:?}");
@@ -78,6 +81,8 @@ pub async fn deploy_account(
             expected_origin: Some(parsed_params.expected_origin),
             contracts: config.contracts,
             paymaster,
+            initial_k1_owners,
+            initial_session,
             ..Default::default()
         };
 
@@ -107,6 +112,8 @@ pub async fn deploy_account(
 pub async fn deploy_account_with_unique_id(
     passkey_parameters: PasskeyParameters,
     unique_account_id: String,
+    initial_k1_owners: Option<Vec<Address>>,
+    initial_session: Option<SessionSpec>,
     config: &Config,
 ) -> eyre::Result<DeployedAccountDetails> {
     let parsed_params = parse_passkey_parameters(&passkey_parameters).await?;
@@ -127,6 +134,8 @@ pub async fn deploy_account_with_unique_id(
         &AccountParams {
             passkey_expected_origin: parsed_params.expected_origin,
         },
+        initial_k1_owners,
+        initial_session,
         paymaster,
         config,
     )

packages/sdk-platforms/rust/zksync-sso/crates/sdk/src/client/ecdsa/actions/deploy.rs

@@ -323,6 +323,9 @@ mod tests {
     #[tokio::test]
     async fn test_deploy_account_with_initial_k1_owners_and_send_transaction()
     -> Result<()> {
+        // Add delay to avoid test run timing out
+        tokio::time::sleep(tokio::time::Duration::from_secs(15)).await;
+
         // Arrange
         let (anvil_zksync, config, _) =
             spawn_node_and_deploy_contracts().await?;