@dynamic-labs/ethereum-aa 4.10.2 → 4.10.4-preview.0

package/src/ZKsyncConnector.js

@@ -0,0 +1,498 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { createPublicClient, http, publicActions, custom, createWalletClient, walletActions, toBytes, keccak256, toHex } from 'viem';
+import { getGeneralPaymasterInput, eip712WalletActions } from 'viem/zksync';
+import { createZksyncPasskeyClient, registerNewPasskey } from 'zksync-sso/client/passkey';
+import { getPublicKeyBytesFromPasskeySignature, encodePasskeyModuleParameters, encodeModuleData } from 'zksync-sso/utils';
+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';
+import { createZksyncEcdsaClient } from './ZKsync/client.js';
+import { zksyncSsoEcdsaWalletActions } from './ZKsync/walletActions.js';
+
+class ZKsyncConnector extends AccountAbstractionConnector {
+    constructor(props) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        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 = ((_d = (_c = props.apiProviders.zksync) === null || _c === void 0 ? void 0 : _c.factoryAddress) !== null && _d !== void 0 ? _d : '0xa980E4B20354d4944de93F2a51f0a14c6E8e481d'); // Fallback if not provided
+        this.paymasterAddress = ((_f = (_e = props.apiProviders.zksync) === null || _e === void 0 ? void 0 : _e.paymasterAddress) !== null && _f !== void 0 ? _f : '0xD681ef8eD603F8F3b1CF9c1ef93548e698F60F0a'); // Fallback if not provided
+        this.passkeyAddress = ((_h = (_g = props.apiProviders.zksync) === null || _g === void 0 ? void 0 : _g.passkeyAddress) !== null && _h !== void 0 ? _h : '0x271546A4a3d8050610367e68040d41ee56E4BB31'); // Fallback if not provided
+        this.sessionKeyAddress = ((_k = (_j = props.apiProviders.zksync) === null || _j === void 0 ? void 0 : _j.sessionAddress) !== null && _k !== void 0 ? _k : '0xA8CC0A6bD462B44A8830bBbfB54Ce19F32815Fb7'); // Fallback if not provided
+        this.enablePasskeys =
+            (_m = (_l = props.settings.sdk.accountAbstraction) === null || _l === void 0 ? void 0 : _l.enablePasskeys) !== null && _m !== void 0 ? _m : 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;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getWalletClient() {
+        if (!this.smartAccount) {
+            return undefined;
+        }
+        return this.smartAccount;
+    }
+    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.deploySmartAccountWithPaymaster();
+                }
+                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.deploySmartAccountWithPaymaster();
+                }
+                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: http(),
+            });
+            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();
+        });
+    }
+    /**
+     * 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) {
+                yield this.deploySmartAccountWithPaymaster();
+            }
+            else {
+                yield this.deploySmartAccountWithoutPaymaster();
+            }
+        });
+    }
+    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);
+        });
+    }
+    /**
+     * 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];
+            if (this.enablePasskeys) {
+                const encodedPasskeyModuleData = yield this.getEncodedPasskeyModuleData();
+                initialValidators.push(encodedPasskeyModuleData);
+            }
+            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/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"]);
@@ -369,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) {
@@ -540,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;
@@ -604,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 {};