@dynamic-labs-wallet/node-evm 0.0.0-preview.114.4 → 0.0.1-paolo-1

package/index.cjs.js

@@ -1,8 +1,21 @@
 'use strict';
 
+var accounts = require('viem/accounts');
 var node = require('@dynamic-labs-wallet/node');
 var viem = require('viem');
+var utils = require('viem/utils');
+var logger$1 = require('@dynamic-labs/logger');
+var axios = require('axios');
+var core = require('@dynamic-labs-wallet/core');
 var chains = require('viem/chains');
+var client = require('@dynamic-labs-sdk/client');
+var core$1 = 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$2 = require('@dynamic-labs-sdk/zerodev/core');
+var ecdsaValidator = require('@zerodev/ecdsa-validator');
+var sdk = require('@zerodev/sdk');
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -20,11 +33,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 viem.stringToHex(message_);
+        if (typeof message_.raw === 'string') return message_.raw;
+        return viem.bytesToHex(message_.raw);
+    })();
+    const prefix = viem.stringToHex(`${EVM_SIGN_MESSAGE_PREFIX}${viem.size(message)}`);
+    return viem.concat([
+        prefix,
+        message
+    ]);
+};
+const formatTypedData = (typedData)=>{
+    return viem.hashTypedData(typedData).slice(2);
 };
 const serializeECDSASignature = (signature)=>{
     return viem.serializeSignature({
@@ -46,32 +72,373 @@ const deriveAccountAddress = ({ rawPublicKey })=>{
     };
 };
 
+const logger = new logger$1.Logger('DynamicWaasWalletClient');
+const logError = ({ message, error, context })=>{
+    if (error instanceof axios.AxiosError) {
+        core.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 = node.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 node.delegatedSignMessage(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 = viem.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 node.delegatedSignMessage(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 = viem.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 node.delegatedSignMessage(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 = utils.hashAuthorization(authorization);
+        const prehashed = digest.startsWith('0x') ? digest.slice(2) : digest;
+        const signatureEcdsa = await node.delegatedSignMessage(client, {
+            walletId,
+            walletApiKey,
+            keyShare,
+            message: prehashed,
+            chainName: client.chainName,
+            isFormatted: true,
+            context: {
+                eip7702Auth: authorization
+            }
+        });
+        const serializedSignature = serializeECDSASignature(signatureEcdsa);
+        const signature = viem.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 node.revokeDelegation(client, params);
+};
+
+const createAccountAdapter = ({ 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 DynamicEvmWalletClient extends node.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 viem.createPublicClient({
             chain,
             transport: viem.http(rpcUrl)
         });
     }
-    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError }) {
+    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 = viem.defineChain({
+                id: chainId,
+                name: `Chain ${chainId}`,
+                nativeCurrency: {
+                    name: 'Ether',
+                    symbol: 'ETH',
+                    decimals: 18
+                },
+                rpcUrls: {
+                    default: {
+                        http: [
+                            rpcUrl
+                        ]
+                    }
+                }
+            });
+        } else {
+            viemChain = chains.mainnet;
+        }
+        return viem.createWalletClient({
+            account,
+            chain: viemChain,
+            transport: viem.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.
+   * @param password - The password to use for the wallet.
+   * @param onError - The function to call if an error occurs.
+   * @param backUpToClientShareService - Whether to back up the external server key shares to the client share service. By default, it is false.
+   * @returns The account address, public key, raw public key, external server key shares, and wallet id.
+   */ async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError, backUpToClientShareService = false }) {
         try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
             // Generate key shares for given threshold signature scheme (TSS)
             const { rawPublicKey, externalServerKeyShares } = await this.keyGen({
                 chainName: this.chainName,
                 thresholdSignatureScheme,
+                skipLock: true,
                 onError,
                 onCeremonyComplete: (accountAddress, walletId)=>{
                     // update wallet map
                     const checksumAddress = viem.getAddress(accountAddress);
+                    const chainConfig = node.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: node.getExternalServerKeyShareBackupInfo()
                     });
+                    this.logger.debug('walletMap updated for wallet', {
+                        context: {
+                            accountAddress,
+                            walletId,
+                            walletMap: this.walletMap
+                        }
+                    });
+                    ceremonyCeremonyCompleteResolver(undefined);
                 }
             });
+            // Wait for the ceremony to complete before proceeding
+            await ceremonyCompletePromise;
             if (!rawPublicKey || !externalServerKeyShares) {
                 throw new Error(ERROR_KEYGEN_FAILED);
             }
@@ -79,53 +446,152 @@ class DynamicEvmWalletClient extends node.DynamicWalletClient {
             const { accountAddress, publicKeyHex } = deriveAccountAddress({
                 rawPublicKey: rawPublicKey
             });
-            void this.storeEncryptedBackupByWalletWithRetry({
+            await this.storeEncryptedBackupByWalletWithRetry({
                 accountAddress,
                 externalServerKeyShares,
-                password
+                password,
+                backUpToClientShareService
             });
             return {
+                walletId: this.walletMap[accountAddress].walletId,
                 accountAddress,
                 rawPublicKey,
                 publicKeyHex,
                 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 }) {
-        await this.verifyPassword({
-            accountAddress,
-            password,
-            walletOperation: node.WalletOperation.SIGN_MESSAGE
-        });
-        await this.getWallet({
-            accountAddress,
-            walletOperation: node.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: node.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
+                password,
+                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 = utils.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: node.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 = viem.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: node.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
@@ -139,16 +605,30 @@ class DynamicEvmWalletClient extends node.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);
         }
     }
-    async signTransaction({ senderAddress, transaction, password = undefined }) {
+    async signTransaction({ senderAddress, transaction, password = undefined, externalServerKeyShares }) {
         await this.verifyPassword({
             accountAddress: senderAddress,
             password,
             walletOperation: node.WalletOperation.SIGN_TRANSACTION
         });
+        // Attempt to recover key shares from backup if not provided
+        await this.ensureKeySharesRecovered({
+            accountAddress: senderAddress,
+            password,
+            walletOperation: node.WalletOperation.SIGN_TRANSACTION,
+            externalServerKeyShares,
+            errorMessage: 'External server key shares are required to sign transaction. No backup shares available for recovery.'
+        });
         const serializedTx = viem.serializeTransaction(transaction);
         const serializedTxBytes = Uint8Array.from(Buffer.from(serializedTx.slice(2), 'hex'));
         if (!(serializedTxBytes instanceof Uint8Array)) {
@@ -159,7 +639,8 @@ class DynamicEvmWalletClient extends node.DynamicWalletClient {
             message: serializedTxBytes,
             accountAddress: senderAddress,
             chainName: this.chainName,
-            password
+            password,
+            externalServerKeyShares
         });
         if (!('r' in signatureEcdsa && 's' in signatureEcdsa && 'v' in signatureEcdsa)) {
             throw new Error('Invalid signature format returned from MPC signing');
@@ -176,20 +657,35 @@ class DynamicEvmWalletClient extends node.DynamicWalletClient {
             const serializedSignedTx = viem.serializeTransaction(signedTx);
             return serializedSignedTx;
         } catch (error) {
-            this.logger.error('Error signing transaction:', error);
+            logError({
+                message: 'Error signing transaction:',
+                error: error,
+                context: {
+                    senderAddress
+                }
+            });
             throw error;
         }
     }
-    async exportPrivateKey({ accountAddress, password = undefined }) {
+    async exportPrivateKey({ accountAddress, password = undefined, externalServerKeyShares }) {
         await this.verifyPassword({
             accountAddress,
             password,
             walletOperation: node.WalletOperation.EXPORT_PRIVATE_KEY
         });
+        // Attempt to recover key shares from backup if not provided
+        await this.ensureKeySharesRecovered({
+            accountAddress,
+            password,
+            walletOperation: node.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,
-            password
+            password,
+            externalServerKeyShares
         });
         return {
             derivedPrivateKey
@@ -205,35 +701,64 @@ class DynamicEvmWalletClient extends node.DynamicWalletClient {
             derivedPrivateKey
         };
     }
-    async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, onError }) {
+    /**
+   * Imports a private key and stores the key shares in the wallet map.
+   * @param privateKey - The private key to import.
+   * @param chainName - The chain name to use for the wallet.
+   * @param thresholdSignatureScheme - The threshold signature scheme to use for the wallet.
+   * @param password - The password to use for the wallet.
+   * @param onError - The function to call if an error occurs.
+   * @param backUpToClientShareService - Whether to back up the external server key shares to the client share service. By default, it is false.
+   * @returns The account address, public key, raw public key, external server key shares.
+   */ async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, backUpToClientShareService = false, onError }) {
+        let ceremonyCeremonyCompleteResolver;
+        const ceremonyCompletePromise = new Promise((resolve)=>{
+            ceremonyCeremonyCompleteResolver = resolve;
+        });
         // TODO: validate private key for EVM
         const { rawPublicKey, externalServerKeyShares } = await this.importRawPrivateKey({
             chainName,
             privateKey,
             thresholdSignatureScheme,
-            onError,
             onCeremonyComplete: (accountAddress, walletId)=>{
                 // update wallet map
                 const checksumAddress = viem.getAddress(accountAddress);
+                const chainConfig = node.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: node.getExternalServerKeyShareBackupInfo()
                 });
+                ceremonyCeremonyCompleteResolver(undefined);
+            },
+            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;
         if (!rawPublicKey || !externalServerKeyShares) {
             throw new Error('Error creating wallet account');
         }
         const { accountAddress, publicKeyHex } = deriveAccountAddress({
             rawPublicKey: rawPublicKey
         });
-        void this.storeEncryptedBackupByWalletWithRetry({
+        await this.storeEncryptedBackupByWalletWithRetry({
             accountAddress,
             externalServerKeyShares,
-            password
+            password,
+            backUpToClientShareService
         });
         return {
             accountAddress,
@@ -247,14 +772,217 @@ class DynamicEvmWalletClient extends node.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';
     }
 }
 
+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 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$1.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 = viem$1.mapNetworkDataToViemChain(activeNetworkData);
+        var _options_bundlerRpc;
+        const bundlerRpc = (_options_bundlerRpc = options.bundlerRpc) != null ? _options_bundlerRpc : core$2.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$2.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$2.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$2.getZerodevProviderFromSettings(this.dynamicClient);
+        core$1.assertDefined(zerodevProvider, 'Zerodev provider is not enabled in project settings');
+        const useEIP7702 = zerodevProvider.enableEIP7702;
+        const entryPointVersion = zerodevProvider.entryPointVersion;
+        const entryPoint = core$2.getEntryPoint(entryPointVersion);
+        if (useEIP7702) {
+            return sdk.createKernelAccount(publicClient, {
+                eip7702Account: signer,
+                entryPoint,
+                kernelVersion: sdk.constants.KERNEL_V3_3
+            });
+        }
+        const kernelVersionValue = zerodevProvider.kernelVersion;
+        const kernelVersion = core$2.getKernelVersion({
+            entryPoint,
+            kernelVersion: kernelVersionValue
+        });
+        var _zerodevProvider_enableKernelV3Migration;
+        const kernelV3MigrationEnabled = (_zerodevProvider_enableKernelV3Migration = zerodevProvider.enableKernelV3Migration) != null ? _zerodevProvider_enableKernelV3Migration : false;
+        if (kernelV3MigrationEnabled) {
+            const apiKernelVersion = core$2.getKernelVersion({
+                entryPoint,
+                kernelVersion: zerodevProvider.kernelVersion
+            });
+            return ecdsaValidator.createEcdsaKernelMigrationAccount(publicClient, {
+                entryPoint,
+                migrationVersion: {
+                    from: kernelVersion,
+                    to: apiKernelVersion
+                },
+                signer
+            });
+        }
+        const validator = await core$2.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;
+exports.ERROR_KEYGEN_FAILED = ERROR_KEYGEN_FAILED;
+exports.ERROR_SIGN_MESSAGE = ERROR_SIGN_MESSAGE;
+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.createAccountAdapter = createAccountAdapter;
+exports.createDelegatedEvmWalletClient = createDelegatedEvmWalletClient;
+exports.createZerodevClient = createZerodevClient;
+exports.delegatedSignAuthorization = delegatedSignAuthorization;
+exports.delegatedSignMessage = delegatedSignMessage;
+exports.delegatedSignTransaction = delegatedSignTransaction;
+exports.delegatedSignTypedData = delegatedSignTypedData;
+exports.deriveAccountAddress = deriveAccountAddress;
+exports.formatEVMMessage = formatEVMMessage;
+exports.formatTypedData = formatTypedData;
+exports.revokeDelegation = revokeDelegation;
+exports.serializeECDSASignature = serializeECDSASignature;