@dynamic-labs/ethereum-aa 4.9.12 → 4.9.13-preview.1

package/src/ZKsyncConnector.js

@@ -0,0 +1,426 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { createPublicClient, http, publicActions, walletActions, toBytes, keccak256, toHex } from 'viem';
+import { getGeneralPaymasterInput, eip712WalletActions } from 'viem/zksync';
+import { deployAccount } from 'zksync-sso/client';
+import { createZksyncPasskeyClient, registerNewPasskey } from 'zksync-sso/client/passkey';
+import { EthereumWallet, getOrMapViemChain, createViemUiTransaction } from '@dynamic-labs/ethereum-core';
+import { parseEvmNetworks, StorageService, DynamicError } from '@dynamic-labs/utils';
+import { AccountAbstractionConnector } from './AccountAbstractionConnector.js';
+import { AAFactoryABI } from './utils/abi.js';
+import { zksyncSsoEcdsaWalletActions } from './ZKsync/walletActions.js';
+import { createZksyncEcdsaClient } from './ZKsync/client.js';
+
+class ZKsyncConnector extends AccountAbstractionConnector {
+    constructor(props) {
+        var _a, _b, _c, _d, _e;
+        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.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 = 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 __awaiter(this, void 0, void 0, function* () {
+            if (!this.smartAccountAddress) {
+                throw new Error('Smart account address is not initialized');
+            }
+            return [this.smartAccountAddress];
+        });
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getWalletClient() {
+        return __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 createZksyncEcdsaClient({
+                address: this.smartAccountAddress,
+                chain: getOrMapViemChain(this.evmNetworks[0]),
+                contracts: {
+                    accountFactory: this.factoryAddress,
+                    session: '0x5Da0ba1366F05a14603FC6aC906B99CdC6BA851A',
+                },
+                owner: eoaSigner,
+                transport: http(),
+            });
+            return walletClient;
+        });
+    }
+    getSigner() {
+        return __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 __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 __awaiter(this, void 0, void 0, function* () {
+            const storedCredentialPublicKey = 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 = createZksyncPasskeyClient({
+                address: '0xf2484bEA13038C2d110dCf0DfCF3b251B8d6A7Ea',
+                chain,
+                contracts: {
+                    accountFactory: this.factoryAddress,
+                    passkey: '0xF69e92B224f527365F4434B729134aE69C60B963',
+                    session: '0x5Da0ba1366F05a14603FC6aC906B99CdC6BA851A',
+                },
+                credentialPublicKey,
+                transport: http(),
+                userDisplayName: 'Vinicius',
+                userName: 'vinicius.macelai@gmail.com',
+            });
+            this.passkeyClient = passkeyClient;
+        });
+    }
+    // Create your account client
+    createSmartAccountClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.smartAccount;
+        });
+    }
+    deploySmartAccountWithZksyncSso() {
+        return __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 = getGeneralPaymasterInput({
+                innerInput: new Uint8Array(),
+            });
+            const storedCredentialPublicKey = StorageService.getItem('credentialPublicKey');
+            let credentialPublicKey = storedCredentialPublicKey
+                ? new Uint8Array(Object.values(storedCredentialPublicKey))
+                : null;
+            if (!credentialPublicKey) {
+                const { credentialPublicKey: newCredentialPublicKey } = yield registerNewPasskey({
+                    attestationType: 'none',
+                    authenticatorSelection: {
+                        authenticatorAttachment: 'platform',
+                        requireResidentKey: false,
+                        userVerification: 'required',
+                    },
+                    userDisplayName: this.smartAccountAddress,
+                    userName: this.smartAccountAddress,
+                });
+                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 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 __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 = getGeneralPaymasterInput({
+                innerInput: new Uint8Array(),
+            });
+            const requestWithPaymaster = Object.assign(Object.assign({}, request), { paymaster,
+                paymasterInput });
+            yield this.executeAccountDeployment(walletClient, requestWithPaymaster);
+        });
+    }
+    signMessage(message) {
+        return __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 __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];
+            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 __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 yield 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 request to execute
+     * @throws {ZkSyncConnectorError} If transaction execution fails
+     * @testable This method can be mocked in tests
+     */
+    executeAccountDeployment(walletClient, request) {
+        return __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 __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 __awaiter(this, void 0, void 0, function* () {
+            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,
+            });
+        });
+    }
+    registerEoa(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ smartWalletAddress, eoaAddress, eoaConnector, shouldSetEoaConnector, }) {
+            throw new Error('Not implemented');
+        });
+    }
+}
+
+export { ZKsyncConnector };

package/src/ZeroDevConnector.cjs

@@ -16,8 +16,9 @@ var createEcsdaKernelAccountClient = require('./utils/createEcsdaKernelAccountCl
 var getEcdsaValidator = require('./utils/getEcdsaValidator.cjs');
 var getEntryPoint = require('./utils/getEntryPoint.cjs');
 var getKernelVersion = require('./utils/getKernelVersion.cjs');
+var AccountAbstractionConnector = require('./AccountAbstractionConnector.cjs');
 
-class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
+class ZeroDevConnector extends AccountAbstractionConnector.AccountAbstractionConnector {
     constructor(opts) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         super(opts);
@@ -28,7 +29,6 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
         this.ChainWallet = ethereumCore.EthereumWallet;
         this.connectedChain = 'EVM';
         this.supportedChains = ['ETH', 'EVM'];
-        this.isGasSponsorshipDisabled = false;
         this.isEmbeddedWallet = true;
         this.providersFromApi = [];
         this.name = 'ZeroDev';
@@ -60,6 +60,9 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
         this.defaultChainId = defaultProvider === null || defaultProvider === void 0 ? void 0 : defaultProvider.chain;
         this.ecdsaProviderType = (_j = opts.apiProviders.zerodev) === null || _j === void 0 ? void 0 : _j.ecdsaProviderType;
     }
+    confirmTransactionStatus() {
+        throw new Error('confirmTransactionStatus not implemented in ZeroDevConnector');
+    }
     get currentNetworkProvider() {
         // check if the last used chain id is in the provider map
         if (this.providerMap[this.lastUsedChainId]) {
@@ -104,13 +107,6 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
             handleChainChange(chainId);
         });
     }
-    /**
-     * @deprecated You should get the EOA connector by passing the SCW to getEOAConnector,
-     * from the useSmartWallet hook
-     */
-    getEOAConnector() {
-        return this.eoaConnector;
-    }
     getAccountAbstractionProvider({ withSponsorship, } = {}) {
         if (withSponsorship && this.kernelClientWithSponsorship) {
             return this.kernelClientWithSponsorship;
@@ -122,6 +118,14 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
             utils.StorageService.removeItem(constants.ZERO_DEV_LAST_USED_CHAIN_ID_KEY);
         });
     }
+    initialize(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ smartWalletAddress, eoaAddress, eoaConnector, properties, shouldSetEoaConnector, }) {
+            yield this.registerEoa(Object.assign({ eoaAddress,
+                eoaConnector,
+                shouldSetEoaConnector,
+                smartWalletAddress }, properties));
+        });
+    }
     registerEoa(_a) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             var { smartWalletAddress, eoaAddress, eoaConnector, shouldSetEoaConnector = false } = _a, properties = _tslib.__rest(_a, ["smartWalletAddress", "eoaAddress", "eoaConnector", "shouldSetEoaConnector"]);
@@ -258,6 +262,7 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
                         signer,
                     }),
                     this.createKernelClient({
+                        authorization: this.authorization,
                         chainId: chain,
                         paymaster: 'SPONSOR',
                         projectId: clientId,
@@ -281,7 +286,7 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
         });
     }
     createKernelClient(_a) {
-        return _tslib.__awaiter(this, arguments, void 0, function* ({ chainId, projectId, signer, paymaster, }) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ chainId, projectId, signer, paymaster, authorization, }) {
             if (chainId && this.providerMap[chainId]) {
                 return paymaster === 'SPONSOR'
                     ? this.providerMap[chainId].kernelClientWithSponsorship
@@ -292,9 +297,9 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
                 throw new utils.DynamicError('No EOA connector');
             const chain = ethereumCore.chainsMap[chainId];
             let kernelClient;
-            if (this.enableEIP7702Mode && this.authorization) {
+            if (this.enableEIP7702Mode) {
                 kernelClient = yield createEcsdaKernelAccountClient.createEcdsaKernelAccountClientWith7702({
-                    authorization: this.authorization,
+                    authorization,
                     bundlerRpc: ZeroDevConnector.bundlerRpc,
                     chain,
                     ecdsaValidator: getEcdsaValidator.getEcdsaValidator(this.ecdsaProviderType),
@@ -368,7 +373,7 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
             onSendTransaction: (_b) => _tslib.__awaiter(this, [_b], void 0, function* ({ transaction }) {
                 try {
                     this._walletUiUtils.disabledConfirmationOnce();
-                    const effectiveProvider = this.isGasSponsorshipDisabled
+                    const effectiveProvider = this.isGasSponsorshipDisabled()
                         ? provider
                         : this.kernelClientWithSponsorship;
                     if (!effectiveProvider) {
@@ -539,9 +544,6 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
             return sponsored;
         });
     }
-    disableGasSponsorshipOnce() {
-        this.isGasSponsorshipDisabled = true;
-    }
     getBalance(address) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -603,6 +605,9 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
     getEnabledNetworks() {
         return this.evmNetworks;
     }
+    initializeZksyncConnector() {
+        throw new Error('Not implemented');
+    }
 }
 
 exports.ZeroDevConnector = ZeroDevConnector;

package/src/ZeroDevConnector.d.ts

@@ -6,11 +6,12 @@ import { type Chain as ViemChain } from 'viem/chains';
 import { EntryPointType, KERNEL_VERSION_TYPE } from '@zerodev/sdk/types';
 import { EthereumWallet, RegisterEvmProvidersConfig } from '@dynamic-labs/ethereum-core';
 import { EcdsaValidatorOptions, Provider, ProviderEntryPointVersionEnum, ProviderEnum, ProviderKernelVersionEnum, ProviderMultichainAccountAbstractionProviders } from '@dynamic-labs/sdk-api-core';
-import { Chain, IZeroDevConnector, InternalWalletConnector, WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { Chain, InternalWalletConnector, IZeroDevConnector } from '@dynamic-labs/wallet-connector-core';
 import { WalletBookSchema } from '@dynamic-labs/wallet-book';
-import { EvmNetwork, GenericNetwork, IUITransaction, WalletUiUtils } from '@dynamic-labs/types';
+import { GenericNetwork, IUITransaction, TransactionReceipt, WalletUiUtils } from '@dynamic-labs/types';
 import { BundlerProvider } from './utils';
-type ZeroDevConnectorProps = {
+import { AccountAbstractionConnector, AccountAbstractionConnectorProps } from './AccountAbstractionConnector';
+type ZeroDevConnectorProps = AccountAbstractionConnectorProps & {
     apiProviders: {
         [key in ProviderEnum]?: Provider;
     };
@@ -23,7 +24,7 @@ type ZeroDevConnectorProps = {
     providersConfig?: RegisterEvmProvidersConfig;
 };
 type KernelClient = KernelAccountClient<Transport, ViemChain, SmartAccount, Client, RpcSchema>;
-export declare class ZeroDevConnector extends WalletConnectorBase<typeof EthereumWallet> implements IZeroDevConnector {
+export declare class ZeroDevConnector extends AccountAbstractionConnector implements IZeroDevConnector {
     clientId: string;
     eoaConnector: InternalWalletConnector | undefined;
     eoaAddress: string | undefined;
@@ -32,9 +33,7 @@ export declare class ZeroDevConnector extends WalletConnectorBase<typeof Ethereu
     ChainWallet: typeof EthereumWallet;
     connectedChain: Chain;
     supportedChains: Chain[];
-    evmNetworks: EvmNetwork[];
     providersConfig: RegisterEvmProvidersConfig;
-    private isGasSponsorshipDisabled;
     isEmbeddedWallet: boolean;
     entryPoint: EntryPointType<EntryPointVersion>;
     kernelVersion: KERNEL_VERSION_TYPE;
@@ -62,9 +61,9 @@ export declare class ZeroDevConnector extends WalletConnectorBase<typeof Ethereu
         name: string;
     };
     enableEIP7702Mode: boolean;
-    private _walletUiUtils;
     private authorization?;
     constructor(opts: ZeroDevConnectorProps);
+    confirmTransactionStatus(): Promise<TransactionReceipt>;
     get currentNetworkProvider(): {
         kernelClient: KernelClient;
         kernelClientWithSponsorship: KernelClient;
@@ -76,15 +75,22 @@ export declare class ZeroDevConnector extends WalletConnectorBase<typeof Ethereu
     switchNetwork({ networkChainId, }: {
         networkChainId?: number | string;
     }): Promise<void>;
-    /**
-     * @deprecated You should get the EOA connector by passing the SCW to getEOAConnector,
-     * from the useSmartWallet hook
-     */
-    getEOAConnector(): InternalWalletConnector | undefined;
-    getAccountAbstractionProvider({ withSponsorship, }?: {
+    getAccountAbstractionProvider<T = KernelClient | undefined>({ withSponsorship, }?: {
         withSponsorship?: boolean;
-    }): KernelClient | undefined;
+    }): T;
     endSession(): Promise<void>;
+    initialize({ smartWalletAddress, eoaAddress, eoaConnector, properties, shouldSetEoaConnector, }: {
+        smartWalletAddress: string;
+        eoaAddress: string;
+        eoaConnector: InternalWalletConnector;
+        shouldSetEoaConnector: boolean;
+        properties?: {
+            ecdsaProviderType?: EcdsaValidatorOptions;
+            kernelVersion?: ProviderKernelVersionEnum;
+            entryPointVersion?: ProviderEntryPointVersionEnum;
+            enableKernelV3Migration?: boolean;
+        };
+    }): Promise<void>;
     registerEoa({ smartWalletAddress, eoaAddress, eoaConnector, shouldSetEoaConnector, ...properties }: {
         smartWalletAddress: string;
         eoaAddress: string;
@@ -7812,12 +7818,12 @@ export declare class ZeroDevConnector extends WalletConnectorBase<typeof Ethereu
         value?: bigint;
         data?: string;
     }): Promise<boolean>;
-    disableGasSponsorshipOnce(): void;
     getBalance(address: string): Promise<string | undefined>;
     signMessage(messageToSign: string): Promise<string | undefined>;
     createUiTransaction(from: string): Promise<IUITransaction>;
     validateActiveWallet(expectedAddress: string): Promise<void>;
     getBlockExplorerUrlsForCurrentNetwork(): Promise<string[]>;
     getEnabledNetworks(): GenericNetwork[];
+    initializeZksyncConnector(): Promise<void>;
 }
 export {};