@dynamic-labs/ethereum-aa 4.11.1 → 4.12.0

package/src/ZKsyncConnector.js

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

package/src/ZeroDevConnector.cjs

@@ -16,8 +16,10 @@ var createEcsdaKernelAccountClient = require('./utils/createEcsdaKernelAccountCl
 var getEcdsaValidator = require('./utils/getEcdsaValidator.cjs');
 var getEntryPoint = require('./utils/getEntryPoint.cjs');
 var getKernelVersion = require('./utils/getKernelVersion.cjs');
+require('zksync-sso/utils');
+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 +30,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 +61,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 +108,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 +119,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 +374,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) {
@@ -428,11 +433,6 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
             return provider;
         });
     }
-    getSigner() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            return this.getWalletClient();
-        });
-    }
     formatUserOperation(params) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -540,9 +540,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;
@@ -561,17 +558,6 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
             return client.signMessage({ message: messageToSign });
         });
     }
-    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, publicClient, walletClient });
-        });
-    }
     validateActiveWallet(expectedAddress) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             if (this.enableEIP7702Mode) {
@@ -595,15 +581,6 @@ class ZeroDevConnector extends walletConnectorCore.WalletConnectorBase {
             });
         });
     }
-    getBlockExplorerUrlsForCurrentNetwork() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            return (_b = (_a = this.eoaConnector) === null || _a === void 0 ? void 0 : _a.getBlockExplorerUrlsForCurrentNetwork()) !== null && _b !== void 0 ? _b : [];
-        });
-    }
-    getEnabledNetworks() {
-        return this.evmNetworks;
-    }
 }
 
 exports.ZeroDevConnector = ZeroDevConnector;