@dynamic-labs/ethereum-aa-zksync 4.18.6 → 4.18.8

package/CHANGELOG.md

@@ -1,4 +1,31 @@
 
+### [4.18.8](https://github.com/dynamic-labs/dynamic-auth/compare/v4.18.7...v4.18.8) (2025-05-22)
+
+### Bug Fixes
+
+* allow closing widget right after login ([#8760](https://github.com/dynamic-labs/dynamic-auth/issues/8760)) ([a9afff0](https://github.com/dynamic-labs/dynamic-auth/commit/a9afff0ab2a685853b39aed88e10bf1e700e4c8c))
+* user wallets turning empty when linking new wallets ([#8775](https://github.com/dynamic-labs/dynamic-auth/issues/8775)) ([04215f5](https://github.com/dynamic-labs/dynamic-auth/commit/04215f5307e16ec4e1a7ff235a0d7df2340c3447))
+
+### [4.18.7](https://github.com/dynamic-labs/dynamic-auth/compare/v4.18.6...v4.18.7) (2025-05-21)
+
+
+### Features
+
+* add zero dev kernel migration to v3.3 ([#8747](https://github.com/dynamic-labs/dynamic-auth/issues/8747)) ([ce10ef8](https://github.com/dynamic-labs/dynamic-auth/commit/ce10ef85d12452c2c21758c909f1e28f9fa5fbae))
+* bump [@dynamic-labs-wallet](https://github.com/dynamic-labs-wallet) to v0.0.74 ([#8746](https://github.com/dynamic-labs/dynamic-auth/issues/8746)) ([98e3a0b](https://github.com/dynamic-labs/dynamic-auth/commit/98e3a0b845e7d6c34a2c748597198825713f4bcf))
+* support kernel versio 0.3.2 and 0.3.3 ([#8738](https://github.com/dynamic-labs/dynamic-auth/issues/8738)) ([1115830](https://github.com/dynamic-labs/dynamic-auth/commit/1115830966318960d39a497c8b29188d9d9a447f))
+* v3 solana confirmation ui ([#8731](https://github.com/dynamic-labs/dynamic-auth/issues/8731)) ([cfa5ba0](https://github.com/dynamic-labs/dynamic-auth/commit/cfa5ba07a946b847e60388c80afbd8aa233e9ebf))
+* v3 svm send balance ([#8726](https://github.com/dynamic-labs/dynamic-auth/issues/8726)) ([236ec48](https://github.com/dynamic-labs/dynamic-auth/commit/236ec4843152f4b720aa7332e650db68c2d111b2))
+
+
+### Bug Fixes
+
+* **alex/qntm-3201:** send empty data field when using zksync sendbalance ([#8733](https://github.com/dynamic-labs/dynamic-auth/issues/8733)) ([4c42035](https://github.com/dynamic-labs/dynamic-auth/commit/4c420350cf7404ac80db8b552594233a3de9fb57))
+* allow for continuing signing if zksync account exists while attempting to deploy ([#8736](https://github.com/dynamic-labs/dynamic-auth/issues/8736)) ([1ff82e4](https://github.com/dynamic-labs/dynamic-auth/commit/1ff82e418e14300b9dec662fba517c5533c1caac))
+* api kernel version on react native extension ([#8754](https://github.com/dynamic-labs/dynamic-auth/issues/8754)) ([c2f0bb4](https://github.com/dynamic-labs/dynamic-auth/commit/c2f0bb4ac86214f4e3bbdac5cf4b481a7a304449))
+* CTRL wallet eip6963 detection ([#8727](https://github.com/dynamic-labs/dynamic-auth/issues/8727)) ([194334f](https://github.com/dynamic-labs/dynamic-auth/commit/194334f7fd541917d9a7f6b452145a47cf7ae853))
+* **QNTM-3249:** fix mobile layout alignment in send view ([#8740](https://github.com/dynamic-labs/dynamic-auth/issues/8740)) ([7d8e02c](https://github.com/dynamic-labs/dynamic-auth/commit/7d8e02c11830f547b6fcfbc7b518ee3f045df41a))
+
 ### [4.18.6](https://github.com/dynamic-labs/dynamic-auth/compare/v4.18.5...v4.18.6) (2025-05-16)
 
 

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.18.6";
+var version = "4.18.8";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.18.6";
+var version = "4.18.8";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/ethereum-aa-zksync",
-  "version": "4.18.6",
+  "version": "4.18.8",
   "description": "Core package for Ethereum Account Abstraction utilities and types",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,15 +18,15 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
-    "@dynamic-labs/sdk-api-core": "0.0.669",
+    "@dynamic-labs/sdk-api-core": "0.0.672",
     "zksync-sso": "0.1.0",
-    "@dynamic-labs/assert-package-version": "4.18.6",
-    "@dynamic-labs/ethereum-aa-core": "4.18.6",
-    "@dynamic-labs/ethereum-core": "4.18.6",
-    "@dynamic-labs/types": "4.18.6",
-    "@dynamic-labs/utils": "4.18.6",
-    "@dynamic-labs/wallet-book": "4.18.6",
-    "@dynamic-labs/wallet-connector-core": "4.18.6"
+    "@dynamic-labs/assert-package-version": "4.18.8",
+    "@dynamic-labs/ethereum-aa-core": "4.18.8",
+    "@dynamic-labs/ethereum-core": "4.18.8",
+    "@dynamic-labs/types": "4.18.8",
+    "@dynamic-labs/utils": "4.18.8",
+    "@dynamic-labs/wallet-book": "4.18.8",
+    "@dynamic-labs/wallet-connector-core": "4.18.8"
   },
   "peerDependencies": {
     "viem": "^2.21.60"

package/src/connector/ZKsyncConnector.cjs

@@ -6,17 +6,21 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _tslib = require('../../_virtual/_tslib.cjs');
 var viem = require('viem');
 var zksync = require('viem/zksync');
+var abi = require('zksync-sso/abi');
 var passkey = require('zksync-sso/client/passkey');
 var utils$1 = require('zksync-sso/utils');
 var client = require('zksync-sso/client');
 var ecdsa = require('zksync-sso/client/ecdsa');
+var accounts = require('viem/accounts');
 var ethereumCore = require('@dynamic-labs/ethereum-core');
 var utils = require('@dynamic-labs/utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
 var ethereumAaCore = require('@dynamic-labs/ethereum-aa-core');
 var getSalt = require('../utils/getSalt.cjs');
 var passkeys = require('../utils/passkeys.cjs');
 var deployment = require('../utils/deployment.cjs');
 var network = require('../utils/network.cjs');
+var session = require('../utils/session.cjs');
 
 class ZKsyncConnector extends ethereumAaCore.AccountAbstractionBaseConnector {
     constructor(props) {
@@ -315,33 +319,18 @@ class ZKsyncConnector extends ethereumAaCore.AccountAbstractionBaseConnector {
     }
     deploySmartAccount(_a) {
         return _tslib.__awaiter(this, arguments, void 0, function* ({ withPaymaster, }) {
+            var _b, _c;
             if (!this.chainId) {
                 throw new Error('Chain ID is not initialized');
             }
-            if (!this.eoaConnector) {
+            if (!this.eoaConnector || !this.eoaAddress) {
                 throw new Error('EOA connector is not initialized');
             }
-            yield network.ensureEoaConnectorNetwork(this.eoaConnector, this.chainId);
-            if (withPaymaster && this.paymasterAddress) {
-                yield this.deploySmartAccountWithPaymaster();
-            }
-            else {
-                yield this.deploySmartAccountWithoutPaymaster();
-            }
-        });
-    }
-    deploySmartAccountWithPaymaster() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            if (!this.paymasterAddress) {
-                throw new Error('Paymaster address is not initialized');
-            }
             if (!this.smartAccountAddress) {
                 throw new Error('Smart account address is not initialized');
             }
-            if (!this.eoaAddress) {
-                throw new Error('EOA address is not initialized');
-            }
-            const paymaster = this.paymasterAddress;
+            yield network.ensureEoaConnectorNetwork(this.eoaConnector, this.chainId);
+            const deployWithPaymaster = withPaymaster && this.paymasterAddress;
             const publicClient = yield this.getTypedPublicClient();
             const walletClient = yield this.getTypedWalletClient();
             const deploymentParams = yield deployment.getDeploymentParameters({
@@ -351,36 +340,23 @@ class ZKsyncConnector extends ethereumAaCore.AccountAbstractionBaseConnector {
                 saltText: this.saltText,
                 sessionKeyAddress: this.sessionKeyAddress,
             });
-            const { request } = yield deployment.simulateAccountDeployment(publicClient, walletClient, deploymentParams, this.factoryAddress, false);
-            const paymasterInput = zksync.getGeneralPaymasterInput({
-                innerInput: new Uint8Array(),
-            });
-            const requestWithPaymaster = Object.assign(Object.assign({}, request), { paymaster,
-                paymasterInput });
-            yield deployment.executeAccountDeployment(walletClient, publicClient, requestWithPaymaster, this.smartAccountAddress);
-            this._isSmartAccountDeployed = true;
-        });
-    }
-    /**
-     * Deploys a new smart account contract
-     * @throws {ZkSyncConnectorError} If deployment fails
-     * @testable This method can be mocked in tests
-     */
-    deploySmartAccountWithoutPaymaster() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            if (!this.eoaConnector) {
-                throw new Error('EOA connector is not initialized');
+            try {
+                let { request } = yield deployment.simulateAccountDeployment(publicClient, walletClient, deploymentParams, this.factoryAddress, !deployWithPaymaster);
+                if (deployWithPaymaster) {
+                    const paymasterInput = zksync.getGeneralPaymasterInput({
+                        innerInput: new Uint8Array(),
+                    });
+                    request = Object.assign(Object.assign({}, request), { paymaster: this.paymasterAddress, paymasterInput });
+                }
+                yield deployment.executeAccountDeployment(walletClient, publicClient, request, this.smartAccountAddress);
             }
-            if (!this.smartAccountAddress) {
-                throw new Error('Smart account address is not initialized');
+            catch (error) {
+                // If the account already exists, we don't want to throw an error and continue
+                if (((_c = (_b = error === null || error === void 0 ? void 0 : error.cause) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.errorName) !== 'ACCOUNT_ALREADY_EXISTS') {
+                    throw error;
+                }
             }
-            const walletClient = yield this.getTypedWalletClient();
-            const publicClient = yield this.getTypedPublicClient();
-            const deploymentParams = yield this.getDeploymentParameters();
-            // Simulate the contract deployment first
-            const { request } = yield deployment.simulateAccountDeployment(publicClient, walletClient, deploymentParams, this.factoryAddress, false);
-            // Execute the deployment transaction
-            yield deployment.executeAccountDeployment(walletClient, publicClient, request, this.smartAccountAddress);
+            this._isSmartAccountDeployed = true;
         });
     }
     /**
@@ -489,6 +465,106 @@ class ZKsyncConnector extends ethereumAaCore.AccountAbstractionBaseConnector {
             return isDeployed;
         });
     }
+    getSmartAccountCreationBlock() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            // check cache first
+            const cachedBlock = utils.StorageService.getItem(`smart-account-creation-block-${this.smartAccountAddress}`);
+            if (cachedBlock) {
+                return Number(cachedBlock);
+            }
+            const publicClient = yield this.getPublicClient();
+            try {
+                const createAccountLogs = yield publicClient.getContractEvents({
+                    abi: abi.AAFactoryAbi,
+                    address: this.factoryAddress,
+                    args: {
+                        accountAddress: this.smartAccountAddress,
+                    },
+                    eventName: 'AccountCreated',
+                    fromBlock: BigInt(0),
+                });
+                if (createAccountLogs.length === 0) {
+                    return 0;
+                }
+                // cache the block number
+                utils.StorageService.setItem(`smart-account-creation-block-${this.smartAccountAddress}`, createAccountLogs[0].blockNumber.toString());
+                return Number(createAccountLogs[0].blockNumber);
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('[ZKsyncConnector] Error getting smart account creation block: ', error);
+                return 0;
+            }
+        });
+    }
+    listSessions() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccount) {
+                throw new Error('Smart account is not initialized');
+            }
+            if (!this._isSmartAccountDeployed) {
+                return [];
+            }
+            const smartAccountCreationBlock = yield this.getSmartAccountCreationBlock();
+            const publicClient = yield this.getPublicClient();
+            try {
+                // Get all created session information
+                const createSessionLogs = (yield publicClient.getContractEvents({
+                    abi: abi.SessionKeyValidatorAbi,
+                    address: this.sessionKeyAddress,
+                    args: {
+                        account: this.smartAccountAddress,
+                    },
+                    eventName: 'SessionCreated',
+                    // only get sessions from the block when the smart account was created
+                    fromBlock: BigInt(smartAccountCreationBlock),
+                })).filter((log) => log.args.sessionSpec && log.args.sessionHash);
+                // Get all revoked session hashes
+                const revokedSessionHashes = (yield publicClient.getContractEvents({
+                    abi: abi.SessionKeyValidatorAbi,
+                    address: this.sessionKeyAddress,
+                    args: {
+                        account: this.smartAccountAddress,
+                    },
+                    eventName: 'SessionRevoked',
+                    // only get sessions from the block when the smart account was created
+                    fromBlock: BigInt(smartAccountCreationBlock),
+                }))
+                    .filter((log) => log.args.sessionHash)
+                    .map((log) => log.args.sessionHash);
+                const activeSessions = createSessionLogs
+                    .filter((log) => log.args.sessionHash &&
+                    // filter out the sessions that have been revoked
+                    !revokedSessionHashes.includes(log.args.sessionHash))
+                    .map((log) => ({
+                    blockNumber: log.blockNumber,
+                    session: log.args.sessionSpec,
+                    sessionId: log.args.sessionHash,
+                    timestamp: new Date(
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    parseInt(log.blockTimestamp, 16) * 1000).getTime(),
+                    transactionHash: log.transactionHash,
+                }))
+                    .sort((a, b) => {
+                    if (a.blockNumber < b.blockNumber)
+                        return 1;
+                    if (a.blockNumber > b.blockNumber)
+                        return -1;
+                    return 0;
+                });
+                return activeSessions.map((session$1) => {
+                    var _a;
+                    return (Object.assign(Object.assign({}, session$1), { origin: (_a = session.retrieveSessionFromStorage(session$1.sessionId)) === null || _a === void 0 ? void 0 : _a.origin }));
+                });
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('[ZKsyncConnector] Error listing sessions: ', error);
+                return [];
+            }
+        });
+    }
     getAddress() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -499,6 +575,59 @@ class ZKsyncConnector extends ethereumAaCore.AccountAbstractionBaseConnector {
             return this.smartAccountAddress;
         });
     }
+    revokeSession(sessionId) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccount) {
+                throw new Error('Smart account is not initialized');
+            }
+            const params = {
+                sessionId,
+            };
+            if (this.paymasterAddress) {
+                params.paymaster = {
+                    address: this.paymasterAddress,
+                    paymasterInput: zksync.getGeneralPaymasterInput({
+                        innerInput: new Uint8Array(),
+                    }),
+                };
+            }
+            yield this.smartAccount.revokeSession(params);
+            utils.StorageService.removeItem(`zksync-session-${sessionId}`);
+        });
+    }
+    createSession(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ sessionConfig, origin, }) {
+            if (!this.smartAccount) {
+                throw new Error('Smart account is not initialized');
+            }
+            const safeSessionConfig = session.enforceSessionConfigRestrictions(sessionConfig);
+            const privateKey = accounts.generatePrivateKey();
+            const signer = accounts.privateKeyToAccount(privateKey);
+            const params = {
+                sessionConfig: Object.assign(Object.assign({}, safeSessionConfig), { signer: signer.address }),
+            };
+            if (this.paymasterAddress) {
+                params.paymaster = {
+                    address: this.paymasterAddress,
+                    paymasterInput: zksync.getGeneralPaymasterInput({
+                        innerInput: new Uint8Array(),
+                    }),
+                };
+            }
+            yield this.smartAccount.createSession(params);
+            const sessionHash = session.getSessionHash(params.sessionConfig);
+            const serializedSessionConfig = session.stringifySessionConfig(params.sessionConfig);
+            const originURI = origin
+                ? new URL(origin).hostname
+                : utils.PlatformService.getHostname();
+            utils.StorageService.setItem(`zksync-session-${sessionHash}`, {
+                origin: originURI,
+                sessionConfig: serializedSessionConfig,
+                sessionKey: privateKey,
+            });
+            return { expiresAt: safeSessionConfig.expiresAt, sessionId: sessionHash };
+        });
+    }
     validateActiveWallet(expectedAddress) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             const currentAddress = yield this.getAddress();

package/src/connector/ZKsyncConnector.d.ts

@@ -3,6 +3,7 @@ import { ZksyncSsoPasskeyClient } from 'zksync-sso/client/passkey';
 import { SessionConfig } from 'zksync-sso/utils';
 import { ZksyncSsoSessionClient } from 'zksync-sso/client';
 import { ZksyncSsoEcdsaClient } from 'zksync-sso/client/ecdsa';
+import { CreateSessionArgs, RevokeSessionArgs } from 'node_modules/zksync-sso/dist/_types/client/session/actions/session';
 import { EthereumWallet, RegisterEvmProvidersConfig } from '@dynamic-labs/ethereum-core';
 import { ProjectSettings, Provider, ProviderEnum } from '@dynamic-labs/sdk-api-core';
 import { EvmNetwork, GenericNetwork, WalletUiUtils } from '@dynamic-labs/types';
@@ -10,6 +11,7 @@ import { WalletBookSchema } from '@dynamic-labs/wallet-book';
 import { Chain, IAccountAbstractionWalletConnector, InternalWalletConnector, WalletConnector } from '@dynamic-labs/wallet-connector-core';
 import { AccountAbstractionBaseConnector, AccountAbstractionConnectorProps } from '@dynamic-labs/ethereum-aa-core';
 import { DeploymentParams } from '../utils';
+import { SessionInformation, SessionConfigWithoutSigner } from '../types';
 type ZKsyncConnectorProps = AccountAbstractionConnectorProps & {
     apiProviders: {
         [key in ProviderEnum]?: Provider;
@@ -16528,8 +16530,8 @@ export declare class ZKsyncConnector extends AccountAbstractionBaseConnector imp
             sourceId?: number | undefined;
             testnet?: boolean | undefined;
         } & import("viem").ChainConfig<import("viem").ChainFormatters | undefined, Record<string, unknown> | undefined>, Account, chainOverride_9>) => Promise<`0x${string}`>;
-        createSession: (args: Omit<import("node_modules/zksync-sso/dist/_types/client/session/actions/session").CreateSessionArgs, "contracts">) => Promise<import("node_modules/zksync-sso/dist/_types/client/session/actions/session").CreateSessionReturnType>;
-        revokeSession: (args: Omit<import("node_modules/zksync-sso/dist/_types/client/session/actions/session").RevokeSessionArgs, "contracts">) => Promise<import("node_modules/zksync-sso/dist/_types/client/session/actions/session").RevokeSessionReturnType>;
+        createSession: (args: Omit<CreateSessionArgs, "contracts">) => Promise<import("node_modules/zksync-sso/dist/_types/client/session/actions/session").CreateSessionReturnType>;
+        revokeSession: (args: Omit<RevokeSessionArgs, "contracts">) => Promise<import("node_modules/zksync-sso/dist/_types/client/session/actions/session").RevokeSessionReturnType>;
         extend: <const client extends {
             [x: string]: unknown;
             account?: undefined;
@@ -17668,13 +17670,6 @@ export declare class ZKsyncConnector extends AccountAbstractionBaseConnector imp
     deploySmartAccount({ withPaymaster, }: {
         withPaymaster: boolean;
     }): Promise<void>;
-    private deploySmartAccountWithPaymaster;
-    /**
-     * Deploys a new smart account contract
-     * @throws {ZkSyncConnectorError} If deployment fails
-     * @testable This method can be mocked in tests
-     */
-    private deploySmartAccountWithoutPaymaster;
     /**
      * Gets typed public client from EOA connector
      * @throws {ZkSyncConnectorError} If public client cannot be obtained
@@ -17700,7 +17695,17 @@ export declare class ZKsyncConnector extends AccountAbstractionBaseConnector imp
      * @returns Promise that resolves when the check is complete
      */
     protected checkIsDeployed(): Promise<boolean>;
+    private getSmartAccountCreationBlock;
+    listSessions(): Promise<SessionInformation[]>;
     getAddress(): Promise<string | undefined>;
+    revokeSession(sessionId: `0x${string}`): Promise<void>;
+    createSession({ sessionConfig, origin, }: {
+        sessionConfig: SessionConfigWithoutSigner;
+        origin?: string;
+    }): Promise<{
+        expiresAt: bigint;
+        sessionId: `0x${string}`;
+    }>;
     validateActiveWallet(expectedAddress: string): Promise<void>;
     isSmartAccountDeployed(refetch?: boolean): Promise<boolean>;
 }

package/src/connector/ZKsyncConnector.js

@@ -2,17 +2,21 @@
 import { __awaiter } from '../../_virtual/_tslib.js';
 import { createWalletClient, custom, publicActions, createPublicClient, http, walletActions, toHex } from 'viem';
 import { getGeneralPaymasterInput, eip712WalletActions } from 'viem/zksync';
+import { AAFactoryAbi, SessionKeyValidatorAbi } from 'zksync-sso/abi';
 import { createZksyncPasskeyClient, registerNewPasskey } from 'zksync-sso/client/passkey';
 import { encodeModuleData } from 'zksync-sso/utils';
 import { createZksyncSessionClient } from 'zksync-sso/client';
 import { createZksyncEcdsaClient, zksyncSsoEcdsaWalletActions } from 'zksync-sso/client/ecdsa';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 import { EthereumWallet, chainsMap, confirmationTransport, getOrMapViemChain } from '@dynamic-labs/ethereum-core';
-import { parseEvmNetworks, DeferredPromise, StorageService, DynamicError } from '@dynamic-labs/utils';
+import { parseEvmNetworks, DeferredPromise, StorageService, PlatformService, DynamicError } from '@dynamic-labs/utils';
+import { logger } from '@dynamic-labs/wallet-connector-core';
 import { AccountAbstractionBaseConnector } from '@dynamic-labs/ethereum-aa-core';
 import { getSalt } from '../utils/getSalt.js';
 import { getEncodedPasskeyModuleData } from '../utils/passkeys.js';
 import { getDeploymentParameters, simulateAccountDeployment, executeAccountDeployment } from '../utils/deployment.js';
 import { ensureEoaConnectorNetwork } from '../utils/network.js';
+import { retrieveSessionFromStorage, enforceSessionConfigRestrictions, getSessionHash, stringifySessionConfig } from '../utils/session.js';
 
 class ZKsyncConnector extends AccountAbstractionBaseConnector {
     constructor(props) {
@@ -311,33 +315,18 @@ class ZKsyncConnector extends AccountAbstractionBaseConnector {
     }
     deploySmartAccount(_a) {
         return __awaiter(this, arguments, void 0, function* ({ withPaymaster, }) {
+            var _b, _c;
             if (!this.chainId) {
                 throw new Error('Chain ID is not initialized');
             }
-            if (!this.eoaConnector) {
+            if (!this.eoaConnector || !this.eoaAddress) {
                 throw new Error('EOA connector is not initialized');
             }
-            yield ensureEoaConnectorNetwork(this.eoaConnector, this.chainId);
-            if (withPaymaster && this.paymasterAddress) {
-                yield this.deploySmartAccountWithPaymaster();
-            }
-            else {
-                yield this.deploySmartAccountWithoutPaymaster();
-            }
-        });
-    }
-    deploySmartAccountWithPaymaster() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.paymasterAddress) {
-                throw new Error('Paymaster address is not initialized');
-            }
             if (!this.smartAccountAddress) {
                 throw new Error('Smart account address is not initialized');
             }
-            if (!this.eoaAddress) {
-                throw new Error('EOA address is not initialized');
-            }
-            const paymaster = this.paymasterAddress;
+            yield ensureEoaConnectorNetwork(this.eoaConnector, this.chainId);
+            const deployWithPaymaster = withPaymaster && this.paymasterAddress;
             const publicClient = yield this.getTypedPublicClient();
             const walletClient = yield this.getTypedWalletClient();
             const deploymentParams = yield getDeploymentParameters({
@@ -347,36 +336,23 @@ class ZKsyncConnector extends AccountAbstractionBaseConnector {
                 saltText: this.saltText,
                 sessionKeyAddress: this.sessionKeyAddress,
             });
-            const { request } = yield simulateAccountDeployment(publicClient, walletClient, deploymentParams, this.factoryAddress, false);
-            const paymasterInput = getGeneralPaymasterInput({
-                innerInput: new Uint8Array(),
-            });
-            const requestWithPaymaster = Object.assign(Object.assign({}, request), { paymaster,
-                paymasterInput });
-            yield executeAccountDeployment(walletClient, publicClient, requestWithPaymaster, this.smartAccountAddress);
-            this._isSmartAccountDeployed = true;
-        });
-    }
-    /**
-     * Deploys a new smart account contract
-     * @throws {ZkSyncConnectorError} If deployment fails
-     * @testable This method can be mocked in tests
-     */
-    deploySmartAccountWithoutPaymaster() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.eoaConnector) {
-                throw new Error('EOA connector is not initialized');
+            try {
+                let { request } = yield simulateAccountDeployment(publicClient, walletClient, deploymentParams, this.factoryAddress, !deployWithPaymaster);
+                if (deployWithPaymaster) {
+                    const paymasterInput = getGeneralPaymasterInput({
+                        innerInput: new Uint8Array(),
+                    });
+                    request = Object.assign(Object.assign({}, request), { paymaster: this.paymasterAddress, paymasterInput });
+                }
+                yield executeAccountDeployment(walletClient, publicClient, request, this.smartAccountAddress);
             }
-            if (!this.smartAccountAddress) {
-                throw new Error('Smart account address is not initialized');
+            catch (error) {
+                // If the account already exists, we don't want to throw an error and continue
+                if (((_c = (_b = error === null || error === void 0 ? void 0 : error.cause) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.errorName) !== 'ACCOUNT_ALREADY_EXISTS') {
+                    throw error;
+                }
             }
-            const walletClient = yield this.getTypedWalletClient();
-            const publicClient = yield this.getTypedPublicClient();
-            const deploymentParams = yield this.getDeploymentParameters();
-            // Simulate the contract deployment first
-            const { request } = yield simulateAccountDeployment(publicClient, walletClient, deploymentParams, this.factoryAddress, false);
-            // Execute the deployment transaction
-            yield executeAccountDeployment(walletClient, publicClient, request, this.smartAccountAddress);
+            this._isSmartAccountDeployed = true;
         });
     }
     /**
@@ -485,6 +461,106 @@ class ZKsyncConnector extends AccountAbstractionBaseConnector {
             return isDeployed;
         });
     }
+    getSmartAccountCreationBlock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            // check cache first
+            const cachedBlock = StorageService.getItem(`smart-account-creation-block-${this.smartAccountAddress}`);
+            if (cachedBlock) {
+                return Number(cachedBlock);
+            }
+            const publicClient = yield this.getPublicClient();
+            try {
+                const createAccountLogs = yield publicClient.getContractEvents({
+                    abi: AAFactoryAbi,
+                    address: this.factoryAddress,
+                    args: {
+                        accountAddress: this.smartAccountAddress,
+                    },
+                    eventName: 'AccountCreated',
+                    fromBlock: BigInt(0),
+                });
+                if (createAccountLogs.length === 0) {
+                    return 0;
+                }
+                // cache the block number
+                StorageService.setItem(`smart-account-creation-block-${this.smartAccountAddress}`, createAccountLogs[0].blockNumber.toString());
+                return Number(createAccountLogs[0].blockNumber);
+            }
+            catch (error) {
+                logger.error('[ZKsyncConnector] Error getting smart account creation block: ', error);
+                return 0;
+            }
+        });
+    }
+    listSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccount) {
+                throw new Error('Smart account is not initialized');
+            }
+            if (!this._isSmartAccountDeployed) {
+                return [];
+            }
+            const smartAccountCreationBlock = yield this.getSmartAccountCreationBlock();
+            const publicClient = yield this.getPublicClient();
+            try {
+                // Get all created session information
+                const createSessionLogs = (yield publicClient.getContractEvents({
+                    abi: SessionKeyValidatorAbi,
+                    address: this.sessionKeyAddress,
+                    args: {
+                        account: this.smartAccountAddress,
+                    },
+                    eventName: 'SessionCreated',
+                    // only get sessions from the block when the smart account was created
+                    fromBlock: BigInt(smartAccountCreationBlock),
+                })).filter((log) => log.args.sessionSpec && log.args.sessionHash);
+                // Get all revoked session hashes
+                const revokedSessionHashes = (yield publicClient.getContractEvents({
+                    abi: SessionKeyValidatorAbi,
+                    address: this.sessionKeyAddress,
+                    args: {
+                        account: this.smartAccountAddress,
+                    },
+                    eventName: 'SessionRevoked',
+                    // only get sessions from the block when the smart account was created
+                    fromBlock: BigInt(smartAccountCreationBlock),
+                }))
+                    .filter((log) => log.args.sessionHash)
+                    .map((log) => log.args.sessionHash);
+                const activeSessions = createSessionLogs
+                    .filter((log) => log.args.sessionHash &&
+                    // filter out the sessions that have been revoked
+                    !revokedSessionHashes.includes(log.args.sessionHash))
+                    .map((log) => ({
+                    blockNumber: log.blockNumber,
+                    session: log.args.sessionSpec,
+                    sessionId: log.args.sessionHash,
+                    timestamp: new Date(
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    parseInt(log.blockTimestamp, 16) * 1000).getTime(),
+                    transactionHash: log.transactionHash,
+                }))
+                    .sort((a, b) => {
+                    if (a.blockNumber < b.blockNumber)
+                        return 1;
+                    if (a.blockNumber > b.blockNumber)
+                        return -1;
+                    return 0;
+                });
+                return activeSessions.map((session) => {
+                    var _a;
+                    return (Object.assign(Object.assign({}, session), { origin: (_a = retrieveSessionFromStorage(session.sessionId)) === null || _a === void 0 ? void 0 : _a.origin }));
+                });
+            }
+            catch (error) {
+                logger.error('[ZKsyncConnector] Error listing sessions: ', error);
+                return [];
+            }
+        });
+    }
     getAddress() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -495,6 +571,59 @@ class ZKsyncConnector extends AccountAbstractionBaseConnector {
             return this.smartAccountAddress;
         });
     }
+    revokeSession(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccount) {
+                throw new Error('Smart account is not initialized');
+            }
+            const params = {
+                sessionId,
+            };
+            if (this.paymasterAddress) {
+                params.paymaster = {
+                    address: this.paymasterAddress,
+                    paymasterInput: getGeneralPaymasterInput({
+                        innerInput: new Uint8Array(),
+                    }),
+                };
+            }
+            yield this.smartAccount.revokeSession(params);
+            StorageService.removeItem(`zksync-session-${sessionId}`);
+        });
+    }
+    createSession(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sessionConfig, origin, }) {
+            if (!this.smartAccount) {
+                throw new Error('Smart account is not initialized');
+            }
+            const safeSessionConfig = enforceSessionConfigRestrictions(sessionConfig);
+            const privateKey = generatePrivateKey();
+            const signer = privateKeyToAccount(privateKey);
+            const params = {
+                sessionConfig: Object.assign(Object.assign({}, safeSessionConfig), { signer: signer.address }),
+            };
+            if (this.paymasterAddress) {
+                params.paymaster = {
+                    address: this.paymasterAddress,
+                    paymasterInput: getGeneralPaymasterInput({
+                        innerInput: new Uint8Array(),
+                    }),
+                };
+            }
+            yield this.smartAccount.createSession(params);
+            const sessionHash = getSessionHash(params.sessionConfig);
+            const serializedSessionConfig = stringifySessionConfig(params.sessionConfig);
+            const originURI = origin
+                ? new URL(origin).hostname
+                : PlatformService.getHostname();
+            StorageService.setItem(`zksync-session-${sessionHash}`, {
+                origin: originURI,
+                sessionConfig: serializedSessionConfig,
+                sessionKey: privateKey,
+            });
+            return { expiresAt: safeSessionConfig.expiresAt, sessionId: sessionHash };
+        });
+    }
     validateActiveWallet(expectedAddress) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentAddress = yield this.getAddress();

package/src/index.d.ts

@@ -1,3 +1,4 @@
 import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
 export { isZKsyncConnector } from './utils';
+export { type SessionInformation } from './types';
 export declare const ZKsyncSmartWalletConnectors: (props: any) => WalletConnectorConstructor[];

package/src/types/index.d.ts

@@ -1,8 +1,34 @@
+import { SessionConfig } from 'zksync-sso/utils';
 import { GenericNetwork, WalletUiUtils } from '@dynamic-labs/types';
 import { WalletBookSchema } from '@dynamic-labs/wallet-book';
 import { InternalWalletConnector } from '@dynamic-labs/wallet-connector-core';
+export type SessionConfigWithoutSigner = Omit<SessionConfig, 'signer'>;
+export type ConvertBigIntToString<T> = T extends bigint ? string : T extends Array<infer U> ? Array<ConvertBigIntToString<U>> : T extends object ? {
+    [K in keyof T]: ConvertBigIntToString<T[K]>;
+} : T;
+export type SessionConfigJSON = ConvertBigIntToString<SessionConfig>;
 export type AccountAbstractionConnectorProps = {
     walletUiUtils: WalletUiUtils<InternalWalletConnector>;
     walletBook: WalletBookSchema;
     evmNetworks: GenericNetwork[];
 };
+export type SessionInformation = {
+    blockNumber: bigint;
+    session: SessionConfig;
+    sessionId: string;
+    timestamp: number;
+    transactionHash: string;
+    origin?: string;
+};
+export type ChainSessionInformation = {
+    blockNumber: bigint;
+    session: SessionConfig;
+    sessionId: `0x${string}`;
+    timestamp: number;
+    transactionHash: `0x${string}`;
+};
+export type SessionStorageItem = {
+    origin?: string;
+    sessionConfig: SessionConfigJSON;
+    sessionKey: string;
+};

package/src/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from './passkeys';
 export * from './deployment';
 export * from './network';
 export * from './isZKsyncConnector';
+export * from './session';

package/src/utils/session.cjs

@@ -0,0 +1,52 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var viem = require('viem');
+var utils = require('zksync-sso/utils');
+var utils$1 = require('@dynamic-labs/utils');
+
+const DEFAULT_EXPIRATION_TIME = 86400; // 1 day
+const enforceSessionConfigRestrictions = (sessionConfig) => {
+    const now = Math.floor(Date.now() / 1000);
+    const maxExpirationTime = now + DEFAULT_EXPIRATION_TIME;
+    if (!sessionConfig.expiresAt ||
+        Number(sessionConfig.expiresAt) > maxExpirationTime) {
+        sessionConfig.expiresAt = BigInt(maxExpirationTime);
+    }
+    return sessionConfig;
+};
+const getSessionHash = (sessionConfig) => {
+    const sessionHash = utils.encodeSession(sessionConfig);
+    return viem.keccak256(sessionHash);
+};
+const parseSessionConfigJSON = (sessionConfig) => {
+    const serializeLimit = (limit) => ({
+        limit: BigInt(limit.limit),
+        limitType: limit.limitType,
+        period: BigInt(limit.period),
+    });
+    return Object.assign(Object.assign({}, sessionConfig), { callPolicies: sessionConfig.callPolicies.map((policy) => (Object.assign(Object.assign({}, policy), { constraints: policy.constraints.map((constraint) => (Object.assign(Object.assign({}, constraint), { index: BigInt(constraint.index), limit: serializeLimit(constraint.limit) }))), maxValuePerUse: BigInt(policy.maxValuePerUse), valueLimit: serializeLimit(policy.valueLimit) }))), expiresAt: BigInt(sessionConfig.expiresAt), feeLimit: serializeLimit(sessionConfig.feeLimit), transferPolicies: sessionConfig.transferPolicies.map((policy) => (Object.assign(Object.assign({}, policy), { maxValuePerUse: BigInt(policy.maxValuePerUse), valueLimit: serializeLimit(policy.valueLimit) }))) });
+};
+const stringifySessionConfig = (sessionConfig) => {
+    const stringifyLimit = (limit) => ({
+        limit: limit.limit.toString(),
+        limitType: limit.limitType,
+        period: limit.period.toString(),
+    });
+    return Object.assign(Object.assign({}, sessionConfig), { callPolicies: sessionConfig.callPolicies.map((policy) => (Object.assign(Object.assign({}, policy), { constraints: policy.constraints.map((constraint) => (Object.assign(Object.assign({}, constraint), { index: constraint.index.toString(), limit: stringifyLimit(constraint.limit) }))), maxValuePerUse: policy.maxValuePerUse.toString(), valueLimit: stringifyLimit(policy.valueLimit) }))), expiresAt: sessionConfig.expiresAt.toString(), feeLimit: stringifyLimit(sessionConfig.feeLimit), transferPolicies: sessionConfig.transferPolicies.map((policy) => (Object.assign(Object.assign({}, policy), { maxValuePerUse: policy.maxValuePerUse.toString(), valueLimit: stringifyLimit(policy.valueLimit) }))) });
+};
+const retrieveSessionFromStorage = (sessionId) => {
+    const session = utils$1.StorageService.getItem(`zksync-session-${sessionId}`);
+    if (!session) {
+        return undefined;
+    }
+    return Object.assign(Object.assign({}, session), { sessionConfig: parseSessionConfigJSON(session.sessionConfig) });
+};
+
+exports.enforceSessionConfigRestrictions = enforceSessionConfigRestrictions;
+exports.getSessionHash = getSessionHash;
+exports.parseSessionConfigJSON = parseSessionConfigJSON;
+exports.retrieveSessionFromStorage = retrieveSessionFromStorage;
+exports.stringifySessionConfig = stringifySessionConfig;

package/src/utils/session.d.ts

@@ -0,0 +1,11 @@
+import { SessionConfig } from 'zksync-sso/utils';
+import { SessionConfigJSON, SessionConfigWithoutSigner } from '../types';
+export declare const enforceSessionConfigRestrictions: (sessionConfig: SessionConfigWithoutSigner) => SessionConfigWithoutSigner;
+export declare const getSessionHash: (sessionConfig: SessionConfig) => `0x${string}`;
+export declare const parseSessionConfigJSON: (sessionConfig: SessionConfigJSON) => SessionConfig;
+export declare const stringifySessionConfig: (sessionConfig: SessionConfig) => SessionConfigJSON;
+export declare const retrieveSessionFromStorage: (sessionId: string) => {
+    sessionConfig: SessionConfig;
+    origin?: string | undefined;
+    sessionKey: string;
+} | undefined;

package/src/utils/session.js

@@ -0,0 +1,44 @@
+'use client'
+import { keccak256 } from 'viem';
+import { encodeSession } from 'zksync-sso/utils';
+import { StorageService } from '@dynamic-labs/utils';
+
+const DEFAULT_EXPIRATION_TIME = 86400; // 1 day
+const enforceSessionConfigRestrictions = (sessionConfig) => {
+    const now = Math.floor(Date.now() / 1000);
+    const maxExpirationTime = now + DEFAULT_EXPIRATION_TIME;
+    if (!sessionConfig.expiresAt ||
+        Number(sessionConfig.expiresAt) > maxExpirationTime) {
+        sessionConfig.expiresAt = BigInt(maxExpirationTime);
+    }
+    return sessionConfig;
+};
+const getSessionHash = (sessionConfig) => {
+    const sessionHash = encodeSession(sessionConfig);
+    return keccak256(sessionHash);
+};
+const parseSessionConfigJSON = (sessionConfig) => {
+    const serializeLimit = (limit) => ({
+        limit: BigInt(limit.limit),
+        limitType: limit.limitType,
+        period: BigInt(limit.period),
+    });
+    return Object.assign(Object.assign({}, sessionConfig), { callPolicies: sessionConfig.callPolicies.map((policy) => (Object.assign(Object.assign({}, policy), { constraints: policy.constraints.map((constraint) => (Object.assign(Object.assign({}, constraint), { index: BigInt(constraint.index), limit: serializeLimit(constraint.limit) }))), maxValuePerUse: BigInt(policy.maxValuePerUse), valueLimit: serializeLimit(policy.valueLimit) }))), expiresAt: BigInt(sessionConfig.expiresAt), feeLimit: serializeLimit(sessionConfig.feeLimit), transferPolicies: sessionConfig.transferPolicies.map((policy) => (Object.assign(Object.assign({}, policy), { maxValuePerUse: BigInt(policy.maxValuePerUse), valueLimit: serializeLimit(policy.valueLimit) }))) });
+};
+const stringifySessionConfig = (sessionConfig) => {
+    const stringifyLimit = (limit) => ({
+        limit: limit.limit.toString(),
+        limitType: limit.limitType,
+        period: limit.period.toString(),
+    });
+    return Object.assign(Object.assign({}, sessionConfig), { callPolicies: sessionConfig.callPolicies.map((policy) => (Object.assign(Object.assign({}, policy), { constraints: policy.constraints.map((constraint) => (Object.assign(Object.assign({}, constraint), { index: constraint.index.toString(), limit: stringifyLimit(constraint.limit) }))), maxValuePerUse: policy.maxValuePerUse.toString(), valueLimit: stringifyLimit(policy.valueLimit) }))), expiresAt: sessionConfig.expiresAt.toString(), feeLimit: stringifyLimit(sessionConfig.feeLimit), transferPolicies: sessionConfig.transferPolicies.map((policy) => (Object.assign(Object.assign({}, policy), { maxValuePerUse: policy.maxValuePerUse.toString(), valueLimit: stringifyLimit(policy.valueLimit) }))) });
+};
+const retrieveSessionFromStorage = (sessionId) => {
+    const session = StorageService.getItem(`zksync-session-${sessionId}`);
+    if (!session) {
+        return undefined;
+    }
+    return Object.assign(Object.assign({}, session), { sessionConfig: parseSessionConfigJSON(session.sessionConfig) });
+};
+
+export { enforceSessionConfigRestrictions, getSessionHash, parseSessionConfigJSON, retrieveSessionFromStorage, stringifySessionConfig };