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

package/src/ZeroDevConnector.js

@@ -1,18 +1,19 @@
 'use client'
 import { __awaiter } from '../_virtual/_tslib.js';
-import { createEcdsaKernelAccountClient } from '@zerodev/presets';
 import { publicActions, custom, createWalletClient, isHex, fromHex, formatEther } from 'viem';
-import { walletClientToSmartAccountSigner } from 'permissionless';
+import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07, walletClientToSmartAccountSigner } from 'permissionless/utils';
+import { ProviderEntryPointVersionEnum } from '@dynamic-labs/sdk-api-core';
 import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
 import { confirmationTransport, chainsMap, unFormatTransaction, createViemUiTransaction } from '@dynamic-labs/viem-utils';
 import { parseEvmNetworks, DynamicError, DeferredPromise, wrapMethodWithCallback, TransactionGasCannotBeSponsoredError, InsufficientFundsError } from '@dynamic-labs/utils';
 import { isEthWalletConnector } from '@dynamic-labs/ethereum';
 import { cachedChainIdKey, fetchChain } from './utils/fetchChain.js';
 import { logger } from './utils/logger.js';
+import { createEcdsaKernelAccountClient } from './utils/createEcsdaKernelAccountClient.js';
 
 class ZeroDevConnector extends WalletConnectorBase {
     constructor(opts) {
-        var _a;
+        var _a, _b;
         super(opts);
         this.connectedChain = 'EVM';
         this.supportedChains = ['ETH', 'EVM'];
@@ -34,6 +35,11 @@ class ZeroDevConnector extends WalletConnectorBase {
         this.projectId = zeroDevProjectId;
         this._walletUiUtils = opts.walletUiUtils;
         this.evmNetworks = parseEvmNetworks(opts.evmNetworks);
+        this.entryPoint =
+            ((_b = opts.apiProviders.zerodev) === null || _b === void 0 ? void 0 : _b.entryPointVersion) ===
+                ProviderEntryPointVersionEnum.V6
+                ? ENTRYPOINT_ADDRESS_V06
+                : ENTRYPOINT_ADDRESS_V07;
     }
     getEOAConnector() {
         return this.eoaConnector;
@@ -65,6 +71,7 @@ class ZeroDevConnector extends WalletConnectorBase {
             }
             const kernelClient = yield createEcdsaKernelAccountClient({
                 chain: yield fetchChain(this.projectId),
+                entryPointAddress: this.entryPoint,
                 paymaster: 'NONE',
                 projectId: this.projectId,
                 provider: ZeroDevConnector.bundlerProvider,
@@ -102,6 +109,7 @@ class ZeroDevConnector extends WalletConnectorBase {
             const signer = yield eoaConnector.getSigner();
             this.kernelClientWithSponsorship = yield createEcdsaKernelAccountClient({
                 chain: yield fetchChain(this.projectId),
+                entryPointAddress: this.entryPoint,
                 paymaster: 'SPONSOR',
                 projectId: this.projectId,
                 provider: ZeroDevConnector.bundlerProvider,
@@ -201,7 +209,8 @@ class ZeroDevConnector extends WalletConnectorBase {
     }
     getPublicClient() {
         return __awaiter(this, void 0, void 0, function* () {
-            const provider = this.kernelClient.extend(publicActions);
+            var _a;
+            const provider = (_a = this.kernelClient) === null || _a === void 0 ? void 0 : _a.extend(publicActions);
             if (!provider)
                 throw new DynamicError('No provider');
             return provider;
@@ -215,9 +224,9 @@ class ZeroDevConnector extends WalletConnectorBase {
     canSponsorTransactionGas(transaction) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield this.getKernelClientWithSponsorshipValidation();
+                const kernelClientWithSponsorship = yield this.getKernelClientWithSponsorshipValidation();
                 const userOperation = {
-                    callData: yield this.kernelClientWithSponsorship.account.encodeCallData({
+                    callData: yield kernelClientWithSponsorship.account.encodeCallData({
                         data: transaction.data ? transaction.data : '0x',
                         to: transaction.to,
                         /**
@@ -226,11 +235,11 @@ class ZeroDevConnector extends WalletConnectorBase {
                          */
                         value: transaction.value && isHex(transaction.value)
                             ? fromHex(transaction.value, 'bigint')
-                            : '0x0',
+                            : fromHex('0x0', 'bigint'),
                     }),
                 };
-                const result = yield this.kernelClientWithSponsorship.prepareUserOperationRequest({
-                    account: this.kernelClientWithSponsorship.account,
+                const result = yield kernelClientWithSponsorship.prepareUserOperationRequest({
+                    account: kernelClientWithSponsorship.account,
                     userOperation,
                 });
                 if (!result)
@@ -248,7 +257,8 @@ class ZeroDevConnector extends WalletConnectorBase {
     }
     getBalance() {
         return __awaiter(this, void 0, void 0, function* () {
-            const rpcClient = this.kernelClient.extend(publicActions);
+            var _a;
+            const rpcClient = (_a = this.kernelClient) === null || _a === void 0 ? void 0 : _a.extend(publicActions);
             if (!rpcClient)
                 throw new DynamicError('No RPC client');
             const address = yield this.getAddress();

package/src/index.d.ts

@@ -1,5 +1,5 @@
-import { Provider as BundlerProvider } from '@zerodev/presets';
 import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+import { BundlerProvider } from './utils';
 export * from './ethereum-aa';
 export { isZeroDevConnector } from './utils/isZeroDevConnector';
 export declare const ZeroDevSmartWalletConnectorsWithConfig: ({ bundlerProvider, }?: {

package/src/utils/createEcsdaKernelAccountClient.cjs

@@ -0,0 +1,76 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var ecdsaValidator = require('@zerodev/ecdsa-validator');
+var accounts = require('@zerodev/sdk/accounts');
+var clients = require('@zerodev/sdk/clients');
+var viem = require('viem');
+
+const getZeroDevBundlerRPC = (projectId, provider) => {
+    let rpc = `https://rpc.zerodev.app/api/v2/bundler/${projectId}`;
+    if (provider) {
+        rpc += `?bundlerProvider=${provider}`;
+    }
+    return rpc;
+};
+const getZeroDevPaymasterRPC = (projectId, provider) => {
+    let rpc = `https://rpc.zerodev.app/api/v2/paymaster/${projectId}`;
+    if (provider) {
+        rpc += `?paymasterProvider=${provider}`;
+    }
+    return rpc;
+};
+const isERC20 = (value) => viem.isAddress(value);
+const createEcdsaKernelAccountClient = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ chain, projectId, signer, provider, index, paymaster = 'SPONSOR', entryPointAddress, }) {
+    const publicClient = viem.createPublicClient({
+        transport: viem.http(getZeroDevBundlerRPC(projectId, provider)),
+    });
+    const ecdsaValidator$1 = yield ecdsaValidator.signerToEcdsaValidator(publicClient, {
+        entryPoint: entryPointAddress,
+        signer,
+    });
+    const account = yield accounts.createKernelAccount(publicClient, {
+        entryPoint: entryPointAddress,
+        index,
+        plugins: {
+            sudo: ecdsaValidator$1,
+        },
+    });
+    const zerodevPaymaster = clients.createZeroDevPaymasterClient({
+        chain: chain,
+        entryPoint: entryPointAddress,
+        transport: viem.http(getZeroDevPaymasterRPC(projectId, provider)),
+    });
+    const kernelClient = clients.createKernelAccountClient({
+        account,
+        bundlerTransport: viem.http(getZeroDevBundlerRPC(projectId, provider)),
+        chain,
+        entryPoint: entryPointAddress,
+        middleware: paymaster !== 'NONE'
+            ? {
+                sponsorUserOperation: (_b) => _tslib.__awaiter(void 0, [_b], void 0, function* ({ userOperation }) {
+                    const _userOperation = userOperation;
+                    if (isERC20(paymaster)) {
+                        return zerodevPaymaster.sponsorUserOperation({
+                            entryPoint: entryPointAddress,
+                            gasToken: paymaster,
+                            userOperation: _userOperation,
+                        });
+                    }
+                    return zerodevPaymaster.sponsorUserOperation({
+                        entryPoint: entryPointAddress,
+                        userOperation: _userOperation,
+                    });
+                }),
+            }
+            : undefined,
+    });
+    return kernelClient;
+});
+
+exports.createEcdsaKernelAccountClient = createEcdsaKernelAccountClient;
+exports.getZeroDevBundlerRPC = getZeroDevBundlerRPC;
+exports.getZeroDevPaymasterRPC = getZeroDevPaymasterRPC;

package/src/utils/createEcsdaKernelAccountClient.d.ts

@@ -0,0 +1,19 @@
+import { KernelSmartAccount } from '@zerodev/sdk/accounts';
+import { KernelAccountClient } from '@zerodev/sdk/clients';
+import { SmartAccountSigner } from 'permissionless/accounts';
+import { EntryPoint } from 'permissionless/types';
+import { Address, HttpTransport, Chain } from 'viem';
+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}`>({ chain, projectId, signer, provider, index, paymaster, entryPointAddress, }: {
+    chain: TChain;
+    projectId: string;
+    signer: SmartAccountSigner<TSource, TAddress>;
+    paymaster: PaymasterType;
+    entryPointAddress: entryPoint;
+    provider?: BundlerProvider;
+    index?: bigint;
+}) => Promise<KernelAccountClient<entryPoint, HttpTransport, TChain, KernelSmartAccount<entryPoint, HttpTransport, TChain>>>;

package/src/utils/createEcsdaKernelAccountClient.js

@@ -0,0 +1,70 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { signerToEcdsaValidator } from '@zerodev/ecdsa-validator';
+import { createKernelAccount } from '@zerodev/sdk/accounts';
+import { createZeroDevPaymasterClient, createKernelAccountClient } from '@zerodev/sdk/clients';
+import { createPublicClient, http, isAddress } from 'viem';
+
+const getZeroDevBundlerRPC = (projectId, provider) => {
+    let rpc = `https://rpc.zerodev.app/api/v2/bundler/${projectId}`;
+    if (provider) {
+        rpc += `?bundlerProvider=${provider}`;
+    }
+    return rpc;
+};
+const getZeroDevPaymasterRPC = (projectId, provider) => {
+    let rpc = `https://rpc.zerodev.app/api/v2/paymaster/${projectId}`;
+    if (provider) {
+        rpc += `?paymasterProvider=${provider}`;
+    }
+    return rpc;
+};
+const isERC20 = (value) => isAddress(value);
+const createEcdsaKernelAccountClient = (_a) => __awaiter(void 0, [_a], void 0, function* ({ chain, projectId, signer, provider, index, paymaster = 'SPONSOR', entryPointAddress, }) {
+    const publicClient = createPublicClient({
+        transport: http(getZeroDevBundlerRPC(projectId, provider)),
+    });
+    const ecdsaValidator = yield signerToEcdsaValidator(publicClient, {
+        entryPoint: entryPointAddress,
+        signer,
+    });
+    const account = yield createKernelAccount(publicClient, {
+        entryPoint: entryPointAddress,
+        index,
+        plugins: {
+            sudo: ecdsaValidator,
+        },
+    });
+    const zerodevPaymaster = createZeroDevPaymasterClient({
+        chain: chain,
+        entryPoint: entryPointAddress,
+        transport: http(getZeroDevPaymasterRPC(projectId, provider)),
+    });
+    const kernelClient = createKernelAccountClient({
+        account,
+        bundlerTransport: http(getZeroDevBundlerRPC(projectId, provider)),
+        chain,
+        entryPoint: entryPointAddress,
+        middleware: paymaster !== 'NONE'
+            ? {
+                sponsorUserOperation: (_b) => __awaiter(void 0, [_b], void 0, function* ({ userOperation }) {
+                    const _userOperation = userOperation;
+                    if (isERC20(paymaster)) {
+                        return zerodevPaymaster.sponsorUserOperation({
+                            entryPoint: entryPointAddress,
+                            gasToken: paymaster,
+                            userOperation: _userOperation,
+                        });
+                    }
+                    return zerodevPaymaster.sponsorUserOperation({
+                        entryPoint: entryPointAddress,
+                        userOperation: _userOperation,
+                    });
+                }),
+            }
+            : undefined,
+    });
+    return kernelClient;
+});
+
+export { createEcdsaKernelAccountClient, getZeroDevBundlerRPC, getZeroDevPaymasterRPC };

package/src/utils/index.d.ts

@@ -1,3 +1,4 @@
 export * from './fetchChain';
 export * from './logger';
 export * from './isZeroDevConnector';
+export * from './createEcsdaKernelAccountClient';