@dynamic-labs/ethereum-aa-zksync 4.14.0

package/src/utils/abi.d.ts

@@ -0,0 +1,102 @@
+export declare const AAFactoryABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "_beaconProxyBytecodeHash";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_beacon";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "ACCOUNT_ALREADY_EXISTS";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "accountAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "uniqueAccountId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "AccountCreated";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "accountId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "accountMappings";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "deployedAccount";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "beacon";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "beaconProxyBytecodeHash";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "uniqueId";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "initialValidators";
+        readonly type: "bytes[]";
+    }, {
+        readonly internalType: "address[]";
+        readonly name: "initialK1Owners";
+        readonly type: "address[]";
+    }];
+    readonly name: "deployProxySsoAccount";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "accountAddress";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getEncodedBeacon";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

package/src/utils/abi.js

@@ -0,0 +1,84 @@
+'use client'
+const AAFactoryABI = [
+    {
+        inputs: [
+            {
+                internalType: 'bytes32',
+                name: '_beaconProxyBytecodeHash',
+                type: 'bytes32',
+            },
+            { internalType: 'address', name: '_beacon', type: 'address' },
+        ],
+        stateMutability: 'nonpayable',
+        type: 'constructor',
+    },
+    {
+        inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
+        name: 'ACCOUNT_ALREADY_EXISTS',
+        type: 'error',
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: 'address',
+                name: 'accountAddress',
+                type: 'address',
+            },
+            {
+                indexed: false,
+                internalType: 'bytes32',
+                name: 'uniqueAccountId',
+                type: 'bytes32',
+            },
+        ],
+        name: 'AccountCreated',
+        type: 'event',
+    },
+    {
+        inputs: [{ internalType: 'bytes32', name: 'accountId', type: 'bytes32' }],
+        name: 'accountMappings',
+        outputs: [
+            { internalType: 'address', name: 'deployedAccount', type: 'address' },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'beacon',
+        outputs: [{ internalType: 'address', name: '', type: 'address' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'beaconProxyBytecodeHash',
+        outputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'bytes32', name: 'uniqueId', type: 'bytes32' },
+            { internalType: 'bytes[]', name: 'initialValidators', type: 'bytes[]' },
+            { internalType: 'address[]', name: 'initialK1Owners', type: 'address[]' },
+        ],
+        name: 'deployProxySsoAccount',
+        outputs: [
+            { internalType: 'address', name: 'accountAddress', type: 'address' },
+        ],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'getEncodedBeacon',
+        outputs: [{ internalType: 'bytes', name: '', type: 'bytes' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+
+export { AAFactoryABI };

package/src/utils/deployment.cjs

@@ -0,0 +1,97 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var utils = require('zksync-sso/utils');
+var viem = require('viem');
+var abi = require('./abi.cjs');
+var passkeys = require('./passkeys.cjs');
+var getSalt = require('./getSalt.cjs');
+
+/**
+ * Returns the parameters needed for deploying the smart account
+ * @returns Deployment parameters object
+ * @testable This method can be overridden in tests
+ */
+const getDeploymentParameters = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ eoaAddress, enablePasskeys, passkeyAddress, sessionKeyAddress, saltText, }) {
+    const initialValidators = [];
+    const initialK1Owners = [eoaAddress];
+    // TODO: revisit this logic, maybe we should always add the passkey module data,
+    //  otherwise if people active passkeys later, old accounts will not be able to use passkey module
+    if (enablePasskeys && passkeyAddress) {
+        const encodedPasskeyModuleData = yield passkeys.getEncodedPasskeyModuleData({
+            passkeyAddress,
+        });
+        initialValidators.push(encodedPasskeyModuleData);
+    }
+    if (sessionKeyAddress) {
+        const encodedSessionKeyModuleData = utils.encodeModuleData({
+            address: sessionKeyAddress,
+            parameters: '0x',
+        });
+        initialValidators.push(encodedSessionKeyModuleData);
+    }
+    return {
+        initialK1Owners,
+        initialValidators,
+        salt: getSalt.getSalt(saltText),
+    };
+});
+/**
+ * Simulates the smart account deployment
+ * @param publicClient - The public client to use for simulation
+ * @param walletClient - The wallet client to use for account information
+ * @param params - The deployment parameters
+ * @returns The simulation result
+ * @throws {ZkSyncConnectorError} If simulation fails
+ * @testable This method can be mocked in tests
+ */
+const simulateAccountDeployment = (publicClient_1, walletClient_1, params_1, factoryAddress_1, ...args_1) => _tslib.__awaiter(void 0, [publicClient_1, walletClient_1, params_1, factoryAddress_1, ...args_1], void 0, function* (publicClient, walletClient, params, factoryAddress, checkBalance = true) {
+    var _b, _c, _d;
+    // this is to keep the same salt as calculated on zksync sso package
+    const salt = viem.keccak256(viem.toHex(params.salt));
+    const gasEstimate = yield publicClient.estimateContractGas({
+        abi: abi.AAFactoryABI,
+        account: (_b = walletClient.account) === null || _b === void 0 ? void 0 : _b.address,
+        address: factoryAddress,
+        args: [salt, params.initialValidators, params.initialK1Owners],
+        functionName: 'deployProxySsoAccount',
+    });
+    if (checkBalance) {
+        const balance = yield publicClient.getBalance({
+            address: (_c = walletClient.account) === null || _c === void 0 ? void 0 : _c.address,
+        });
+        if (balance < gasEstimate) {
+            throw new Error('Insufficient balance to deploy account');
+        }
+    }
+    // Simulate the contract call
+    return publicClient.simulateContract({
+        abi: abi.AAFactoryABI,
+        account: (_d = walletClient.account) === null || _d === void 0 ? void 0 : _d.address,
+        address: factoryAddress,
+        args: [salt, params.initialValidators, params.initialK1Owners],
+        functionName: 'deployProxySsoAccount',
+    });
+});
+/**
+ * Executes the smart account deployment transaction
+ * @param walletClient - The wallet client to use for transaction execution
+ * @param request - The deployment request object containing transaction parameters
+ * @returns Promise that resolves when the deployment transaction is confirmed
+ * @throws {DynamicError} If the smart account address is not initialized
+ * @throws {Error} If transaction execution or confirmation fails
+ */
+const executeAccountDeployment = (walletClient, publicClient, request, smartAccountAddress) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    if (!smartAccountAddress) {
+        throw new Error('Smart account address is not initialized');
+    }
+    const tx = yield walletClient.writeContract(request);
+    yield publicClient.waitForTransactionReceipt({ hash: tx });
+});
+
+exports.executeAccountDeployment = executeAccountDeployment;
+exports.getDeploymentParameters = getDeploymentParameters;
+exports.simulateAccountDeployment = simulateAccountDeployment;

package/src/utils/deployment.d.ts

@@ -0,0 +1,37 @@
+import { PublicClient, WalletClient } from 'viem';
+export interface DeploymentParams {
+    initialK1Owners: `0x${string}`[];
+    initialValidators: `0x${string}`[];
+    salt: `0x${string}`;
+}
+/**
+ * Returns the parameters needed for deploying the smart account
+ * @returns Deployment parameters object
+ * @testable This method can be overridden in tests
+ */
+export declare const getDeploymentParameters: ({ eoaAddress, enablePasskeys, passkeyAddress, sessionKeyAddress, saltText, }: {
+    eoaAddress: `0x${string}`;
+    enablePasskeys: boolean;
+    passkeyAddress: `0x${string}`;
+    sessionKeyAddress: `0x${string}`;
+    saltText?: string;
+}) => Promise<DeploymentParams>;
+/**
+ * Simulates the smart account deployment
+ * @param publicClient - The public client to use for simulation
+ * @param walletClient - The wallet client to use for account information
+ * @param params - The deployment parameters
+ * @returns The simulation result
+ * @throws {ZkSyncConnectorError} If simulation fails
+ * @testable This method can be mocked in tests
+ */
+export declare const simulateAccountDeployment: (publicClient: PublicClient, walletClient: WalletClient, params: DeploymentParams, factoryAddress: `0x${string}`, checkBalance?: boolean) => Promise<any>;
+/**
+ * Executes the smart account deployment transaction
+ * @param walletClient - The wallet client to use for transaction execution
+ * @param request - The deployment request object containing transaction parameters
+ * @returns Promise that resolves when the deployment transaction is confirmed
+ * @throws {DynamicError} If the smart account address is not initialized
+ * @throws {Error} If transaction execution or confirmation fails
+ */
+export declare const executeAccountDeployment: (walletClient: WalletClient, publicClient: PublicClient, request: any, smartAccountAddress: `0x${string}`) => Promise<void>;

package/src/utils/deployment.js

@@ -0,0 +1,91 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { encodeModuleData } from 'zksync-sso/utils';
+import { keccak256, toHex } from 'viem';
+import { AAFactoryABI } from './abi.js';
+import { getEncodedPasskeyModuleData } from './passkeys.js';
+import { getSalt } from './getSalt.js';
+
+/**
+ * Returns the parameters needed for deploying the smart account
+ * @returns Deployment parameters object
+ * @testable This method can be overridden in tests
+ */
+const getDeploymentParameters = (_a) => __awaiter(void 0, [_a], void 0, function* ({ eoaAddress, enablePasskeys, passkeyAddress, sessionKeyAddress, saltText, }) {
+    const initialValidators = [];
+    const initialK1Owners = [eoaAddress];
+    // TODO: revisit this logic, maybe we should always add the passkey module data,
+    //  otherwise if people active passkeys later, old accounts will not be able to use passkey module
+    if (enablePasskeys && passkeyAddress) {
+        const encodedPasskeyModuleData = yield getEncodedPasskeyModuleData({
+            passkeyAddress,
+        });
+        initialValidators.push(encodedPasskeyModuleData);
+    }
+    if (sessionKeyAddress) {
+        const encodedSessionKeyModuleData = encodeModuleData({
+            address: sessionKeyAddress,
+            parameters: '0x',
+        });
+        initialValidators.push(encodedSessionKeyModuleData);
+    }
+    return {
+        initialK1Owners,
+        initialValidators,
+        salt: getSalt(saltText),
+    };
+});
+/**
+ * Simulates the smart account deployment
+ * @param publicClient - The public client to use for simulation
+ * @param walletClient - The wallet client to use for account information
+ * @param params - The deployment parameters
+ * @returns The simulation result
+ * @throws {ZkSyncConnectorError} If simulation fails
+ * @testable This method can be mocked in tests
+ */
+const simulateAccountDeployment = (publicClient_1, walletClient_1, params_1, factoryAddress_1, ...args_1) => __awaiter(void 0, [publicClient_1, walletClient_1, params_1, factoryAddress_1, ...args_1], void 0, function* (publicClient, walletClient, params, factoryAddress, checkBalance = true) {
+    var _b, _c, _d;
+    // this is to keep the same salt as calculated on zksync sso package
+    const salt = keccak256(toHex(params.salt));
+    const gasEstimate = yield publicClient.estimateContractGas({
+        abi: AAFactoryABI,
+        account: (_b = walletClient.account) === null || _b === void 0 ? void 0 : _b.address,
+        address: factoryAddress,
+        args: [salt, params.initialValidators, params.initialK1Owners],
+        functionName: 'deployProxySsoAccount',
+    });
+    if (checkBalance) {
+        const balance = yield publicClient.getBalance({
+            address: (_c = walletClient.account) === null || _c === void 0 ? void 0 : _c.address,
+        });
+        if (balance < gasEstimate) {
+            throw new Error('Insufficient balance to deploy account');
+        }
+    }
+    // Simulate the contract call
+    return publicClient.simulateContract({
+        abi: AAFactoryABI,
+        account: (_d = walletClient.account) === null || _d === void 0 ? void 0 : _d.address,
+        address: factoryAddress,
+        args: [salt, params.initialValidators, params.initialK1Owners],
+        functionName: 'deployProxySsoAccount',
+    });
+});
+/**
+ * Executes the smart account deployment transaction
+ * @param walletClient - The wallet client to use for transaction execution
+ * @param request - The deployment request object containing transaction parameters
+ * @returns Promise that resolves when the deployment transaction is confirmed
+ * @throws {DynamicError} If the smart account address is not initialized
+ * @throws {Error} If transaction execution or confirmation fails
+ */
+const executeAccountDeployment = (walletClient, publicClient, request, smartAccountAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!smartAccountAddress) {
+        throw new Error('Smart account address is not initialized');
+    }
+    const tx = yield walletClient.writeContract(request);
+    yield publicClient.waitForTransactionReceipt({ hash: tx });
+});
+
+export { executeAccountDeployment, getDeploymentParameters, simulateAccountDeployment };

package/src/utils/getSalt.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var viem = require('viem');
+
+const getSalt = (saltText = 'DynamicLabs') => `0x${Buffer.from(viem.toBytes(saltText, { size: 32 })).toString('hex')}`;
+
+exports.getSalt = getSalt;

package/src/utils/getSalt.d.ts

@@ -0,0 +1 @@
+export declare const getSalt: (saltText?: string) => `0x${string}`;

package/src/utils/getSalt.js

@@ -0,0 +1,6 @@
+'use client'
+import { toBytes } from 'viem';
+
+const getSalt = (saltText = 'DynamicLabs') => `0x${Buffer.from(toBytes(saltText, { size: 32 })).toString('hex')}`;
+
+export { getSalt };

package/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './getSalt';
+export * from './passkeys';
+export * from './deployment';
+export * from './network';
+export * from './isZKsyncConnector';

package/src/utils/isZKsyncConnector.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const isZKsyncConnector = (connector) => (connector === null || connector === void 0 ? void 0 : connector.key) === 'zksync';
+
+exports.isZKsyncConnector = isZKsyncConnector;

package/src/utils/isZKsyncConnector.d.ts

@@ -0,0 +1,3 @@
+import { WalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { ZKsyncConnector } from '../connector';
+export declare const isZKsyncConnector: (connector: ZKsyncConnector | WalletConnector) => connector is ZKsyncConnector;

package/src/utils/isZKsyncConnector.js

@@ -0,0 +1,4 @@
+'use client'
+const isZKsyncConnector = (connector) => (connector === null || connector === void 0 ? void 0 : connector.key) === 'zksync';
+
+export { isZKsyncConnector };

package/src/utils/network.cjs

@@ -0,0 +1,17 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+
+const ensureEoaConnectorNetwork = (eoaConnector, chainId) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const eoaNetwork = yield eoaConnector.getNetwork();
+    if (Number(eoaNetwork) !== chainId) {
+        yield eoaConnector.switchNetwork({
+            networkChainId: chainId,
+        });
+    }
+});
+
+exports.ensureEoaConnectorNetwork = ensureEoaConnectorNetwork;

package/src/utils/network.d.ts

@@ -0,0 +1,2 @@
+import { WalletConnector } from '@dynamic-labs/wallet-connector-core';
+export declare const ensureEoaConnectorNetwork: (eoaConnector: WalletConnector, chainId: number) => Promise<void>;

package/src/utils/network.js

@@ -0,0 +1,13 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+
+const ensureEoaConnectorNetwork = (eoaConnector, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+    const eoaNetwork = yield eoaConnector.getNetwork();
+    if (Number(eoaNetwork) !== chainId) {
+        yield eoaConnector.switchNetwork({
+            networkChainId: chainId,
+        });
+    }
+});
+
+export { ensureEoaConnectorNetwork };

package/src/utils/passkeys.cjs

@@ -0,0 +1,41 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var utils$1 = require('zksync-sso/utils');
+var utils = require('@dynamic-labs/utils');
+
+/**
+ * Retrieves and encodes passkey module data for smart account deployment
+ * @returns Encoded passkey module data as a hex string
+ * @throws {Error} If credential public key or ID is not found
+ * @private
+ */
+const getEncodedPasskeyModuleData = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ passkeyAddress, }) {
+    if (!passkeyAddress) {
+        throw new Error('Passkey address is not initialized');
+    }
+    const storedCredentialPublicKey = utils.StorageService.getItem('credentialPublicKey');
+    if (!storedCredentialPublicKey) {
+        throw new Error('Credential public key not found');
+    }
+    const credentialPublicKey = new Uint8Array(Object.values(storedCredentialPublicKey));
+    const credentialId = utils.StorageService.getItem('credentialId');
+    if (!credentialId) {
+        throw new Error('Credential ID not found');
+    }
+    const passkeyPublicKey = utils$1.getPublicKeyBytesFromPasskeySignature(credentialPublicKey);
+    const encodedPasskeyParameters = utils$1.encodePasskeyModuleParameters({
+        credentialId: credentialId,
+        expectedOrigin: window.location.origin,
+        passkeyPublicKey,
+    });
+    return utils$1.encodeModuleData({
+        address: passkeyAddress,
+        parameters: encodedPasskeyParameters,
+    });
+});
+
+exports.getEncodedPasskeyModuleData = getEncodedPasskeyModuleData;

package/src/utils/passkeys.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Retrieves and encodes passkey module data for smart account deployment
+ * @returns Encoded passkey module data as a hex string
+ * @throws {Error} If credential public key or ID is not found
+ * @private
+ */
+export declare const getEncodedPasskeyModuleData: ({ passkeyAddress, }: {
+    passkeyAddress?: `0x${string}`;
+}) => Promise<`0x${string}`>;

package/src/utils/passkeys.js

@@ -0,0 +1,37 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { getPublicKeyBytesFromPasskeySignature, encodePasskeyModuleParameters, encodeModuleData } from 'zksync-sso/utils';
+import { StorageService } from '@dynamic-labs/utils';
+
+/**
+ * Retrieves and encodes passkey module data for smart account deployment
+ * @returns Encoded passkey module data as a hex string
+ * @throws {Error} If credential public key or ID is not found
+ * @private
+ */
+const getEncodedPasskeyModuleData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ passkeyAddress, }) {
+    if (!passkeyAddress) {
+        throw new Error('Passkey address is not initialized');
+    }
+    const storedCredentialPublicKey = StorageService.getItem('credentialPublicKey');
+    if (!storedCredentialPublicKey) {
+        throw new Error('Credential public key not found');
+    }
+    const credentialPublicKey = new Uint8Array(Object.values(storedCredentialPublicKey));
+    const credentialId = StorageService.getItem('credentialId');
+    if (!credentialId) {
+        throw new Error('Credential ID not found');
+    }
+    const passkeyPublicKey = getPublicKeyBytesFromPasskeySignature(credentialPublicKey);
+    const encodedPasskeyParameters = encodePasskeyModuleParameters({
+        credentialId: credentialId,
+        expectedOrigin: window.location.origin,
+        passkeyPublicKey,
+    });
+    return encodeModuleData({
+        address: passkeyAddress,
+        parameters: encodedPasskeyParameters,
+    });
+});
+
+export { getEncodedPasskeyModuleData };