@dynamic-labs/ethereum-aa 4.9.11 → 4.9.13-preview.0

package/src/ZKsync/walletActions.cjs

@@ -0,0 +1,93 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var viem = require('viem');
+var actions = require('viem/actions');
+var zksync = require('viem/zksync');
+var paymaster = require('zksync-sso/paymaster');
+
+const zksyncSsoEcdsaWalletActions = (client) => ({
+    deployContract: (args) => actions.deployContract(client, args),
+    getAddresses: () => actions.getAddresses(client),
+    getChainId: () => actions.getChainId(client),
+    sendRawTransaction: (args) => actions.sendRawTransaction(client, args),
+    sendTransaction: (args) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const unformattedTx = Object.assign({}, args);
+        if ('eip712Meta' in unformattedTx) {
+            const eip712Meta = unformattedTx.eip712Meta;
+            unformattedTx.gasPerPubdata = eip712Meta.gasPerPubdata
+                ? BigInt(eip712Meta.gasPerPubdata)
+                : undefined;
+            unformattedTx.factoryDeps = eip712Meta.factoryDeps;
+            unformattedTx.customSignature = eip712Meta.customSignature;
+            unformattedTx.paymaster = (_a = eip712Meta.paymasterParams) === null || _a === void 0 ? void 0 : _a.paymaster;
+            unformattedTx.paymasterInput = ((_b = eip712Meta.paymasterParams) === null || _b === void 0 ? void 0 : _b.paymasterInput)
+                ? viem.bytesToHex(new Uint8Array((_c = eip712Meta.paymasterParams) === null || _c === void 0 ? void 0 : _c.paymasterInput))
+                : undefined;
+            delete unformattedTx.eip712Meta;
+        }
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        const _f = yield paymaster.getTransactionWithPaymasterData(client.chain.id, client.account.address, unformattedTx, client.paymasterHandler), unformattedTxWithPaymaster = _tslib.__rest(_f, ["chainId"]);
+        const formatters = (_d = client.chain) === null || _d === void 0 ? void 0 : _d.formatters;
+        const format = ((_e = formatters === null || formatters === void 0 ? void 0 : formatters.transaction) === null || _e === void 0 ? void 0 : _e.format) || viem.formatTransaction;
+        const tx = Object.assign(Object.assign({}, format(unformattedTxWithPaymaster)), { type: 'eip712' });
+        return yield sendEip712Transaction(client, tx);
+    }),
+    signMessage: (args) => actions.signMessage(client, args),
+    signTransaction: (args) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        const _g = yield paymaster.getTransactionWithPaymasterData(client.chain.id, client.account.address, args, client.paymasterHandler), unformattedTxWithPaymaster = _tslib.__rest(_g, ["chainId"]);
+        return zksync.signTransaction(client, Object.assign(Object.assign({}, args), { type: 'eip712', unformattedTxWithPaymaster }));
+    }),
+    signTypedData: (args) => actions.signTypedData(client, args),
+    writeContract: (args) => actions.writeContract(client, args),
+});
+const sendEip712Transaction = (client, parameters) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    var _h;
+    const { account: account_ = client.account, chain = client.chain } = parameters, rest = _tslib.__rest(parameters, ["account", "chain"]);
+    if (!account_)
+        throw new Error('Account not found.');
+    const { account } = client;
+    if (!account)
+        throw new Error('Account not found.');
+    const request = yield getAction(client, actions.prepareTransactionRequest, 'prepareTransactionRequest')(Object.assign({ account,
+        chain, nonceManager: account.nonceManager }, rest));
+    const serializer = (_h = chain === null || chain === void 0 ? void 0 : chain.serializers) === null || _h === void 0 ? void 0 : _h.transaction;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const serializedTransaction = (yield account.signTransaction(request, {
+        serializer,
+    }));
+    return yield getAction(client, actions.sendRawTransaction, 'sendRawTransaction')({
+        serializedTransaction,
+    });
+});
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
+const getAction = (client, actionFn, 
+// cspell:ignore minifiers
+// Some minifiers drop `Function.prototype.name`, or replace it with short letters,
+// meaning that `actionFn.name` will not always work. For that case, the consumer
+// needs to pass the name explicitly.
+name) => {
+    const action_implicit = client[actionFn.name];
+    if (typeof action_implicit === 'function')
+        return action_implicit;
+    const action_explicit = client[name];
+    if (typeof action_explicit === 'function')
+        return action_explicit;
+    return (params) => actionFn(client, params);
+};
+
+exports.getAction = getAction;
+exports.sendEip712Transaction = sendEip712Transaction;
+exports.zksyncSsoEcdsaWalletActions = zksyncSsoEcdsaWalletActions;

package/src/ZKsync/walletActions.d.ts

@@ -0,0 +1,15 @@
+import { type Account, type Chain, type Client, type PublicActions, type RpcSchema, type SendTransactionRequest, type Transport, type WalletActions } from 'viem';
+import { type ChainEIP712, type SendEip712TransactionParameters, type SendEip712TransactionReturnType } from 'viem/zksync';
+export type ZksyncSsoEcdsaWalletActions<chain extends Chain, account extends Account> = Omit<WalletActions<chain, account>, 'addChain' | 'getPermissions' | 'requestAddresses' | 'requestPermissions' | 'switchChain' | 'watchAsset' | 'prepareTransactionRequest'>;
+export declare const zksyncSsoEcdsaWalletActions: <transport extends Transport, chain extends Chain, account extends Account>(client: Client<transport, chain, account>) => any;
+export declare const sendEip712Transaction: <chain extends ChainEIP712 | undefined, account extends Account | undefined, request extends SendTransactionRequest<chain, chainOverride>, chainOverride extends ChainEIP712 | undefined = undefined>(client: Client<Transport, chain, account>, parameters: SendEip712TransactionParameters<chain, account, chainOverride, request>) => Promise<SendEip712TransactionReturnType>;
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
+export declare const getAction: <transport extends Transport, chain extends Chain | undefined, account extends Account | undefined, rpcSchema extends RpcSchema | undefined, extended extends {
+    [key: string]: unknown;
+}, client extends Client<transport, chain, account, rpcSchema, extended>, parameters, returnType>(client: client, actionFn: (_: any, parameters: parameters) => returnType, name: keyof PublicActions | keyof WalletActions | string) => ((parameters: parameters) => returnType);

package/src/ZKsync/walletActions.js

@@ -0,0 +1,87 @@
+'use client'
+import { __awaiter, __rest } from '../../_virtual/_tslib.js';
+import { bytesToHex, formatTransaction } from 'viem';
+import { deployContract, getAddresses, getChainId, sendRawTransaction, signMessage, signTypedData, writeContract, prepareTransactionRequest } from 'viem/actions';
+import { signTransaction } from 'viem/zksync';
+import { getTransactionWithPaymasterData } from 'zksync-sso/paymaster';
+
+const zksyncSsoEcdsaWalletActions = (client) => ({
+    deployContract: (args) => deployContract(client, args),
+    getAddresses: () => getAddresses(client),
+    getChainId: () => getChainId(client),
+    sendRawTransaction: (args) => sendRawTransaction(client, args),
+    sendTransaction: (args) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const unformattedTx = Object.assign({}, args);
+        if ('eip712Meta' in unformattedTx) {
+            const eip712Meta = unformattedTx.eip712Meta;
+            unformattedTx.gasPerPubdata = eip712Meta.gasPerPubdata
+                ? BigInt(eip712Meta.gasPerPubdata)
+                : undefined;
+            unformattedTx.factoryDeps = eip712Meta.factoryDeps;
+            unformattedTx.customSignature = eip712Meta.customSignature;
+            unformattedTx.paymaster = (_a = eip712Meta.paymasterParams) === null || _a === void 0 ? void 0 : _a.paymaster;
+            unformattedTx.paymasterInput = ((_b = eip712Meta.paymasterParams) === null || _b === void 0 ? void 0 : _b.paymasterInput)
+                ? bytesToHex(new Uint8Array((_c = eip712Meta.paymasterParams) === null || _c === void 0 ? void 0 : _c.paymasterInput))
+                : undefined;
+            delete unformattedTx.eip712Meta;
+        }
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        const _f = yield getTransactionWithPaymasterData(client.chain.id, client.account.address, unformattedTx, client.paymasterHandler), unformattedTxWithPaymaster = __rest(_f, ["chainId"]);
+        const formatters = (_d = client.chain) === null || _d === void 0 ? void 0 : _d.formatters;
+        const format = ((_e = formatters === null || formatters === void 0 ? void 0 : formatters.transaction) === null || _e === void 0 ? void 0 : _e.format) || formatTransaction;
+        const tx = Object.assign(Object.assign({}, format(unformattedTxWithPaymaster)), { type: 'eip712' });
+        return yield sendEip712Transaction(client, tx);
+    }),
+    signMessage: (args) => signMessage(client, args),
+    signTransaction: (args) => __awaiter(void 0, void 0, void 0, function* () {
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        const _g = yield getTransactionWithPaymasterData(client.chain.id, client.account.address, args, client.paymasterHandler), unformattedTxWithPaymaster = __rest(_g, ["chainId"]);
+        return signTransaction(client, Object.assign(Object.assign({}, args), { type: 'eip712', unformattedTxWithPaymaster }));
+    }),
+    signTypedData: (args) => signTypedData(client, args),
+    writeContract: (args) => writeContract(client, args),
+});
+const sendEip712Transaction = (client, parameters) => __awaiter(void 0, void 0, void 0, function* () {
+    var _h;
+    const { account: account_ = client.account, chain = client.chain } = parameters, rest = __rest(parameters, ["account", "chain"]);
+    if (!account_)
+        throw new Error('Account not found.');
+    const { account } = client;
+    if (!account)
+        throw new Error('Account not found.');
+    const request = yield getAction(client, prepareTransactionRequest, 'prepareTransactionRequest')(Object.assign({ account,
+        chain, nonceManager: account.nonceManager }, rest));
+    const serializer = (_h = chain === null || chain === void 0 ? void 0 : chain.serializers) === null || _h === void 0 ? void 0 : _h.transaction;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const serializedTransaction = (yield account.signTransaction(request, {
+        serializer,
+    }));
+    return yield getAction(client, sendRawTransaction, 'sendRawTransaction')({
+        serializedTransaction,
+    });
+});
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
+const getAction = (client, actionFn, 
+// cspell:ignore minifiers
+// Some minifiers drop `Function.prototype.name`, or replace it with short letters,
+// meaning that `actionFn.name` will not always work. For that case, the consumer
+// needs to pass the name explicitly.
+name) => {
+    const action_implicit = client[actionFn.name];
+    if (typeof action_implicit === 'function')
+        return action_implicit;
+    const action_explicit = client[name];
+    if (typeof action_explicit === 'function')
+        return action_explicit;
+    return (params) => actionFn(client, params);
+};
+
+export { getAction, sendEip712Transaction, zksyncSsoEcdsaWalletActions };

package/src/ZKsyncConnector.cjs

@@ -0,0 +1,430 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var viem = require('viem');
+var zksync = require('viem/zksync');
+var client$1 = require('zksync-sso/client');
+var passkey = require('zksync-sso/client/passkey');
+var ethereumCore = require('@dynamic-labs/ethereum-core');
+var utils = require('@dynamic-labs/utils');
+var AccountAbstractionConnector = require('./AccountAbstractionConnector.cjs');
+var abi = require('./utils/abi.cjs');
+var walletActions = require('./ZKsync/walletActions.cjs');
+var client = require('./ZKsync/client.cjs');
+
+class ZKsyncConnector extends AccountAbstractionConnector.AccountAbstractionConnector {
+    constructor(props) {
+        var _a, _b, _c, _d, _e;
+        super(props);
+        // Core wallet properties
+        this.ChainWallet = ethereumCore.EthereumWallet;
+        this.name = 'ZKsync';
+        this.overrideKey = 'zksync';
+        // Chain configuration
+        this.connectedChain = 'EVM';
+        this.evmNetworks = [];
+        this.supportedChains = ['ETH', 'EVM'];
+        this.enableEIP7702Mode = false;
+        this.walletFallback = {
+            brand: {
+                alt: 'Smart Wallet',
+                spriteId: 'smartwallet',
+            },
+            name: 'ZKsync',
+        };
+        this._walletUiUtils = props.walletUiUtils;
+        this.chainId = (_a = props.apiProviders.zksync) === null || _a === void 0 ? void 0 : _a.defaultChainId;
+        this.evmNetworks = utils.parseEvmNetworks(props.evmNetworks).filter((network) => network.chainId === this.chainId);
+        this.factoryAddress = ((_c = (_b = props.apiProviders.zksync) === null || _b === void 0 ? void 0 : _b.factoryAddress) !== null && _c !== void 0 ? _c : '0x2e620D52467CfA4C664F92005Ab0f0181d3d1E79'); // Fallback if not provided
+        this.paymasterAddress = ((_e = (_d = props.apiProviders.zksync) === null || _d === void 0 ? void 0 : _d.paymasterAddress) !== null && _e !== void 0 ? _e : '0xA78CAC56c9D491Ece2FF303aEcc627Bf71C6dc1c'); // Fallback if not provided
+    }
+    getEnabledNetworks() {
+        return this.evmNetworks;
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            return [this.smartAccountAddress];
+        });
+    }
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            return this.chainId;
+        });
+    }
+    getPublicClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return viem.createPublicClient({
+                chain: zksync.zksyncSepoliaTestnet,
+                transport: viem.http(),
+            });
+        });
+    }
+    canSponsorTransactionGas() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    getAccountAbstractionProvider() {
+        return this.smartAccount;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getWalletClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const eoaSigner = yield ((_a = this.eoaConnector) === null || _a === void 0 ? void 0 : _a.getSigner());
+            if (!eoaSigner) {
+                throw new Error('EOA wallet client not found');
+            }
+            const walletClient = yield client.createZksyncEcdsaClient({
+                address: this.smartAccountAddress,
+                chain: zksync.zksyncSepoliaTestnet,
+                contracts: {
+                    accountFactory: this.factoryAddress,
+                    session: '0x5Da0ba1366F05a14603FC6aC906B99CdC6BA851A',
+                },
+                owner: eoaSigner,
+                transport: viem.http(),
+            });
+            return walletClient;
+        });
+    }
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.getWalletClient();
+        });
+    }
+    /**
+     * 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 _tslib.__awaiter(this, arguments, void 0, function* ({ eoaConnector, smartAccountAddress, }) {
+            this.eoaConnector = eoaConnector;
+            this.eoaAddress = yield eoaConnector.getAddress();
+            this.smartAccountAddress = smartAccountAddress;
+            this.smartAccount = (yield this.getWalletClient());
+            // Check if account needs deployment
+            const shouldDeploy = yield this.shouldDeployAccount(smartAccountAddress);
+            if (!shouldDeploy) {
+                return;
+            }
+        });
+    }
+    createPasskeyClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const storedCredentialPublicKey = utils.StorageService.getItem('credentialPublicKey');
+            const credentialPublicKey = storedCredentialPublicKey
+                ? new Uint8Array(Object.values(storedCredentialPublicKey))
+                : null;
+            if (!credentialPublicKey) {
+                throw new Error('Credential public key not found');
+            }
+            const publicClient = yield this.getTypedPublicClient();
+            const { chain } = publicClient;
+            if (!chain) {
+                throw new Error('Chain not found');
+            }
+            const passkeyClient = passkey.createZksyncPasskeyClient({
+                address: '0xf2484bEA13038C2d110dCf0DfCF3b251B8d6A7Ea',
+                chain,
+                contracts: {
+                    accountFactory: this.factoryAddress,
+                    passkey: '0xF69e92B224f527365F4434B729134aE69C60B963',
+                    session: '0x5Da0ba1366F05a14603FC6aC906B99CdC6BA851A',
+                },
+                credentialPublicKey,
+                transport: viem.http(),
+                userDisplayName: 'Vinicius',
+                userName: 'vinicius.macelai@gmail.com',
+            });
+            this.passkeyClient = passkeyClient;
+        });
+    }
+    // Create your account client
+    createSmartAccountClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.smartAccount;
+        });
+    }
+    deploySmartAccountWithZksyncSso() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const walletClient = yield this.getWalletClient();
+            if (!walletClient) {
+                throw new Error('Wallet client not found');
+            }
+            const deploymentParams = yield this.getDeploymentParameters();
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const shouldDeploy = yield this.shouldDeployAccount(this.smartAccountAddress);
+            if (!shouldDeploy) {
+                throw new Error('Smart account already deployed');
+            }
+            const paymasterInput = zksync.getGeneralPaymasterInput({
+                innerInput: new Uint8Array(),
+            });
+            const storedCredentialPublicKey = utils.StorageService.getItem('credentialPublicKey');
+            let credentialPublicKey = storedCredentialPublicKey
+                ? new Uint8Array(Object.values(storedCredentialPublicKey))
+                : null;
+            if (!credentialPublicKey) {
+                const { credentialPublicKey: newCredentialPublicKey } = yield passkey.registerNewPasskey({
+                    attestationType: 'none',
+                    authenticatorSelection: {
+                        authenticatorAttachment: 'platform',
+                        requireResidentKey: false,
+                        userVerification: 'required',
+                    },
+                    userDisplayName: this.smartAccountAddress,
+                    userName: this.smartAccountAddress,
+                });
+                utils.StorageService.setItem('credentialPublicKey', newCredentialPublicKey);
+                credentialPublicKey = new Uint8Array(newCredentialPublicKey);
+            }
+            if (!((_a = walletClient.account) === null || _a === void 0 ? void 0 : _a.address)) {
+                throw new Error('Wallet client not found');
+            }
+            yield client$1.deployAccount(walletClient, {
+                contracts: {
+                    accountFactory: this.factoryAddress,
+                    passkey: '0xa9ab0dE9d83cc4827261EaccF536859f4A562b72',
+                    session: '0x5Da0ba1366F05a14603FC6aC906B99CdC6BA851A',
+                },
+                credentialId: (_b = walletClient.account) === null || _b === void 0 ? void 0 : _b.address,
+                credentialPublicKey,
+                paymasterAddress: '0xa20D5f00A693e4Eb260AAdc7458fe415981c8051',
+                paymasterInput: paymasterInput,
+                uniqueAccountId: deploymentParams.salt,
+            });
+        });
+    }
+    deploySmartAccountWithPaymaster() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            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 = zksync.getGeneralPaymasterInput({
+                innerInput: new Uint8Array(),
+            });
+            const requestWithPaymaster = Object.assign(Object.assign({}, request), { paymaster,
+                paymasterInput });
+            yield this.executeAccountDeployment(walletClient, requestWithPaymaster);
+        });
+    }
+    signMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const walletClient = yield this.getWalletClient();
+            if (!walletClient) {
+                throw new Error('Wallet client not found');
+            }
+            return yield walletClient.signMessage({
+                account: walletClient.account,
+                message,
+            });
+        });
+    }
+    /**
+     * Deploys a new smart account contract
+     * @throws {ZkSyncConnectorError} If deployment fails
+     * @testable This method can be mocked in tests
+     */
+    deploySmartAccount() {
+        return _tslib.__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 _tslib.__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 _tslib.__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(viem.publicActions)
+                .extend(viem.walletActions)
+                .extend(zksync.eip712WalletActions())
+                .extend(walletActions.zksyncSsoEcdsaWalletActions);
+        });
+    }
+    /**
+     * Returns the parameters needed for deploying the smart account
+     * @returns Deployment parameters object
+     * @testable This method can be overridden in tests
+     */
+    getDeploymentParameters() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const salt = `0x${Buffer.from(viem.toBytes('DynamicLabs', { size: 32 })).toString('hex')}`;
+            const initialValidators = [];
+            const initialK1Owners = [this.eoaAddress];
+            return {
+                initialK1Owners,
+                initialValidators,
+                salt,
+            };
+        });
+    }
+    /**
+     * 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 _tslib.__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 = viem.keccak256(viem.toHex(params.salt));
+            const gasEstimate = yield publicClient.estimateContractGas({
+                abi: 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 yield publicClient.simulateContract({
+                abi: 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 request to execute
+     * @throws {ZkSyncConnectorError} If transaction execution fails
+     * @testable This method can be mocked in tests
+     */
+    executeAccountDeployment(walletClient, request) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            const shouldDeploy = yield this.shouldDeployAccount(this.smartAccountAddress);
+            if (!shouldDeploy) {
+                throw new Error('Smart account already deployed');
+            }
+            yield walletClient.writeContract(request);
+        });
+    }
+    /**
+     * Checks if a smart account needs to be deployed
+     * @param smartAccountAddress - The address of the smart account
+     * @returns True if the account needs to be deployed, false otherwise
+     * @throws {ZkSyncConnectorError} If the check fails
+     * @testable This method can be mocked in tests
+     */
+    shouldDeployAccount(smartAccountAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const client = yield ((_a = this.eoaConnector) === null || _a === void 0 ? void 0 : _a.getPublicClient());
+            if (!client) {
+                throw new Error('Failed to get public client from EOA connector');
+            }
+            const code = yield client.getCode({
+                address: smartAccountAddress,
+            });
+            return !code || code === '0x';
+        });
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccount) {
+                throw new Error('Smart account is not initialized');
+            }
+            return this.smartAccountAddress;
+        });
+    }
+    validateActiveWallet(expectedAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const currentAddress = yield this.getAddress();
+            if (currentAddress !== expectedAddress) {
+                throw new utils.DynamicError('Invalid active wallet');
+            }
+            return;
+        });
+    }
+    createUiTransaction(from) {
+        return _tslib.__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 utils.DynamicError('No public client available');
+            }
+            return ethereumCore.createViemUiTransaction({
+                from: from,
+                publicClient: publicClient,
+                walletClient: walletClient,
+            });
+        });
+    }
+    registerEoa(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ smartWalletAddress, eoaAddress, eoaConnector, shouldSetEoaConnector, }) {
+            throw new Error('Not implemented');
+        });
+    }
+}
+
+exports.ZKsyncConnector = ZKsyncConnector;