@dynamic-labs/ethereum-aa 4.10.4-preview.2 → 4.11.0

package/src/ZKsyncConnector.js

@@ -1,586 +0,0 @@
-'use client'
-import { __awaiter } from '../_virtual/_tslib.js';
-import { createPublicClient, http, createWalletClient, custom, publicActions, walletActions, toBytes, keccak256, toHex } from 'viem';
-import { getGeneralPaymasterInput, eip712WalletActions } from 'viem/zksync';
-import { createZksyncPasskeyClient, registerNewPasskey } from 'zksync-sso/client/passkey';
-import { encodeModuleData, getPublicKeyBytesFromPasskeySignature, encodePasskeyModuleParameters } from 'zksync-sso/utils';
-import { createZksyncSessionClient } from 'zksync-sso/client';
-import { createZksyncEcdsaClient, zksyncSsoEcdsaWalletActions } from 'zksync-sso/client/ecdsa';
-import { EthereumWallet, getOrMapViemChain, confirmationTransport, createViemUiTransaction } from '@dynamic-labs/ethereum-core';
-import { parseEvmNetworks, DeferredPromise, StorageService, DynamicError } from '@dynamic-labs/utils';
-import { AccountAbstractionConnector } from './AccountAbstractionConnector.js';
-import { AAFactoryABI } from './utils/abi.js';
-
-class ZKsyncConnector extends AccountAbstractionConnector {
-    constructor(props) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        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.enablePasskeys =
-            (_h = (_g = props.settings.sdk.accountAbstraction) === null || _g === void 0 ? void 0 : _g.enablePasskeys) !== null && _h !== void 0 ? _h : 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() {
-        const smartAccountClient = this.smartAccount;
-        if (!smartAccountClient) {
-            return undefined;
-        }
-        const transport = this.getWalletClientTransport(smartAccountClient);
-        return createWalletClient({
-            account: smartAccountClient.account,
-            chain: 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 this public client if performance becomes an issue.
-                            const publicClient = createPublicClient({
-                                chain: smartAccountClient.chain,
-                                transport: http(undefined, this.providersConfig.httpTransportConfig), // Use configured transport if available
-                            });
-                            return publicClient.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),
-            // TODO: remove this. We should not be passing references to wallet connectors
-            walletConnector: this,
-            walletUiUtils: this._walletUiUtils,
-        });
-        return transport;
-    }
-    getSigner() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getWalletClient();
-        });
-    }
-    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');
-            }
-            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
-     */
-    initializeZksyncConnector(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ eoaConnector, smartAccountAddress, }) {
-            this.initializedDeferredPromise = this.initializedDeferredPromise
-                ? this.initializedDeferredPromise
-                : new DeferredPromise();
-            this.eoaConnector = eoaConnector;
-            this.eoaAddress = yield eoaConnector.getAddress();
-            this.smartAccountAddress = smartAccountAddress;
-            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');
-            }
-            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');
-            }
-            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,
-                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* () {
-            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 (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');
-            }
-            const paymaster = this.paymasterAddress;
-            const publicClient = yield this.getTypedPublicClient();
-            const walletClient = yield this.getTypedWalletClient();
-            const deploymentParams = yield this.getDeploymentParameters();
-            const { request } = yield this.simulateAccountDeployment(publicClient, walletClient, deploymentParams, false);
-            const paymasterInput = getGeneralPaymasterInput({
-                innerInput: new Uint8Array(),
-            });
-            const requestWithPaymaster = Object.assign(Object.assign({}, request), { paymaster,
-                paymasterInput });
-            yield this.executeAccountDeployment(walletClient, requestWithPaymaster);
-        });
-    }
-    /**
-     * 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');
-            }
-            const walletClient = yield this.getTypedWalletClient();
-            const publicClient = yield this.getTypedPublicClient();
-            const deploymentParams = yield this.getDeploymentParameters();
-            // Simulate the contract deployment first
-            const { request } = yield this.simulateAccountDeployment(publicClient, walletClient, deploymentParams, false);
-            // Execute the deployment transaction
-            yield this.executeAccountDeployment(walletClient, request);
-        });
-    }
-    /**
-     * 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
-     * @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* () {
-            const salt = `0x${Buffer.from(toBytes('DynamicLabs', { size: 32 })).toString('hex')}`;
-            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 this.getEncodedPasskeyModuleData();
-                initialValidators.push(encodedPasskeyModuleData);
-            }
-            if (this.sessionKeyAddress) {
-                const encodedSessionKeyModuleData = encodeModuleData({
-                    address: this.sessionKeyAddress,
-                    parameters: '0x',
-                });
-                initialValidators.push(encodedSessionKeyModuleData);
-            }
-            return {
-                initialK1Owners,
-                initialValidators,
-                salt,
-            };
-        });
-    }
-    /**
-     * 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
-     */
-    getEncodedPasskeyModuleData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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, // TODO: how is this going to be set?
-                passkeyPublicKey,
-            });
-            return encodeModuleData({
-                address: this.passkeyAddress,
-                parameters: encodedPasskeyParameters,
-            });
-        });
-    }
-    /**
-     * 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
-     */
-    simulateAccountDeployment(publicClient_1, walletClient_1, params_1) {
-        return __awaiter(this, arguments, void 0, function* (publicClient, walletClient, params, checkBalance = true) {
-            var _a, _b, _c;
-            // 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: (_a = walletClient.account) === null || _a === void 0 ? void 0 : _a.address,
-                address: this.factoryAddress,
-                args: [salt, params.initialValidators, params.initialK1Owners],
-                functionName: 'deployProxySsoAccount',
-            });
-            if (checkBalance) {
-                const balance = yield publicClient.getBalance({
-                    address: (_b = walletClient.account) === null || _b === void 0 ? void 0 : _b.address,
-                });
-                if (balance < gasEstimate) {
-                    throw new Error('Insufficient balance to deploy account');
-                }
-            }
-            // Simulate the contract call
-            return publicClient.simulateContract({
-                abi: AAFactoryABI,
-                account: (_c = walletClient.account) === null || _c === void 0 ? void 0 : _c.address,
-                address: this.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
-     */
-    executeAccountDeployment(walletClient, request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.smartAccountAddress) {
-                throw new Error('Smart account address is not initialized');
-            }
-            const tx = yield walletClient.writeContract(request);
-            const publicClient = yield this.getPublicClient();
-            yield publicClient.waitForTransactionReceipt({ hash: tx });
-            this._isSmartAccountDeployed = true;
-        });
-    }
-    signMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const walletClient = this.getWalletClient();
-            if (!walletClient) {
-                throw new Error('Wallet client not found');
-            }
-            return yield 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* () {
-            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;
-        });
-    }
-    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');
-            }
-            return;
-        });
-    }
-    createUiTransaction(from) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.validateActiveWallet(from);
-            const walletClient = this.getWalletClient();
-            const publicClient = yield this.getPublicClient();
-            if (!publicClient || !walletClient) {
-                throw new DynamicError('No public client available');
-            }
-            return createViemUiTransaction({
-                from: from,
-                publicClient: publicClient,
-                walletClient: walletClient,
-            });
-        });
-    }
-    isSmartAccountDeployed() {
-        return __awaiter(this, arguments, void 0, function* (refetch = false) {
-            if (refetch) {
-                yield this.checkIsDeployed();
-            }
-            return this._isSmartAccountDeployed;
-        });
-    }
-    registerEoa(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ smartWalletAddress, eoaAddress, eoaConnector, shouldSetEoaConnector, }) {
-            throw new Error('Not implemented');
-        });
-    }
-}
-
-export { ZKsyncConnector };

package/src/utils/abi.cjs

@@ -1,88 +0,0 @@
-'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;