@dynamic-labs-wallet/evm 0.0.0-beta-191.1

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,328 @@
+'use strict';
+
+var browser = require('@dynamic-labs-wallet/browser');
+var viem = require('viem');
+var chains = require('viem/chains');
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+const EVM_SIGN_MESSAGE_PREFIX = `\x19Ethereum Signed Message:\n`;
+
+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 serializeECDSASignature = (signature)=>{
+    return viem.serializeSignature({
+        r: `0x${Buffer.from(signature.r).toString('hex')}`,
+        s: `0x${Buffer.from(signature.s).toString('hex')}`,
+        v: BigInt(signature.v)
+    });
+};
+
+const checkRawPublicKeyInstance = (rawPublicKey)=>{
+    if (!(rawPublicKey instanceof browser.EcdsaPublicKey)) {
+        throw new Error('Invalid raw public key');
+    }
+};
+
+class DynamicEvmWalletClient extends browser.DynamicWalletClient {
+    createViemPublicClient({ chain, rpcUrl }) {
+        return viem.createPublicClient({
+            chain,
+            transport: viem.http(rpcUrl)
+        });
+    }
+    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError, signedSessionId }) {
+        try {
+            // Create a promise that will resolve when the ceremony is complete
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            // Generate key shares for given threshold signature scheme (TSS)
+            const { rawPublicKey, clientKeyShares } = await this.keyGen({
+                chainName: this.chainName,
+                thresholdSignatureScheme,
+                onError: (error)=>{
+                    this.logger.error(browser.ERROR_CREATE_WALLET_ACCOUNT, error);
+                    onError == null ? void 0 : onError(error);
+                },
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    const checksumAddress = viem.getAddress(accountAddress);
+                    this.walletMap[checksumAddress] = _extends({}, this.walletMap[checksumAddress] || {}, {
+                        accountAddress: checksumAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        clientKeySharesBackupInfo: browser.getClientKeyShareBackupInfo()
+                    });
+                    this.logger.debug('walletMap updated for wallet', {
+                        context: {
+                            accountAddress,
+                            walletId,
+                            walletMap: this.walletMap
+                        }
+                    });
+                    // Resolve the promise when ceremony is complete
+                    ceremonyCeremonyCompleteResolver(undefined);
+                }
+            });
+            // Wait for the ceremony to complete before proceeding
+            await ceremonyCompletePromise;
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(browser.ERROR_KEYGEN_FAILED);
+            }
+            checkRawPublicKeyInstance(rawPublicKey);
+            const { accountAddress, publicKeyHex } = await this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            // Update client key shares in wallet map
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password,
+                signedSessionId
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex
+            };
+        } catch (error) {
+            this.logger.error(browser.ERROR_CREATE_WALLET_ACCOUNT, error);
+            throw new Error(browser.ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    async signMessage({ message, accountAddress, password = undefined, signedSessionId }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: browser.WalletOperation.SIGN_MESSAGE,
+            signedSessionId
+        });
+        try {
+            if (!accountAddress) {
+                throw new Error(browser.ERROR_ACCOUNT_ADDRESS_REQUIRED);
+            }
+            // Format the message for EVM signing
+            const formattedMessage = formatEVMMessage(message);
+            // Sign the message using MPC
+            const signatureEcdsa = await this.sign({
+                message: formattedMessage,
+                accountAddress: accountAddress,
+                chainName: this.chainName,
+                password,
+                signedSessionId
+            });
+            // Serialize the signature
+            const serializedSignature = serializeECDSASignature(signatureEcdsa);
+            return serializedSignature;
+        } catch (error) {
+            this.logger.error(browser.ERROR_SIGN_MESSAGE, error);
+            throw new Error(browser.ERROR_SIGN_MESSAGE);
+        }
+    }
+    async verifyMessageSignature({ accountAddress, message, signature }) {
+        try {
+            // Verify the signature using the public client
+            const publicClient = this.createViemPublicClient({
+                chain: chains.mainnet
+            });
+            const verified = await publicClient.verifyMessage({
+                address: accountAddress,
+                message,
+                signature: signature
+            });
+            return verified;
+        } catch (error) {
+            this.logger.error(browser.ERROR_VERIFY_MESSAGE_SIGNATURE, error);
+            throw new Error(browser.ERROR_VERIFY_MESSAGE_SIGNATURE);
+        }
+    }
+    async signTransaction({ senderAddress, transaction, password = undefined, signedSessionId }) {
+        await this.verifyPassword({
+            accountAddress: senderAddress,
+            password,
+            walletOperation: browser.WalletOperation.SIGN_TRANSACTION,
+            signedSessionId
+        });
+        const serializedTx = viem.serializeTransaction(transaction);
+        const serializedTxBytes = Uint8Array.from(Buffer.from(serializedTx.slice(2), 'hex'));
+        if (!(serializedTxBytes instanceof Uint8Array)) {
+            throw new Error('Invalid serializedTxBytes');
+        }
+        // Get signature using MPC (this will coordinate with server party)
+        const signatureEcdsa = await this.sign({
+            message: serializedTxBytes,
+            accountAddress: senderAddress,
+            chainName: this.chainName,
+            password,
+            signedSessionId
+        });
+        if (!('r' in signatureEcdsa && 's' in signatureEcdsa && 'v' in signatureEcdsa)) {
+            throw new Error('Invalid signature format returned from MPC signing');
+        }
+        try {
+            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) {
+            this.logger.error('Error signing transaction:', error);
+            throw error;
+        }
+    }
+    deriveAccountAddress({ rawPublicKey }) {
+        const serializedUncompressed = rawPublicKey.serializeUncompressed();
+        const firstByteRemoved = serializedUncompressed.slice(1);
+        const hashed = browser.MessageHash.keccak256(firstByteRemoved).bytes;
+        const lastTwentyBytes = hashed.slice(-20);
+        const accountAddress = '0x' + Buffer.from(lastTwentyBytes).toString('hex');
+        const publicKeyHex = rawPublicKey.pubKeyAsHex();
+        return {
+            accountAddress: viem.getAddress(accountAddress),
+            publicKeyHex
+        };
+    }
+    async exportPrivateKey({ accountAddress, password = undefined, signedSessionId }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: browser.WalletOperation.EXPORT_PRIVATE_KEY,
+            signedSessionId
+        });
+        const { derivedPrivateKey } = await this.exportKey({
+            accountAddress,
+            chainName: this.chainName,
+            password,
+            signedSessionId
+        });
+        return derivedPrivateKey;
+    }
+    async offlineExportPrivateKey({ keyShares, derivationPath }) {
+        const { derivedPrivateKey } = await this.offlineExportKey({
+            chainName: this.chainName,
+            keyShares,
+            derivationPath
+        });
+        return {
+            derivedPrivateKey
+        };
+    }
+    async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, onError, signedSessionId }) {
+        try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            //remove 0x if it exists
+            const formattedPrivateKey = privateKey.startsWith('0x') ? privateKey.slice(2) : privateKey;
+            // TODO: validate private key for EVM
+            const { rawPublicKey, clientKeyShares } = await this.importRawPrivateKey({
+                chainName,
+                privateKey: formattedPrivateKey,
+                thresholdSignatureScheme,
+                onError: (error)=>{
+                    this.logger.error(browser.ERROR_IMPORT_PRIVATE_KEY, error);
+                    onError == null ? void 0 : onError(error);
+                },
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    const checksumAddress = viem.getAddress(accountAddress);
+                    this.walletMap[checksumAddress] = _extends({}, this.walletMap[checksumAddress] || {}, {
+                        accountAddress: checksumAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        clientKeySharesBackupInfo: browser.getClientKeyShareBackupInfo()
+                    });
+                    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 || !clientKeyShares) {
+                throw new Error(browser.ERROR_IMPORT_PRIVATE_KEY);
+            }
+            checkRawPublicKeyInstance(rawPublicKey);
+            const { accountAddress, publicKeyHex } = await this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            // Update client key shares in wallet map
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password,
+                signedSessionId
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex
+            };
+        } catch (error) {
+            this.logger.error(browser.ERROR_IMPORT_PRIVATE_KEY, error);
+            throw error;
+        }
+    }
+    async getEvmWallets() {
+        const wallets = await this.getWallets();
+        const evmWallets = wallets.filter((wallet)=>wallet.chainName === 'eip155');
+        return evmWallets;
+    }
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, baseClientRelayApiUrl }){
+        super({
+            environmentId,
+            authToken,
+            baseApiUrl,
+            baseMPCRelayApiUrl,
+            storageKey,
+            debug,
+            baseClientRelayApiUrl
+        }), this.chainName = 'EVM';
+    }
+}
+
+exports.DynamicEvmWalletClient = DynamicEvmWalletClient;

package/index.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.esm.js

@@ -0,0 +1,326 @@
+import { EcdsaPublicKey, DynamicWalletClient, getClientKeyShareBackupInfo, ERROR_CREATE_WALLET_ACCOUNT, ERROR_KEYGEN_FAILED, WalletOperation, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_SIGN_MESSAGE, ERROR_VERIFY_MESSAGE_SIGNATURE, MessageHash, ERROR_IMPORT_PRIVATE_KEY } from '@dynamic-labs-wallet/browser';
+import { stringToHex, bytesToHex, size, concat, serializeSignature, createPublicClient, http, getAddress, serializeTransaction } from 'viem';
+import { mainnet } from 'viem/chains';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+const EVM_SIGN_MESSAGE_PREFIX = `\x19Ethereum Signed Message:\n`;
+
+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 serializeECDSASignature = (signature)=>{
+    return serializeSignature({
+        r: `0x${Buffer.from(signature.r).toString('hex')}`,
+        s: `0x${Buffer.from(signature.s).toString('hex')}`,
+        v: BigInt(signature.v)
+    });
+};
+
+const checkRawPublicKeyInstance = (rawPublicKey)=>{
+    if (!(rawPublicKey instanceof EcdsaPublicKey)) {
+        throw new Error('Invalid raw public key');
+    }
+};
+
+class DynamicEvmWalletClient extends DynamicWalletClient {
+    createViemPublicClient({ chain, rpcUrl }) {
+        return createPublicClient({
+            chain,
+            transport: http(rpcUrl)
+        });
+    }
+    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError, signedSessionId }) {
+        try {
+            // Create a promise that will resolve when the ceremony is complete
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            // Generate key shares for given threshold signature scheme (TSS)
+            const { rawPublicKey, clientKeyShares } = await this.keyGen({
+                chainName: this.chainName,
+                thresholdSignatureScheme,
+                onError: (error)=>{
+                    this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+                    onError == null ? void 0 : onError(error);
+                },
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    const checksumAddress = getAddress(accountAddress);
+                    this.walletMap[checksumAddress] = _extends({}, this.walletMap[checksumAddress] || {}, {
+                        accountAddress: checksumAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
+                    });
+                    this.logger.debug('walletMap updated for wallet', {
+                        context: {
+                            accountAddress,
+                            walletId,
+                            walletMap: this.walletMap
+                        }
+                    });
+                    // Resolve the promise when ceremony is complete
+                    ceremonyCeremonyCompleteResolver(undefined);
+                }
+            });
+            // Wait for the ceremony to complete before proceeding
+            await ceremonyCompletePromise;
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(ERROR_KEYGEN_FAILED);
+            }
+            checkRawPublicKeyInstance(rawPublicKey);
+            const { accountAddress, publicKeyHex } = await this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            // Update client key shares in wallet map
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password,
+                signedSessionId
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex
+            };
+        } catch (error) {
+            this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    async signMessage({ message, accountAddress, password = undefined, signedSessionId }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_MESSAGE,
+            signedSessionId
+        });
+        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 signatureEcdsa = await this.sign({
+                message: formattedMessage,
+                accountAddress: accountAddress,
+                chainName: this.chainName,
+                password,
+                signedSessionId
+            });
+            // Serialize the signature
+            const serializedSignature = serializeECDSASignature(signatureEcdsa);
+            return serializedSignature;
+        } catch (error) {
+            this.logger.error(ERROR_SIGN_MESSAGE, error);
+            throw new Error(ERROR_SIGN_MESSAGE);
+        }
+    }
+    async verifyMessageSignature({ accountAddress, message, signature }) {
+        try {
+            // Verify the signature using the public client
+            const publicClient = this.createViemPublicClient({
+                chain: mainnet
+            });
+            const verified = await publicClient.verifyMessage({
+                address: accountAddress,
+                message,
+                signature: signature
+            });
+            return verified;
+        } catch (error) {
+            this.logger.error(ERROR_VERIFY_MESSAGE_SIGNATURE, error);
+            throw new Error(ERROR_VERIFY_MESSAGE_SIGNATURE);
+        }
+    }
+    async signTransaction({ senderAddress, transaction, password = undefined, signedSessionId }) {
+        await this.verifyPassword({
+            accountAddress: senderAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_TRANSACTION,
+            signedSessionId
+        });
+        const serializedTx = serializeTransaction(transaction);
+        const serializedTxBytes = Uint8Array.from(Buffer.from(serializedTx.slice(2), 'hex'));
+        if (!(serializedTxBytes instanceof Uint8Array)) {
+            throw new Error('Invalid serializedTxBytes');
+        }
+        // Get signature using MPC (this will coordinate with server party)
+        const signatureEcdsa = await this.sign({
+            message: serializedTxBytes,
+            accountAddress: senderAddress,
+            chainName: this.chainName,
+            password,
+            signedSessionId
+        });
+        if (!('r' in signatureEcdsa && 's' in signatureEcdsa && 'v' in signatureEcdsa)) {
+            throw new Error('Invalid signature format returned from MPC signing');
+        }
+        try {
+            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) {
+            this.logger.error('Error signing transaction:', error);
+            throw error;
+        }
+    }
+    deriveAccountAddress({ rawPublicKey }) {
+        const serializedUncompressed = rawPublicKey.serializeUncompressed();
+        const firstByteRemoved = serializedUncompressed.slice(1);
+        const hashed = MessageHash.keccak256(firstByteRemoved).bytes;
+        const lastTwentyBytes = hashed.slice(-20);
+        const accountAddress = '0x' + Buffer.from(lastTwentyBytes).toString('hex');
+        const publicKeyHex = rawPublicKey.pubKeyAsHex();
+        return {
+            accountAddress: getAddress(accountAddress),
+            publicKeyHex
+        };
+    }
+    async exportPrivateKey({ accountAddress, password = undefined, signedSessionId }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY,
+            signedSessionId
+        });
+        const { derivedPrivateKey } = await this.exportKey({
+            accountAddress,
+            chainName: this.chainName,
+            password,
+            signedSessionId
+        });
+        return derivedPrivateKey;
+    }
+    async offlineExportPrivateKey({ keyShares, derivationPath }) {
+        const { derivedPrivateKey } = await this.offlineExportKey({
+            chainName: this.chainName,
+            keyShares,
+            derivationPath
+        });
+        return {
+            derivedPrivateKey
+        };
+    }
+    async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, onError, signedSessionId }) {
+        try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            //remove 0x if it exists
+            const formattedPrivateKey = privateKey.startsWith('0x') ? privateKey.slice(2) : privateKey;
+            // TODO: validate private key for EVM
+            const { rawPublicKey, clientKeyShares } = await this.importRawPrivateKey({
+                chainName,
+                privateKey: formattedPrivateKey,
+                thresholdSignatureScheme,
+                onError: (error)=>{
+                    this.logger.error(ERROR_IMPORT_PRIVATE_KEY, error);
+                    onError == null ? void 0 : onError(error);
+                },
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    const checksumAddress = getAddress(accountAddress);
+                    this.walletMap[checksumAddress] = _extends({}, this.walletMap[checksumAddress] || {}, {
+                        accountAddress: checksumAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
+                    });
+                    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 || !clientKeyShares) {
+                throw new Error(ERROR_IMPORT_PRIVATE_KEY);
+            }
+            checkRawPublicKeyInstance(rawPublicKey);
+            const { accountAddress, publicKeyHex } = await this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            // Update client key shares in wallet map
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password,
+                signedSessionId
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex
+            };
+        } catch (error) {
+            this.logger.error(ERROR_IMPORT_PRIVATE_KEY, error);
+            throw error;
+        }
+    }
+    async getEvmWallets() {
+        const wallets = await this.getWallets();
+        const evmWallets = wallets.filter((wallet)=>wallet.chainName === 'eip155');
+        return evmWallets;
+    }
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, baseClientRelayApiUrl }){
+        super({
+            environmentId,
+            authToken,
+            baseApiUrl,
+            baseMPCRelayApiUrl,
+            storageKey,
+            debug,
+            baseClientRelayApiUrl
+        }), this.chainName = 'EVM';
+    }
+}
+
+export { DynamicEvmWalletClient };

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@dynamic-labs-wallet/evm",
+  "version": "0.0.0-beta-191.1",
+  "license": "MIT",
+  "dependencies": {
+    "@dynamic-labs-wallet/browser": "0.0.0-beta-191.1"
+  },
+  "peerDependencies": {
+    "viem": "^2.22.1"
+  },
+  "nx": {
+    "sourceRoot": "packages/evm/src",
+    "projectType": "library",
+    "name": "evm",
+    "targets": {
+      "build": {}
+    }
+  },
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "types": "./index.esm.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.esm.d.ts",
+      "import": "./index.esm.js",
+      "require": "./index.cjs.js",
+      "default": "./index.cjs.js"
+    }
+  }
+}

package/src/client/client.d.ts

@@ -0,0 +1,68 @@
+import { DynamicWalletClient, EcdsaKeygenResult, EcdsaPublicKey, Ed25519KeygenResult, ThresholdSignatureScheme, DynamicWalletClientProps } from '@dynamic-labs-wallet/browser';
+import { type PublicClient, type Chain, type SignableMessage, type TransactionSerializable } from 'viem';
+export declare class DynamicEvmWalletClient extends DynamicWalletClient {
+    readonly chainName = "EVM";
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, baseClientRelayApiUrl, }: DynamicWalletClientProps);
+    createViemPublicClient({ chain, rpcUrl, }: {
+        chain: Chain;
+        rpcUrl?: string;
+    }): PublicClient;
+    createWalletAccount({ thresholdSignatureScheme, password, onError, signedSessionId, }: {
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+        signedSessionId?: string;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
+    }>;
+    signMessage({ message, accountAddress, password, signedSessionId, }: {
+        message: string;
+        accountAddress: string;
+        password?: string;
+        signedSessionId?: string;
+    }): Promise<`0x${string}`>;
+    verifyMessageSignature({ accountAddress, message, signature, }: {
+        accountAddress: string;
+        message: SignableMessage;
+        signature: any;
+    }): Promise<boolean>;
+    signTransaction({ senderAddress, transaction, password, signedSessionId, }: {
+        senderAddress: string;
+        transaction: TransactionSerializable;
+        password?: string;
+        signedSessionId?: string;
+    }): Promise<string>;
+    deriveAccountAddress({ rawPublicKey }: {
+        rawPublicKey: EcdsaPublicKey;
+    }): {
+        accountAddress: `0x${string}`;
+        publicKeyHex: any;
+    };
+    exportPrivateKey({ accountAddress, password, signedSessionId, }: {
+        accountAddress: string;
+        password?: string;
+        signedSessionId?: string;
+    }): Promise<string | undefined>;
+    offlineExportPrivateKey({ keyShares, derivationPath, }: {
+        keyShares: (EcdsaKeygenResult | Ed25519KeygenResult)[];
+        derivationPath?: string;
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password, onError, signedSessionId, }: {
+        privateKey: string;
+        chainName: string;
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+        signedSessionId?: string;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
+    }>;
+    getEvmWallets(): Promise<any>;
+}
+//# sourceMappingURL=client.d.ts.map

package/src/client/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"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"}

package/src/client/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const EVM_SIGN_MESSAGE_PREFIX = "\u0019Ethereum Signed Message:\n";
+//# sourceMappingURL=constants.d.ts.map

package/src/client/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/client/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,qCAAmC,CAAC"}

package/src/client/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const checkRawPublicKeyInstance: (rawPublicKey: any) => void;
+//# sourceMappingURL=helpers.d.ts.map

package/src/client/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/client/helpers.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB,iBAAkB,GAAG,SAI1D,CAAC"}

package/src/client/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/src/index.d.ts

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

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/src/utils.d.ts

@@ -0,0 +1,6 @@
+import type { EcdsaSignature } from '@dynamic-labs-wallet/browser';
+export declare const formatEVMMessage: (message_: string | {
+    raw: string | Uint8Array;
+}) => `0x${string}`;
+export declare const serializeECDSASignature: (signature: EcdsaSignature) => `0x${string}`;
+//# sourceMappingURL=utils.d.ts.map

package/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../packages/src/utils.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,eAAO,MAAM,gBAAgB,aACjB,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,kBAUhD,CAAC;AAEF,eAAO,MAAM,uBAAuB,cAAe,cAAc,kBAMhE,CAAC"}