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": "0x47e179ec197488593b187f80a00eb0da91f1b9d0b13f8733639f19c30a34926a"
   }
 }

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

@@ -20,7 +20,7 @@ pub async fn deploy_contracts_and_update_example_configs(
     println!("  ExampleAuthServerPaymaster: {}", contracts.account_paymaster);
     println!("  Recovery: {}", contracts.recovery);
 
-    let deploy_wallet = Some(DeployWallet::random());
+    let deploy_wallet = Some(DeployWallet::rich_wallet());
     let config = Config::new(contracts, node_url.clone(), deploy_wallet);
 
     for path in config_paths {

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

@@ -2,9 +2,11 @@ mod balance;
 mod deployment;
 mod fetch;
 mod fund;
+mod owners;
 mod send;
 mod session;
 mod transaction;
+mod validators;
 
 #[derive(Debug, Clone, uniffi::Record)]
 pub struct Account {

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

@@ -1,14 +1,24 @@
 use crate::config;
+use sdk::api::{
+    account::{
+        passkey::{
+            passkey_parameters::PasskeyParameters as SdkPasskeyParameters,
+            rp_id::{AndroidRpId as SdkAndroidRpId, RpId as SdkRpId},
+        },
+        session::decode_session_config,
+    },
+    utils::parse_address,
+};
 
 #[derive(Debug, uniffi::Record)]
 pub struct AndroidRpId {
     pub origin: String,
     pub rp_id: String,
 }
 
-impl From<AndroidRpId> for sdk::api::account::deployment::AndroidRpId {
+impl From<AndroidRpId> for SdkAndroidRpId {
     fn from(android_rp_id: AndroidRpId) -> Self {
-        sdk::api::account::deployment::AndroidRpId {
+        SdkAndroidRpId {
             origin: android_rp_id.origin,
             rp_id: android_rp_id.rp_id,
         }
@@ -45,16 +55,12 @@ impl RpId {
     }
 }
 
-impl From<RpId> for sdk::api::account::deployment::RpId {
+impl From<RpId> for SdkRpId {
     fn from(rp_id: RpId) -> Self {
         match rp_id {
-            RpId::Apple(rp_id) => {
-                sdk::api::account::deployment::RpId::Apple(rp_id)
-            }
+            RpId::Apple(rp_id) => SdkRpId::Apple(rp_id),
             RpId::Android(android_rp_id) => {
-                sdk::api::account::deployment::RpId::Android(
-                    android_rp_id.into(),
-                )
+                SdkRpId::Android(android_rp_id.into())
             }
         }
     }
@@ -68,11 +74,9 @@ pub struct PasskeyParameters {
     pub rp_id: RpId,
 }
 
-impl From<PasskeyParameters>
-    for sdk::api::account::deployment::PasskeyParameters
-{
+impl From<PasskeyParameters> for SdkPasskeyParameters {
     fn from(passkey_parameters: PasskeyParameters) -> Self {
-        sdk::api::account::deployment::PasskeyParameters {
+        SdkPasskeyParameters {
             credential_raw_attestation_object: passkey_parameters
                 .credential_raw_attestation_object,
             credential_raw_client_data_json: passkey_parameters
@@ -103,15 +107,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 +160,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/owners.rs

@@ -0,0 +1,45 @@
+use crate::config;
+use sdk::api::{
+    account::owners::is_k1_owner as is_k1_owner_sdk, utils::parse_address,
+};
+
+#[derive(Debug, uniffi::Record)]
+pub struct IsK1OwnerArgs {
+    pub account: String,
+    pub owner_address: String,
+}
+
+#[derive(Debug, thiserror::Error, uniffi::Error)]
+pub enum IsK1OwnerError {
+    #[error("{0}")]
+    IsK1Owner(String),
+    #[error("Invalid address: {0}")]
+    InvalidAccountAddress(String),
+    #[error("Invalid owner address: {0}")]
+    InvalidOwnerAddress(String),
+    #[error("Invalid config: {0}")]
+    InvalidConfig(String),
+}
+
+#[uniffi::export(async_runtime = "tokio")]
+pub async fn is_k1_owner(
+    args: IsK1OwnerArgs,
+    config: config::Config,
+) -> Result<bool, IsK1OwnerError> {
+    let account = parse_address(&args.account)
+        .map_err(|e| IsK1OwnerError::InvalidAccountAddress(e.to_string()))?;
+    let owner_address = parse_address(&args.owner_address)
+        .map_err(|e| IsK1OwnerError::InvalidOwnerAddress(e.to_string()))?;
+    let result = is_k1_owner_sdk(
+        account,
+        owner_address,
+        &(config.try_into()
+            as Result<sdk::config::Config, config::ConfigError>)
+            .map_err(|e: config::ConfigError| {
+                IsK1OwnerError::InvalidConfig(e.to_string())
+            })?,
+    )
+    .await
+    .map_err(|e| IsK1OwnerError::IsK1Owner(e.to_string()))?;
+    Ok(result)
+}

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,
+    })
+}