@dynamic-labs/ethereum-aa-zksync 4.14.0

package/src/connector/ZKsyncConnector.js

@@ -0,0 +1,516 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { createWalletClient, custom, publicActions, createPublicClient, http, walletActions, toHex } from 'viem';
+import { getGeneralPaymasterInput, eip712WalletActions } from 'viem/zksync';
+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 { EthereumWallet, chainsMap, confirmationTransport, getOrMapViemChain } from '@dynamic-labs/ethereum-core';
+import { parseEvmNetworks, DeferredPromise, StorageService, DynamicError } from '@dynamic-labs/utils';
+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';
+
+class ZKsyncConnector extends AccountAbstractionBaseConnector {
+    constructor(props) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        super(props);
+        // Core wallet properties
+        this.ChainWallet = EthereumWallet;
+        this.name = 'ZKsync';
+        this.overrideKey = 'zksync';
+        // Chain configuration
+        this.connectedChain = 'EVM';
+        this.evmNetworks = [];
+        this.supportedChains = ['ETH', 'EVM'];
+        this._isSmartAccountDeployed = false;
+        this.enablePasskeys = true;
+        this.enableEIP7702Mode = false;
+        this.walletFallback = {
+            brand: {
+                alt: 'Smart Wallet',
+                spriteId: 'smartwallet',
+            },
+            name: 'ZKsync',
+        };
+        this._walletUiUtils = props.walletUiUtils;
+        this.providersConfig = (_a = props.providersConfig) !== null && _a !== void 0 ? _a : {};
+        this.chainId = (_b = props.apiProviders.zksync) === null || _b === void 0 ? void 0 : _b.defaultChainId;
+        this.evmNetworks = parseEvmNetworks(props.evmNetworks).filter((network) => network.chainId === this.chainId);
+        this.factoryAddress = (_c = props.apiProviders.zksync) === null || _c === void 0 ? void 0 : _c.factoryAddress; // Fallback if not provided
+        this.paymasterAddress = (_d = props.apiProviders.zksync) === null || _d === void 0 ? void 0 : _d.paymasterAddress; // Fallback if not provided
+        this.passkeyAddress = (_e = props.apiProviders.zksync) === null || _e === void 0 ? void 0 : _e.passkeyAddress; // Fallback if not provided
+        this.sessionKeyAddress = (_f = props.apiProviders.zksync) === null || _f === void 0 ? void 0 : _f.sessionAddress; // Fallback if not provided
+        this.saltText = (_g = props.apiProviders.zksync) === null || _g === void 0 ? void 0 : _g.salt;
+        this.enablePasskeys =
+            (_j = (_h = props.settings.sdk.accountAbstraction) === null || _h === void 0 ? void 0 : _h.enablePasskeys) !== null && _j !== void 0 ? _j : false;
+    }
+    getEnabledNetworks() {
+        return this.evmNetworks;
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield ((_a = this.initializedDeferredPromise) === null || _a === void 0 ? void 0 : _a.promise);
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            return [this.smartAccountAddress];
+        });
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield ((_a = this.initializedDeferredPromise) === null || _a === void 0 ? void 0 : _a.promise);
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            return this.chainId;
+        });
+    }
+    getPublicClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return createPublicClient({
+                chain: getOrMapViemChain(this.evmNetworks[0]),
+                transport: http(),
+            });
+        });
+    }
+    canSponsorTransactionGas() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    getAccountAbstractionProvider() {
+        return this.smartAccount;
+    }
+    getWalletClient(chainId) {
+        const smartAccountClient = this.smartAccount;
+        if (!smartAccountClient) {
+            return undefined;
+        }
+        const transport = this.getWalletClientTransport(smartAccountClient);
+        return createWalletClient({
+            account: smartAccountClient.account,
+            chain: chainId ? chainsMap[chainId] : smartAccountClient.chain,
+            transport,
+        });
+    }
+    getWalletClientTransport(smartAccountClient) {
+        return custom({
+            request: (_a) => __awaiter(this, [_a], void 0, function* ({ method, params, }) {
+                const handleRequest = () => __awaiter(this, void 0, void 0, function* () {
+                    var _b;
+                    switch (method) {
+                        case 'personal_sign':
+                            // Delegate signing to the smart account client instance
+                            return smartAccountClient.signMessage({ message: params[0] });
+                        case 'eth_signTypedData_v4': {
+                            // Delegate typed data signing to the smart account client instance
+                            // Note: ZKsync usually expects JSON string for EIP712, but viem standard passes object.
+                            // The smartAccountClient's signTypedData should handle the expected format internally.
+                            const signTypedDataParams = params[1]; // Assuming standard viem format
+                            return smartAccountClient.signTypedData(signTypedDataParams);
+                        }
+                        case 'eth_sendTransaction':
+                            // Delegate transaction sending to the smart account client instance.
+                            // This ensures deployment checks, paymaster logic, etc., are handled.
+                            return smartAccountClient.sendTransaction(params[0]);
+                        case 'eth_accounts':
+                        case 'eth_requestAccounts':
+                            // Return the smart account address
+                            return ((_b = smartAccountClient.account) === null || _b === void 0 ? void 0 : _b.address)
+                                ? [smartAccountClient.account.address]
+                                : [];
+                        case 'eth_chainId': {
+                            // Return chainId from the smart account client
+                            const chainId = yield smartAccountClient.getChainId();
+                            return toHex(chainId);
+                        }
+                        default: {
+                            // For other read-only methods, delegate to a basic public client transport.
+                            // Avoid creating a new client/transport on every call if possible,
+                            // but for simplicity here, we create it transiently.
+                            // Consider caching the provided client if performance becomes an issue.
+                            return smartAccountClient.request({ method, params });
+                        }
+                    }
+                });
+                // The internal confirmationTransport used by smartAccountClient via its 'owner'
+                // should handle the UI prompts. We don't need to add extra prompts here.
+                return handleRequest();
+            }),
+        });
+    }
+    getTransport(provider) {
+        const transport = confirmationTransport({
+            getAccounts: () => __awaiter(this, void 0, void 0, function* () { return [provider.account.address]; }),
+            onPersonalSign: (_a) => __awaiter(this, [_a], void 0, function* ({ message }) {
+                this._walletUiUtils.disabledConfirmationOnce();
+                if (!this._isSmartAccountDeployed) {
+                    yield this.deploySmartAccount({
+                        withPaymaster: true,
+                    });
+                }
+                this._walletUiUtils.disabledConfirmationOnce();
+                return provider.signMessage({
+                    message,
+                });
+            }),
+            onSignTypedData: (_b) => __awaiter(this, [_b], void 0, function* ({ message }) {
+                this._walletUiUtils.disabledConfirmationOnce();
+                const signTypedData = JSON.parse(message);
+                if (!this._isSmartAccountDeployed) {
+                    yield this.deploySmartAccount({
+                        withPaymaster: true,
+                    });
+                }
+                this._walletUiUtils.disabledConfirmationOnce();
+                return provider.signTypedData({
+                    domain: signTypedData.domain,
+                    message: signTypedData.message,
+                    primaryType: signTypedData.primaryType,
+                    types: signTypedData.types,
+                });
+            }),
+            provider: provider.extend(publicActions),
+            transport: custom(provider, this.providersConfig.httpTransportConfig),
+            walletConnector: this,
+            walletUiUtils: this._walletUiUtils,
+        });
+        return transport;
+    }
+    createEcdsaClient(eoaConnector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const eoaSigner = yield (eoaConnector === null || eoaConnector === void 0 ? void 0 : eoaConnector.getSigner());
+            if (!eoaSigner) {
+                throw new Error('EOA wallet client not found');
+            }
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const transport = this.getTransport(eoaSigner);
+            const ownerWithTransport = createWalletClient(Object.assign(Object.assign({}, eoaSigner), { transport }));
+            const walletClient = yield createZksyncEcdsaClient({
+                address: this.smartAccountAddress,
+                chain: getOrMapViemChain(this.evmNetworks[0]),
+                contracts: {
+                    accountFactory: this.factoryAddress,
+                    session: this.sessionKeyAddress,
+                },
+                owner: ownerWithTransport,
+                transport: custom(ownerWithTransport),
+            });
+            return walletClient;
+        });
+    }
+    /**
+     * Implementation of the interface method required by IAccountAbstractionWalletConnector
+     * @param eoaConnector - The EOA connector to use for signing transactions
+     * @param smartAccountAddress - The address of the smart account
+     */
+    initialize(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ eoaConnector, smartWalletAddress, }) {
+            this.initializedDeferredPromise = this.initializedDeferredPromise
+                ? this.initializedDeferredPromise
+                : new DeferredPromise();
+            this.eoaConnector = eoaConnector;
+            this.eoaAddress = (yield eoaConnector.getAddress());
+            this.smartAccountAddress = smartWalletAddress;
+            this.smartAccount = (yield this.createEcdsaClient(eoaConnector));
+            yield this.checkIsDeployed();
+            this.initializedDeferredPromise.resolve();
+        });
+    }
+    createSessionClient(sessionKey, sessionConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            if (!this.sessionKeyAddress) {
+                throw new Error('Session key address is not initialized');
+            }
+            return createZksyncSessionClient({
+                address: this.smartAccountAddress,
+                chain: getOrMapViemChain(this.evmNetworks[0]),
+                contracts: {
+                    session: this.sessionKeyAddress,
+                },
+                sessionConfig,
+                sessionKey,
+                transport: http(),
+            });
+        });
+    }
+    /**
+     * Creates a passkey client for ZKsync authentication
+     *
+     * This method initializes a passkey client using stored credentials and
+     * configures it with the necessary contract addresses and chain information.
+     *
+     */
+    createPasskeyClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            if (!this.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 publicClient = yield this.getTypedPublicClient();
+            const { chain } = publicClient;
+            if (!chain) {
+                throw new Error('Chain information not available');
+            }
+            const contractAddresses = {
+                accountFactory: this.factoryAddress,
+                passkey: this.passkeyAddress,
+                recovery: this.recoveryAddress,
+                session: this.sessionKeyAddress,
+            };
+            this.passkeyClient = createZksyncPasskeyClient({
+                address: this.smartAccountAddress,
+                chain,
+                contracts: contractAddresses,
+                credentialPublicKey,
+                transport: http(),
+                userDisplayName: this.smartAccountAddress,
+                userName: this.smartAccountAddress,
+            });
+        });
+    }
+    registerPasskeyAndDeploy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const { credentialPublicKey, credentialId } = yield registerNewPasskey({
+                attestationType: 'none',
+                authenticatorSelection: {
+                    authenticatorAttachment: 'platform',
+                    requireResidentKey: false,
+                    userVerification: 'required',
+                },
+                userDisplayName: this.smartAccountAddress,
+                userName: this.smartAccountAddress,
+            });
+            StorageService.setItem('credentialPublicKey', credentialPublicKey);
+            StorageService.setItem('credentialId', credentialId);
+            yield this.deploySmartAccount({
+                withPaymaster: true,
+            });
+        });
+    }
+    deploySmartAccount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ withPaymaster, }) {
+            if (!this.chainId) {
+                throw new Error('Chain ID is not initialized');
+            }
+            if (!this.eoaConnector) {
+                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;
+            const publicClient = yield this.getTypedPublicClient();
+            const walletClient = yield this.getTypedWalletClient();
+            const deploymentParams = yield getDeploymentParameters({
+                enablePasskeys: this.enablePasskeys,
+                eoaAddress: this.eoaAddress,
+                passkeyAddress: this.passkeyAddress,
+                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');
+            }
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            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);
+        });
+    }
+    /**
+     * Gets typed public client from EOA connector
+     * @throws {ZkSyncConnectorError} If public client cannot be obtained
+     * @testable This method can be mocked in tests
+     */
+    getTypedPublicClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.eoaConnector) {
+                throw new Error('EOA connector is not initialized');
+            }
+            const publicClient = yield this.eoaConnector.getPublicClient();
+            if (!publicClient) {
+                throw new Error('Failed to get public client from EOA connector');
+            }
+            return publicClient;
+        });
+    }
+    /**
+     * Gets typed wallet client from EOA connector on the correct chain
+     * @throws {ZkSyncConnectorError} If wallet client cannot be obtained
+     * @testable This method can be mocked in tests
+     */
+    getTypedWalletClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.eoaConnector) {
+                throw new Error('EOA connector is not initialized');
+            }
+            const walletClient = yield this.eoaConnector.getWalletClient();
+            if (!walletClient) {
+                throw new Error('Failed to get wallet client from EOA connector');
+            }
+            return walletClient
+                .extend(publicActions)
+                .extend(walletActions)
+                .extend(eip712WalletActions())
+                .extend(zksyncSsoEcdsaWalletActions);
+        });
+    }
+    /**
+     * Returns the parameters needed for deploying the smart account
+     * @returns Deployment parameters object
+     * @testable This method can be overridden in tests
+     */
+    getDeploymentParameters() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.eoaAddress) {
+                throw new Error('EOA address is not initialized');
+            }
+            const initialValidators = [];
+            const initialK1Owners = [this.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 (this.enablePasskeys && this.passkeyAddress) {
+                const encodedPasskeyModuleData = yield getEncodedPasskeyModuleData({
+                    passkeyAddress: this.passkeyAddress,
+                });
+                initialValidators.push(encodedPasskeyModuleData);
+            }
+            if (this.sessionKeyAddress) {
+                const encodedSessionKeyModuleData = encodeModuleData({
+                    address: this.sessionKeyAddress,
+                    parameters: '0x',
+                });
+                initialValidators.push(encodedSessionKeyModuleData);
+            }
+            return {
+                initialK1Owners,
+                initialValidators,
+                salt: getSalt(this.saltText),
+            };
+        });
+    }
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletClient = this.getWalletClient();
+            if (!walletClient) {
+                throw new Error('Error fetching signer');
+            }
+            return walletClient.signMessage({
+                account: walletClient.account,
+                message,
+            });
+        });
+    }
+    /**
+     * Checks if a smart account is deployed
+     * @throws {ZkSyncConnectorError} If the check fails
+     * @returns Promise that resolves when the check is complete
+     */
+    checkIsDeployed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const client = yield this.getPublicClient();
+            if (!client) {
+                throw new Error('Failed to get public client from EOA connector');
+            }
+            const code = yield client.getCode({
+                address: this.smartAccountAddress,
+            });
+            const isDeployed = Boolean(code);
+            this._isSmartAccountDeployed = isDeployed;
+            return isDeployed;
+        });
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield ((_a = this.initializedDeferredPromise) === null || _a === void 0 ? void 0 : _a.promise);
+            if (!this.smartAccount) {
+                throw new Error('Smart account is not initialized');
+            }
+            return this.smartAccountAddress;
+        });
+    }
+    validateActiveWallet(expectedAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentAddress = yield this.getAddress();
+            if (currentAddress !== expectedAddress) {
+                throw new DynamicError('Invalid active wallet');
+            }
+        });
+    }
+    isSmartAccountDeployed() {
+        return __awaiter(this, arguments, void 0, function* (refetch = false) {
+            if (refetch) {
+                yield this.checkIsDeployed();
+            }
+            return this._isSmartAccountDeployed;
+        });
+    }
+}
+
+export { ZKsyncConnector };

package/src/connector/index.d.ts

@@ -0,0 +1 @@
+export { ZKsyncConnector } from './ZKsyncConnector';

package/src/index.cjs

@@ -0,0 +1,25 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assertPackageVersion = require('@dynamic-labs/assert-package-version');
+var _package = require('../package.cjs');
+var ZKsyncConnector = require('./connector/ZKsyncConnector.cjs');
+require('viem');
+require('../_virtual/_tslib.cjs');
+require('zksync-sso/utils');
+require('@dynamic-labs/utils');
+var isZKsyncConnector = require('./utils/isZKsyncConnector.cjs');
+
+assertPackageVersion.assertPackageVersion('@dynamic-labs/ethereum-aa-zksync', _package.version);
+const ZKsyncSmartWalletConnectors = (props) => {
+    var _a;
+    if ((_a = props.apiProviders) === null || _a === void 0 ? void 0 : _a.zksync) {
+        return [ZKsyncConnector.ZKsyncConnector];
+    }
+    return [];
+};
+
+exports.isZKsyncConnector = isZKsyncConnector.isZKsyncConnector;
+exports.ZKsyncSmartWalletConnectors = ZKsyncSmartWalletConnectors;

package/src/index.d.ts

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

package/src/index.js

@@ -0,0 +1,20 @@
+'use client'
+import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
+import { version } from '../package.js';
+import { ZKsyncConnector } from './connector/ZKsyncConnector.js';
+import 'viem';
+import '../_virtual/_tslib.js';
+import 'zksync-sso/utils';
+import '@dynamic-labs/utils';
+export { isZKsyncConnector } from './utils/isZKsyncConnector.js';
+
+assertPackageVersion('@dynamic-labs/ethereum-aa-zksync', version);
+const ZKsyncSmartWalletConnectors = (props) => {
+    var _a;
+    if ((_a = props.apiProviders) === null || _a === void 0 ? void 0 : _a.zksync) {
+        return [ZKsyncConnector];
+    }
+    return [];
+};
+
+export { ZKsyncSmartWalletConnectors };

package/src/types/index.d.ts

@@ -0,0 +1,8 @@
+import { GenericNetwork, WalletUiUtils } from '@dynamic-labs/types';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { InternalWalletConnector } from '@dynamic-labs/wallet-connector-core';
+export type AccountAbstractionConnectorProps = {
+    walletUiUtils: WalletUiUtils<InternalWalletConnector>;
+    walletBook: WalletBookSchema;
+    evmNetworks: GenericNetwork[];
+};

package/src/utils/abi.cjs

@@ -0,0 +1,88 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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',
+    },
+];
+
+exports.AAFactoryABI = AAFactoryABI;