@dynamic-labs/ethereum-aa 4.0.0-alpha.8 → 4.0.0

package/src/ZeroDevConnector.js

@@ -1,9 +1,10 @@
 'use client'
 import { __awaiter } from '../_virtual/_tslib.js';
-import { publicActions, custom, createWalletClient, isHex, fromHex, formatEther } from 'viem';
-import { walletClientToSmartAccountSigner } from 'permissionless/utils';
+import { publicActions, custom, createWalletClient, toHex, formatEther } from 'viem';
+import { toAccount } from 'viem/accounts';
+import { getEntryPoint as getEntryPoint$1 } from '@zerodev/sdk/constants';
 import { EthereumWallet, isEthWalletConnector, chainsMap, confirmationTransport, unFormatTransaction, createViemUiTransaction } from '@dynamic-labs/ethereum-core';
-import { WalletConnectorBase, eventListenerHandlers, isTurnkeyWalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { WalletConnectorBase, eventListenerHandlers } from '@dynamic-labs/wallet-connector-core';
 import { parseEvmNetworks, StorageService, DeferredPromise, parseChainId, DynamicError, wrapMethodWithCallback, TransactionGasCannotBeSponsoredError, InsufficientFundsError } from '@dynamic-labs/utils';
 import { ZERO_DEV_LAST_USED_CHAIN_ID_KEY } from './constants.js';
 import { logger } from './utils/logger.js';
@@ -16,7 +17,10 @@ class ZeroDevConnector extends WalletConnectorBase {
     constructor(opts) {
         var _a, _b, _c, _d;
         super(opts);
+        // provider map maintains the kernel clients per chain
         this.providerMap = {};
+        // eoa connector map maintains the eoa address and connector for each smart wallet address
+        this.eoaConnectorMap = {};
         this.ChainWallet = EthereumWallet;
         this.connectedChain = 'EVM';
         this.supportedChains = ['ETH', 'EVM'];
@@ -109,23 +113,54 @@ class ZeroDevConnector extends WalletConnectorBase {
             StorageService.removeItem(ZERO_DEV_LAST_USED_CHAIN_ID_KEY);
         });
     }
-    setEoaConnector(connector) {
-        return __awaiter(this, void 0, void 0, function* () {
+    registerEoa(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ smartWalletAddress, eoaAddress, eoaConnector, shouldSetEoaConnector = false, ecdsaProviderType, kernelVersion, entryPointVersion, }) {
+            const properties = {
+                ecdsaProviderType,
+                entryPointVersion,
+                kernelVersion,
+            };
+            this.eoaConnectorMap[smartWalletAddress] = {
+                eoaAddress,
+                eoaConnector,
+                properties,
+            };
+            // if this is the primary wallet, set the eoa connector and kernel clients
+            if (shouldSetEoaConnector && this.eoaAddress !== eoaAddress) {
+                yield this.setEoaConnector({
+                    connector: eoaConnector,
+                    eoaAddress,
+                    properties,
+                });
+            }
+        });
+    }
+    setEoaConnector(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ eoaAddress, connector, properties, }) {
+            var _b;
             if (!connector) {
                 logger.error('No EOA connector provided');
                 return;
             }
             this.kernelClientDeferredPromise = new DeferredPromise();
             this.eoaConnector = connector;
+            this.eoaAddress = eoaAddress;
+            if (properties) {
+                this.ecdsaProviderType =
+                    (_b = properties.ecdsaProviderType) !== null && _b !== void 0 ? _b : this.ecdsaProviderType;
+                this.entryPoint = properties.entryPointVersion
+                    ? getEntryPoint(properties.entryPointVersion)
+                    : this.entryPoint;
+                this.kernelVersion = properties.entryPointVersion
+                    ? getKernelVersion(properties.kernelVersion, this.entryPoint)
+                    : this.kernelVersion;
+            }
             if (isEthWalletConnector(this.eoaConnector) &&
                 !this.eoaConnector.getActiveAccount()) {
                 yield this.eoaConnector.getConnectedAccounts();
             }
             const signer = yield this.eoaConnector.getSigner();
-            if (!(signer === null || signer === void 0 ? void 0 : signer.account)) {
-                logger.error('No signer account found');
-                return;
-            }
+            signer.account = toAccount(eoaAddress);
             yield this.generateProviderMap(signer);
             this.evmNetworks = this.evmNetworks.filter((network) => Boolean(this.providerMap[network.chainId]));
             this.kernelClientDeferredPromise.resolve();
@@ -147,23 +182,29 @@ class ZeroDevConnector extends WalletConnectorBase {
     }
     generateProviderMap(signer) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const provider of this.providersFromApi) {
+            // reset the chains provider map when eoa connector changes
+            this.providerMap = {};
+            yield Promise.all(this.providersFromApi.map((provider) => __awaiter(this, void 0, void 0, function* () {
                 if (!this.providerMap[provider.chain]) {
-                    this.providerMap[provider.chain] = {
-                        kernelClient: yield this.getKernelClientWithoutSponsorshipValidation({
+                    const [kernelClient, kernelClientWithSponsorship] = yield Promise.all([
+                        this.getKernelClientWithoutSponsorshipValidation({
                             chainId: provider.chain,
                             projectId: provider.clientId,
                             signer,
                         }),
-                        kernelClientWithSponsorship: yield this.getKernelClientWithSponsorshipValidation({
+                        this.getKernelClientWithSponsorshipValidation({
                             chainId: provider.chain,
                             projectId: provider.clientId,
                             signer,
                         }),
+                    ]);
+                    this.providerMap[provider.chain] = {
+                        kernelClient,
+                        kernelClientWithSponsorship,
                     };
                 }
                 yield this.warnIfProjectChainNotEnabled(parseChainId(provider.chain));
-            }
+            })));
         });
     }
     getKernelClientWithoutSponsorshipValidation(_a) {
@@ -178,13 +219,13 @@ class ZeroDevConnector extends WalletConnectorBase {
                 bundlerRpc: ZeroDevConnector.bundlerRpc,
                 chain: chainsMap[chainId],
                 ecdsaValidator: getEcdsaValidator(this.ecdsaProviderType),
-                entryPointAddress: this.entryPoint,
+                entryPoint: this.entryPoint,
                 kernelVersion: this.kernelVersion,
                 paymaster: 'NONE',
                 paymasterRpc: ZeroDevConnector.paymasterRpc,
                 projectId,
                 provider: ZeroDevConnector.bundlerProvider,
-                signer: walletClientToSmartAccountSigner(signer),
+                signer,
             });
             wrapMethodWithCallback(kernelClient, 'sendUserOperation', (original, ...args) => {
                 this._walletUiUtils.disabledConfirmationOnce();
@@ -205,13 +246,13 @@ class ZeroDevConnector extends WalletConnectorBase {
                 bundlerRpc: ZeroDevConnector.bundlerRpc,
                 chain: chainsMap[chainId],
                 ecdsaValidator: getEcdsaValidator(this.ecdsaProviderType),
-                entryPointAddress: this.entryPoint,
+                entryPoint: this.entryPoint,
                 kernelVersion: this.kernelVersion,
                 paymaster: 'SPONSOR',
                 paymasterRpc: ZeroDevConnector.paymasterRpc,
                 projectId,
                 provider: ZeroDevConnector.bundlerProvider,
-                signer: walletClientToSmartAccountSigner(signer),
+                signer,
             });
             wrapMethodWithCallback(kernelClientWithSponsorship, 'sendUserOperation', (original, ...args) => {
                 this._walletUiUtils.disabledConfirmationOnce();
@@ -249,7 +290,6 @@ class ZeroDevConnector extends WalletConnectorBase {
             onPersonalSign: (_a) => __awaiter(this, [_a], void 0, function* ({ message }) {
                 this._walletUiUtils.disabledConfirmationOnce();
                 return provider.signMessage({
-                    account: provider.account,
                     message,
                 });
             }),
@@ -280,7 +320,6 @@ class ZeroDevConnector extends WalletConnectorBase {
                 this._walletUiUtils.disabledConfirmationOnce();
                 const signTypedData = JSON.parse(message);
                 return provider.signTypedData({
-                    account: provider.account,
                     domain: signTypedData.domain,
                     message: signTypedData.message,
                     primaryType: signTypedData.primaryType,
@@ -296,14 +335,12 @@ class ZeroDevConnector extends WalletConnectorBase {
         return transport;
     }
     getWalletClient(chainId) {
-        var _a;
         const provider = this.kernelClient;
         if (!provider)
             return undefined;
         const transport = this.getTransport(provider);
-        const address = (_a = provider.account) === null || _a === void 0 ? void 0 : _a.address;
         const walletClient = createWalletClient({
-            account: address,
+            account: toAccount(provider.account.address),
             chain: chainId ? chainsMap[chainId] : provider.chain,
             transport,
         });
@@ -323,38 +360,109 @@ class ZeroDevConnector extends WalletConnectorBase {
             return this.getWalletClient();
         });
     }
-    canSponsorTransactionGas(transaction) {
+    formatUserOperation(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const kernelAccount = (_a = this.getAccountAbstractionProvider()) === null || _a === void 0 ? void 0 : _a.account;
+            const entryPoint = kernelAccount === null || kernelAccount === void 0 ? void 0 : kernelAccount.entryPoint;
+            const isV6 = (entryPoint === null || entryPoint === void 0 ? void 0 : entryPoint.address.toLowerCase()) ===
+                getEntryPoint$1('0.6').address.toLowerCase();
+            if (isV6) {
+                return {
+                    callData: params.callData,
+                    callGasLimit: toHex(params.callGasLimit),
+                    // setting initCode to 0x since it is only used for transaction simulation
+                    initCode: '0x',
+                    maxFeePerGas: toHex(params.maxFeePerGas),
+                    maxPriorityFeePerGas: toHex(params.maxPriorityFeePerGas),
+                    nonce: toHex(params.nonce),
+                    paymasterAndData: params.paymasterAndData.toLowerCase(),
+                    preVerificationGas: toHex(params.preVerificationGas),
+                    sender: params.sender,
+                    signature: '0x',
+                    verificationGasLimit: toHex(params.verificationGasLimit),
+                };
+            }
+            const accountGasLimits = '0x' +
+                '000000000000000000000000000' + // 27 zeros
+                toHex(params.verificationGasLimit).slice(2) +
+                '000000000000000000000000000' + // 27 zeros
+                toHex(params.callGasLimit).slice(2);
+            const preVerificationGas = toHex(params.preVerificationGas);
+            const gasFees = '0x' +
+                '00000000000000000000000000' + // 26 zeros
+                toHex(params.maxPriorityFeePerGas).slice(2).padStart(6, '0') +
+                '0000000000000000000000' + // 22 zeros
+                toHex(params.maxFeePerGas).slice(2).padStart(10, '0');
+            const paymasterAndData = params.paymaster
+                ? '0x' +
+                    params.paymaster.slice(2).toLowerCase() +
+                    toHex(params.paymasterVerificationGasLimit).slice(2).padStart(32, '0') + // Make sure it's 32 chars
+                    toHex(params.paymasterPostOpGasLimit).slice(2).padStart(32, '0') + // Make sure it's 32 chars
+                    params.paymasterData.slice(2) // Include full paymaster data
+                : '0x';
+            return {
+                accountGasLimits: accountGasLimits,
+                callData: params.callData,
+                gasFees: gasFees,
+                // setting initCode to 0x since it is only used for transaction simulation
+                initCode: '0x',
+                nonce: toHex(params.nonce),
+                paymasterAndData: paymasterAndData.toLowerCase(),
+                preVerificationGas: preVerificationGas,
+                sender: params.sender,
+                signature: '0x',
+            };
+        });
+    }
+    getCurrentUserOperation(transaction) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             try {
                 const { kernelClientWithSponsorship } = this;
                 if (!kernelClientWithSponsorship) {
                     throw new DynamicError('No kernel client with sponsorship found');
                 }
-                const userOperation = {
-                    callData: yield kernelClientWithSponsorship.account.encodeCallData({
+                const value = BigInt((_a = transaction.value) !== null && _a !== void 0 ? _a : 0);
+                const callData = yield kernelClientWithSponsorship.account.encodeCalls([
+                    {
                         data: transaction.data ? transaction.data : '0x',
                         to: transaction.to,
-                        /**
-                         * if value is undefined, it will be set to 0x0 so the sponsorship
-                         * check does not fail
-                         */
-                        value: transaction.value && isHex(transaction.value)
-                            ? fromHex(transaction.value, 'bigint')
-                            : fromHex('0x0', 'bigint'),
-                    }),
-                };
-                const result = yield kernelClientWithSponsorship.prepareUserOperationRequest({
-                    account: kernelClientWithSponsorship.account,
-                    userOperation,
-                });
-                if (!result)
-                    return false;
-                return result.paymasterAndData !== '0x';
+                        value,
+                    },
+                ]);
+                let sponsorResult;
+                let unsponsoredResult;
+                try {
+                    sponsorResult = yield kernelClientWithSponsorship.prepareUserOperation({
+                        callData,
+                    });
+                }
+                catch (err) {
+                    logger.debug('[ZeroDevConnector] Sponsored UserOp Attempt Failed:', err);
+                    unsponsoredResult = yield ((_b = this.kernelClient) === null || _b === void 0 ? void 0 : _b.prepareUserOperation({
+                        callData,
+                    }));
+                }
+                if ((sponsorResult === null || sponsorResult === void 0 ? void 0 : sponsorResult.paymasterAndData) === '0x')
+                    return { sponsored: false, userOperation: sponsorResult };
+                return sponsorResult
+                    ? { sponsored: true, userOperation: sponsorResult }
+                    : { sponsored: false, userOperation: unsponsoredResult };
             }
             catch (err) {
-                logger.debug(err);
+                logger.debug('[ZeroDevConnector] Error in getCurrentUserOperation:', err);
+                return { sponsored: false, userOperation: undefined };
+            }
+        });
+    }
+    canSponsorTransactionGas(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sponsored } = yield this.getCurrentUserOperation(transaction);
+            if (!sponsored) {
                 return false;
             }
+            return sponsored;
         });
     }
     disableGasSponsorshipOnce() {
@@ -390,23 +498,18 @@ class ZeroDevConnector extends WalletConnectorBase {
         });
     }
     validateActiveWallet(expectedAddress) {
-        const _super = Object.create(null, {
-            validateActiveWallet: { get: () => super.validateActiveWallet }
-        });
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const eoaConnector = this === null || this === void 0 ? void 0 : this.eoaConnector;
-            if (eoaConnector && isTurnkeyWalletConnector(eoaConnector)) {
-                const verifiedCredentials = eoaConnector === null || eoaConnector === void 0 ? void 0 : eoaConnector.verifiedCredentials;
-                const expectedEoaAddress = (_a = verifiedCredentials === null || verifiedCredentials === void 0 ? void 0 : verifiedCredentials.find((vc) => vc.smartWalletRefAddress === expectedAddress)) === null || _a === void 0 ? void 0 : _a.address;
-                if (!expectedEoaAddress) {
-                    throw new DynamicError('No EOA connector');
-                }
-                yield (eoaConnector === null || eoaConnector === void 0 ? void 0 : eoaConnector.validateActiveWallet(expectedEoaAddress));
-            }
-            else {
-                yield _super.validateActiveWallet.call(this, expectedAddress);
+            const eoa = this.eoaConnectorMap[expectedAddress];
+            if (!eoa) {
+                throw new DynamicError('No EOA connector');
             }
+            const { eoaAddress, eoaConnector, properties } = eoa;
+            yield eoaConnector.validateActiveWallet(eoaAddress);
+            yield this.setEoaConnector({
+                connector: eoaConnector,
+                eoaAddress,
+                properties,
+            });
         });
     }
 }

package/src/utils/createEcsdaKernelAccountClient.cjs

@@ -6,6 +6,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _tslib = require('../../_virtual/_tslib.cjs');
 var accounts = require('@zerodev/sdk/accounts');
 var clients = require('@zerodev/sdk/clients');
+var actions = require('@zerodev/sdk/actions');
 var viem = require('viem');
 
 const getZeroDevBundlerRPC = (projectId, provider) => {
@@ -23,19 +24,20 @@ const getZeroDevPaymasterRPC = (projectId, provider) => {
     return rpc;
 };
 const isERC20 = (value) => viem.isAddress(value);
-const createEcdsaKernelAccountClient = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ bundlerRpc, chain, paymasterRpc, projectId, signer, provider, index, paymaster = 'SPONSOR', entryPointAddress, kernelVersion, ecdsaValidator, }) {
+const createEcdsaKernelAccountClient = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ bundlerRpc, chain, paymasterRpc, projectId, signer, provider, index, paymaster = 'SPONSOR', entryPoint, kernelVersion, ecdsaValidator, }) {
     const resolvedBundlerRpc = bundlerRpc !== null && bundlerRpc !== void 0 ? bundlerRpc : getZeroDevBundlerRPC(projectId, provider);
     const resolvedPaymasterRpc = paymasterRpc !== null && paymasterRpc !== void 0 ? paymasterRpc : getZeroDevPaymasterRPC(projectId, provider);
     const publicClient = viem.createPublicClient({
+        chain,
         transport: viem.http(resolvedBundlerRpc),
     });
     const validator = yield ecdsaValidator(publicClient, {
-        entryPoint: entryPointAddress,
+        entryPoint,
         kernelVersion,
         signer,
     });
     const account = yield accounts.createKernelAccount(publicClient, {
-        entryPoint: entryPointAddress,
+        entryPoint,
         index,
         kernelVersion,
         plugins: {
@@ -43,33 +45,33 @@ const createEcdsaKernelAccountClient = (_a) => _tslib.__awaiter(void 0, [_a], vo
         },
     });
     const zerodevPaymaster = clients.createZeroDevPaymasterClient({
-        chain: chain,
-        entryPoint: entryPointAddress,
+        chain,
         transport: viem.http(resolvedPaymasterRpc),
     });
     const kernelClient = clients.createKernelAccountClient({
         account,
         bundlerTransport: viem.http(resolvedBundlerRpc),
         chain,
-        entryPoint: entryPointAddress,
-        middleware: paymaster !== 'NONE'
+        client: publicClient,
+        paymaster: paymaster !== 'NONE'
             ? {
-                sponsorUserOperation: (_b) => _tslib.__awaiter(void 0, [_b], void 0, function* ({ userOperation }) {
+                getPaymasterData: (userOperation) => {
                     const _userOperation = userOperation;
                     if (isERC20(paymaster)) {
                         return zerodevPaymaster.sponsorUserOperation({
-                            entryPoint: entryPointAddress,
                             gasToken: paymaster,
                             userOperation: _userOperation,
                         });
                     }
                     return zerodevPaymaster.sponsorUserOperation({
-                        entryPoint: entryPointAddress,
                         userOperation: _userOperation,
                     });
-                }),
+                },
             }
             : undefined,
+        userOperation: {
+            estimateFeesPerGas: (_b) => _tslib.__awaiter(void 0, [_b], void 0, function* ({ bundlerClient }) { return actions.getUserOperationGasPrice(bundlerClient); }),
+        },
     });
     return kernelClient;
 });

package/src/utils/createEcsdaKernelAccountClient.d.ts

@@ -1,24 +1,23 @@
-import { KernelSmartAccount } from '@zerodev/sdk/accounts';
+import { SmartAccount, EntryPointVersion } from 'viem/account-abstraction';
 import { KernelAccountClient } from '@zerodev/sdk/clients';
-import { SmartAccountSigner } from 'permissionless/accounts';
-import { EntryPoint } from 'permissionless/types';
-import { Address, HttpTransport, Chain } from 'viem';
-import { GetKernelVersion } from '@zerodev/sdk/types';
+import { type Chain as ViemChain } from 'viem/chains';
+import { Address, WalletClient, Account, type Client, type RpcSchema, type Transport } from 'viem';
+import { EntryPointType, GetKernelVersion } from '@zerodev/sdk/types';
 export type BundlerProvider = 'STACKUP' | 'PIMLICO' | 'ALCHEMY' | 'GELATO';
 export type ERC20Paymaster = Address;
 export type PaymasterType = 'NONE' | 'SPONSOR' | ERC20Paymaster;
 export declare const getZeroDevBundlerRPC: (projectId: string, provider?: BundlerProvider) => string;
 export declare const getZeroDevPaymasterRPC: (projectId: string, provider?: BundlerProvider) => string;
-export declare const createEcdsaKernelAccountClient: <entryPoint extends EntryPoint, TChain extends Chain | undefined = Chain | undefined, TSource extends string = "custom", TAddress extends `0x${string}` = `0x${string}`>({ bundlerRpc, chain, paymasterRpc, projectId, signer, provider, index, paymaster, entryPointAddress, kernelVersion, ecdsaValidator, }: {
-    bundlerRpc?: string;
+export declare const createEcdsaKernelAccountClient: <entryPoint extends EntryPointVersion, TChain extends ViemChain | undefined = ViemChain | undefined>({ bundlerRpc, chain, paymasterRpc, projectId, signer, provider, index, paymaster, entryPoint, kernelVersion, ecdsaValidator, }: {
+    bundlerRpc?: string | undefined;
     chain: TChain;
     projectId: string;
-    signer: SmartAccountSigner<TSource, TAddress>;
+    signer: WalletClient<Transport, ViemChain, Account>;
     paymaster: PaymasterType;
-    paymasterRpc?: string;
-    entryPointAddress: entryPoint;
-    provider?: BundlerProvider;
-    index?: bigint;
+    paymasterRpc?: string | undefined;
+    entryPoint: EntryPointType<entryPoint>;
+    provider?: BundlerProvider | undefined;
+    index?: bigint | undefined;
     kernelVersion: GetKernelVersion<entryPoint>;
     ecdsaValidator: any;
-}) => Promise<KernelAccountClient<entryPoint, HttpTransport, TChain, KernelSmartAccount<entryPoint>>>;
+}) => Promise<KernelAccountClient<Transport, ViemChain, SmartAccount, Client, RpcSchema>>;

package/src/utils/createEcsdaKernelAccountClient.js

@@ -2,6 +2,7 @@
 import { __awaiter } from '../../_virtual/_tslib.js';
 import { createKernelAccount } from '@zerodev/sdk/accounts';
 import { createZeroDevPaymasterClient, createKernelAccountClient } from '@zerodev/sdk/clients';
+import { getUserOperationGasPrice } from '@zerodev/sdk/actions';
 import { createPublicClient, http, isAddress } from 'viem';
 
 const getZeroDevBundlerRPC = (projectId, provider) => {
@@ -19,19 +20,20 @@ const getZeroDevPaymasterRPC = (projectId, provider) => {
     return rpc;
 };
 const isERC20 = (value) => isAddress(value);
-const createEcdsaKernelAccountClient = (_a) => __awaiter(void 0, [_a], void 0, function* ({ bundlerRpc, chain, paymasterRpc, projectId, signer, provider, index, paymaster = 'SPONSOR', entryPointAddress, kernelVersion, ecdsaValidator, }) {
+const createEcdsaKernelAccountClient = (_a) => __awaiter(void 0, [_a], void 0, function* ({ bundlerRpc, chain, paymasterRpc, projectId, signer, provider, index, paymaster = 'SPONSOR', entryPoint, kernelVersion, ecdsaValidator, }) {
     const resolvedBundlerRpc = bundlerRpc !== null && bundlerRpc !== void 0 ? bundlerRpc : getZeroDevBundlerRPC(projectId, provider);
     const resolvedPaymasterRpc = paymasterRpc !== null && paymasterRpc !== void 0 ? paymasterRpc : getZeroDevPaymasterRPC(projectId, provider);
     const publicClient = createPublicClient({
+        chain,
         transport: http(resolvedBundlerRpc),
     });
     const validator = yield ecdsaValidator(publicClient, {
-        entryPoint: entryPointAddress,
+        entryPoint,
         kernelVersion,
         signer,
     });
     const account = yield createKernelAccount(publicClient, {
-        entryPoint: entryPointAddress,
+        entryPoint,
         index,
         kernelVersion,
         plugins: {
@@ -39,33 +41,33 @@ const createEcdsaKernelAccountClient = (_a) => __awaiter(void 0, [_a], void 0, f
         },
     });
     const zerodevPaymaster = createZeroDevPaymasterClient({
-        chain: chain,
-        entryPoint: entryPointAddress,
+        chain,
         transport: http(resolvedPaymasterRpc),
     });
     const kernelClient = createKernelAccountClient({
         account,
         bundlerTransport: http(resolvedBundlerRpc),
         chain,
-        entryPoint: entryPointAddress,
-        middleware: paymaster !== 'NONE'
+        client: publicClient,
+        paymaster: paymaster !== 'NONE'
             ? {
-                sponsorUserOperation: (_b) => __awaiter(void 0, [_b], void 0, function* ({ userOperation }) {
+                getPaymasterData: (userOperation) => {
                     const _userOperation = userOperation;
                     if (isERC20(paymaster)) {
                         return zerodevPaymaster.sponsorUserOperation({
-                            entryPoint: entryPointAddress,
                             gasToken: paymaster,
                             userOperation: _userOperation,
                         });
                     }
                     return zerodevPaymaster.sponsorUserOperation({
-                        entryPoint: entryPointAddress,
                         userOperation: _userOperation,
                     });
-                }),
+                },
             }
             : undefined,
+        userOperation: {
+            estimateFeesPerGas: (_b) => __awaiter(void 0, [_b], void 0, function* ({ bundlerClient }) { return getUserOperationGasPrice(bundlerClient); }),
+        },
     });
     return kernelClient;
 });

package/src/utils/getEntryPoint.cjs

@@ -3,21 +3,21 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var permissionless = require('permissionless');
+var constants = require('@zerodev/sdk/constants');
 var sdkApiCore = require('@dynamic-labs/sdk-api-core');
 var logger = require('./logger.cjs');
 
 const getEntryPoint = (entryPoint) => {
     if (entryPoint === undefined ||
         entryPoint === sdkApiCore.ProviderEntryPointVersionEnum.V7) {
-        return permissionless.ENTRYPOINT_ADDRESS_V07;
+        return constants.getEntryPoint('0.7');
     }
     else if (entryPoint === sdkApiCore.ProviderEntryPointVersionEnum.V6) {
-        return permissionless.ENTRYPOINT_ADDRESS_V06;
+        return constants.getEntryPoint('0.6');
     }
     else {
         logger.logger.error('Invalid entry point version', entryPoint);
-        return permissionless.ENTRYPOINT_ADDRESS_V07;
+        return constants.getEntryPoint('0.7');
     }
 };
 

package/src/utils/getEntryPoint.d.ts

@@ -1 +1 @@
-export declare const getEntryPoint: (entryPoint: string | undefined) => "0x0000000071727De22E5E9d8BAf0edAc6f37da032" | "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
+export declare const getEntryPoint: (entryPoint: string | undefined) => import("@zerodev/sdk/types").EntryPointType<"0.7"> | import("@zerodev/sdk/types").EntryPointType<"0.6">;

package/src/utils/getEntryPoint.js

@@ -1,19 +1,19 @@
 'use client'
-import { ENTRYPOINT_ADDRESS_V07, ENTRYPOINT_ADDRESS_V06 } from 'permissionless';
+import { getEntryPoint as getEntryPoint$1 } from '@zerodev/sdk/constants';
 import { ProviderEntryPointVersionEnum } from '@dynamic-labs/sdk-api-core';
 import { logger } from './logger.js';
 
 const getEntryPoint = (entryPoint) => {
     if (entryPoint === undefined ||
         entryPoint === ProviderEntryPointVersionEnum.V7) {
-        return ENTRYPOINT_ADDRESS_V07;
+        return getEntryPoint$1('0.7');
     }
     else if (entryPoint === ProviderEntryPointVersionEnum.V6) {
-        return ENTRYPOINT_ADDRESS_V06;
+        return getEntryPoint$1('0.6');
     }
     else {
         logger.error('Invalid entry point version', entryPoint);
-        return ENTRYPOINT_ADDRESS_V07;
+        return getEntryPoint$1('0.7');
     }
 };
 

package/src/utils/getKernelVersion.cjs

@@ -3,7 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var permissionless = require('permissionless');
 var constants = require('@zerodev/sdk/constants');
 var sdkApiCore = require('@dynamic-labs/sdk-api-core');
 var logger = require('./logger.cjs');
@@ -11,14 +10,14 @@ var logger = require('./logger.cjs');
 const getKernelVersion = (kernelVersion, entryPointAddress) => {
     if (kernelVersion === sdkApiCore.ProviderKernelVersionEnum.V31 ||
         (kernelVersion === undefined &&
-            entryPointAddress === permissionless.ENTRYPOINT_ADDRESS_V07)) {
+            entryPointAddress.address === constants.getEntryPoint('0.7').address)) {
         return constants.KERNEL_V3_1;
     }
     else if (kernelVersion === sdkApiCore.ProviderKernelVersionEnum.V30) {
         return constants.KERNEL_V3_0;
     }
     else if (kernelVersion === sdkApiCore.ProviderKernelVersionEnum.V24 ||
-        entryPointAddress === permissionless.ENTRYPOINT_ADDRESS_V06 // v0.6 only supports v2.4
+        entryPointAddress.address === constants.getEntryPoint('0.6').address // v0.6 only supports v2.4
     ) {
         return constants.KERNEL_V2_4;
     }

package/src/utils/getKernelVersion.d.ts

@@ -1,4 +1,4 @@
 import { KERNEL_VERSION_TYPE } from '@zerodev/sdk/types';
+import { getEntryPoint } from '@zerodev/sdk/constants';
 import { ProviderKernelVersionEnum } from '@dynamic-labs/sdk-api-core';
-import { getEntryPoint } from './getEntryPoint';
 export declare const getKernelVersion: (kernelVersion: ProviderKernelVersionEnum | undefined, entryPointAddress: ReturnType<typeof getEntryPoint>) => KERNEL_VERSION_TYPE;

package/src/utils/getKernelVersion.js

@@ -1,20 +1,19 @@
 'use client'
-import { ENTRYPOINT_ADDRESS_V07, ENTRYPOINT_ADDRESS_V06 } from 'permissionless';
-import { KERNEL_V3_1, KERNEL_V3_0, KERNEL_V2_4 } from '@zerodev/sdk/constants';
+import { getEntryPoint, KERNEL_V3_1, KERNEL_V3_0, KERNEL_V2_4 } from '@zerodev/sdk/constants';
 import { ProviderKernelVersionEnum } from '@dynamic-labs/sdk-api-core';
 import { logger } from './logger.js';
 
 const getKernelVersion = (kernelVersion, entryPointAddress) => {
     if (kernelVersion === ProviderKernelVersionEnum.V31 ||
         (kernelVersion === undefined &&
-            entryPointAddress === ENTRYPOINT_ADDRESS_V07)) {
+            entryPointAddress.address === getEntryPoint('0.7').address)) {
         return KERNEL_V3_1;
     }
     else if (kernelVersion === ProviderKernelVersionEnum.V30) {
         return KERNEL_V3_0;
     }
     else if (kernelVersion === ProviderKernelVersionEnum.V24 ||
-        entryPointAddress === ENTRYPOINT_ADDRESS_V06 // v0.6 only supports v2.4
+        entryPointAddress.address === getEntryPoint('0.6').address // v0.6 only supports v2.4
     ) {
         return KERNEL_V2_4;
     }