@dynamic-labs-wallet/node-svm 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,323 @@
+'use strict';
+
+var node = require('@dynamic-labs-wallet/node');
+var web3_js = require('@solana/web3.js');
+
+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 ERROR_CREATE_WALLET_ACCOUNT = 'Error creating svm wallet account';
+
+async function getBalance({ address, rpcUrl = node.SOLANA_RPC_URL }) {
+    const connection = new web3_js.Connection(rpcUrl != null ? rpcUrl : 'https://api.devnet.solana.com');
+    const balance = await connection.getBalance(new web3_js.PublicKey(address));
+    return balance;
+}
+async function createSolanaTransaction({ senderSolanaAddress, amount, to, rpcUrl = 'https://api.devnet.solana.com' }) {
+    const connection = new web3_js.Connection(rpcUrl != null ? rpcUrl : 'https://api.devnet.solana.com');
+    const balance = await getBalance({
+        address: senderSolanaAddress,
+        rpcUrl
+    });
+    if (balance < amount * 1e9) {
+        throw new Error('Insufficient balance');
+    }
+    const fromPubkey = new web3_js.PublicKey(senderSolanaAddress);
+    const transaction = new web3_js.Transaction().add(web3_js.SystemProgram.transfer({
+        fromPubkey: fromPubkey,
+        toPubkey: new web3_js.PublicKey(to),
+        lamports: amount * 1e9
+    }));
+    const { blockhash } = await connection.getLatestBlockhash();
+    transaction.recentBlockhash = blockhash;
+    transaction.feePayer = fromPubkey;
+    const serializedTransaction = transaction.serializeMessage();
+    return {
+        transaction,
+        serializedTransaction
+    };
+}
+const addSignatureToTransaction = ({ transaction, signature, signerPublicKey })=>{
+    transaction.addSignature(signerPublicKey, Buffer.from(signature));
+    return transaction;
+};
+async function sendTransaction({ signedTransaction, rpcUrl = 'https://api.devnet.solana.com' }) {
+    const connection = new web3_js.Connection(rpcUrl != null ? rpcUrl : 'https://api.devnet.solana.com');
+    const txid = await connection.sendRawTransaction(Buffer.from(signedTransaction));
+    return txid;
+}
+
+class DynamicSvmWalletClient extends node.DynamicWalletClient {
+    /**
+   * Creates a wallet account on the Solana chain
+   *
+   * @param thresholdSignatureScheme The threshold signature scheme to use
+   * @returns The account address, public key hex, raw public key, and client key shares
+   */ async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError }) {
+        try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            const { rawPublicKey, externalServerKeyShares } = await this.keyGen({
+                chainName: this.chainName,
+                thresholdSignatureScheme,
+                onError,
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
+                        accountAddress,
+                        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 || !(rawPublicKey instanceof Uint8Array)) {
+                throw new Error('Raw public key is not a Uint8Array');
+            }
+            if (!externalServerKeyShares) {
+                throw new Error('Error creating wallet account');
+            }
+            const { accountAddress } = await this.deriveAccountAddress(rawPublicKey);
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                externalServerKeyShares,
+                password
+            });
+            return {
+                accountAddress,
+                rawPublicKey: rawPublicKey,
+                externalServerKeyShares
+            };
+        } catch (error) {
+            this.logger.error('Error in createWalletAccount:', error);
+            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    // Function to properly derive account address
+    async deriveAccountAddress(rawPublicKey) {
+        const pubKey = new web3_js.PublicKey(rawPublicKey);
+        const fromKey = pubKey.toBase58();
+        const accountAddress = fromKey;
+        return {
+            accountAddress
+        };
+    }
+    /**
+   * This function takes a message and returns it after being signed with MPC
+   *
+   * @param message The message to sign (Uint8Array)
+   * @param accountAddress Solana address (base58 encoded)
+   * @param password The password for encrypted backup shares
+   */ async signMessage({ message, accountAddress, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: node.WalletOperation.SIGN_MESSAGE
+        });
+        if (!accountAddress) {
+            throw new Error('Account address is required');
+        }
+        try {
+            const signatureEd25519 = await this.sign({
+                message,
+                accountAddress: accountAddress,
+                chainName: this.chainName,
+                password
+            });
+            const base58Signature = new web3_js.PublicKey(signatureEd25519).toBase58();
+            return base58Signature;
+        } catch (error) {
+            this.logger.error('Error signing message:', error);
+            throw error;
+        }
+    }
+    async signTransaction({ senderAddress, transaction, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress: senderAddress,
+            password,
+            walletOperation: node.WalletOperation.SIGN_TRANSACTION
+        });
+        try {
+            let messageToSign;
+            if (transaction instanceof web3_js.VersionedTransaction) {
+                // For versioned transactions, we need to sign the message directly
+                const messageBytes = transaction.message.serialize();
+                messageToSign = Buffer.from(messageBytes).toString('hex');
+            } else {
+                // For legacy transactions, serialize the message
+                const messageBytes = transaction.serializeMessage();
+                messageToSign = Buffer.from(messageBytes).toString('hex');
+            }
+            const signatureEd25519 = await this.sign({
+                message: messageToSign,
+                accountAddress: senderAddress,
+                chainName: this.chainName,
+                password
+            });
+            if (!signatureEd25519) {
+                throw new Error('Signature is undefined');
+            }
+            const senderPublicKey = new web3_js.PublicKey(senderAddress);
+            const signedTransaction = addSignatureToTransaction({
+                transaction,
+                signature: signatureEd25519,
+                signerPublicKey: senderPublicKey
+            });
+            return signedTransaction;
+        } catch (error) {
+            this.logger.error('Error in signTransaction:', error);
+            if (error instanceof Error) {
+                this.logger.error('Error details:', error);
+            }
+            throw error;
+        }
+    }
+    /**
+   * Exports the private key for a given account address
+   *
+   * @param accountAddress The account address to export the private key for
+   * @param password The password for encrypted backup shares
+   * @returns The private key
+   */ async exportPrivateKey({ accountAddress, password = undefined }) {
+        const { derivedPrivateKey } = await this.exportKey({
+            accountAddress,
+            chainName: this.chainName,
+            password
+        });
+        if (!derivedPrivateKey) {
+            throw new Error('Derived private key is undefined');
+        }
+        const encodedPrivateKey = new web3_js.PublicKey(derivedPrivateKey).toBase58();
+        return {
+            derivedPrivateKey: encodedPrivateKey
+        };
+    }
+    /**
+   * Exports the private key for a given account address
+   *
+   * @param keyShares The key shares to export the private key for
+   * @returns The private key
+   */ async offlineExportPrivateKey({ keyShares, derivationPath }) {
+        const { derivedPrivateKey } = await this.offlineExportKey({
+            chainName: this.chainName,
+            keyShares,
+            derivationPath
+        });
+        return {
+            derivedPrivateKey
+        };
+    }
+    /**
+   * Converts the private key to a hex string
+   *
+   * @param privateKey The private key to convert
+   * @returns The hex string
+   */ decodePrivateKeyForSolana(privateKey) {
+        const decoded = new web3_js.PublicKey(privateKey).toBase58();
+        const slicedBytes = decoded.slice(0, 32);
+        return Buffer.from(slicedBytes).toString('hex');
+    }
+    getPublicKeyFromPrivateKey(privateKey) {
+        const privateKeyBytes = new web3_js.PublicKey(privateKey).toBase58();
+        const keypair = web3_js.Keypair.fromSecretKey(Buffer.from(privateKeyBytes));
+        const publicKeyBase58 = keypair.publicKey.toBase58();
+        return publicKeyBase58;
+    }
+    encodePublicKey(publicKey) {
+        const pubKey = new web3_js.PublicKey(publicKey);
+        const fromKey = pubKey.toBase58();
+        return fromKey;
+    }
+    /**
+   * Imports the private key for a given account address
+   *
+   * @param privateKey The private key to import
+   * @param chainName The chain name to import the private key for
+   * @param thresholdSignatureScheme The threshold signature scheme to use
+   * @param password The password for encrypted backup shares
+   * @returns The account address, raw public key, and client key shares
+   */ async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, onError }) {
+        let ceremonyCeremonyCompleteResolver;
+        const ceremonyCompletePromise = new Promise((resolve)=>{
+            ceremonyCeremonyCompleteResolver = resolve;
+        });
+        //get public key from private key
+        const publicKey = this.getPublicKeyFromPrivateKey(privateKey);
+        const formattedPrivateKey = await this.decodePrivateKeyForSolana(privateKey);
+        const { rawPublicKey, externalServerKeyShares } = await this.importRawPrivateKey({
+            chainName,
+            privateKey: formattedPrivateKey,
+            thresholdSignatureScheme,
+            onError,
+            onCeremonyComplete: (accountAddress, walletId)=>{
+                // update wallet map
+                this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
+                    accountAddress,
+                    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 } = await this.deriveAccountAddress(rawPublicKey);
+        if (accountAddress !== publicKey) {
+            throw new Error(`Public key mismatch: derived address ${accountAddress} !== public key ${publicKey}`);
+        }
+        await this.storeEncryptedBackupByWalletWithRetry({
+            accountAddress,
+            externalServerKeyShares,
+            password
+        });
+        return {
+            accountAddress,
+            rawPublicKey: rawPublicKey,
+            externalServerKeyShares
+        };
+    }
+    async getSvmWallets() {
+        const wallets = await this.getWallets();
+        const svmWallets = wallets.filter((wallet)=>wallet.chainName === 'solana');
+        return svmWallets;
+    }
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl }){
+        super({
+            environmentId,
+            baseApiUrl,
+            baseMPCRelayApiUrl
+        }), this.chainName = 'SVM';
+    }
+}
+
+exports.DynamicSvmWalletClient = DynamicSvmWalletClient;
+exports.addSignatureToTransaction = addSignatureToTransaction;
+exports.createSolanaTransaction = createSolanaTransaction;
+exports.getBalance = getBalance;
+exports.sendTransaction = sendTransaction;

package/index.esm.d.ts

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

package/index.esm.js

@@ -0,0 +1,317 @@
+import { SOLANA_RPC_URL, DynamicWalletClient, getExternalServerKeyShareBackupInfo, WalletOperation } from '@dynamic-labs-wallet/node';
+import { Connection, PublicKey, Transaction, SystemProgram, VersionedTransaction, Keypair } from '@solana/web3.js';
+
+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 ERROR_CREATE_WALLET_ACCOUNT = 'Error creating svm wallet account';
+
+async function getBalance({ address, rpcUrl = SOLANA_RPC_URL }) {
+    const connection = new Connection(rpcUrl != null ? rpcUrl : 'https://api.devnet.solana.com');
+    const balance = await connection.getBalance(new PublicKey(address));
+    return balance;
+}
+async function createSolanaTransaction({ senderSolanaAddress, amount, to, rpcUrl = 'https://api.devnet.solana.com' }) {
+    const connection = new Connection(rpcUrl != null ? rpcUrl : 'https://api.devnet.solana.com');
+    const balance = await getBalance({
+        address: senderSolanaAddress,
+        rpcUrl
+    });
+    if (balance < amount * 1e9) {
+        throw new Error('Insufficient balance');
+    }
+    const fromPubkey = new PublicKey(senderSolanaAddress);
+    const transaction = new Transaction().add(SystemProgram.transfer({
+        fromPubkey: fromPubkey,
+        toPubkey: new PublicKey(to),
+        lamports: amount * 1e9
+    }));
+    const { blockhash } = await connection.getLatestBlockhash();
+    transaction.recentBlockhash = blockhash;
+    transaction.feePayer = fromPubkey;
+    const serializedTransaction = transaction.serializeMessage();
+    return {
+        transaction,
+        serializedTransaction
+    };
+}
+const addSignatureToTransaction = ({ transaction, signature, signerPublicKey })=>{
+    transaction.addSignature(signerPublicKey, Buffer.from(signature));
+    return transaction;
+};
+async function sendTransaction({ signedTransaction, rpcUrl = 'https://api.devnet.solana.com' }) {
+    const connection = new Connection(rpcUrl != null ? rpcUrl : 'https://api.devnet.solana.com');
+    const txid = await connection.sendRawTransaction(Buffer.from(signedTransaction));
+    return txid;
+}
+
+class DynamicSvmWalletClient extends DynamicWalletClient {
+    /**
+   * Creates a wallet account on the Solana chain
+   *
+   * @param thresholdSignatureScheme The threshold signature scheme to use
+   * @returns The account address, public key hex, raw public key, and client key shares
+   */ async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError }) {
+        try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            const { rawPublicKey, externalServerKeyShares } = await this.keyGen({
+                chainName: this.chainName,
+                thresholdSignatureScheme,
+                onError,
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
+                        accountAddress,
+                        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 || !(rawPublicKey instanceof Uint8Array)) {
+                throw new Error('Raw public key is not a Uint8Array');
+            }
+            if (!externalServerKeyShares) {
+                throw new Error('Error creating wallet account');
+            }
+            const { accountAddress } = await this.deriveAccountAddress(rawPublicKey);
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                externalServerKeyShares,
+                password
+            });
+            return {
+                accountAddress,
+                rawPublicKey: rawPublicKey,
+                externalServerKeyShares
+            };
+        } catch (error) {
+            this.logger.error('Error in createWalletAccount:', error);
+            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    // Function to properly derive account address
+    async deriveAccountAddress(rawPublicKey) {
+        const pubKey = new PublicKey(rawPublicKey);
+        const fromKey = pubKey.toBase58();
+        const accountAddress = fromKey;
+        return {
+            accountAddress
+        };
+    }
+    /**
+   * This function takes a message and returns it after being signed with MPC
+   *
+   * @param message The message to sign (Uint8Array)
+   * @param accountAddress Solana address (base58 encoded)
+   * @param password The password for encrypted backup shares
+   */ async signMessage({ message, accountAddress, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_MESSAGE
+        });
+        if (!accountAddress) {
+            throw new Error('Account address is required');
+        }
+        try {
+            const signatureEd25519 = await this.sign({
+                message,
+                accountAddress: accountAddress,
+                chainName: this.chainName,
+                password
+            });
+            const base58Signature = new PublicKey(signatureEd25519).toBase58();
+            return base58Signature;
+        } catch (error) {
+            this.logger.error('Error signing message:', error);
+            throw error;
+        }
+    }
+    async signTransaction({ senderAddress, transaction, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress: senderAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_TRANSACTION
+        });
+        try {
+            let messageToSign;
+            if (transaction instanceof VersionedTransaction) {
+                // For versioned transactions, we need to sign the message directly
+                const messageBytes = transaction.message.serialize();
+                messageToSign = Buffer.from(messageBytes).toString('hex');
+            } else {
+                // For legacy transactions, serialize the message
+                const messageBytes = transaction.serializeMessage();
+                messageToSign = Buffer.from(messageBytes).toString('hex');
+            }
+            const signatureEd25519 = await this.sign({
+                message: messageToSign,
+                accountAddress: senderAddress,
+                chainName: this.chainName,
+                password
+            });
+            if (!signatureEd25519) {
+                throw new Error('Signature is undefined');
+            }
+            const senderPublicKey = new PublicKey(senderAddress);
+            const signedTransaction = addSignatureToTransaction({
+                transaction,
+                signature: signatureEd25519,
+                signerPublicKey: senderPublicKey
+            });
+            return signedTransaction;
+        } catch (error) {
+            this.logger.error('Error in signTransaction:', error);
+            if (error instanceof Error) {
+                this.logger.error('Error details:', error);
+            }
+            throw error;
+        }
+    }
+    /**
+   * Exports the private key for a given account address
+   *
+   * @param accountAddress The account address to export the private key for
+   * @param password The password for encrypted backup shares
+   * @returns The private key
+   */ async exportPrivateKey({ accountAddress, password = undefined }) {
+        const { derivedPrivateKey } = await this.exportKey({
+            accountAddress,
+            chainName: this.chainName,
+            password
+        });
+        if (!derivedPrivateKey) {
+            throw new Error('Derived private key is undefined');
+        }
+        const encodedPrivateKey = new PublicKey(derivedPrivateKey).toBase58();
+        return {
+            derivedPrivateKey: encodedPrivateKey
+        };
+    }
+    /**
+   * Exports the private key for a given account address
+   *
+   * @param keyShares The key shares to export the private key for
+   * @returns The private key
+   */ async offlineExportPrivateKey({ keyShares, derivationPath }) {
+        const { derivedPrivateKey } = await this.offlineExportKey({
+            chainName: this.chainName,
+            keyShares,
+            derivationPath
+        });
+        return {
+            derivedPrivateKey
+        };
+    }
+    /**
+   * Converts the private key to a hex string
+   *
+   * @param privateKey The private key to convert
+   * @returns The hex string
+   */ decodePrivateKeyForSolana(privateKey) {
+        const decoded = new PublicKey(privateKey).toBase58();
+        const slicedBytes = decoded.slice(0, 32);
+        return Buffer.from(slicedBytes).toString('hex');
+    }
+    getPublicKeyFromPrivateKey(privateKey) {
+        const privateKeyBytes = new PublicKey(privateKey).toBase58();
+        const keypair = Keypair.fromSecretKey(Buffer.from(privateKeyBytes));
+        const publicKeyBase58 = keypair.publicKey.toBase58();
+        return publicKeyBase58;
+    }
+    encodePublicKey(publicKey) {
+        const pubKey = new PublicKey(publicKey);
+        const fromKey = pubKey.toBase58();
+        return fromKey;
+    }
+    /**
+   * Imports the private key for a given account address
+   *
+   * @param privateKey The private key to import
+   * @param chainName The chain name to import the private key for
+   * @param thresholdSignatureScheme The threshold signature scheme to use
+   * @param password The password for encrypted backup shares
+   * @returns The account address, raw public key, and client key shares
+   */ async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, onError }) {
+        let ceremonyCeremonyCompleteResolver;
+        const ceremonyCompletePromise = new Promise((resolve)=>{
+            ceremonyCeremonyCompleteResolver = resolve;
+        });
+        //get public key from private key
+        const publicKey = this.getPublicKeyFromPrivateKey(privateKey);
+        const formattedPrivateKey = await this.decodePrivateKeyForSolana(privateKey);
+        const { rawPublicKey, externalServerKeyShares } = await this.importRawPrivateKey({
+            chainName,
+            privateKey: formattedPrivateKey,
+            thresholdSignatureScheme,
+            onError,
+            onCeremonyComplete: (accountAddress, walletId)=>{
+                // update wallet map
+                this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
+                    accountAddress,
+                    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 } = await this.deriveAccountAddress(rawPublicKey);
+        if (accountAddress !== publicKey) {
+            throw new Error(`Public key mismatch: derived address ${accountAddress} !== public key ${publicKey}`);
+        }
+        await this.storeEncryptedBackupByWalletWithRetry({
+            accountAddress,
+            externalServerKeyShares,
+            password
+        });
+        return {
+            accountAddress,
+            rawPublicKey: rawPublicKey,
+            externalServerKeyShares
+        };
+    }
+    async getSvmWallets() {
+        const wallets = await this.getWallets();
+        const svmWallets = wallets.filter((wallet)=>wallet.chainName === 'solana');
+        return svmWallets;
+    }
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl }){
+        super({
+            environmentId,
+            baseApiUrl,
+            baseMPCRelayApiUrl
+        }), this.chainName = 'SVM';
+    }
+}
+
+export { DynamicSvmWalletClient, addSignatureToTransaction, createSolanaTransaction, getBalance, sendTransaction };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@dynamic-labs-wallet/node-svm",
+  "version": "0.0.0-beta-191.1",
+  "license": "MIT",
+  "dependencies": {
+    "@dynamic-labs-wallet/node": "0.0.0-beta-191.1",
+    "@solana/web3.js": "^1.98.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "sourceRoot": "packages/node-svm/src",
+    "projectType": "library",
+    "name": "node-svm",
+    "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,103 @@
+import { ServerKeyShare, DynamicWalletClient, Ed25519KeygenResult, ThresholdSignatureScheme } from '@dynamic-labs-wallet/node';
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
+export declare class DynamicSvmWalletClient extends DynamicWalletClient {
+    readonly chainName = "SVM";
+    accountAddress?: string;
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, }: {
+        environmentId: string;
+        authToken: string;
+        baseApiUrl?: string;
+        baseMPCRelayApiUrl?: string;
+    });
+    /**
+     * Creates a wallet account on the Solana chain
+     *
+     * @param thresholdSignatureScheme The threshold signature scheme to use
+     * @returns The account address, public key hex, raw public key, and client key shares
+     */
+    createWalletAccount({ thresholdSignatureScheme, password, onError, }: {
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+    }): Promise<{
+        accountAddress: string;
+        rawPublicKey: Uint8Array;
+        externalServerKeyShares: ServerKeyShare[];
+    }>;
+    deriveAccountAddress(rawPublicKey: Uint8Array): Promise<{
+        accountAddress: string;
+    }>;
+    /**
+     * This function takes a message and returns it after being signed with MPC
+     *
+     * @param message The message to sign (Uint8Array)
+     * @param accountAddress Solana address (base58 encoded)
+     * @param password The password for encrypted backup shares
+     */
+    signMessage({ message, accountAddress, password, }: {
+        message: string;
+        accountAddress: string;
+        password?: string;
+    }): Promise<string>;
+    signTransaction({ senderAddress, transaction, password, }: {
+        senderAddress: string;
+        transaction: VersionedTransaction | Transaction;
+        password?: string;
+    }): Promise<VersionedTransaction | Transaction>;
+    /**
+     * Exports the private key for a given account address
+     *
+     * @param accountAddress The account address to export the private key for
+     * @param password The password for encrypted backup shares
+     * @returns The private key
+     */
+    exportPrivateKey({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string;
+    }): Promise<{
+        derivedPrivateKey: string;
+    }>;
+    /**
+     * Exports the private key for a given account address
+     *
+     * @param keyShares The key shares to export the private key for
+     * @returns The private key
+     */
+    offlineExportPrivateKey({ keyShares, derivationPath, }: {
+        keyShares: Ed25519KeygenResult[];
+        derivationPath?: string;
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    /**
+     * Converts the private key to a hex string
+     *
+     * @param privateKey The private key to convert
+     * @returns The hex string
+     */
+    decodePrivateKeyForSolana(privateKey: string): string;
+    getPublicKeyFromPrivateKey(privateKey: string): string;
+    encodePublicKey(publicKey: Uint8Array): string;
+    /**
+     * Imports the private key for a given account address
+     *
+     * @param privateKey The private key to import
+     * @param chainName The chain name to import the private key for
+     * @param thresholdSignatureScheme The threshold signature scheme to use
+     * @param password The password for encrypted backup shares
+     * @returns The account address, raw public key, and client key shares
+     */
+    importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password, onError, }: {
+        privateKey: string;
+        chainName: string;
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+    }): Promise<{
+        accountAddress: string;
+        rawPublicKey: Uint8Array | undefined;
+        externalServerKeyShares: ServerKeyShare[];
+    }>;
+    getSvmWallets(): 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,mBAAmB,EACnB,wBAAwB,EAGzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEL,WAAW,EACX,oBAAoB,EAErB,MAAM,iBAAiB,CAAC;AAIzB,qBAAa,sBAAuB,SAAQ,mBAAmB;IAC7D,QAAQ,CAAC,SAAS,SAAS;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;gBAEZ,EACV,aAAa,EACb,UAAU,EACV,kBAAkB,GACnB,EAAE;QACD,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,kBAAkB,CAAC,EAAE,MAAM,CAAC;KAC7B;IAQD;;;;;OAKG;IACG,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,UAAU,CAAC;QACzB,uBAAuB,EAAE,cAAc,EAAE,CAAC;KAC3C,CAAC;IAkEI,oBAAoB,CAAC,YAAY,EAAE,UAAU;;;IASnD;;;;;;OAMG;IACG,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;IA4BK,eAAe,CAAC,EACpB,aAAa,EACb,WAAW,EACX,QAAoB,GACrB,EAAE;QACD,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,oBAAoB,GAAG,WAAW,CAAC;QAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,oBAAoB,GAAG,WAAW,CAAC;IAgD/C;;;;;;OAMG;IACG,gBAAgB,CAAC,EACrB,cAAc,EACd,QAAoB,GACrB,EAAE;QACD,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;;;IAaD;;;;;OAKG;IACG,uBAAuB,CAAC,EAC5B,SAAS,EACT,cAAc,GACf,EAAE;QACD,SAAS,EAAE,mBAAmB,EAAE,CAAC;QACjC,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;;;IASD;;;;;OAKG;IACH,yBAAyB,CAAC,UAAU,EAAE,MAAM;IAM5C,0BAA0B,CAAC,UAAU,EAAE,MAAM;IAQ7C,eAAe,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM;IAM9C;;;;;;;;OAQG;IACG,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,UAAU,GAAG,SAAS,CAAC;QACrC,uBAAuB,EAAE,cAAc,EAAE,CAAC;KAC3C,CAAC;IA8DI,aAAa;CAOpB"}

package/src/client/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const ERROR_CREATE_WALLET_ACCOUNT = "Error creating svm wallet account";
+//# 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,2BAA2B,sCAAsC,CAAC"}

package/src/client/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './utils';
+//# 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;AACzB,cAAc,SAAS,CAAC"}

package/src/client/utils.d.ts

@@ -0,0 +1,24 @@
+import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
+export declare function getBalance({ address, rpcUrl, }: {
+    address: string;
+    rpcUrl?: string;
+}): Promise<number>;
+export declare function createSolanaTransaction({ senderSolanaAddress, amount, to, rpcUrl, }: {
+    senderSolanaAddress: string;
+    amount: number;
+    to: string;
+    rpcUrl?: string;
+}): Promise<{
+    transaction: Transaction;
+    serializedTransaction: Buffer;
+}>;
+export declare const addSignatureToTransaction: ({ transaction, signature, signerPublicKey, }: {
+    transaction: Transaction | VersionedTransaction;
+    signature: Uint8Array;
+    signerPublicKey: PublicKey;
+}) => VersionedTransaction | Transaction;
+export declare function sendTransaction({ signedTransaction, rpcUrl, }: {
+    signedTransaction: Uint8Array;
+    rpcUrl?: string;
+}): Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/client/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,SAAS,EAET,WAAW,EACX,oBAAoB,EACrB,MAAM,iBAAiB,CAAC;AAEzB,wBAAsB,UAAU,CAAC,EAC/B,OAAO,EACP,MAAuB,GACxB,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,mBAIA;AAED,wBAAsB,uBAAuB,CAAC,EAC5C,mBAAmB,EACnB,MAAM,EACN,EAAE,EACF,MAAwC,GACzC,EAAE;IACD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;;;GAwBA;AAED,eAAO,MAAM,yBAAyB,iDAInC;IACD,WAAW,EAAE,WAAW,GAAG,oBAAoB,CAAC;IAChD,SAAS,EAAE,UAAU,CAAC;IACtB,eAAe,EAAE,SAAS,CAAC;CAC5B,KAAG,oBAAoB,GAAG,WAG1B,CAAC;AAEF,wBAAsB,eAAe,CAAC,EACpC,iBAAiB,EACjB,MAAwC,GACzC,EAAE;IACD,iBAAiB,EAAE,UAAU,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,mBAMA"}

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client/index';
+//# 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,gBAAgB,CAAC"}