@dynamic-labs-wallet/node-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,281 @@
+'use strict';
+
+var node = require('@dynamic-labs-wallet/node');
+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`;
+// Error messages
+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_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 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 deriveAccountAddress = ({ rawPublicKey })=>{
+    const serializedUncompressed = rawPublicKey.serializeUncompressed();
+    const firstByteRemoved = serializedUncompressed.slice(1);
+    const hashed = node.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
+    };
+};
+
+class DynamicEvmWalletClient extends node.DynamicWalletClient {
+    createViemPublicClient({ chain, rpcUrl }) {
+        return viem.createPublicClient({
+            chain,
+            transport: viem.http(rpcUrl)
+        });
+    }
+    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError }) {
+        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,
+                onError,
+                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,
+                        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);
+            }
+            // Get EVM address from public key
+            const { accountAddress, publicKeyHex } = deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                externalServerKeyShares,
+                password
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex,
+                externalServerKeyShares
+            };
+        } catch (error) {
+            // this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+            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
+        });
+        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
+            });
+            // 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: chains.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 }) {
+        await this.verifyPassword({
+            accountAddress: senderAddress,
+            password,
+            walletOperation: node.WalletOperation.SIGN_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');
+        }
+        // Get signature using MPC (this will coordinate with server party)
+        const signatureEcdsa = await this.sign({
+            message: serializedTxBytes,
+            accountAddress: senderAddress,
+            chainName: this.chainName,
+            password
+        });
+        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;
+        }
+    }
+    async exportPrivateKey({ accountAddress, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: node.WalletOperation.EXPORT_PRIVATE_KEY
+        });
+        const { derivedPrivateKey } = await this.exportKey({
+            accountAddress,
+            chainName: this.chainName,
+            password
+        });
+        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 }) {
+        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);
+                this.walletMap[checksumAddress] = _extends({}, this.walletMap[checksumAddress] || {}, {
+                    accountAddress: checksumAddress,
+                    walletId,
+                    chainName: this.chainName,
+                    thresholdSignatureScheme,
+                    externalServerKeySharesBackupInfo: node.getExternalServerKeyShareBackupInfo()
+                });
+                ceremonyCeremonyCompleteResolver(undefined);
+            }
+        });
+        // 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
+        });
+        await this.storeEncryptedBackupByWalletWithRetry({
+            accountAddress,
+            externalServerKeyShares,
+            password
+        });
+        return {
+            accountAddress,
+            rawPublicKey,
+            publicKeyHex,
+            externalServerKeyShares
+        };
+    }
+    async getEvmWallets() {
+        const wallets = await this.getWallets();
+        const evmWallets = wallets.filter((wallet)=>wallet.chainName === 'eip155');
+        return evmWallets;
+    }
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, debug }){
+        super({
+            environmentId,
+            baseApiUrl,
+            baseMPCRelayApiUrl,
+            debug
+        }), 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,279 @@
+import { MessageHash, DynamicWalletClient, getExternalServerKeyShareBackupInfo, WalletOperation } from '@dynamic-labs-wallet/node';
+import { getAddress, serializeSignature, createPublicClient, http, 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`;
+// Error messages
+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_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 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 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
+    };
+};
+
+class DynamicEvmWalletClient extends DynamicWalletClient {
+    createViemPublicClient({ chain, rpcUrl }) {
+        return createPublicClient({
+            chain,
+            transport: http(rpcUrl)
+        });
+    }
+    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError }) {
+        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,
+                onError,
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    const checksumAddress = getAddress(accountAddress);
+                    this.walletMap[checksumAddress] = _extends({}, this.walletMap[checksumAddress] || {}, {
+                        accountAddress: checksumAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        externalServerKeySharesBackupInfo: 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);
+            }
+            // Get EVM address from public key
+            const { accountAddress, publicKeyHex } = deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                externalServerKeyShares,
+                password
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex,
+                externalServerKeyShares
+            };
+        } catch (error) {
+            // this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    async signMessage({ message, accountAddress, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_MESSAGE
+        });
+        await this.getWallet({
+            accountAddress,
+            walletOperation: WalletOperation.SIGN_MESSAGE
+        });
+        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
+            });
+            // 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 }) {
+        await this.verifyPassword({
+            accountAddress: senderAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_TRANSACTION
+        });
+        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
+        });
+        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;
+        }
+    }
+    async exportPrivateKey({ accountAddress, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY
+        });
+        const { derivedPrivateKey } = await this.exportKey({
+            accountAddress,
+            chainName: this.chainName,
+            password
+        });
+        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 }) {
+        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 = getAddress(accountAddress);
+                this.walletMap[checksumAddress] = _extends({}, this.walletMap[checksumAddress] || {}, {
+                    accountAddress: checksumAddress,
+                    walletId,
+                    chainName: this.chainName,
+                    thresholdSignatureScheme,
+                    externalServerKeySharesBackupInfo: getExternalServerKeyShareBackupInfo()
+                });
+                ceremonyCeremonyCompleteResolver(undefined);
+            }
+        });
+        // 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
+        });
+        await this.storeEncryptedBackupByWalletWithRetry({
+            accountAddress,
+            externalServerKeyShares,
+            password
+        });
+        return {
+            accountAddress,
+            rawPublicKey,
+            publicKeyHex,
+            externalServerKeyShares
+        };
+    }
+    async getEvmWallets() {
+        const wallets = await this.getWallets();
+        const evmWallets = wallets.filter((wallet)=>wallet.chainName === 'eip155');
+        return evmWallets;
+    }
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, debug }){
+        super({
+            environmentId,
+            baseApiUrl,
+            baseMPCRelayApiUrl,
+            debug
+        }), this.chainName = 'EVM';
+    }
+}
+
+export { DynamicEvmWalletClient };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@dynamic-labs-wallet/node-evm",
+  "version": "0.0.0-beta-191.1",
+  "license": "MIT",
+  "dependencies": {
+    "@dynamic-labs-wallet/node": "0.0.0-beta-191.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "viem": "^2.22.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "nx": {
+    "sourceRoot": "packages/node-evm/src",
+    "projectType": "library",
+    "name": "node-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,61 @@
+import { ServerKeyShare, DynamicWalletClient, EcdsaKeygenResult, EcdsaPublicKey, Ed25519KeygenResult, ThresholdSignatureScheme, DynamicWalletClientProps } from '@dynamic-labs-wallet/node';
+import { type PublicClient, type Chain, type SignableMessage, type TransactionSerializable } from 'viem';
+export declare class DynamicEvmWalletClient extends DynamicWalletClient {
+    readonly chainName = "EVM";
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, debug, }: DynamicWalletClientProps);
+    createViemPublicClient({ chain, rpcUrl, }: {
+        chain: Chain;
+        rpcUrl?: string;
+    }): PublicClient;
+    createWalletAccount({ thresholdSignatureScheme, password, onError, }: {
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | undefined;
+        externalServerKeyShares: ServerKeyShare[];
+    }>;
+    signMessage({ message, accountAddress, password, }: {
+        message: string;
+        accountAddress: string;
+        password?: string;
+    }): Promise<`0x${string}`>;
+    verifyMessageSignature({ accountAddress, message, signature, }: {
+        accountAddress: string;
+        message: SignableMessage;
+        signature: any;
+    }): Promise<boolean>;
+    signTransaction({ senderAddress, transaction, password, }: {
+        senderAddress: string;
+        transaction: TransactionSerializable;
+        password?: string;
+    }): Promise<string>;
+    exportPrivateKey({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string;
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    offlineExportPrivateKey({ keyShares, derivationPath, }: {
+        keyShares: (EcdsaKeygenResult | Ed25519KeygenResult)[];
+        derivationPath?: string;
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password, onError, }: {
+        privateKey: string;
+        chainName: string;
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | undefined;
+        externalServerKeyShares: ServerKeyShare[];
+    }>;
+    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":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EAEd,mBAAmB,EACnB,wBAAwB,EACxB,wBAAwB,EAGzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,KAAK,EAEV,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAE7B,MAAM,MAAM,CAAC;AAed,qBAAa,sBAAuB,SAAQ,mBAAmB;IAC7D,QAAQ,CAAC,SAAS,SAAS;gBAEf,EACV,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,KAAK,GACN,EAAE,wBAAwB;IAS3B,sBAAsB,CAAC,EACrB,KAAK,EACL,MAAM,GACP,EAAE;QACD,KAAK,EAAE,KAAK,CAAC;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GAAG,YAAY;IAOV,mBAAmB,CAAC,EACxB,wBAAwB,EACxB,QAAoB,EACpB,OAAO,GACR,EAAE;QACD,wBAAwB,EAAE,wBAAwB,CAAC;QACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;KAClC,GAAG,OAAO,CAAC;QACV,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,cAAc,GAAG,UAAU,GAAG,SAAS,CAAC;QACtD,uBAAuB,EAAE,cAAc,EAAE,CAAC;KAC3C,CAAC;IAiEI,WAAW,CAAC,EAChB,OAAO,EACP,cAAc,EACd,QAAoB,GACrB,EAAE;QACD,OAAO,EAAE,MAAM,CAAC;QAChB,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAqCK,sBAAsB,CAAC,EAC3B,cAAc,EACd,OAAO,EACP,SAAS,GACV,EAAE;QACD,cAAc,EAAE,MAAM,CAAC;QACvB,OAAO,EAAE,eAAe,CAAC;QACzB,SAAS,EAAE,GAAG,CAAC;KAChB;IAmBK,eAAe,CAAC,EACpB,aAAa,EACb,WAAW,EACX,QAAoB,GACrB,EAAE;QACD,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,uBAAuB,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,MAAM,CAAC;IAmDb,gBAAgB,CAAC,EACrB,cAAc,EACd,QAAoB,GACrB,EAAE;QACD,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;;;IAeK,uBAAuB,CAAC,EAC5B,SAAS,EACT,cAAc,GACf,EAAE;QACD,SAAS,EAAE,CAAC,iBAAiB,GAAG,mBAAmB,CAAC,EAAE,CAAC;QACvD,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;;;IASK,gBAAgB,CAAC,EACrB,UAAU,EACV,SAAS,EACT,wBAAwB,EACxB,QAAoB,EACpB,OAAO,GACR,EAAE;QACD,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,wBAAwB,EAAE,wBAAwB,CAAC;QACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;KAClC,GAAG,OAAO,CAAC;QACV,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,cAAc,GAAG,UAAU,GAAG,SAAS,CAAC;QACtD,uBAAuB,EAAE,cAAc,EAAE,CAAC;KAC3C,CAAC;IAqDI,aAAa;CAOpB"}

package/src/client/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const EVM_SIGN_MESSAGE_PREFIX = "\u0019Ethereum Signed Message:\n";
+export declare const ERROR_KEYGEN_FAILED = "Error with keygen";
+export declare const ERROR_CREATE_WALLET_ACCOUNT = "Error creating evm wallet account";
+export declare const ERROR_SIGN_MESSAGE = "Error signing message";
+export declare const ERROR_ACCOUNT_ADDRESS_REQUIRED = "Account address is required";
+export declare const ERROR_VERIFY_MESSAGE_SIGNATURE = "Error verifying message signature";
+//# 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;AAGxE,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,sCAAsC,CAAC;AAE/E,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAE1D,eAAO,MAAM,8BAA8B,gCAAgC,CAAC;AAE5E,eAAO,MAAM,8BAA8B,sCAAsC,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,10 @@
+import { EcdsaSignature, EcdsaPublicKey } from '@dynamic-labs-wallet/node';
+export declare const formatEVMMessage: (message: string) => string;
+export declare const serializeECDSASignature: (signature: EcdsaSignature) => `0x${string}`;
+export declare const deriveAccountAddress: ({ rawPublicKey, }: {
+    rawPublicKey: EcdsaPublicKey;
+}) => {
+    accountAddress: `0x${string}`;
+    publicKeyHex: any;
+};
+//# 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":"AAEA,OAAO,EACL,cAAc,EACd,cAAc,EAEf,MAAM,2BAA2B,CAAC;AAEnC,eAAO,MAAM,gBAAgB,YAAa,MAAM,WAE/C,CAAC;AAEF,eAAO,MAAM,uBAAuB,cAAe,cAAc,kBAMhE,CAAC;AAEF,eAAO,MAAM,oBAAoB,sBAE9B;IACD,YAAY,EAAE,cAAc,CAAC;CAC9B;;;CAQA,CAAC"}