@dynamic-labs/ethereum-aa 0.0.0-exp20240808.0

package/src/ZeroDevConnector.js

@@ -0,0 +1,349 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { toMultiChainECDSAValidator } from '@zerodev/multi-chain-validator';
+import { publicActions, custom, createWalletClient, isHex, fromHex, formatEther } from 'viem';
+import { ENTRYPOINT_ADDRESS_V07, ENTRYPOINT_ADDRESS_V06, walletClientToSmartAccountSigner } from 'permissionless/utils';
+import { KERNEL_V3_1, KERNEL_V3_0, KERNEL_V2_4 } from '@zerodev/sdk/constants';
+import { signerToEcdsaValidator } from '@zerodev/ecdsa-validator';
+import { ProviderEntryPointVersionEnum, ProviderKernelVersionEnum } 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 { EthereumWallet, 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, _b, _c, _d;
+        super(opts);
+        this.ChainWallet = EthereumWallet;
+        this.connectedChain = 'EVM';
+        this.supportedChains = ['ETH', 'EVM'];
+        this.isGasSponsorshipDisabled = false;
+        this.isEmbeddedWallet = true;
+        this.name = 'ZeroDev';
+        this.overrideKey = 'zerodev';
+        this.walletFallback = {
+            brand: {
+                alt: 'Smart Wallet',
+                spriteId: 'smartwallet',
+            },
+            name: 'ZeroDev',
+        };
+        const zeroDevProjectId = (_a = opts.apiProviders.zerodev) === null || _a === void 0 ? void 0 : _a.clientId;
+        if (!zeroDevProjectId) {
+            throw new Error('Missing ZeroDev project ID provided. Add your ZeroDev project id to your project configuration via the Dynamic Labs dashboard.');
+        }
+        this.projectId = zeroDevProjectId;
+        this._walletUiUtils = opts.walletUiUtils;
+        this.evmNetworks = parseEvmNetworks(opts.evmNetworks);
+        this.entryPoint = this.getEntryPoint((_b = opts.apiProviders.zerodev) === null || _b === void 0 ? void 0 : _b.entryPointVersion);
+        this.kernelVersion = this.getKernelVersion((_c = opts.apiProviders.zerodev) === null || _c === void 0 ? void 0 : _c.kernelVersion);
+        this.ecdsaProviderType = (_d = opts.apiProviders.zerodev) === null || _d === void 0 ? void 0 : _d.ecdsaProviderType;
+    }
+    getEntryPoint(entryPoint) {
+        if (entryPoint === undefined ||
+            entryPoint === ProviderEntryPointVersionEnum.V7) {
+            return ENTRYPOINT_ADDRESS_V07;
+        }
+        else if (entryPoint === ProviderEntryPointVersionEnum.V6) {
+            return ENTRYPOINT_ADDRESS_V06;
+        }
+        else {
+            logger.error('Invalid entry point version', entryPoint);
+            return ENTRYPOINT_ADDRESS_V07;
+        }
+    }
+    getKernelVersion(kernelVersion) {
+        if (kernelVersion === ProviderKernelVersionEnum.V31 ||
+            (kernelVersion === undefined &&
+                this.entryPoint === ENTRYPOINT_ADDRESS_V07)) {
+            return KERNEL_V3_1;
+        }
+        else if (kernelVersion === ProviderKernelVersionEnum.V30) {
+            return KERNEL_V3_0;
+        }
+        else if (kernelVersion === ProviderKernelVersionEnum.V24 ||
+            this.entryPoint === ENTRYPOINT_ADDRESS_V06 // v0.6 only supports v2.4
+        ) {
+            return KERNEL_V2_4;
+        }
+        else {
+            logger.error('Invalid kernel version', kernelVersion);
+            return KERNEL_V3_1;
+        }
+    }
+    getEcdsaValidator(ecdsaProviderType) {
+        if (ecdsaProviderType === 'zerodev_signer_to_ecdsa') {
+            return signerToEcdsaValidator;
+        }
+        else if (ecdsaProviderType === 'zerodev_multi_chain') {
+            return toMultiChainECDSAValidator;
+        }
+        else {
+            return signerToEcdsaValidator;
+        }
+    }
+    getEOAConnector() {
+        return this.eoaConnector;
+    }
+    getAccountAbstractionProvider({ withSponsorship, } = {}) {
+        if (withSponsorship && this.kernelClientWithSponsorship) {
+            return this.kernelClientWithSponsorship;
+        }
+        return this.kernelClient;
+    }
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            localStorage.removeItem(cachedChainIdKey);
+        });
+    }
+    setEoaConnector(connector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!connector) {
+                logger.error('No EOA connector provided');
+                return;
+            }
+            this.kernelClientDeferredPromise = new DeferredPromise();
+            this.eoaConnector = connector;
+            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;
+            }
+            const kernelClient = yield createEcdsaKernelAccountClient({
+                bundlerRpc: ZeroDevConnector.bundlerRpc,
+                chain: yield fetchChain(this.projectId),
+                ecdsaValidator: this.getEcdsaValidator(this.ecdsaProviderType),
+                entryPointAddress: this.entryPoint,
+                kernelVersion: this.kernelVersion,
+                paymaster: 'NONE',
+                paymasterRpc: ZeroDevConnector.paymasterRpc,
+                projectId: this.projectId,
+                provider: ZeroDevConnector.bundlerProvider,
+                signer: walletClientToSmartAccountSigner(signer),
+            });
+            wrapMethodWithCallback(kernelClient, 'sendUserOperation', (original, ...args) => {
+                this._walletUiUtils.disabledConfirmationOnce();
+                return original(...args);
+            });
+            this.kernelClient = kernelClient;
+            // set the provider with sponsorship enabled
+            yield this.getKernelClientWithSponsorshipValidation();
+            yield this.checkIsProjectChainEnabled();
+            this.kernelClientDeferredPromise.resolve();
+        });
+    }
+    checkIsProjectChainEnabled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const client = yield this.getPublicClient();
+            const chainName = (_a = client === null || client === void 0 ? void 0 : client.chain) === null || _a === void 0 ? void 0 : _a.name;
+            const chainId = (_b = client === null || client === void 0 ? void 0 : client.chain) === null || _b === void 0 ? void 0 : _b.id;
+            const isProjectChainEnabled = this.evmNetworks.some((network) => network.chainId === chainId);
+            if (!isProjectChainEnabled) {
+                logger.error(`Please make sure to enable ${chainName} (${chainId}) in the Dynamic dashboard (https://app.dynamic.xyz/dashboard/configurations#evm).`);
+            }
+        });
+    }
+    getKernelClientWithSponsorshipValidation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.kernelClientWithSponsorship) {
+                return this.kernelClientWithSponsorship;
+            }
+            const { eoaConnector } = this;
+            if (!eoaConnector)
+                throw new DynamicError('No EOA connector');
+            const signer = yield eoaConnector.getSigner();
+            this.kernelClientWithSponsorship = yield createEcdsaKernelAccountClient({
+                bundlerRpc: ZeroDevConnector.bundlerRpc,
+                chain: yield fetchChain(this.projectId),
+                ecdsaValidator: this.getEcdsaValidator(this.ecdsaProviderType),
+                entryPointAddress: this.entryPoint,
+                kernelVersion: this.kernelVersion,
+                paymaster: 'SPONSOR',
+                paymasterRpc: ZeroDevConnector.paymasterRpc,
+                projectId: this.projectId,
+                provider: ZeroDevConnector.bundlerProvider,
+                signer: walletClientToSmartAccountSigner(signer),
+            });
+            wrapMethodWithCallback(this.kernelClientWithSponsorship, 'sendUserOperation', (original, ...args) => {
+                this._walletUiUtils.disabledConfirmationOnce();
+                return original(...args);
+            });
+            return this.kernelClientWithSponsorship;
+        });
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            yield ((_a = this.kernelClientDeferredPromise) === null || _a === void 0 ? void 0 : _a.promise);
+            return (_c = (_b = this.kernelClient) === null || _b === void 0 ? void 0 : _b.account) === null || _c === void 0 ? void 0 : _c.address;
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            yield ((_a = this.kernelClientDeferredPromise) === null || _a === void 0 ? void 0 : _a.promise);
+            return ((_c = (_b = this.kernelClient) === null || _b === void 0 ? void 0 : _b.account) === null || _c === void 0 ? void 0 : _c.address)
+                ? [yield this.kernelClient.account.address]
+                : [];
+        });
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            yield ((_a = this.kernelClientDeferredPromise) === null || _a === void 0 ? void 0 : _a.promise);
+            return (_c = (_b = this.kernelClient) === null || _b === void 0 ? void 0 : _b.chain) === null || _c === void 0 ? void 0 : _c.id;
+        });
+    }
+    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();
+                return provider.signMessage({
+                    account: provider.account,
+                    message,
+                });
+            }),
+            onSendTransaction: (_b) => __awaiter(this, [_b], void 0, function* ({ transaction }) {
+                try {
+                    this._walletUiUtils.disabledConfirmationOnce();
+                    const effectiveProvider = this.isGasSponsorshipDisabled
+                        ? provider
+                        : yield this.getKernelClientWithSponsorshipValidation();
+                    const response = yield effectiveProvider.sendTransaction(unFormatTransaction(transaction));
+                    return response;
+                }
+                catch (err) {
+                    logger.debug(err);
+                    if (TransactionGasCannotBeSponsoredError.isErrorMessage(err)) {
+                        throw new TransactionGasCannotBeSponsoredError();
+                    }
+                    if (InsufficientFundsError.isErrorMessage(err)) {
+                        throw new InsufficientFundsError();
+                    }
+                    throw err;
+                }
+            }),
+            onSignTypedData: (_c) => __awaiter(this, [_c], void 0, function* ({ message }) {
+                this._walletUiUtils.disabledConfirmationOnce();
+                const signTypedData = JSON.parse(message);
+                return provider.signTypedData({
+                    account: provider.account,
+                    domain: signTypedData.domain,
+                    message: signTypedData.message,
+                    primaryType: signTypedData.primaryType,
+                    types: signTypedData.types,
+                });
+            }),
+            provider: provider.extend(publicActions),
+            transport: custom(provider),
+            walletConnector: this,
+            walletUiUtils: this._walletUiUtils,
+        });
+        return transport;
+    }
+    getWalletClient(chainId) {
+        var _a;
+        const provider = this.kernelClient;
+        if (!provider)
+            throw new DynamicError('No provider');
+        const transport = this.getTransport(provider);
+        const address = (_a = provider.account) === null || _a === void 0 ? void 0 : _a.address;
+        const walletClient = createWalletClient({
+            account: address,
+            chain: chainId ? chainsMap[chainId] : provider.chain,
+            transport,
+        });
+        return walletClient;
+    }
+    getPublicClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+        });
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getWalletClient();
+        });
+    }
+    canSponsorTransactionGas(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const kernelClientWithSponsorship = yield this.getKernelClientWithSponsorshipValidation();
+                const userOperation = {
+                    callData: yield kernelClientWithSponsorship.account.encodeCallData({
+                        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';
+            }
+            catch (err) {
+                logger.debug(err);
+                return false;
+            }
+        });
+    }
+    disableGasSponsorshipOnce() {
+        this.isGasSponsorshipDisabled = true;
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const rpcClient = (_a = this.kernelClient) === null || _a === void 0 ? void 0 : _a.extend(publicActions);
+            if (!rpcClient)
+                throw new DynamicError('No RPC client');
+            return formatEther(yield rpcClient.getBalance({ address: address }));
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.getSigner();
+            const account = yield this.getAddress();
+            if (!account || !client)
+                return;
+            return client.signMessage({
+                account: account,
+                message: messageToSign,
+            });
+        });
+    }
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletClient = this.getWalletClient();
+            const publicClient = yield this.getPublicClient();
+            if (!publicClient || !walletClient) {
+                throw new DynamicError('No public client available');
+            }
+            return createViemUiTransaction({ from, publicClient, walletClient });
+        });
+    }
+}
+
+export { ZeroDevConnector };

package/src/ethereum-aa.cjs

@@ -0,0 +1,9 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class EthereumAaConnector {
+}
+
+exports.EthereumAaConnector = EthereumAaConnector;

package/src/ethereum-aa.d.ts

@@ -0,0 +1,2 @@
+export declare class EthereumAaConnector {
+}

package/src/ethereum-aa.js

@@ -0,0 +1,5 @@
+'use client'
+class EthereumAaConnector {
+}
+
+export { EthereumAaConnector };

package/src/index.cjs

@@ -0,0 +1,27 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ZeroDevConnector = require('./ZeroDevConnector.cjs');
+var ethereumAa = require('./ethereum-aa.cjs');
+var isZeroDevConnector = require('./utils/isZeroDevConnector.cjs');
+
+const ZeroDevSmartWalletConnectorsWithConfig = ({ bundlerProvider, bundlerRpc, paymasterRpc, } = {}) => {
+    ZeroDevConnector.ZeroDevConnector.bundlerProvider = bundlerProvider;
+    ZeroDevConnector.ZeroDevConnector.bundlerRpc = bundlerRpc;
+    ZeroDevConnector.ZeroDevConnector.paymasterRpc = paymasterRpc;
+    return ZeroDevSmartWalletConnectors;
+};
+const ZeroDevSmartWalletConnectors = (props) => {
+    var _a;
+    if ((_a = props.apiProviders) === null || _a === void 0 ? void 0 : _a.zerodev) {
+        return [ZeroDevConnector.ZeroDevConnector];
+    }
+    return [];
+};
+
+exports.EthereumAaConnector = ethereumAa.EthereumAaConnector;
+exports.isZeroDevConnector = isZeroDevConnector.isZeroDevConnector;
+exports.ZeroDevSmartWalletConnectors = ZeroDevSmartWalletConnectors;
+exports.ZeroDevSmartWalletConnectorsWithConfig = ZeroDevSmartWalletConnectorsWithConfig;

package/src/index.d.ts

@@ -0,0 +1,10 @@
+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, bundlerRpc, paymasterRpc, }?: {
+    bundlerProvider?: BundlerProvider;
+    bundlerRpc?: string;
+    paymasterRpc?: string;
+}) => (props: any) => WalletConnectorConstructor[];
+export declare const ZeroDevSmartWalletConnectors: (props: any) => WalletConnectorConstructor[];

package/src/index.js

@@ -0,0 +1,20 @@
+'use client'
+import { ZeroDevConnector } from './ZeroDevConnector.js';
+export { EthereumAaConnector } from './ethereum-aa.js';
+export { isZeroDevConnector } from './utils/isZeroDevConnector.js';
+
+const ZeroDevSmartWalletConnectorsWithConfig = ({ bundlerProvider, bundlerRpc, paymasterRpc, } = {}) => {
+    ZeroDevConnector.bundlerProvider = bundlerProvider;
+    ZeroDevConnector.bundlerRpc = bundlerRpc;
+    ZeroDevConnector.paymasterRpc = paymasterRpc;
+    return ZeroDevSmartWalletConnectors;
+};
+const ZeroDevSmartWalletConnectors = (props) => {
+    var _a;
+    if ((_a = props.apiProviders) === null || _a === void 0 ? void 0 : _a.zerodev) {
+        return [ZeroDevConnector];
+    }
+    return [];
+};
+
+export { ZeroDevSmartWalletConnectors, ZeroDevSmartWalletConnectorsWithConfig };

package/src/utils/createEcsdaKernelAccountClient.cjs

@@ -0,0 +1,79 @@
+'use client'
+'use strict';
+
+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 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* ({ bundlerRpc, chain, paymasterRpc, projectId, signer, provider, index, paymaster = 'SPONSOR', entryPointAddress, 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({
+        transport: viem.http(resolvedBundlerRpc),
+    });
+    const validator = yield ecdsaValidator(publicClient, {
+        entryPoint: entryPointAddress,
+        kernelVersion,
+        signer,
+    });
+    const account = yield accounts.createKernelAccount(publicClient, {
+        entryPoint: entryPointAddress,
+        index,
+        kernelVersion,
+        plugins: {
+            sudo: validator,
+        },
+    });
+    const zerodevPaymaster = clients.createZeroDevPaymasterClient({
+        chain: chain,
+        entryPoint: entryPointAddress,
+        transport: viem.http(resolvedPaymasterRpc),
+    });
+    const kernelClient = clients.createKernelAccountClient({
+        account,
+        bundlerTransport: viem.http(resolvedBundlerRpc),
+        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,24 @@
+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';
+import { 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;
+    chain: TChain;
+    projectId: string;
+    signer: SmartAccountSigner<TSource, TAddress>;
+    paymaster: PaymasterType;
+    paymasterRpc?: string;
+    entryPointAddress: entryPoint;
+    provider?: BundlerProvider;
+    index?: bigint;
+    kernelVersion: GetKernelVersion<entryPoint>;
+    ecdsaValidator: any;
+}) => Promise<KernelAccountClient<entryPoint, HttpTransport, TChain, KernelSmartAccount<entryPoint, HttpTransport, TChain>>>;

package/src/utils/createEcsdaKernelAccountClient.js

@@ -0,0 +1,73 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+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* ({ bundlerRpc, chain, paymasterRpc, projectId, signer, provider, index, paymaster = 'SPONSOR', entryPointAddress, 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({
+        transport: http(resolvedBundlerRpc),
+    });
+    const validator = yield ecdsaValidator(publicClient, {
+        entryPoint: entryPointAddress,
+        kernelVersion,
+        signer,
+    });
+    const account = yield createKernelAccount(publicClient, {
+        entryPoint: entryPointAddress,
+        index,
+        kernelVersion,
+        plugins: {
+            sudo: validator,
+        },
+    });
+    const zerodevPaymaster = createZeroDevPaymasterClient({
+        chain: chain,
+        entryPoint: entryPointAddress,
+        transport: http(resolvedPaymasterRpc),
+    });
+    const kernelClient = createKernelAccountClient({
+        account,
+        bundlerTransport: http(resolvedBundlerRpc),
+        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/fetchChain.cjs

@@ -0,0 +1,29 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var viemUtils = require('@dynamic-labs/viem-utils');
+var logger = require('./logger.cjs');
+
+const cachedChainIdKey = 'dynamic_zd_chain_id';
+const fetchChain = (projectId) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const cachedChainId = localStorage.getItem(cachedChainIdKey);
+        if (cachedChainId) {
+            return viemUtils.chainsMap[cachedChainId];
+        }
+        const response = yield (yield fetch(`https://prod-api.zerodev.app/projects/${projectId}`)).json();
+        localStorage.setItem(cachedChainIdKey, response.chainId);
+        return viemUtils.chainsMap[response.chainId];
+    }
+    catch (err) {
+        logger.logger.error('Failed to fetch ZeroDev project settings from ZeroDev API ' +
+            'This is needed to fetch the chain id so that we know which chain the smart contract is on');
+        throw err;
+    }
+});
+
+exports.cachedChainIdKey = cachedChainIdKey;
+exports.fetchChain = fetchChain;

package/src/utils/fetchChain.d.ts

@@ -0,0 +1,3 @@
+import { type Chain } from 'viem/chains';
+export declare const cachedChainIdKey = "dynamic_zd_chain_id";
+export declare const fetchChain: (projectId: string) => Promise<Chain>;

package/src/utils/fetchChain.js

@@ -0,0 +1,24 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { chainsMap } from '@dynamic-labs/viem-utils';
+import { logger } from './logger.js';
+
+const cachedChainIdKey = 'dynamic_zd_chain_id';
+const fetchChain = (projectId) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const cachedChainId = localStorage.getItem(cachedChainIdKey);
+        if (cachedChainId) {
+            return chainsMap[cachedChainId];
+        }
+        const response = yield (yield fetch(`https://prod-api.zerodev.app/projects/${projectId}`)).json();
+        localStorage.setItem(cachedChainIdKey, response.chainId);
+        return chainsMap[response.chainId];
+    }
+    catch (err) {
+        logger.error('Failed to fetch ZeroDev project settings from ZeroDev API ' +
+            'This is needed to fetch the chain id so that we know which chain the smart contract is on');
+        throw err;
+    }
+});
+
+export { cachedChainIdKey, fetchChain };

package/src/utils/index.d.ts

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