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

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.1.0-alpha.19 (2025-10-10)
+
+This was a version bump only, there were no code changes.
+
+## 0.1.0-alpha.18 (2025-10-08)
+
+### 🚀 Features
+
+- Add TypeDoc for JavaScript SDK API Reference Documentation ([#512](https://github.com/dynamic-labs/dynamic-sdk/pull/512))
+
 ## 0.1.0-alpha.17 (2025-10-02)
 
 ### 🩹 Fixes

package/index.cjs.js

@@ -4,30 +4,73 @@ var assertPackageVersion = require('@dynamic-labs-sdk/assert-package-version');
 var core = require('@dynamic-labs-sdk/client/core');
 var client = require('@dynamic-labs-sdk/client');
 var evm = require('@dynamic-labs-sdk/evm');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var sdk = require('@zerodev/sdk');
 var viem = require('@dynamic-labs-sdk/evm/viem');
+var viem$1 = require('viem');
+var ecdsaValidator = require('@zerodev/ecdsa-validator');
+var multiChainEcdsaValidator = require('@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 = core.getDefaultClient())=>{
-    if (core.hasExtension({
-        extensionKey: ZERODEV_EXTENSION_KEY
-    }, client)) {
-        return;
-    }
-    core.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 = {
+    [sdkApiCore.ProviderKernelVersionEnum.V33]: sdk.constants.KERNEL_V3_3,
+    [sdkApiCore.ProviderKernelVersionEnum.V32]: sdk.constants.KERNEL_V3_2,
+    [sdkApiCore.ProviderKernelVersionEnum.V31]: sdk.constants.KERNEL_V3_1,
+    [sdkApiCore.ProviderKernelVersionEnum.V30]: sdk.constants.KERNEL_V3_0,
+    [sdkApiCore.ProviderKernelVersionEnum.V24]: sdk.constants.KERNEL_V2_4
+};
+const ENTRY_POINT_VERSION_MAP = {
+    0.6: sdk.constants.KERNEL_V2_4,
+    0.7: sdk.constants.KERNEL_V3_1,
+    0.8: sdk.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 === sdkApiCore.WalletProviderEnum.SmartContractWallet && ((_credential_walletName = credential.walletName) == null ? void 0 : _credential_walletName.toLowerCase().startsWith(ZERODEV_METADATA.normalizedWalletName)) && credential.address && credential.chain && core.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;
+    core.assertDefined(projectSettings, 'Project settings are not available');
+    const zerodevProvider = (_projectSettings_providers = projectSettings.providers) == null ? void 0 : _projectSettings_providers.find((provider)=>provider.provider === sdkApiCore.ProviderEnum.Zerodev);
+    core.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.
@@ -48,7 +91,409 @@ const ZERODEV_EXTENSION_KEY = 'zerodev';
     }, client$1);
 };
 
+const getEcdsaValidator = ({ ecdsaProviderType, publicClient, signer, entryPoint, kernelVersion })=>{
+    const params = {
+        entryPoint,
+        kernelVersion,
+        signer
+    };
+    if (ecdsaProviderType === 'zerodev_multi_chain') {
+        return multiChainEcdsaValidator.toMultiChainECDSAValidator(publicClient, params);
+    }
+    return ecdsaValidator.signerToEcdsaValidator(publicClient, params);
+};
+
+const getEntryPoint = (entryPoint)=>{
+    if (entryPoint === sdkApiCore.ProviderEntryPointVersionEnum.V6) {
+        return sdk.constants.getEntryPoint('0.6');
+    }
+    // default to v7
+    return sdk.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 sdk.constants.KERNEL_V3_3;
+};
+
+const shouldUseEIP7702 = ({ smartWalletAccount }, client$1)=>{
+    const zerodevProvider = getZerodevProviderFromSettings(client$1);
+    core.assertDefined(zerodevProvider, 'Zerodev provider is not enabled in project settings');
+    const eoaWalletAccount = client.getOwnerWalletAccountForSmartWalletAccount({
+        smartWalletAccount
+    }, client$1);
+    core.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);
+    core.assertDefined(zerodevProvider, 'Zerodev provider is not enabled in project settings');
+    const signer = await getSignerForSmartWalletAccount({
+        smartWalletAccount
+    }, client);
+    const walletProperties = (_getVerifiedCredentialForWalletAccount = core.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 sdk.createKernelAccount(publicClient, {
+            eip7702Account: signer,
+            entryPoint,
+            kernelVersion: sdk.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 ecdsaValidator.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 sdk.createKernelAccount(publicClient, {
+        entryPoint,
+        kernelVersion,
+        plugins: {
+            sudo: validator
+        }
+    });
+};
+
+const getPaymasterConfig = ({ chain, gasTokenAddress, paymasterRpc })=>{
+    const getPaymasterData = (params)=>{
+        const zerodevPaymaster = sdk.createZeroDevPaymasterClient({
+            chain,
+            transport: viem$1.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);
+    core.assertDefined(zerodevChainProvider, `No zerodev provider found for network id ${networkId}`);
+    var _ref;
+    const paymasterProvider = (_ref = bundlerProvider != null ? bundlerProvider : zerodevProvider.zerodevBundlerProvider) != null ? _ref : sdkApiCore.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$1 = core.getDefaultClient())=>{
+    const { networkData: activeNetworkData } = await client.getActiveNetworkData({
+        walletAccount: smartWalletAccount
+    }, client$1);
+    core.assertDefined(activeNetworkData, 'No active network data found');
+    const viemChain = viem.mapNetworkDataToViemChain(activeNetworkData);
+    const bundlerRpc = bundlerRpcOverride != null ? bundlerRpcOverride : getZerodevRpc({
+        bundlerProvider,
+        networkId: activeNetworkData.networkId,
+        rpcType: 'bundler'
+    }, client$1);
+    const bundlerTransport = viem$1.http(bundlerRpc);
+    const publicClient = viem$1.createPublicClient({
+        chain: viemChain,
+        transport: bundlerTransport
+    });
+    const account = await createKernelAccount({
+        publicClient,
+        smartWalletAccount
+    }, client$1);
+    const paymasterRpc = paymasterRpcOverride != null ? paymasterRpcOverride : getZerodevRpc({
+        bundlerProvider,
+        networkId: activeNetworkData.networkId,
+        rpcType: 'paymaster'
+    }, client$1);
+    const paymasterConfig = withSponsorship ? getPaymasterConfig({
+        chain: viemChain,
+        gasTokenAddress,
+        paymasterRpc
+    }) : {};
+    return sdk.createKernelAccountClient(_extends({
+        account,
+        bundlerTransport,
+        chain: viemChain,
+        client: publicClient,
+        userOperation: {
+            estimateFeesPerGas: async ({ bundlerClient })=>sdk.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$1)=>{
+    const kernelClient = await createKernelClientForWalletAccount({
+        smartWalletAccount: walletAccount
+    }, client$1);
+    const shouldUseEoa = await shouldSignWithEoa({
+        kernelClient,
+        smartWalletAccount: walletAccount
+    }, client$1);
+    if (shouldUseEoa) {
+        const eoaWalletAccount = client.getOwnerWalletAccountForSmartWalletAccount({
+            smartWalletAccount: walletAccount
+        }, client$1);
+        core.assertDefined(eoaWalletAccount, 'Eoa wallet account not found');
+        const { signature } = await client.signMessage({
+            message,
+            walletAccount: eoaWalletAccount
+        });
+        return {
+            signature
+        };
+    }
+    const signature = await kernelClient.signMessage({
+        message
+    });
+    return {
+        signature
+    };
+};
+
+const createZerodevWalletProvider = (client$1)=>{
+    const chain = 'EVM';
+    const walletProviderType = sdkApiCore.WalletProviderEnum.SmartContractWallet;
+    const key = core.formatWalletProviderKey({
+        chain,
+        displayName: ZERODEV_METADATA.displayName,
+        walletProviderType
+    });
+    const getActiveNetworkId = async ()=>core.getActiveNetworkIdFromLastKnownRegistry({
+            client: client$1,
+            walletProviderKey: key
+        });
+    const getConnectedAddresses = async ()=>{
+        const zerodevAddresses = getAllUserZerodevAddresses(client$1);
+        return {
+            addresses: zerodevAddresses
+        };
+    };
+    const request = async ()=>{
+        throw new core.MethodNotImplementedError('request');
+    };
+    const signMessage$1 = async ({ walletAccount, message })=>{
+        core.assertDefined(walletAccount, 'Wallet account is required');
+        if (!evm.isEvmWalletAccount(walletAccount)) {
+            throw new client.InvalidParamError(`walletAccount is not an EVM wallet account`);
+        }
+        return signMessage({
+            message,
+            walletAccount
+        }, client$1);
+    };
+    const switchActiveNetwork = async ({ networkId })=>{
+        const isNetworkEnabled = getZerodevChainProviderForNetworkId({
+            networkId
+        }, client$1);
+        if (!isNetworkEnabled) {
+            throw new client.UnrecognizedNetworkError({
+                networkId,
+                originalError: null,
+                walletProviderKey: key
+            });
+        }
+        return core.switchActiveNetworkInLastKnownRegistry({
+            client: client$1,
+            networkId,
+            walletProviderKey: key
+        });
+    };
+    return {
+        chain,
+        getActiveNetworkId,
+        getConnectedAddresses,
+        groupKey: core.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 = core.getDefaultClient())=>{
+    if (core.hasExtension({
+        extensionKey: ZERODEV_EXTENSION_KEY
+    }, client)) {
+        return;
+    }
+    core.registerExtension({
+        extensionKey: ZERODEV_EXTENSION_KEY
+    }, client);
+    const walletProviderRegistry = core.getWalletProviderRegistry(client);
+    const walletProvider = createZerodevWalletProvider(client);
+    walletProviderRegistry.register({
+        priority: core.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) {
+        core.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.assertPackageVersion(name, version);
 
 exports.addZerodevExtension = addZerodevExtension;
+exports.canSponsorTransaction = canSponsorTransaction;
+exports.createKernelClientForWalletAccount = createKernelClientForWalletAccount;
+exports.estimateTransactionGas = estimateTransactionGas;
 exports.getSignerForSmartWalletAccount = getSignerForSmartWalletAccount;
+exports.isGasSponsorshipError = isGasSponsorshipError;