@dynamic-labs-wallet/evm 0.0.28

package/index.cjs.d.ts

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

package/index.cjs.js

@@ -0,0 +1,296 @@
+'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`;
+// 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)
+    });
+};
+
+class DynamicEvmWalletClient extends browser.DynamicWalletClient {
+    createViemPublicClient({ chain, rpcUrl }) {
+        return viem.createPublicClient({
+            chain,
+            transport: viem.http(rpcUrl)
+        });
+    }
+    async createWalletAccount({ thresholdSignatureScheme }) {
+        try {
+            // Generate key shares for given threshold signature scheme (TSS)
+            const { rawPublicKey, clientKeyShares } = await this.keyGen({
+                chainName: this.chainName,
+                thresholdSignatureScheme
+            });
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(ERROR_KEYGEN_FAILED);
+            }
+            // Get EVM address from public key
+            const { accountAddress, publicKeyHex } = await this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            // Refresh user to get the latest user data
+            const refreshedUser = await this.apiClient.refreshUser();
+            // Find the new wallet in the user's verified credentials
+            const newWallet = refreshedUser.user.verifiedCredentials.find((wallet)=>wallet.address.toLowerCase() === accountAddress.toLowerCase());
+            const newWalletId = newWallet.id;
+            // Store the new wallet in the wallet map
+            this.walletMap[accountAddress] = {
+                accountAddress,
+                walletId: newWalletId,
+                chainName: this.chainName,
+                clientKeyShares: clientKeyShares,
+                thresholdSignatureScheme
+            };
+            // Backup the new wallet
+            await this.storeEncryptedBackupByWallet({
+                accountAddress,
+                password: undefined
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex,
+                clientKeyShares
+            };
+        } catch (error) {
+            this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    async signMessage({ message, accountAddress }) {
+        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
+            });
+            // 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({ chain, senderAddress, toAddress, value, gas, maxFeePerGas, maxPriorityFeePerGas, rpcUrl, broadcastTxn = false }) {
+        const publicClient = this.createViemPublicClient({
+            chain,
+            rpcUrl
+        });
+        // Get the balance of the sender address
+        const balance = await publicClient.getBalance({
+            address: senderAddress
+        });
+        // Calculate total cost (gas * maxFeePerGas + value)
+        const totalCost = gas * maxFeePerGas + value;
+        if (balance < totalCost) {
+            throw new Error(`Insufficient funds. Required: ${totalCost}, Available: ${balance}`);
+        }
+        const walletClient = viem.createWalletClient({
+            chain,
+            transport: viem.http(rpcUrl),
+            account: senderAddress
+        });
+        const nonce = await publicClient.getTransactionCount({
+            address: senderAddress
+        });
+        const transactionRequest = {
+            to: toAddress,
+            value,
+            chainId: chain.id,
+            type: 'eip1559',
+            gas,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            nonce,
+            from: senderAddress,
+            accessList: []
+        };
+        const preparedTx = await walletClient.prepareTransactionRequest(transactionRequest);
+        // Get the transaction hash that needs to be signed
+        const unsignedTx = _extends({}, preparedTx, {
+            type: 'eip1559'
+        });
+        // Get the keccak256 hash of the transaction
+        const serializedTx = viem.serializeTransaction(unsignedTx);
+        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
+        });
+        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 = {
+                to: unsignedTx.to,
+                value: unsignedTx.value,
+                chainId: chain.id,
+                type: 'eip1559',
+                gas: unsignedTx.gas,
+                maxFeePerGas: unsignedTx.maxFeePerGas,
+                maxPriorityFeePerGas: unsignedTx.maxPriorityFeePerGas,
+                nonce: unsignedTx.nonce,
+                r: r,
+                s: s,
+                v: v
+            };
+            // Serialize the signed transaction
+            const serializedSignedTx = viem.serializeTransaction(signedTx);
+            let txHash;
+            // Send the raw transaction
+            if (broadcastTxn) {
+                const sentTxHash = await walletClient.sendRawTransaction({
+                    serializedTransaction: serializedSignedTx
+                });
+                this.logger.info('Transaction broadcasted! Hash:', sentTxHash);
+                txHash = sentTxHash;
+            }
+            return {
+                txHash,
+                signedTx: serializedSignedTx
+            };
+        } catch (error) {
+            this.logger.error('Error signing transaction:', error);
+            throw error;
+        }
+    }
+    async 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,
+            publicKeyHex
+        };
+    }
+    async exportPrivateKey({ accountAddress }) {
+        const { derivedPrivateKey } = await this.exportKey({
+            accountAddress,
+            chainName: this.chainName
+        });
+        return {
+            derivedPrivateKey
+        };
+    }
+    async offlineExportPrivateKey({ keyShares }) {
+        const { derivedPrivateKey } = await this.offlineExportKey({
+            chainName: this.chainName,
+            keyShares
+        });
+        return {
+            derivedPrivateKey
+        };
+    }
+    async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme }) {
+        // TODO: validate private key for EVM
+        const { rawPublicKey, clientKeyShares } = await this.importRawPrivateKey({
+            chainName,
+            privateKey,
+            thresholdSignatureScheme
+        });
+        if (!rawPublicKey || !clientKeyShares) {
+            throw new Error('Error creating wallet account');
+        }
+        const { accountAddress, publicKeyHex } = await this.deriveAccountAddress({
+            rawPublicKey: rawPublicKey
+        });
+        const refreshedUser = await this.apiClient.refreshUser();
+        const newWallet = refreshedUser.user.verifiedCredentials.find((wallet)=>wallet.address.toLowerCase() === accountAddress.toLowerCase());
+        const newWalletId = newWallet.id;
+        this.walletMap[accountAddress] = {
+            accountAddress,
+            walletId: newWalletId,
+            chainName: this.chainName,
+            clientKeyShares,
+            thresholdSignatureScheme
+        };
+        await this.storeEncryptedBackupByWallet({
+            accountAddress
+        });
+        return {
+            accountAddress,
+            rawPublicKey,
+            publicKeyHex,
+            clientKeyShares
+        };
+    }
+    async getEvmWallets() {
+        const wallets = await this.getWallets();
+        const evmWallets = wallets.filter((wallet)=>wallet.chainName === 'eip155');
+        return evmWallets;
+    }
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug }){
+        super({
+            environmentId,
+            authToken,
+            baseApiUrl,
+            baseMPCRelayApiUrl,
+            storageKey,
+            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,294 @@
+import { DynamicWalletClient, MessageHash } from '@dynamic-labs-wallet/browser';
+import { serializeSignature, createPublicClient, http, createWalletClient, 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)
+    });
+};
+
+class DynamicEvmWalletClient extends DynamicWalletClient {
+    createViemPublicClient({ chain, rpcUrl }) {
+        return createPublicClient({
+            chain,
+            transport: http(rpcUrl)
+        });
+    }
+    async createWalletAccount({ thresholdSignatureScheme }) {
+        try {
+            // Generate key shares for given threshold signature scheme (TSS)
+            const { rawPublicKey, clientKeyShares } = await this.keyGen({
+                chainName: this.chainName,
+                thresholdSignatureScheme
+            });
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(ERROR_KEYGEN_FAILED);
+            }
+            // Get EVM address from public key
+            const { accountAddress, publicKeyHex } = await this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            // Refresh user to get the latest user data
+            const refreshedUser = await this.apiClient.refreshUser();
+            // Find the new wallet in the user's verified credentials
+            const newWallet = refreshedUser.user.verifiedCredentials.find((wallet)=>wallet.address.toLowerCase() === accountAddress.toLowerCase());
+            const newWalletId = newWallet.id;
+            // Store the new wallet in the wallet map
+            this.walletMap[accountAddress] = {
+                accountAddress,
+                walletId: newWalletId,
+                chainName: this.chainName,
+                clientKeyShares: clientKeyShares,
+                thresholdSignatureScheme
+            };
+            // Backup the new wallet
+            await this.storeEncryptedBackupByWallet({
+                accountAddress,
+                password: undefined
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex,
+                clientKeyShares
+            };
+        } catch (error) {
+            this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    async signMessage({ message, accountAddress }) {
+        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
+            });
+            // 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({ chain, senderAddress, toAddress, value, gas, maxFeePerGas, maxPriorityFeePerGas, rpcUrl, broadcastTxn = false }) {
+        const publicClient = this.createViemPublicClient({
+            chain,
+            rpcUrl
+        });
+        // Get the balance of the sender address
+        const balance = await publicClient.getBalance({
+            address: senderAddress
+        });
+        // Calculate total cost (gas * maxFeePerGas + value)
+        const totalCost = gas * maxFeePerGas + value;
+        if (balance < totalCost) {
+            throw new Error(`Insufficient funds. Required: ${totalCost}, Available: ${balance}`);
+        }
+        const walletClient = createWalletClient({
+            chain,
+            transport: http(rpcUrl),
+            account: senderAddress
+        });
+        const nonce = await publicClient.getTransactionCount({
+            address: senderAddress
+        });
+        const transactionRequest = {
+            to: toAddress,
+            value,
+            chainId: chain.id,
+            type: 'eip1559',
+            gas,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            nonce,
+            from: senderAddress,
+            accessList: []
+        };
+        const preparedTx = await walletClient.prepareTransactionRequest(transactionRequest);
+        // Get the transaction hash that needs to be signed
+        const unsignedTx = _extends({}, preparedTx, {
+            type: 'eip1559'
+        });
+        // Get the keccak256 hash of the transaction
+        const serializedTx = serializeTransaction(unsignedTx);
+        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
+        });
+        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 = {
+                to: unsignedTx.to,
+                value: unsignedTx.value,
+                chainId: chain.id,
+                type: 'eip1559',
+                gas: unsignedTx.gas,
+                maxFeePerGas: unsignedTx.maxFeePerGas,
+                maxPriorityFeePerGas: unsignedTx.maxPriorityFeePerGas,
+                nonce: unsignedTx.nonce,
+                r: r,
+                s: s,
+                v: v
+            };
+            // Serialize the signed transaction
+            const serializedSignedTx = serializeTransaction(signedTx);
+            let txHash;
+            // Send the raw transaction
+            if (broadcastTxn) {
+                const sentTxHash = await walletClient.sendRawTransaction({
+                    serializedTransaction: serializedSignedTx
+                });
+                this.logger.info('Transaction broadcasted! Hash:', sentTxHash);
+                txHash = sentTxHash;
+            }
+            return {
+                txHash,
+                signedTx: serializedSignedTx
+            };
+        } catch (error) {
+            this.logger.error('Error signing transaction:', error);
+            throw error;
+        }
+    }
+    async 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,
+            publicKeyHex
+        };
+    }
+    async exportPrivateKey({ accountAddress }) {
+        const { derivedPrivateKey } = await this.exportKey({
+            accountAddress,
+            chainName: this.chainName
+        });
+        return {
+            derivedPrivateKey
+        };
+    }
+    async offlineExportPrivateKey({ keyShares }) {
+        const { derivedPrivateKey } = await this.offlineExportKey({
+            chainName: this.chainName,
+            keyShares
+        });
+        return {
+            derivedPrivateKey
+        };
+    }
+    async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme }) {
+        // TODO: validate private key for EVM
+        const { rawPublicKey, clientKeyShares } = await this.importRawPrivateKey({
+            chainName,
+            privateKey,
+            thresholdSignatureScheme
+        });
+        if (!rawPublicKey || !clientKeyShares) {
+            throw new Error('Error creating wallet account');
+        }
+        const { accountAddress, publicKeyHex } = await this.deriveAccountAddress({
+            rawPublicKey: rawPublicKey
+        });
+        const refreshedUser = await this.apiClient.refreshUser();
+        const newWallet = refreshedUser.user.verifiedCredentials.find((wallet)=>wallet.address.toLowerCase() === accountAddress.toLowerCase());
+        const newWalletId = newWallet.id;
+        this.walletMap[accountAddress] = {
+            accountAddress,
+            walletId: newWalletId,
+            chainName: this.chainName,
+            clientKeyShares,
+            thresholdSignatureScheme
+        };
+        await this.storeEncryptedBackupByWallet({
+            accountAddress
+        });
+        return {
+            accountAddress,
+            rawPublicKey,
+            publicKeyHex,
+            clientKeyShares
+        };
+    }
+    async getEvmWallets() {
+        const wallets = await this.getWallets();
+        const evmWallets = wallets.filter((wallet)=>wallet.chainName === 'eip155');
+        return evmWallets;
+    }
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug }){
+        super({
+            environmentId,
+            authToken,
+            baseApiUrl,
+            baseMPCRelayApiUrl,
+            storageKey,
+            debug
+        }), this.chainName = 'EVM';
+    }
+}
+
+export { DynamicEvmWalletClient };

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@dynamic-labs-wallet/evm",
+  "version": "0.0.28",
+  "dependencies": {
+    "@dynamic-labs-wallet/browser": "0.0.28"
+  },
+  "peerDependencies": {
+    "viem": "^2.22.1"
+  },
+  "nx": {
+    "sourceRoot": "packages/evm/src",
+    "projectType": "library",
+    "name": "evm",
+    "targets": {
+      "build": {}
+    }
+  },
+  "type": "module",
+  "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,69 @@
+import { ClientKeyShare, DynamicWalletClient, EcdsaKeygenResult, EcdsaPublicKey, Ed25519KeygenResult, ThresholdSignatureScheme, DynamicWalletClientProps } from '@dynamic-labs-wallet/browser';
+import { type PublicClient, type Chain, type SignableMessage } from 'viem';
+export declare class DynamicEvmWalletClient extends DynamicWalletClient {
+    readonly chainName = "EVM";
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, }: DynamicWalletClientProps);
+    createViemPublicClient({ chain, rpcUrl, }: {
+        chain: Chain;
+        rpcUrl?: string;
+    }): PublicClient;
+    createWalletAccount({ thresholdSignatureScheme, }: {
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | undefined;
+        clientKeyShares: ClientKeyShare[];
+    }>;
+    signMessage({ message, accountAddress, }: {
+        message: string;
+        accountAddress: string;
+    }): Promise<`0x${string}`>;
+    verifyMessageSignature({ accountAddress, message, signature, }: {
+        accountAddress: string;
+        message: SignableMessage;
+        signature: any;
+    }): Promise<boolean>;
+    signTransaction({ chain, senderAddress, toAddress, value, gas, maxFeePerGas, maxPriorityFeePerGas, rpcUrl, broadcastTxn, }: {
+        chain: Chain;
+        senderAddress: string;
+        toAddress: string;
+        value: bigint;
+        gas: bigint;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        rpcUrl?: string;
+        broadcastTxn?: boolean;
+    }): Promise<{
+        txHash?: string;
+        signedTx: string;
+    }>;
+    deriveAccountAddress({ rawPublicKey, }: {
+        rawPublicKey: EcdsaPublicKey;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: any;
+    }>;
+    exportPrivateKey({ accountAddress }: {
+        accountAddress: string;
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    offlineExportPrivateKey({ keyShares, }: {
+        keyShares: (EcdsaKeygenResult | Ed25519KeygenResult)[];
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, }: {
+        privateKey: string;
+        chainName: string;
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | undefined;
+        clientKeyShares: ClientKeyShare[];
+    }>;
+    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,EAEzB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,KAAK,EAEV,KAAK,eAAe,EACrB,MAAM,MAAM,CAAC;AAWd,qBAAa,sBAAuB,SAAQ,mBAAmB;IAC7D,QAAQ,CAAC,SAAS,SAAS;gBAEf,EACV,aAAa,EACb,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,UAAU,EACV,KAAK,GACN,EAAE,wBAAwB;IAW3B,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,GACzB,EAAE;QACD,wBAAwB,EAAE,wBAAwB,CAAC;KACpD,GAAG,OAAO,CAAC;QACV,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,cAAc,GAAG,UAAU,GAAG,SAAS,CAAC;QACtD,eAAe,EAAE,cAAc,EAAE,CAAC;KACnC,CAAC;IAqDI,WAAW,CAAC,EAChB,OAAO,EACP,cAAc,GACf,EAAE;QACD,OAAO,EAAE,MAAM,CAAC;QAChB,cAAc,EAAE,MAAM,CAAC;KACxB;IA0BK,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,KAAK,EACL,aAAa,EACb,SAAS,EACT,KAAK,EACL,GAAG,EACH,YAAY,EACZ,oBAAoB,EACpB,MAAM,EACN,YAAoB,GACrB,EAAE;QACD,KAAK,EAAE,KAAK,CAAC;QACb,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,YAAY,EAAE,MAAM,CAAC;QACrB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,OAAO,CAAC;KACxB,GAAG,OAAO,CAAC;QACV,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IAoHI,oBAAoB,CAAC,EACzB,YAAY,GACb,EAAE;QACD,YAAY,EAAE,cAAc,CAAC;KAC9B;;;;IAUK,gBAAgB,CAAC,EAAE,cAAc,EAAE,EAAE;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE;;;IAQ/D,uBAAuB,CAAC,EAC5B,SAAS,GACV,EAAE;QACD,SAAS,EAAE,CAAC,iBAAiB,GAAG,mBAAmB,CAAC,EAAE,CAAC;KACxD;;;IAQK,gBAAgB,CAAC,EACrB,UAAU,EACV,SAAS,EACT,wBAAwB,GACzB,EAAE;QACD,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,wBAAwB,EAAE,wBAAwB,CAAC;KACpD,GAAG,OAAO,CAAC;QACV,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,cAAc,GAAG,UAAU,GAAG,SAAS,CAAC;QACtD,eAAe,EAAE,cAAc,EAAE,CAAC;KACnC,CAAC;IAyCI,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,4 @@
+import { EcdsaSignature } from '@dynamic-labs-wallet/browser';
+export declare const formatEVMMessage: (message: string) => 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":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D,eAAO,MAAM,gBAAgB,YAAa,MAAM,WAE/C,CAAC;AAEF,eAAO,MAAM,uBAAuB,cAAe,cAAc,kBAMhE,CAAC"}