@dynamic-labs-sdk/zerodev 0.1.0-alpha.17 → 0.1.0-alpha.19

package/index.esm.js

@@ -1,31 +1,74 @@
 import { assertPackageVersion } from '@dynamic-labs-sdk/assert-package-version';
-import { getDefaultClient, hasExtension, registerExtension } from '@dynamic-labs-sdk/client/core';
-import { getOwnerWalletAccountForSmartWalletAccount, NoSmartWalletAccountSignerFoundError } from '@dynamic-labs-sdk/client';
+import { getChainFromVerifiedCredentialChain, assertDefined, getDefaultClient, getVerifiedCredentialForWalletAccount, formatWalletProviderKey, formatWalletProviderGroupKey, getActiveNetworkIdFromLastKnownRegistry, switchActiveNetworkInLastKnownRegistry, MethodNotImplementedError, hasExtension, registerExtension, getWalletProviderRegistry, WalletProviderPriority } from '@dynamic-labs-sdk/client/core';
+import { getOwnerWalletAccountForSmartWalletAccount, NoSmartWalletAccountSignerFoundError, getActiveNetworkData, signMessage as signMessage$1, UnrecognizedNetworkError, InvalidParamError } from '@dynamic-labs-sdk/client';
 import { isEvmWalletAccount } from '@dynamic-labs-sdk/evm';
-import { createWalletClientForWalletAccount } from '@dynamic-labs-sdk/evm/viem';
+import { ProviderKernelVersionEnum, WalletProviderEnum, ProviderEnum, ProviderEntryPointVersionEnum, ZerodevBundlerProvider } from '@dynamic-labs/sdk-api-core';
+import { constants, createKernelAccount as createKernelAccount$1, createZeroDevPaymasterClient, createKernelAccountClient, getUserOperationGasPrice } from '@zerodev/sdk';
+import { createWalletClientForWalletAccount, mapNetworkDataToViemChain } from '@dynamic-labs-sdk/evm/viem';
+import { http, createPublicClient } from 'viem';
+import { signerToEcdsaValidator, createEcdsaKernelMigrationAccount } from '@zerodev/ecdsa-validator';
+import { toMultiChainECDSAValidator } from '@zerodev/multi-chain-ecdsa-validator';
 
 var name = "@dynamic-labs-sdk/zerodev";
-var version = "0.1.0-alpha.17";
+var version = "0.1.0-alpha.19";
 
-const ZERODEV_EXTENSION_KEY = 'zerodev';
-/**
- * Adds the ZeroDev extension to the Dynamic client.
- *
- * This extension enables Account Abstraction integration with ZeroDev
- *
- * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- */ const addZerodevExtension = (client = getDefaultClient())=>{
-    if (hasExtension({
-        extensionKey: ZERODEV_EXTENSION_KEY
-    }, client)) {
-        return;
-    }
-    registerExtension({
-        extensionKey: ZERODEV_EXTENSION_KEY
-    }, client);
-// TODO: implement
+const ZERODEV_METADATA = {
+    displayName: 'ZeroDev',
+    icon: 'https://iconic.dynamic-static-assets.com/icons/sprite.svg#smartwallet',
+    normalizedWalletName: 'zerodev'
+};
+const ZERODEV_RPC_BASE_URL = 'https://rpc.zerodev.app/api/v2';
+const KERNEL_VERSION_MAP = {
+    [ProviderKernelVersionEnum.V33]: constants.KERNEL_V3_3,
+    [ProviderKernelVersionEnum.V32]: constants.KERNEL_V3_2,
+    [ProviderKernelVersionEnum.V31]: constants.KERNEL_V3_1,
+    [ProviderKernelVersionEnum.V30]: constants.KERNEL_V3_0,
+    [ProviderKernelVersionEnum.V24]: constants.KERNEL_V2_4
+};
+const ENTRY_POINT_VERSION_MAP = {
+    0.6: constants.KERNEL_V2_4,
+    0.7: constants.KERNEL_V3_1,
+    0.8: constants.KERNEL_V3_3
 };
 
+const getAllUserZerodevAddresses = (client)=>{
+    var _client_user;
+    var _client_user_verifiedCredentials_filter;
+    const zerodevWalletCredentials = (_client_user_verifiedCredentials_filter = (_client_user = client.user) == null ? void 0 : _client_user.verifiedCredentials.filter((credential)=>{
+        var _credential_walletName;
+        return credential.walletProvider === WalletProviderEnum.SmartContractWallet && ((_credential_walletName = credential.walletName) == null ? void 0 : _credential_walletName.toLowerCase().startsWith(ZERODEV_METADATA.normalizedWalletName)) && credential.address && credential.chain && getChainFromVerifiedCredentialChain(credential.chain) === 'EVM';
+    })) != null ? _client_user_verifiedCredentials_filter : [];
+    const zerodevAddresses = zerodevWalletCredentials.map(// casting because we're already filtering out credentials without an address
+    (credential)=>credential.address);
+    return zerodevAddresses;
+};
+
+const getZerodevProviderFromSettings = (client)=>{
+    var _projectSettings_providers;
+    const projectSettings = client.projectSettings;
+    assertDefined(projectSettings, 'Project settings are not available');
+    const zerodevProvider = (_projectSettings_providers = projectSettings.providers) == null ? void 0 : _projectSettings_providers.find((provider)=>provider.provider === ProviderEnum.Zerodev);
+    assertDefined(zerodevProvider, 'Zerodev is not configured in project settings');
+    return zerodevProvider;
+};
+
+const getZerodevChainProviderForNetworkId = ({ networkId }, client)=>{
+    var _zerodevProvider_multichainAccountAbstractionProviders;
+    const zerodevProvider = getZerodevProviderFromSettings(client);
+    return (_zerodevProvider_multichainAccountAbstractionProviders = zerodevProvider.multichainAccountAbstractionProviders) == null ? void 0 : _zerodevProvider_multichainAccountAbstractionProviders.find((provider)=>provider.chain === networkId);
+};
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
 /**
  * Gets a WalletClient instance for the EOA of the smart wallet account.
  * You can use this signer to sign EVM transactions.
@@ -46,6 +89,404 @@ const ZERODEV_EXTENSION_KEY = 'zerodev';
     }, client);
 };
 
+const getEcdsaValidator = ({ ecdsaProviderType, publicClient, signer, entryPoint, kernelVersion })=>{
+    const params = {
+        entryPoint,
+        kernelVersion,
+        signer
+    };
+    if (ecdsaProviderType === 'zerodev_multi_chain') {
+        return toMultiChainECDSAValidator(publicClient, params);
+    }
+    return signerToEcdsaValidator(publicClient, params);
+};
+
+const getEntryPoint = (entryPoint)=>{
+    if (entryPoint === ProviderEntryPointVersionEnum.V6) {
+        return constants.getEntryPoint('0.6');
+    }
+    // default to v7
+    return constants.getEntryPoint('0.7');
+};
+
+const getKernelVersion = ({ kernelVersion, entryPoint })=>{
+    // If kernel version is explicitly provided, use it
+    if (kernelVersion && kernelVersion in KERNEL_VERSION_MAP) {
+        return KERNEL_VERSION_MAP[kernelVersion];
+    }
+    // If no kernel version provided, determine based on entry point version
+    const entryPointVersion = entryPoint.version;
+    if (entryPointVersion in ENTRY_POINT_VERSION_MAP) {
+        return ENTRY_POINT_VERSION_MAP[entryPointVersion];
+    }
+    // Fallback to latest version
+    return constants.KERNEL_V3_3;
+};
+
+const shouldUseEIP7702 = ({ smartWalletAccount }, client)=>{
+    const zerodevProvider = getZerodevProviderFromSettings(client);
+    assertDefined(zerodevProvider, 'Zerodev provider is not enabled in project settings');
+    const eoaWalletAccount = getOwnerWalletAccountForSmartWalletAccount({
+        smartWalletAccount
+    }, client);
+    assertDefined(eoaWalletAccount, 'EOA wallet account is not found');
+    return zerodevProvider.enableEIP7702 && // with EIP7702, the EOA wallet account address is the same as the smart wallet account address
+    smartWalletAccount.address === eoaWalletAccount.address;
+};
+
+const createKernelAccount = async ({ publicClient, smartWalletAccount }, client)=>{
+    var _getVerifiedCredentialForWalletAccount;
+    const zerodevProvider = getZerodevProviderFromSettings(client);
+    assertDefined(zerodevProvider, 'Zerodev provider is not enabled in project settings');
+    const signer = await getSignerForSmartWalletAccount({
+        smartWalletAccount
+    }, client);
+    const walletProperties = (_getVerifiedCredentialForWalletAccount = getVerifiedCredentialForWalletAccount({
+        walletAccount: smartWalletAccount
+    }, client)) == null ? void 0 : _getVerifiedCredentialForWalletAccount.walletProperties;
+    var _walletProperties_entryPointVersion;
+    const entryPointVersion = (_walletProperties_entryPointVersion = walletProperties == null ? void 0 : walletProperties.entryPointVersion) != null ? _walletProperties_entryPointVersion : zerodevProvider.entryPointVersion;
+    const entryPoint = getEntryPoint(entryPointVersion);
+    const useEIP7702 = shouldUseEIP7702({
+        smartWalletAccount
+    }, client);
+    if (useEIP7702) {
+        return createKernelAccount$1(publicClient, {
+            eip7702Account: signer,
+            entryPoint,
+            kernelVersion: constants.KERNEL_V3_3
+        });
+    }
+    var _walletProperties_kernelVersion;
+    const kernelVersionValue = (_walletProperties_kernelVersion = walletProperties == null ? void 0 : walletProperties.kernelVersion) != null ? _walletProperties_kernelVersion : zerodevProvider.kernelVersion;
+    const kernelVersion = getKernelVersion({
+        entryPoint,
+        kernelVersion: kernelVersionValue
+    });
+    var _zerodevProvider_enableKernelV3Migration;
+    const kernelV3MigrationEnabled = (_zerodevProvider_enableKernelV3Migration = zerodevProvider.enableKernelV3Migration) != null ? _zerodevProvider_enableKernelV3Migration : false;
+    if (kernelV3MigrationEnabled) {
+        const apiKernelVersion = getKernelVersion({
+            entryPoint,
+            kernelVersion: zerodevProvider.kernelVersion
+        });
+        return createEcdsaKernelMigrationAccount(publicClient, {
+            entryPoint,
+            migrationVersion: {
+                from: kernelVersion,
+                to: apiKernelVersion
+            },
+            signer
+        });
+    }
+    var _walletProperties_ecdsaProviderType;
+    const validator = await getEcdsaValidator({
+        ecdsaProviderType: (_walletProperties_ecdsaProviderType = walletProperties == null ? void 0 : walletProperties.ecdsaProviderType) != null ? _walletProperties_ecdsaProviderType : zerodevProvider.ecdsaProviderType,
+        entryPoint,
+        kernelVersion,
+        publicClient,
+        signer
+    });
+    return createKernelAccount$1(publicClient, {
+        entryPoint,
+        kernelVersion,
+        plugins: {
+            sudo: validator
+        }
+    });
+};
+
+const getPaymasterConfig = ({ chain, gasTokenAddress, paymasterRpc })=>{
+    const getPaymasterData = (params)=>{
+        const zerodevPaymaster = createZeroDevPaymasterClient({
+            chain,
+            transport: http(paymasterRpc)
+        });
+        return zerodevPaymaster.sponsorUserOperation({
+            gasToken: gasTokenAddress,
+            userOperation: params
+        });
+    };
+    return {
+        paymaster: {
+            getPaymasterData
+        }
+    };
+};
+
+const getZerodevRpc = ({ networkId, bundlerProvider, rpcType }, client)=>{
+    const zerodevProvider = getZerodevProviderFromSettings(client);
+    if (zerodevProvider == null ? void 0 : zerodevProvider.zerodevPaymasterRpcUrl) {
+        return zerodevProvider.zerodevPaymasterRpcUrl;
+    }
+    const zerodevChainProvider = getZerodevChainProviderForNetworkId({
+        networkId
+    }, client);
+    assertDefined(zerodevChainProvider, `No zerodev provider found for network id ${networkId}`);
+    var _ref;
+    const paymasterProvider = (_ref = bundlerProvider != null ? bundlerProvider : zerodevProvider.zerodevBundlerProvider) != null ? _ref : ZerodevBundlerProvider.Pimlico;
+    const paramName = rpcType === 'bundler' ? 'bundlerProvider' : 'paymasterProvider';
+    return `${ZERODEV_RPC_BASE_URL}/${rpcType}/${zerodevChainProvider.clientId}?${paramName}=${paymasterProvider}`;
+};
+
+/**
+ * Creates a KernelClient instance for a given smart wallet account.
+ *
+ * @param params.smartWalletAccount - The smart wallet account to create the KernelClient for.
+ * @param [params.bundlerProvider] - A custom bundler provider to use
+ * @param [params.bundlerRpc] - A custom bundler RPC to use
+ * @param [params.paymasterRpc] - A custom paymaster RPC to use
+ * @param [params.gasTokenAddress] - The address of a custom ERC20 token to use as a gas token
+ * @param [params.withSponsorship] - Whether to use sponsorship for the KernelClient or not (default is true).
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns A promise that resolves to a KernelClient instance.
+ */ const createKernelClientForWalletAccount = async ({ smartWalletAccount, withSponsorship = true, bundlerProvider, bundlerRpc: bundlerRpcOverride, paymasterRpc: paymasterRpcOverride, gasTokenAddress }, client = getDefaultClient())=>{
+    const { networkData: activeNetworkData } = await getActiveNetworkData({
+        walletAccount: smartWalletAccount
+    }, client);
+    assertDefined(activeNetworkData, 'No active network data found');
+    const viemChain = mapNetworkDataToViemChain(activeNetworkData);
+    const bundlerRpc = bundlerRpcOverride != null ? bundlerRpcOverride : getZerodevRpc({
+        bundlerProvider,
+        networkId: activeNetworkData.networkId,
+        rpcType: 'bundler'
+    }, client);
+    const bundlerTransport = http(bundlerRpc);
+    const publicClient = createPublicClient({
+        chain: viemChain,
+        transport: bundlerTransport
+    });
+    const account = await createKernelAccount({
+        publicClient,
+        smartWalletAccount
+    }, client);
+    const paymasterRpc = paymasterRpcOverride != null ? paymasterRpcOverride : getZerodevRpc({
+        bundlerProvider,
+        networkId: activeNetworkData.networkId,
+        rpcType: 'paymaster'
+    }, client);
+    const paymasterConfig = withSponsorship ? getPaymasterConfig({
+        chain: viemChain,
+        gasTokenAddress,
+        paymasterRpc
+    }) : {};
+    return createKernelAccountClient(_extends({
+        account,
+        bundlerTransport,
+        chain: viemChain,
+        client: publicClient,
+        userOperation: {
+            estimateFeesPerGas: async ({ bundlerClient })=>getUserOperationGasPrice(bundlerClient)
+        }
+    }, paymasterConfig));
+};
+
+const shouldSignWithEoa = async ({ kernelClient, smartWalletAccount }, client)=>{
+    const useEIP7702 = shouldUseEIP7702({
+        smartWalletAccount
+    }, client);
+    if (!useEIP7702) {
+        return false;
+    }
+    const isDeployed = await kernelClient.account.isDeployed();
+    return !isDeployed;
+};
+
+const signMessage = async ({ walletAccount, message }, client)=>{
+    const kernelClient = await createKernelClientForWalletAccount({
+        smartWalletAccount: walletAccount
+    }, client);
+    const shouldUseEoa = await shouldSignWithEoa({
+        kernelClient,
+        smartWalletAccount: walletAccount
+    }, client);
+    if (shouldUseEoa) {
+        const eoaWalletAccount = getOwnerWalletAccountForSmartWalletAccount({
+            smartWalletAccount: walletAccount
+        }, client);
+        assertDefined(eoaWalletAccount, 'Eoa wallet account not found');
+        const { signature } = await signMessage$1({
+            message,
+            walletAccount: eoaWalletAccount
+        });
+        return {
+            signature
+        };
+    }
+    const signature = await kernelClient.signMessage({
+        message
+    });
+    return {
+        signature
+    };
+};
+
+const createZerodevWalletProvider = (client)=>{
+    const chain = 'EVM';
+    const walletProviderType = WalletProviderEnum.SmartContractWallet;
+    const key = formatWalletProviderKey({
+        chain,
+        displayName: ZERODEV_METADATA.displayName,
+        walletProviderType
+    });
+    const getActiveNetworkId = async ()=>getActiveNetworkIdFromLastKnownRegistry({
+            client,
+            walletProviderKey: key
+        });
+    const getConnectedAddresses = async ()=>{
+        const zerodevAddresses = getAllUserZerodevAddresses(client);
+        return {
+            addresses: zerodevAddresses
+        };
+    };
+    const request = async ()=>{
+        throw new MethodNotImplementedError('request');
+    };
+    const signMessage$1 = async ({ walletAccount, message })=>{
+        assertDefined(walletAccount, 'Wallet account is required');
+        if (!isEvmWalletAccount(walletAccount)) {
+            throw new InvalidParamError(`walletAccount is not an EVM wallet account`);
+        }
+        return signMessage({
+            message,
+            walletAccount
+        }, client);
+    };
+    const switchActiveNetwork = async ({ networkId })=>{
+        const isNetworkEnabled = getZerodevChainProviderForNetworkId({
+            networkId
+        }, client);
+        if (!isNetworkEnabled) {
+            throw new UnrecognizedNetworkError({
+                networkId,
+                originalError: null,
+                walletProviderKey: key
+            });
+        }
+        return switchActiveNetworkInLastKnownRegistry({
+            client,
+            networkId,
+            walletProviderKey: key
+        });
+    };
+    return {
+        chain,
+        getActiveNetworkId,
+        getConnectedAddresses,
+        groupKey: formatWalletProviderGroupKey(ZERODEV_METADATA.displayName),
+        key,
+        metadata: {
+            displayName: ZERODEV_METADATA.displayName,
+            icon: ZERODEV_METADATA.icon
+        },
+        request,
+        signMessage: signMessage$1,
+        switchActiveNetwork,
+        walletProviderType
+    };
+};
+
+const ZERODEV_EXTENSION_KEY = 'zerodev';
+/**
+ * Adds the ZeroDev extension to the Dynamic client.
+ *
+ * This extension enables Account Abstraction integration with ZeroDev
+ *
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ */ const addZerodevExtension = (client = getDefaultClient())=>{
+    if (hasExtension({
+        extensionKey: ZERODEV_EXTENSION_KEY
+    }, client)) {
+        return;
+    }
+    registerExtension({
+        extensionKey: ZERODEV_EXTENSION_KEY
+    }, client);
+    const walletProviderRegistry = getWalletProviderRegistry(client);
+    const walletProvider = createZerodevWalletProvider(client);
+    walletProviderRegistry.register({
+        priority: WalletProviderPriority.WALLET_SDK,
+        walletProvider
+    });
+};
+
+const prepareUserOperationWithKernelClient = async ({ kernelClient, transaction })=>{
+    var _transaction_data;
+    const callData = await kernelClient.account.encodeCalls([
+        {
+            data: (_transaction_data = transaction.data) != null ? _transaction_data : '0x',
+            to: transaction.to,
+            value: transaction.value
+        }
+    ]);
+    return kernelClient.prepareUserOperation({
+        callData
+    });
+};
+
+/**
+ * Checks if a transaction can be sponsored
+ * @param params.transaction - The transaction to check if it can be sponsored
+ * @param params.kernelClient - The kernel client to use to check if the transaction can be sponsored. If no provided, a walletAccount is required to create a kernel client with sponsorship.
+ * @param params.walletAccount - The wallet account that will be used to send the transaction, Only required if no kernel client is provided
+ * @returns True if the transaction can be sponsored, false otherwise
+ */ const canSponsorTransaction = async ({ walletAccount, transaction, kernelClient })=>{
+    let kernelClientToUse = kernelClient;
+    if (!kernelClientToUse) {
+        assertDefined(walletAccount, 'Please provide either a wallet account or a kernel client in the parameters');
+        kernelClientToUse = await createKernelClientForWalletAccount({
+            smartWalletAccount: walletAccount
+        });
+    }
+    try {
+        const sponsorResult = await prepareUserOperationWithKernelClient({
+            kernelClient: kernelClientToUse,
+            transaction
+        });
+        const hasPaymaster = sponsorResult.paymasterAndData !== '0x';
+        return hasPaymaster;
+    } catch (e) {
+        return false;
+    }
+};
+
+const calculateGasForUserOperation = ({ userOperationData })=>{
+    // Sum all gas units
+    const totalGasUnits = userOperationData.callGasLimit + userOperationData.verificationGasLimit + userOperationData.preVerificationGas;
+    // Multiply by maxFeePerGas to get the total gas cost in wei
+    const gasCost = totalGasUnits * userOperationData.maxFeePerGas;
+    return gasCost;
+};
+
+/**
+ * Estimates the total gas for a transaction
+ * @param params.transaction - The transaction to estimate the gas for
+ * @param params.walletAccount - The wallet account that will be used to send the transaction
+ * @returns The gas for the transaction in wei
+ */ const estimateTransactionGas = async ({ walletAccount, transaction })=>{
+    try {
+        const kernelClientWithoutSponsorship = await createKernelClientForWalletAccount({
+            smartWalletAccount: walletAccount,
+            withSponsorship: false
+        });
+        const unsponsoredUserOperation = await prepareUserOperationWithKernelClient({
+            kernelClient: kernelClientWithoutSponsorship,
+            transaction
+        });
+        return calculateGasForUserOperation({
+            userOperationData: unsponsoredUserOperation
+        });
+    } catch (e) {
+        return null;
+    }
+};
+
+const isGasSponsorshipError = (err)=>{
+    var _errorWithMessage_message;
+    const errorWithMessage = err;
+    return (errorWithMessage == null ? void 0 : (_errorWithMessage_message = errorWithMessage.message) == null ? void 0 : _errorWithMessage_message.includes('userOp did not match any gas sponsoring policies')) || false;
+};
+
 assertPackageVersion(name, version);
 
-export { addZerodevExtension, getSignerForSmartWalletAccount };
+export { addZerodevExtension, canSponsorTransaction, createKernelClientForWalletAccount, estimateTransactionGas, getSignerForSmartWalletAccount, isGasSponsorshipError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs-sdk/zerodev",
-  "version": "0.1.0-alpha.17",
+  "version": "0.1.0-alpha.19",
   "type": "module",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",
@@ -14,10 +14,10 @@
     }
   },
   "dependencies": {
-    "@dynamic-labs-sdk/assert-package-version": "0.1.0-alpha.17",
-    "@dynamic-labs-sdk/client": "0.1.0-alpha.17",
-    "@dynamic-labs-sdk/evm": "0.1.0-alpha.17",
-    "@dynamic-labs/sdk-api-core": "0.0.791",
+    "@dynamic-labs-sdk/assert-package-version": "0.1.0-alpha.19",
+    "@dynamic-labs-sdk/client": "0.1.0-alpha.19",
+    "@dynamic-labs-sdk/evm": "0.1.0-alpha.19",
+    "@dynamic-labs/sdk-api-core": "0.0.805",
     "@zerodev/ecdsa-validator": "5.4.9",
     "@zerodev/multi-chain-ecdsa-validator": "5.4.5",
     "@zerodev/sdk": "5.4.36"

package/src/addZerodevExtension/addZerodevExtension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addZerodevExtension.d.ts","sourceRoot":"","sources":["../../../../../packages/zerodev/src/addZerodevExtension/addZerodevExtension.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,qBAAqB,YAAY,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,wBAQ/B,CAAC"}
+{"version":3,"file":"addZerodevExtension.d.ts","sourceRoot":"","sources":["../../../../../packages/zerodev/src/addZerodevExtension/addZerodevExtension.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,qBAAqB,YAAY,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,wBAe/B,CAAC"}

package/src/canSponsorTransaction/canSponsorTransaction.d.ts

@@ -0,0 +1,29 @@
+import type { EvmWalletAccount } from '@dynamic-labs-sdk/evm';
+import type { Hex } from 'viem';
+import type { KernelClient } from '../KernelClient.types';
+type CanSponsorTransactionBaseParams = {
+    transaction: {
+        data?: Hex;
+        to: Hex;
+        value: bigint;
+    };
+};
+type CanSponsorTransactionWithWalletParams = CanSponsorTransactionBaseParams & {
+    kernelClient?: never;
+    walletAccount: EvmWalletAccount;
+};
+type CanSponsorTransactionWithClientParams = CanSponsorTransactionBaseParams & {
+    kernelClient: KernelClient;
+    walletAccount?: never;
+};
+export type CanSponsorTransactionParams = CanSponsorTransactionWithWalletParams | CanSponsorTransactionWithClientParams;
+/**
+ * Checks if a transaction can be sponsored
+ * @param params.transaction - The transaction to check if it can be sponsored
+ * @param params.kernelClient - The kernel client to use to check if the transaction can be sponsored. If no provided, a walletAccount is required to create a kernel client with sponsorship.
+ * @param params.walletAccount - The wallet account that will be used to send the transaction, Only required if no kernel client is provided
+ * @returns True if the transaction can be sponsored, false otherwise
+ */
+export declare const canSponsorTransaction: ({ walletAccount, transaction, kernelClient, }: CanSponsorTransactionParams) => Promise<boolean>;
+export {};
+//# sourceMappingURL=canSponsorTransaction.d.ts.map

package/src/canSponsorTransaction/canSponsorTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canSponsorTransaction.d.ts","sourceRoot":"","sources":["../../../../../packages/zerodev/src/canSponsorTransaction/canSponsorTransaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAGhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1D,KAAK,+BAA+B,GAAG;IACrC,WAAW,EAAE;QACX,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,EAAE,EAAE,GAAG,CAAC;QACR,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;CACH,CAAC;AAEF,KAAK,qCAAqC,GAAG,+BAA+B,GAAG;IAC7E,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,aAAa,EAAE,gBAAgB,CAAC;CACjC,CAAC;AAEF,KAAK,qCAAqC,GAAG,+BAA+B,GAAG;IAC7E,YAAY,EAAE,YAAY,CAAC;IAC3B,aAAa,CAAC,EAAE,KAAK,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GACnC,qCAAqC,GACrC,qCAAqC,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,kDAI/B,2BAA2B,KAAG,OAAO,CAAC,OAAO,CA0B/C,CAAC"}

package/src/canSponsorTransaction/index.d.ts

@@ -0,0 +1,2 @@
+export { canSponsorTransaction, type CanSponsorTransactionParams, } from './canSponsorTransaction';
+//# sourceMappingURL=index.d.ts.map

package/src/canSponsorTransaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/zerodev/src/canSponsorTransaction/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,KAAK,2BAA2B,GACjC,MAAM,yBAAyB,CAAC"}

package/src/constants.d.ts

@@ -1,5 +1,10 @@
 import type { KERNEL_VERSION_TYPE } from '@zerodev/sdk/types';
 import type { EntryPointVersion } from 'viem/account-abstraction';
+export declare const ZERODEV_METADATA: {
+    displayName: string;
+    icon: string;
+    normalizedWalletName: string;
+};
 export declare const ZERODEV_RPC_BASE_URL = "https://rpc.zerodev.app/api/v2";
 export declare const KERNEL_VERSION_MAP: {
     readonly v3_3: import("@zerodev/sdk/types").KERNEL_V3_VERSION_TYPE;

package/src/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../packages/zerodev/src/constants.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,eAAO,MAAM,oBAAoB,mCAAmC,CAAC;AAErE,eAAO,MAAM,kBAAkB;;;;;;CAMrB,CAAC;AAEX,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,iBAAiB,EACjB,mBAAmB,CAKX,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../packages/zerodev/src/constants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,eAAO,MAAM,gBAAgB;;;;CAI5B,CAAC;AAEF,eAAO,MAAM,oBAAoB,mCAAmC,CAAC;AAErE,eAAO,MAAM,kBAAkB;;;;;;CAMrB,CAAC;AAEX,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,iBAAiB,EACjB,mBAAmB,CAKX,CAAC"}

package/src/createKernelClientForWalletAccount/createKernelClientForWalletAccount.d.ts

@@ -0,0 +1,27 @@
+import type { EvmWalletAccount } from '@dynamic-labs-sdk/evm';
+import type { ZerodevBundlerProvider } from '@dynamic-labs/sdk-api-core';
+import type { Hex } from 'viem';
+import type { KernelClient } from '../KernelClient.types';
+type CreateKernelClientForWalletAccountParams = {
+    bundlerProvider?: ZerodevBundlerProvider;
+    bundlerRpc?: string;
+    gasTokenAddress?: Hex;
+    paymasterRpc?: string;
+    smartWalletAccount: EvmWalletAccount;
+    withSponsorship?: boolean;
+};
+/**
+ * Creates a KernelClient instance for a given smart wallet account.
+ *
+ * @param params.smartWalletAccount - The smart wallet account to create the KernelClient for.
+ * @param [params.bundlerProvider] - A custom bundler provider to use
+ * @param [params.bundlerRpc] - A custom bundler RPC to use
+ * @param [params.paymasterRpc] - A custom paymaster RPC to use
+ * @param [params.gasTokenAddress] - The address of a custom ERC20 token to use as a gas token
+ * @param [params.withSponsorship] - Whether to use sponsorship for the KernelClient or not (default is true).
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns A promise that resolves to a KernelClient instance.
+ */
+export declare const createKernelClientForWalletAccount: ({ smartWalletAccount, withSponsorship, bundlerProvider, bundlerRpc: bundlerRpcOverride, paymasterRpc: paymasterRpcOverride, gasTokenAddress, }: CreateKernelClientForWalletAccountParams, client?: any) => Promise<KernelClient>;
+export {};
+//# sourceMappingURL=createKernelClientForWalletAccount.d.ts.map

package/src/createKernelClientForWalletAccount/createKernelClientForWalletAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createKernelClientForWalletAccount.d.ts","sourceRoot":"","sources":["../../../../../packages/zerodev/src/createKernelClientForWalletAccount/createKernelClientForWalletAccount.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAKzE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAGhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAK1D,KAAK,wCAAwC,GAAG;IAC9C,eAAe,CAAC,EAAE,sBAAsB,CAAC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,gBAAgB,CAAC;IACrC,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kCAAkC,mJAQ1C,wCAAwC,mBAE1C,OAAO,CAAC,YAAY,CAkEtB,CAAC"}

package/src/createKernelClientForWalletAccount/index.d.ts

@@ -0,0 +1,2 @@
+export { createKernelClientForWalletAccount } from './createKernelClientForWalletAccount';
+//# sourceMappingURL=index.d.ts.map

package/src/createKernelClientForWalletAccount/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/zerodev/src/createKernelClientForWalletAccount/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,sCAAsC,CAAC"}

package/src/estimateTransactionGas/estimateTransactionGas.d.ts

@@ -0,0 +1,18 @@
+import type { EvmWalletAccount } from '@dynamic-labs-sdk/evm';
+import type { Hex } from 'viem';
+export type EstimateTransactionGasParams = {
+    transaction: {
+        data?: Hex;
+        to: Hex;
+        value: bigint;
+    };
+    walletAccount: EvmWalletAccount;
+};
+/**
+ * Estimates the total gas for a transaction
+ * @param params.transaction - The transaction to estimate the gas for
+ * @param params.walletAccount - The wallet account that will be used to send the transaction
+ * @returns The gas for the transaction in wei
+ */
+export declare const estimateTransactionGas: ({ walletAccount, transaction, }: EstimateTransactionGasParams) => Promise<bigint | null>;
+//# sourceMappingURL=estimateTransactionGas.d.ts.map

package/src/estimateTransactionGas/estimateTransactionGas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimateTransactionGas.d.ts","sourceRoot":"","sources":["../../../../../packages/zerodev/src/estimateTransactionGas/estimateTransactionGas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAMhC,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,EAAE;QACX,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,EAAE,EAAE,GAAG,CAAC;QACR,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,aAAa,EAAE,gBAAgB,CAAC;CACjC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,oCAGhC,4BAA4B,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAqBtD,CAAC"}

package/src/estimateTransactionGas/index.d.ts

@@ -0,0 +1,2 @@
+export { estimateTransactionGas, type EstimateTransactionGasParams, } from './estimateTransactionGas';
+//# sourceMappingURL=index.d.ts.map

package/src/estimateTransactionGas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/zerodev/src/estimateTransactionGas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,4BAA4B,GAClC,MAAM,0BAA0B,CAAC"}