@dynamic-labs-wallet/node-evm 0.0.0-pr384.1 → 0.0.0-pr506.0

package/index.esm.js

@@ -1,6 +1,19 @@
-import { MessageHash, DynamicWalletClient, getExternalServerKeyShareBackupInfo, WalletOperation } from '@dynamic-labs-wallet/node';
-import { getAddress, serializeSignature, createPublicClient, http, serializeTransaction } from 'viem';
+import { toAccount } from 'viem/accounts';
+import { MessageHash, createDelegatedWalletClient, delegatedSignMessage as delegatedSignMessage$1, revokeDelegation as revokeDelegation$1, DynamicWalletClient, getMPCChainConfig, getExternalServerKeyShareBackupInfo, WalletOperation } from '@dynamic-labs-wallet/node';
+import { stringToHex, bytesToHex, size, concat, hashTypedData, serializeSignature, getAddress, serializeTransaction, parseSignature, createPublicClient, http, defineChain, createWalletClient } from 'viem';
+import { hashAuthorization } from 'viem/utils';
+import { Logger } from '@dynamic-labs/logger';
+import { AxiosError } from 'axios';
+import { handleAxiosError } from '@dynamic-labs-wallet/core';
 import { mainnet } from 'viem/chains';
+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';
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -18,11 +31,24 @@ const EVM_SIGN_MESSAGE_PREFIX = `\x19Ethereum Signed Message:\n`;
 const ERROR_KEYGEN_FAILED = 'Error with keygen';
 const ERROR_CREATE_WALLET_ACCOUNT = 'Error creating evm wallet account';
 const ERROR_SIGN_MESSAGE = 'Error signing message';
+const ERROR_SIGN_TYPED_DATA = 'Error signing typed data';
 const ERROR_ACCOUNT_ADDRESS_REQUIRED = 'Account address is required';
 const ERROR_VERIFY_MESSAGE_SIGNATURE = 'Error verifying message signature';
 
-const formatEVMMessage = (message)=>{
-    return `${EVM_SIGN_MESSAGE_PREFIX}${message.length}${message}`;
+const formatEVMMessage = (message_)=>{
+    const message = (()=>{
+        if (typeof message_ === 'string') return stringToHex(message_);
+        if (typeof message_.raw === 'string') return message_.raw;
+        return bytesToHex(message_.raw);
+    })();
+    const prefix = stringToHex(`${EVM_SIGN_MESSAGE_PREFIX}${size(message)}`);
+    return concat([
+        prefix,
+        message
+    ]);
+};
+const formatTypedData = (typedData)=>{
+    return hashTypedData(typedData).slice(2);
 };
 const serializeECDSASignature = (signature)=>{
     return serializeSignature({
@@ -44,13 +70,327 @@ const deriveAccountAddress = ({ rawPublicKey })=>{
     };
 };
 
+const logger = new Logger('DynamicWaasWalletClient');
+const logError = ({ message, error, context })=>{
+    if (error instanceof AxiosError) {
+        handleAxiosError(error, message, context, logger);
+    }
+    logger.error('[DynamicWaasWalletClient] Error in node-evm client', {
+        error: error instanceof Error ? error.message : String(error),
+        context
+    });
+};
+
+/**
+ * Creates a delegated EVM wallet client for functional operations
+ */ const createDelegatedEvmWalletClient = ({ environmentId, baseApiUrl, baseMPCRelayApiUrl, apiKey, debug = false })=>{
+    const baseClient = createDelegatedWalletClient({
+        environmentId,
+        baseApiUrl,
+        baseMPCRelayApiUrl,
+        apiKey,
+        debug
+    });
+    const evmClient = _extends({}, baseClient, {
+        chainName: 'EVM'
+    });
+    return evmClient;
+};
+/**
+ * Signs a message using delegated signing for EVM
+ */ const delegatedSignMessage = async (client, { walletId, walletApiKey, keyShare, message, context, onError })=>{
+    try {
+        if (!keyShare || !walletId || !walletApiKey) {
+            throw new Error('Delegated key share, wallet ID, and wallet API key are required to sign a message');
+        }
+        const formattedMessage = formatEVMMessage(message);
+        const resolvedContext = context != null ? context : {
+            evmMessage: message
+        };
+        const signatureEcdsa = await delegatedSignMessage$1(client, {
+            walletId,
+            walletApiKey,
+            keyShare,
+            message: formattedMessage,
+            chainName: client.chainName,
+            context: resolvedContext,
+            onError
+        });
+        const serializedSignature = serializeECDSASignature(signatureEcdsa);
+        return serializedSignature;
+    } catch (error) {
+        logError({
+            message: 'Error in delegatedSignMessage',
+            error: error,
+            context: {
+                walletId
+            }
+        });
+        throw error;
+    }
+};
+/**
+ * Signs a transaction using delegated signing for EVM
+ */ const delegatedSignTransaction = async (client, { walletId, walletApiKey, keyShare, transaction })=>{
+    try {
+        // Serialize the transaction
+        const serializedTx = serializeTransaction(transaction);
+        const serializedTxBytes = Uint8Array.from(Buffer.from(serializedTx.slice(2), 'hex'));
+        if (!(serializedTxBytes instanceof Uint8Array)) {
+            throw new Error('Invalid serializedTxBytes');
+        }
+        // Use the delegated sign message function from node package
+        const signatureEcdsa = await delegatedSignMessage$1(client, {
+            walletId,
+            walletApiKey,
+            keyShare,
+            message: serializedTxBytes,
+            chainName: client.chainName
+        });
+        if (!('r' in signatureEcdsa && 's' in signatureEcdsa && 'v' in signatureEcdsa)) {
+            throw new Error('Invalid signature format returned from MPC signing');
+        }
+        // Construct the signed transaction
+        const r = `0x${Buffer.from(signatureEcdsa.r).toString('hex')}`;
+        const s = `0x${Buffer.from(signatureEcdsa.s).toString('hex')}`;
+        const v = BigInt(signatureEcdsa.v);
+        const signedTx = _extends({}, transaction, {
+            r: r,
+            s: s,
+            v: v
+        });
+        const serializedSignedTx = serializeTransaction(signedTx);
+        return serializedSignedTx;
+    } catch (error) {
+        logError({
+            message: 'Error in delegatedSignTransaction',
+            error: error,
+            context: {
+                walletId
+            }
+        });
+        throw error;
+    }
+};
+/**
+ * Signs typed data using delegated signing for EVM
+ */ const delegatedSignTypedData = async (client, { walletId, walletApiKey, keyShare, typedData })=>{
+    try {
+        if (!keyShare || !walletId || !walletApiKey) {
+            throw new Error('Delegated key share, wallet ID, and wallet API key are required to sign typed data');
+        }
+        const formattedTypedData = formatTypedData(typedData);
+        const signatureEcdsa = await delegatedSignMessage$1(client, {
+            walletId,
+            walletApiKey,
+            keyShare,
+            message: formattedTypedData,
+            chainName: client.chainName,
+            isFormatted: true,
+            context: {
+                evmTypedData: typedData
+            }
+        });
+        const serializedSignature = serializeECDSASignature(signatureEcdsa);
+        return serializedSignature;
+    } catch (error) {
+        logError({
+            message: 'Error in delegatedSignTypedData',
+            error: error,
+            context: {
+                walletId
+            }
+        });
+        throw error;
+    }
+};
+/**
+ * Signs EIP-7702 authorization using delegated signing for EVM
+ */ const delegatedSignAuthorization = async (client, { walletId, walletApiKey, keyShare, authorization })=>{
+    try {
+        if (!keyShare || !walletId || !walletApiKey) {
+            throw new Error('Delegated key share, wallet ID, and wallet API key are required to sign authorization');
+        }
+        const digest = hashAuthorization(authorization);
+        const prehashed = digest.startsWith('0x') ? digest.slice(2) : digest;
+        const signatureEcdsa = await delegatedSignMessage$1(client, {
+            walletId,
+            walletApiKey,
+            keyShare,
+            message: prehashed,
+            chainName: client.chainName,
+            isFormatted: true,
+            context: {
+                eip7702Auth: authorization
+            }
+        });
+        const serializedSignature = serializeECDSASignature(signatureEcdsa);
+        const signature = parseSignature(serializedSignature);
+        return signature;
+    } catch (error) {
+        logError({
+            message: 'Error in delegatedSignAuthorization',
+            error: error,
+            context: {
+                walletId
+            }
+        });
+        throw error;
+    }
+};
+/**
+ * Revoke delegation - delegates to the node package
+ */ const revokeDelegation = async (client, params)=>{
+    return revokeDelegation$1(client, params);
+};
+
+const createAccountAdapter = ({ 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 DynamicEvmWalletClient extends DynamicWalletClient {
+    get jwtAuthToken() {
+        return this.baseJWTAuthToken;
+    }
+    get apiUrl() {
+        var _this_baseApiUrl;
+        return (_this_baseApiUrl = this.baseApiUrl) != null ? _this_baseApiUrl : 'https://app.dynamicauth.com';
+    }
     createViemPublicClient({ chain, rpcUrl }) {
         return createPublicClient({
             chain,
             transport: http(rpcUrl)
         });
     }
+    async getWalletClient({ accountAddress, password, externalServerKeyShares, chain, chainId, rpcUrl }) {
+        const account = createAccountAdapter({
+            evmClient: this,
+            accountAddress: accountAddress,
+            password,
+            externalServerKeyShares
+        });
+        let viemChain;
+        if (chain) {
+            viemChain = chain;
+        } else if (chainId) {
+            if (!rpcUrl) {
+                throw new Error('rpcUrl is required when providing chainId. Please provide a valid RPC URL for the chain.');
+            }
+            viemChain = defineChain({
+                id: chainId,
+                name: `Chain ${chainId}`,
+                nativeCurrency: {
+                    name: 'Ether',
+                    symbol: 'ETH',
+                    decimals: 18
+                },
+                rpcUrls: {
+                    default: {
+                        http: [
+                            rpcUrl
+                        ]
+                    }
+                }
+            });
+        } else {
+            viemChain = mainnet;
+        }
+        return createWalletClient({
+            account,
+            chain: viemChain,
+            transport: http(rpcUrl)
+        });
+    }
     /**
    * Creates a new wallet account and stores the key shares in the wallet map.
    * @param thresholdSignatureScheme - The threshold signature scheme to use for the wallet.
@@ -68,15 +408,21 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
             const { rawPublicKey, externalServerKeyShares } = await this.keyGen({
                 chainName: this.chainName,
                 thresholdSignatureScheme,
+                skipLock: true,
                 onError,
                 onCeremonyComplete: (accountAddress, walletId)=>{
                     // update wallet map
                     const checksumAddress = getAddress(accountAddress);
+                    const chainConfig = getMPCChainConfig(this.chainName);
                     this.walletMap[checksumAddress] = _extends({}, this.walletMap[checksumAddress] || {}, {
                         accountAddress: checksumAddress,
                         walletId,
                         chainName: this.chainName,
                         thresholdSignatureScheme,
+                        derivationPath: JSON.stringify(Object.fromEntries(chainConfig.derivationPath.map((value, index)=>[
+                                index,
+                                value
+                            ]))),
                         externalServerKeySharesBackupInfo: getExternalServerKeyShareBackupInfo()
                     });
                     this.logger.debug('walletMap updated for wallet', {
@@ -112,42 +458,138 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
                 externalServerKeyShares
             };
         } catch (error) {
-            // this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+            logError({
+                message: ERROR_CREATE_WALLET_ACCOUNT,
+                error: error,
+                context: {}
+            });
             throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
         }
     }
-    async signMessage({ message, accountAddress, password = undefined, externalServerKeyShares }) {
-        await this.verifyPassword({
-            accountAddress,
-            password,
-            walletOperation: WalletOperation.SIGN_MESSAGE
-        });
-        await this.getWallet({
-            accountAddress,
-            walletOperation: WalletOperation.SIGN_MESSAGE
-        });
+    async signMessage({ message, accountAddress, password = undefined, externalServerKeyShares, context, onError }) {
         try {
             if (!accountAddress) {
                 throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
             }
             // Format the message for EVM signing
             const formattedMessage = formatEVMMessage(message);
-            // Sign the message using MPC
+            const resolvedContext = context != null ? context : {
+                evmMessage: message
+            };
+            // Attempt to recover key shares from backup if not provided
+            await this.ensureKeySharesRecovered({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.SIGN_MESSAGE,
+                externalServerKeyShares,
+                errorMessage: 'External server key shares are required to sign a message. No backup shares available for recovery.'
+            });
             const signatureEcdsa = await this.sign({
                 message: formattedMessage,
                 accountAddress: accountAddress,
                 chainName: this.chainName,
                 password,
-                externalServerKeyShares
+                externalServerKeyShares,
+                context: resolvedContext,
+                onError
             });
             // Serialize the signature
             const serializedSignature = serializeECDSASignature(signatureEcdsa);
             return serializedSignature;
         } catch (error) {
-            this.logger.error(ERROR_SIGN_MESSAGE, error);
+            logError({
+                message: ERROR_SIGN_MESSAGE,
+                error: error,
+                context: {
+                    accountAddress
+                }
+            });
             throw new Error(ERROR_SIGN_MESSAGE);
         }
     }
+    isSignAuthorizationSupported() {
+        return true;
+    }
+    async signAuthorization({ authorization, accountAddress, password = undefined, externalServerKeyShares, onError }) {
+        try {
+            if (!accountAddress) {
+                throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+            }
+            const digest = hashAuthorization(authorization);
+            const prehashed = digest.startsWith('0x') ? digest.slice(2) : digest;
+            // Attempt to recover key shares from backup if not provided
+            await this.ensureKeySharesRecovered({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.SIGN_MESSAGE,
+                externalServerKeyShares,
+                errorMessage: 'External server key shares are required to sign authorization. No backup shares available for recovery.'
+            });
+            const signatureEcdsa = await this.sign({
+                message: prehashed,
+                accountAddress: accountAddress,
+                chainName: this.chainName,
+                password,
+                externalServerKeyShares,
+                isFormatted: true,
+                context: {
+                    eip7702Auth: authorization
+                },
+                onError
+            });
+            const serializedSignature = serializeECDSASignature(signatureEcdsa);
+            const signature = parseSignature(serializedSignature);
+            return signature;
+        } catch (error) {
+            logError({
+                message: ERROR_SIGN_MESSAGE,
+                error: error,
+                context: {
+                    accountAddress
+                }
+            });
+            throw new Error(ERROR_SIGN_MESSAGE);
+        }
+    }
+    async signTypedData({ accountAddress, typedData, password = undefined, externalServerKeyShares, onError }) {
+        try {
+            if (!accountAddress) {
+                throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+            }
+            const formattedTypedData = formatTypedData(typedData);
+            // Attempt to recover key shares from backup if not provided
+            await this.ensureKeySharesRecovered({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.SIGN_MESSAGE,
+                externalServerKeyShares,
+                errorMessage: 'External server key shares are required to sign typed data. No backup shares available for recovery.'
+            });
+            const signatureEcdsa = await this.sign({
+                message: formattedTypedData,
+                accountAddress: accountAddress,
+                chainName: this.chainName,
+                password,
+                externalServerKeyShares,
+                isFormatted: true,
+                context: {
+                    evmTypedData: typedData
+                },
+                onError
+            });
+            const serializedSignature = serializeECDSASignature(signatureEcdsa);
+            return serializedSignature;
+        } catch (error) {
+            logError({
+                message: ERROR_SIGN_TYPED_DATA,
+                error: error,
+                context: {
+                    accountAddress
+                }
+            });
+            throw new Error(ERROR_SIGN_TYPED_DATA);
+        }
+    }
     async verifyMessageSignature({ accountAddress, message, signature }) {
         try {
             // Verify the signature using the public client
@@ -161,7 +603,13 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
             });
             return verified;
         } catch (error) {
-            this.logger.error(ERROR_VERIFY_MESSAGE_SIGNATURE, error);
+            logError({
+                message: ERROR_VERIFY_MESSAGE_SIGNATURE,
+                error: error,
+                context: {
+                    accountAddress
+                }
+            });
             throw new Error(ERROR_VERIFY_MESSAGE_SIGNATURE);
         }
     }
@@ -171,6 +619,14 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
             password,
             walletOperation: WalletOperation.SIGN_TRANSACTION
         });
+        // Attempt to recover key shares from backup if not provided
+        await this.ensureKeySharesRecovered({
+            accountAddress: senderAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_TRANSACTION,
+            externalServerKeyShares,
+            errorMessage: 'External server key shares are required to sign transaction. No backup shares available for recovery.'
+        });
         const serializedTx = serializeTransaction(transaction);
         const serializedTxBytes = Uint8Array.from(Buffer.from(serializedTx.slice(2), 'hex'));
         if (!(serializedTxBytes instanceof Uint8Array)) {
@@ -199,7 +655,13 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
             const serializedSignedTx = serializeTransaction(signedTx);
             return serializedSignedTx;
         } catch (error) {
-            this.logger.error('Error signing transaction:', error);
+            logError({
+                message: 'Error signing transaction:',
+                error: error,
+                context: {
+                    senderAddress
+                }
+            });
             throw error;
         }
     }
@@ -209,6 +671,14 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
             password,
             walletOperation: WalletOperation.EXPORT_PRIVATE_KEY
         });
+        // Attempt to recover key shares from backup if not provided
+        await this.ensureKeySharesRecovered({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY,
+            externalServerKeyShares,
+            errorMessage: 'External server key shares are required to export private key. No backup shares available for recovery.'
+        });
         const { derivedPrivateKey } = await this.exportKey({
             accountAddress,
             chainName: this.chainName,
@@ -251,16 +721,28 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
             onCeremonyComplete: (accountAddress, walletId)=>{
                 // update wallet map
                 const checksumAddress = getAddress(accountAddress);
+                const chainConfig = getMPCChainConfig(this.chainName);
                 this.walletMap[checksumAddress] = _extends({}, this.walletMap[checksumAddress] || {}, {
                     accountAddress: checksumAddress,
                     walletId,
                     chainName: this.chainName,
                     thresholdSignatureScheme,
+                    derivationPath: JSON.stringify(Object.fromEntries(chainConfig.derivationPath.map((value, index)=>[
+                            index,
+                            value
+                        ]))),
                     externalServerKeySharesBackupInfo: getExternalServerKeyShareBackupInfo()
                 });
                 ceremonyCeremonyCompleteResolver(undefined);
             },
-            onError
+            onError: (e)=>{
+                logError({
+                    message: 'importPrivateKey: onError',
+                    error: e,
+                    context: {}
+                });
+                onError == null ? void 0 : onError(e);
+            }
         });
         // Wait for the ceremony to complete before proceeding
         await ceremonyCompletePromise;
@@ -288,14 +770,198 @@ class DynamicEvmWalletClient extends DynamicWalletClient {
         const evmWallets = wallets.filter((wallet)=>wallet.chainName === 'eip155');
         return evmWallets;
     }
-    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, debug }){
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, debug, enableMPCAccelerator }){
         super({
             environmentId,
             baseApiUrl,
             baseMPCRelayApiUrl,
-            debug
+            debug,
+            enableMPCAccelerator
         }), this.chainName = 'EVM';
     }
 }
 
-export { DynamicEvmWalletClient };
+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);
+};
+
+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 = createAccountAdapter({
+            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, createAccountAdapter, createDelegatedEvmWalletClient, createZerodevClient, delegatedSignAuthorization, delegatedSignMessage, delegatedSignTransaction, delegatedSignTypedData, deriveAccountAddress, formatEVMMessage, formatTypedData, revokeDelegation, serializeECDSASignature };