@dynamic-labs-wallet/node-evm 0.0.185 → 0.0.186

package/index.cjs.js

@@ -4,6 +4,15 @@ var node = require('@dynamic-labs-wallet/node');
 var viem = require('viem');
 var chains = require('viem/chains');
 var utils = require('viem/utils');
+var client = require('@dynamic-labs-sdk/client');
+var core = require('@dynamic-labs-sdk/client/core');
+var viem$1 = require('@dynamic-labs-sdk/evm/viem');
+var waas = require('@dynamic-labs-sdk/evm/waas');
+var zerodev = require('@dynamic-labs-sdk/zerodev');
+var core$1 = require('@dynamic-labs-sdk/zerodev/core');
+var ecdsaValidator = require('@zerodev/ecdsa-validator');
+var sdk = require('@zerodev/sdk');
+var accounts = require('viem/accounts');
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -65,7 +74,8 @@ class DynamicEvmWalletClient extends node.DynamicWalletClient {
         return this.baseJWTAuthToken;
     }
     get apiUrl() {
-        return this.baseApiUrl;
+        var _this_baseApiUrl;
+        return (_this_baseApiUrl = this.baseApiUrl) != null ? _this_baseApiUrl : 'https://app.dynamicauth.com';
     }
     createViemPublicClient({ chain, rpcUrl }) {
         return viem.createPublicClient({
@@ -521,6 +531,283 @@ class DynamicEvmWalletClient extends node.DynamicWalletClient {
     return node.revokeDelegation(client, params);
 };
 
+const getJwtExpiration = (jwt)=>{
+    if (!jwt) {
+        return 0;
+    }
+    return JSON.parse(Buffer.from(jwt.split('.')[1], 'base64').toString()).exp * 1000;
+};
+class MemoryStorageAdapter {
+    async getItem(key) {
+        if (key.includes('session')) {
+            // This is a workaround so we can pass the JWT that the authenticate the node SDK to
+            // the vanilla client, once set we can refresh the user and populate the user data, wallets and etc.
+            return JSON.stringify({
+                value: {
+                    token: this.jwt,
+                    sessionExpiration: getJwtExpiration(this.jwt),
+                    legacyToken: null,
+                    mfaToken: null,
+                    captchaToken: null,
+                    sessionKeys: null
+                }
+            });
+        }
+        var _this_store_get;
+        return (_this_store_get = this.store.get(key)) != null ? _this_store_get : null;
+    }
+    async setItem(key, value) {
+        this.store.set(key, value);
+    }
+    async removeItem(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+    get size() {
+        return this.store.size;
+    }
+    constructor(jwt){
+        this.store = new Map();
+        this.jwt = jwt;
+    }
+}
+const createMemoryStorageAdapter = (jwt)=>{
+    return new MemoryStorageAdapter(jwt);
+};
+
+const createViemSignerAdapter = ({ evmClient, accountAddress, password, externalServerKeyShares, delegated })=>{
+    return accounts.toAccount({
+        address: accountAddress,
+        signMessage: async ({ message })=>{
+            if (delegated) {
+                return delegatedSignMessage(delegated.delegatedClient, {
+                    walletId: delegated.walletId,
+                    walletApiKey: delegated.walletApiKey,
+                    keyShare: delegated.keyShare,
+                    message: message
+                });
+            }
+            const signature = await evmClient.signMessage({
+                message: message,
+                accountAddress,
+                password,
+                externalServerKeyShares
+            });
+            return signature;
+        },
+        signTypedData: async (typedData)=>{
+            if (delegated) {
+                return delegatedSignTypedData(delegated.delegatedClient, {
+                    walletId: delegated.walletId,
+                    walletApiKey: delegated.walletApiKey,
+                    keyShare: delegated.keyShare,
+                    typedData: typedData
+                });
+            }
+            return evmClient.signTypedData({
+                accountAddress,
+                typedData: typedData,
+                password: password,
+                externalServerKeyShares
+            });
+        },
+        signTransaction: async (transaction)=>{
+            if (delegated) {
+                return delegatedSignTransaction(delegated.delegatedClient, {
+                    walletId: delegated.walletId,
+                    walletApiKey: delegated.walletApiKey,
+                    keyShare: delegated.keyShare,
+                    transaction
+                });
+            }
+            const signedTx = await evmClient.signTransaction({
+                senderAddress: accountAddress,
+                transaction,
+                password,
+                externalServerKeyShares
+            });
+            return signedTx;
+        },
+        signAuthorization: async (authorization)=>{
+            if (delegated) {
+                const signature = await delegatedSignAuthorization(delegated.delegatedClient, {
+                    walletId: delegated.walletId,
+                    walletApiKey: delegated.walletApiKey,
+                    keyShare: delegated.keyShare,
+                    authorization
+                });
+                var _authorization_address;
+                const signedAuthorization = {
+                    address: (_authorization_address = authorization.address) != null ? _authorization_address : authorization.contractAddress,
+                    chainId: authorization.chainId,
+                    nonce: authorization.nonce,
+                    r: signature.r,
+                    s: signature.s,
+                    v: signature.v,
+                    yParity: signature.yParity
+                };
+                return signedAuthorization;
+            }
+            const signature = await evmClient.signAuthorization({
+                authorization,
+                accountAddress,
+                password,
+                externalServerKeyShares
+            });
+            var _authorization_address1;
+            const signedAuthorization = {
+                address: (_authorization_address1 = authorization.address) != null ? _authorization_address1 : authorization.contractAddress,
+                chainId: authorization.chainId,
+                nonce: authorization.nonce,
+                r: signature.r,
+                s: signature.s,
+                v: signature.v,
+                yParity: signature.yParity
+            };
+            return signedAuthorization;
+        }
+    });
+};
+
+class DynamicEvmZeroDevClient {
+    async initialize() {
+        await client.initializeClient(this.dynamicClient);
+        if ('jwtAuthToken' in this.evmClient) {
+            // Fetch user data to populate wallet accounts
+            await client.refreshUser(this.dynamicClient);
+        }
+    }
+    /**
+   * Get network data by networkId from project configuration
+   */ getNetworkData(networkId) {
+        const networksData = client.getNetworksData(this.dynamicClient);
+        const networkData = networksData.find((n)=>n.networkId === networkId);
+        core.assertDefined(networkData, `No network found with networkId: ${networkId}. Available networks: ${networksData.map((n)=>n.networkId).join(', ')}`);
+        return networkData;
+    }
+    async createKernelClientForAddress(options) {
+        const viemSigner = createViemSignerAdapter({
+            evmClient: this.evmClient,
+            accountAddress: options.address,
+            password: options.password,
+            externalServerKeyShares: options.externalServerKeyShares,
+            delegated: options.delegated
+        });
+        const activeNetworkData = this.getNetworkData(options.networkId);
+        const viemChain = viem$1.mapNetworkDataToViemChain(activeNetworkData);
+        var _options_bundlerRpc;
+        const bundlerRpc = (_options_bundlerRpc = options.bundlerRpc) != null ? _options_bundlerRpc : core$1.getZerodevRpc({
+            bundlerProvider: options.bundlerProvider,
+            networkId: activeNetworkData.networkId,
+            rpcType: 'bundler'
+        }, this.dynamicClient);
+        const bundlerTransport = viem.http(bundlerRpc);
+        const publicClient = viem.createPublicClient({
+            chain: viemChain,
+            transport: bundlerTransport
+        });
+        const account = await this.createKernelAccountWithCustomSigner({
+            publicClient,
+            signer: viemSigner
+        });
+        var _options_paymasterRpc;
+        const paymasterRpc = (_options_paymasterRpc = options.paymasterRpc) != null ? _options_paymasterRpc : core$1.getZerodevRpc({
+            bundlerProvider: options.bundlerProvider,
+            networkId: activeNetworkData.networkId,
+            rpcType: 'paymaster'
+        }, this.dynamicClient);
+        var _options_withSponsorship;
+        const paymasterConfig = ((_options_withSponsorship = options.withSponsorship) != null ? _options_withSponsorship : true) ? core$1.getPaymasterConfig({
+            chain: viemChain,
+            gasTokenAddress: options.gasTokenAddress,
+            paymasterRpc
+        }) : {};
+        const kernelClient = sdk.createKernelAccountClient(_extends({
+            account,
+            bundlerTransport,
+            chain: viemChain,
+            client: publicClient,
+            userOperation: {
+                estimateFeesPerGas: async ({ bundlerClient })=>sdk.getUserOperationGasPrice(bundlerClient)
+            }
+        }, paymasterConfig));
+        return kernelClient;
+    }
+    async createKernelAccountWithCustomSigner({ publicClient, signer }) {
+        const zerodevProvider = core$1.getZerodevProviderFromSettings(this.dynamicClient);
+        core.assertDefined(zerodevProvider, 'Zerodev provider is not enabled in project settings');
+        const useEIP7702 = zerodevProvider.enableEIP7702;
+        const entryPointVersion = zerodevProvider.entryPointVersion;
+        const entryPoint = core$1.getEntryPoint(entryPointVersion);
+        if (useEIP7702) {
+            return sdk.createKernelAccount(publicClient, {
+                eip7702Account: signer,
+                entryPoint,
+                kernelVersion: sdk.constants.KERNEL_V3_3
+            });
+        }
+        const kernelVersionValue = zerodevProvider.kernelVersion;
+        const kernelVersion = core$1.getKernelVersion({
+            entryPoint,
+            kernelVersion: kernelVersionValue
+        });
+        var _zerodevProvider_enableKernelV3Migration;
+        const kernelV3MigrationEnabled = (_zerodevProvider_enableKernelV3Migration = zerodevProvider.enableKernelV3Migration) != null ? _zerodevProvider_enableKernelV3Migration : false;
+        if (kernelV3MigrationEnabled) {
+            const apiKernelVersion = core$1.getKernelVersion({
+                entryPoint,
+                kernelVersion: zerodevProvider.kernelVersion
+            });
+            return ecdsaValidator.createEcdsaKernelMigrationAccount(publicClient, {
+                entryPoint,
+                migrationVersion: {
+                    from: kernelVersion,
+                    to: apiKernelVersion
+                },
+                signer
+            });
+        }
+        const validator = await core$1.getEcdsaValidator({
+            ecdsaProviderType: zerodevProvider.ecdsaProviderType,
+            entryPoint,
+            kernelVersion,
+            publicClient,
+            signer
+        });
+        return sdk.createKernelAccount(publicClient, {
+            entryPoint,
+            kernelVersion,
+            plugins: {
+                sudo: validator
+            }
+        });
+    }
+    constructor(evmClient){
+        this.evmClient = evmClient;
+        var _evmClient_jwtAuthToken;
+        const authToken = 'jwtAuthToken' in evmClient ? (_evmClient_jwtAuthToken = evmClient.jwtAuthToken) != null ? _evmClient_jwtAuthToken : null : null;
+        const storageAdapter = createMemoryStorageAdapter(authToken);
+        this.dynamicClient = client.createDynamicClient({
+            environmentId: evmClient.environmentId,
+            autoInitialize: false,
+            coreConfig: {
+                storageAdapter,
+                fetch: fetch,
+                apiBaseUrl: `${evmClient.apiUrl}/api/v0`
+            }
+        });
+        zerodev.addZerodevExtension(this.dynamicClient);
+        waas.addWaasEvmExtension(this.dynamicClient);
+    }
+}
+const createZerodevClient = async (evmClient)=>{
+    const client = new DynamicEvmZeroDevClient(evmClient);
+    await client.initialize();
+    return client;
+};
+
 exports.DynamicEvmWalletClient = DynamicEvmWalletClient;
 exports.ERROR_ACCOUNT_ADDRESS_REQUIRED = ERROR_ACCOUNT_ADDRESS_REQUIRED;
 exports.ERROR_CREATE_WALLET_ACCOUNT = ERROR_CREATE_WALLET_ACCOUNT;
@@ -530,6 +817,7 @@ exports.ERROR_SIGN_TYPED_DATA = ERROR_SIGN_TYPED_DATA;
 exports.ERROR_VERIFY_MESSAGE_SIGNATURE = ERROR_VERIFY_MESSAGE_SIGNATURE;
 exports.EVM_SIGN_MESSAGE_PREFIX = EVM_SIGN_MESSAGE_PREFIX;
 exports.createDelegatedEvmWalletClient = createDelegatedEvmWalletClient;
+exports.createZerodevClient = createZerodevClient;
 exports.delegatedSignAuthorization = delegatedSignAuthorization;
 exports.delegatedSignMessage = delegatedSignMessage;
 exports.delegatedSignTransaction = delegatedSignTransaction;

package/index.esm.js

@@ -2,6 +2,15 @@ import { MessageHash, DynamicWalletClient, getMPCChainConfig, getExternalServerK
 import { stringToHex, bytesToHex, size, concat, hashTypedData, serializeSignature, getAddress, createPublicClient, http, parseSignature, serializeTransaction } from 'viem';
 import { mainnet } from 'viem/chains';
 import { hashAuthorization } from 'viem/utils';
+import { initializeClient, refreshUser, getNetworksData, createDynamicClient } from '@dynamic-labs-sdk/client';
+import { assertDefined } from '@dynamic-labs-sdk/client/core';
+import { mapNetworkDataToViemChain } from '@dynamic-labs-sdk/evm/viem';
+import { addWaasEvmExtension } from '@dynamic-labs-sdk/evm/waas';
+import { addZerodevExtension } from '@dynamic-labs-sdk/zerodev';
+import { getZerodevRpc, getPaymasterConfig, getZerodevProviderFromSettings, getEntryPoint, getKernelVersion, getEcdsaValidator } from '@dynamic-labs-sdk/zerodev/core';
+import { createEcdsaKernelMigrationAccount } from '@zerodev/ecdsa-validator';
+import { createKernelAccountClient, getUserOperationGasPrice, createKernelAccount, constants } from '@zerodev/sdk';
+import { toAccount } from 'viem/accounts';
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -63,7 +72,8 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
         return this.baseJWTAuthToken;
     }
     get apiUrl() {
-        return this.baseApiUrl;
+        var _this_baseApiUrl;
+        return (_this_baseApiUrl = this.baseApiUrl) != null ? _this_baseApiUrl : 'https://app.dynamicauth.com';
     }
     createViemPublicClient({ chain, rpcUrl }) {
         return createPublicClient({
@@ -519,4 +529,281 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
     return revokeDelegation$1(client, params);
 };
 
-export { DynamicEvmWalletClient, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_CREATE_WALLET_ACCOUNT, ERROR_KEYGEN_FAILED, ERROR_SIGN_MESSAGE, ERROR_SIGN_TYPED_DATA, ERROR_VERIFY_MESSAGE_SIGNATURE, EVM_SIGN_MESSAGE_PREFIX, createDelegatedEvmWalletClient, delegatedSignAuthorization, delegatedSignMessage, delegatedSignTransaction, delegatedSignTypedData, deriveAccountAddress, formatEVMMessage, formatTypedData, revokeDelegation, serializeECDSASignature };
+const getJwtExpiration = (jwt)=>{
+    if (!jwt) {
+        return 0;
+    }
+    return JSON.parse(Buffer.from(jwt.split('.')[1], 'base64').toString()).exp * 1000;
+};
+class MemoryStorageAdapter {
+    async getItem(key) {
+        if (key.includes('session')) {
+            // This is a workaround so we can pass the JWT that the authenticate the node SDK to
+            // the vanilla client, once set we can refresh the user and populate the user data, wallets and etc.
+            return JSON.stringify({
+                value: {
+                    token: this.jwt,
+                    sessionExpiration: getJwtExpiration(this.jwt),
+                    legacyToken: null,
+                    mfaToken: null,
+                    captchaToken: null,
+                    sessionKeys: null
+                }
+            });
+        }
+        var _this_store_get;
+        return (_this_store_get = this.store.get(key)) != null ? _this_store_get : null;
+    }
+    async setItem(key, value) {
+        this.store.set(key, value);
+    }
+    async removeItem(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+    get size() {
+        return this.store.size;
+    }
+    constructor(jwt){
+        this.store = new Map();
+        this.jwt = jwt;
+    }
+}
+const createMemoryStorageAdapter = (jwt)=>{
+    return new MemoryStorageAdapter(jwt);
+};
+
+const createViemSignerAdapter = ({ evmClient, accountAddress, password, externalServerKeyShares, delegated })=>{
+    return toAccount({
+        address: accountAddress,
+        signMessage: async ({ message })=>{
+            if (delegated) {
+                return delegatedSignMessage(delegated.delegatedClient, {
+                    walletId: delegated.walletId,
+                    walletApiKey: delegated.walletApiKey,
+                    keyShare: delegated.keyShare,
+                    message: message
+                });
+            }
+            const signature = await evmClient.signMessage({
+                message: message,
+                accountAddress,
+                password,
+                externalServerKeyShares
+            });
+            return signature;
+        },
+        signTypedData: async (typedData)=>{
+            if (delegated) {
+                return delegatedSignTypedData(delegated.delegatedClient, {
+                    walletId: delegated.walletId,
+                    walletApiKey: delegated.walletApiKey,
+                    keyShare: delegated.keyShare,
+                    typedData: typedData
+                });
+            }
+            return evmClient.signTypedData({
+                accountAddress,
+                typedData: typedData,
+                password: password,
+                externalServerKeyShares
+            });
+        },
+        signTransaction: async (transaction)=>{
+            if (delegated) {
+                return delegatedSignTransaction(delegated.delegatedClient, {
+                    walletId: delegated.walletId,
+                    walletApiKey: delegated.walletApiKey,
+                    keyShare: delegated.keyShare,
+                    transaction
+                });
+            }
+            const signedTx = await evmClient.signTransaction({
+                senderAddress: accountAddress,
+                transaction,
+                password,
+                externalServerKeyShares
+            });
+            return signedTx;
+        },
+        signAuthorization: async (authorization)=>{
+            if (delegated) {
+                const signature = await delegatedSignAuthorization(delegated.delegatedClient, {
+                    walletId: delegated.walletId,
+                    walletApiKey: delegated.walletApiKey,
+                    keyShare: delegated.keyShare,
+                    authorization
+                });
+                var _authorization_address;
+                const signedAuthorization = {
+                    address: (_authorization_address = authorization.address) != null ? _authorization_address : authorization.contractAddress,
+                    chainId: authorization.chainId,
+                    nonce: authorization.nonce,
+                    r: signature.r,
+                    s: signature.s,
+                    v: signature.v,
+                    yParity: signature.yParity
+                };
+                return signedAuthorization;
+            }
+            const signature = await evmClient.signAuthorization({
+                authorization,
+                accountAddress,
+                password,
+                externalServerKeyShares
+            });
+            var _authorization_address1;
+            const signedAuthorization = {
+                address: (_authorization_address1 = authorization.address) != null ? _authorization_address1 : authorization.contractAddress,
+                chainId: authorization.chainId,
+                nonce: authorization.nonce,
+                r: signature.r,
+                s: signature.s,
+                v: signature.v,
+                yParity: signature.yParity
+            };
+            return signedAuthorization;
+        }
+    });
+};
+
+class DynamicEvmZeroDevClient {
+    async initialize() {
+        await initializeClient(this.dynamicClient);
+        if ('jwtAuthToken' in this.evmClient) {
+            // Fetch user data to populate wallet accounts
+            await refreshUser(this.dynamicClient);
+        }
+    }
+    /**
+   * Get network data by networkId from project configuration
+   */ getNetworkData(networkId) {
+        const networksData = getNetworksData(this.dynamicClient);
+        const networkData = networksData.find((n)=>n.networkId === networkId);
+        assertDefined(networkData, `No network found with networkId: ${networkId}. Available networks: ${networksData.map((n)=>n.networkId).join(', ')}`);
+        return networkData;
+    }
+    async createKernelClientForAddress(options) {
+        const viemSigner = createViemSignerAdapter({
+            evmClient: this.evmClient,
+            accountAddress: options.address,
+            password: options.password,
+            externalServerKeyShares: options.externalServerKeyShares,
+            delegated: options.delegated
+        });
+        const activeNetworkData = this.getNetworkData(options.networkId);
+        const viemChain = mapNetworkDataToViemChain(activeNetworkData);
+        var _options_bundlerRpc;
+        const bundlerRpc = (_options_bundlerRpc = options.bundlerRpc) != null ? _options_bundlerRpc : getZerodevRpc({
+            bundlerProvider: options.bundlerProvider,
+            networkId: activeNetworkData.networkId,
+            rpcType: 'bundler'
+        }, this.dynamicClient);
+        const bundlerTransport = http(bundlerRpc);
+        const publicClient = createPublicClient({
+            chain: viemChain,
+            transport: bundlerTransport
+        });
+        const account = await this.createKernelAccountWithCustomSigner({
+            publicClient,
+            signer: viemSigner
+        });
+        var _options_paymasterRpc;
+        const paymasterRpc = (_options_paymasterRpc = options.paymasterRpc) != null ? _options_paymasterRpc : getZerodevRpc({
+            bundlerProvider: options.bundlerProvider,
+            networkId: activeNetworkData.networkId,
+            rpcType: 'paymaster'
+        }, this.dynamicClient);
+        var _options_withSponsorship;
+        const paymasterConfig = ((_options_withSponsorship = options.withSponsorship) != null ? _options_withSponsorship : true) ? getPaymasterConfig({
+            chain: viemChain,
+            gasTokenAddress: options.gasTokenAddress,
+            paymasterRpc
+        }) : {};
+        const kernelClient = createKernelAccountClient(_extends({
+            account,
+            bundlerTransport,
+            chain: viemChain,
+            client: publicClient,
+            userOperation: {
+                estimateFeesPerGas: async ({ bundlerClient })=>getUserOperationGasPrice(bundlerClient)
+            }
+        }, paymasterConfig));
+        return kernelClient;
+    }
+    async createKernelAccountWithCustomSigner({ publicClient, signer }) {
+        const zerodevProvider = getZerodevProviderFromSettings(this.dynamicClient);
+        assertDefined(zerodevProvider, 'Zerodev provider is not enabled in project settings');
+        const useEIP7702 = zerodevProvider.enableEIP7702;
+        const entryPointVersion = zerodevProvider.entryPointVersion;
+        const entryPoint = getEntryPoint(entryPointVersion);
+        if (useEIP7702) {
+            return createKernelAccount(publicClient, {
+                eip7702Account: signer,
+                entryPoint,
+                kernelVersion: constants.KERNEL_V3_3
+            });
+        }
+        const kernelVersionValue = 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
+            });
+        }
+        const validator = await getEcdsaValidator({
+            ecdsaProviderType: zerodevProvider.ecdsaProviderType,
+            entryPoint,
+            kernelVersion,
+            publicClient,
+            signer
+        });
+        return createKernelAccount(publicClient, {
+            entryPoint,
+            kernelVersion,
+            plugins: {
+                sudo: validator
+            }
+        });
+    }
+    constructor(evmClient){
+        this.evmClient = evmClient;
+        var _evmClient_jwtAuthToken;
+        const authToken = 'jwtAuthToken' in evmClient ? (_evmClient_jwtAuthToken = evmClient.jwtAuthToken) != null ? _evmClient_jwtAuthToken : null : null;
+        const storageAdapter = createMemoryStorageAdapter(authToken);
+        this.dynamicClient = createDynamicClient({
+            environmentId: evmClient.environmentId,
+            autoInitialize: false,
+            coreConfig: {
+                storageAdapter,
+                fetch: fetch,
+                apiBaseUrl: `${evmClient.apiUrl}/api/v0`
+            }
+        });
+        addZerodevExtension(this.dynamicClient);
+        addWaasEvmExtension(this.dynamicClient);
+    }
+}
+const createZerodevClient = async (evmClient)=>{
+    const client = new DynamicEvmZeroDevClient(evmClient);
+    await client.initialize();
+    return client;
+};
+
+export { DynamicEvmWalletClient, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_CREATE_WALLET_ACCOUNT, ERROR_KEYGEN_FAILED, ERROR_SIGN_MESSAGE, ERROR_SIGN_TYPED_DATA, ERROR_VERIFY_MESSAGE_SIGNATURE, EVM_SIGN_MESSAGE_PREFIX, createDelegatedEvmWalletClient, createZerodevClient, delegatedSignAuthorization, delegatedSignMessage, delegatedSignTransaction, delegatedSignTypedData, deriveAccountAddress, formatEVMMessage, formatTypedData, revokeDelegation, serializeECDSASignature };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@dynamic-labs-wallet/node-evm",
-  "version": "0.0.185",
+  "version": "0.0.186",
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@dynamic-labs-wallet/node": "0.0.185",
+    "@dynamic-labs-wallet/node": "0.0.186",
     "@dynamic-labs/sdk-api-core": "^0.0.801",
     "@dynamic-labs-sdk/client": "^0.1.0-alpha.22",
     "@dynamic-labs-sdk/zerodev": "^0.1.0-alpha.22",

package/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from './client/index.js';
 export * from './delegatedClient.js';
+export * from './zerodev/index.js';
 //# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}

package/src/zerodev/index.d.ts

@@ -0,0 +1,3 @@
+export { createZerodevClient } from './client.js';
+export type { KernelClient } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/zerodev/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}