@dynamic-labs-wallet/node-svm 0.0.0-preview.160.0 → 0.0.1-paolo-1

package/index.cjs.js

@@ -2,6 +2,9 @@
 
 var node = require('@dynamic-labs-wallet/node');
 var web3_js = require('@solana/web3.js');
+var logger$1 = require('@dynamic-labs/logger');
+var axios = require('axios');
+var core = require('@dynamic-labs-wallet/core');
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -16,95 +19,163 @@ function _extends() {
 
 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;
+// Base58 encoding/decoding (Bitcoin alphabet) without external dependencies
+// Implementation adapted from the reference algorithm; suitable for keys/signatures
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const ALPHABET_MAP = {};
+for(let i = 0; i < ALPHABET.length; i++)ALPHABET_MAP[ALPHABET[i]] = i;
+function encodeBase58(source) {
+    const bytes = source instanceof Uint8Array ? source : new Uint8Array(source);
+    if (bytes.length === 0) return '';
+    // Count leading zeros
+    let zeros = 0;
+    while(zeros < bytes.length && bytes[zeros] === 0)zeros++;
+    // Allocate enough space in big-endian base58 representation.
+    // log(256) / log(58), rounded up.
+    const size = (bytes.length - zeros) * 138 / 100 + 1 >>> 0;
+    const b58 = new Uint8Array(size);
+    let length = 0;
+    for(let i = zeros; i < bytes.length; i++){
+        let carry = bytes[i];
+        let j = 0;
+        for(let k = size - 1; (carry !== 0 || j < length) && k >= 0; k--, j++){
+            carry += 256 * b58[k] >>> 0;
+            b58[k] = carry % 58 >>> 0;
+            carry = carry / 58 >>> 0;
+        }
+        length = j;
+    }
+    // Skip leading zeros in base58 result
+    let it = size - length;
+    while(it < size && b58[it] === 0)it++;
+    // Translate the result into a string.
+    let str = '';
+    for(let i = 0; i < zeros; i++)str += '1';
+    for(; it < size; it++)str += ALPHABET[b58[it]];
+    return str;
 }
-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');
+function decodeBase58(str) {
+    if (str.length === 0) return new Uint8Array();
+    // Count leading zeros
+    let zeros = 0;
+    while(zeros < str.length && str[zeros] === '1')zeros++;
+    // Allocate enough space in big-endian base256 representation.
+    // log(58) / log(256), rounded up.
+    const size = (str.length - zeros) * 733 / 1000 + 1 >>> 0;
+    const b256 = new Uint8Array(size);
+    let length = 0;
+    for(let i = zeros; i < str.length; i++){
+        const value = ALPHABET_MAP[str[i]];
+        if (value === undefined) throw new Error('Invalid base58 character');
+        let carry = value;
+        let j = 0;
+        for(let k = size - 1; (carry !== 0 || j < length) && k >= 0; k--, j++){
+            carry += 58 * b256[k] >>> 0;
+            b256[k] = (carry & 0xff) >>> 0;
+            carry = carry >> 8 >>> 0;
+        }
+        length = j;
     }
-    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
-    };
+    // Skip leading zeros in b256
+    let it = size - length;
+    while(it < size && b256[it] === 0)it++;
+    const out = new Uint8Array(zeros + (size - it));
+    out.fill(0, 0, zeros);
+    let j = zeros;
+    while(it < size)out[j++] = b256[it++];
+    return out;
 }
-const addSignatureToTransaction = ({ transaction, signature, signerPublicKey })=>{
-    transaction.addSignature(signerPublicKey, Buffer.from(signature));
-    return transaction;
+
+const logger = new logger$1.Logger('DynamicWaasWalletClient');
+const logError = ({ message, error, context })=>{
+    if (error instanceof axios.AxiosError) {
+        core.handleAxiosError(error, message, context, logger);
+    }
+    logger.error('[DynamicWaasWalletClient] Error in node-svm client', {
+        error: error instanceof Error ? error.message : String(error),
+        context
+    });
 };
-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;
-}
 
+// Helper: normalize bytes to hex without triggering Buffer.from(string, encoding) overload
+const toHex = (bytes)=>(Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes)).toString('hex');
 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 }) {
+   */ async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError, backUpToClientShareService = false }) {
         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
+                    const chainConfig = node.getMPCChainConfig(this.chainName);
                     this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
                         accountAddress,
                         walletId,
                         chainName: this.chainName,
                         thresholdSignatureScheme,
+                        derivationPath: JSON.stringify(Object.fromEntries(chainConfig.derivationPath.map((value, index)=>[
+                                index,
+                                value
+                            ]))),
                         externalServerKeySharesBackupInfo: node.getExternalServerKeyShareBackupInfo()
                     });
+                    this.logger.debug('walletMap updated for wallet', {
+                        context: {
+                            accountAddress,
+                            walletId,
+                            walletMap: this.walletMap
+                        }
+                    });
+                    ceremonyCeremonyCompleteResolver(undefined);
                 }
             });
-            if (!rawPublicKey || !(rawPublicKey instanceof Uint8Array)) {
-                throw new Error('Raw public key is not a Uint8Array');
+            // Wait for the ceremony to complete before proceeding
+            await ceremonyCompletePromise;
+            if (!rawPublicKey || !(rawPublicKey instanceof Uint8Array || typeof rawPublicKey === 'string')) {
+                throw new Error('Raw public key is not a Uint8Array or string' + typeof rawPublicKey);
             }
             if (!externalServerKeyShares) {
                 throw new Error('Error creating wallet account');
             }
             const { accountAddress } = await this.deriveAccountAddress(rawPublicKey);
-            void this.storeEncryptedBackupByWalletWithRetry({
+            await this.storeEncryptedBackupByWalletWithRetry({
                 accountAddress,
                 externalServerKeyShares,
-                password
+                password,
+                backUpToClientShareService
             });
             return {
                 accountAddress,
-                rawPublicKey: rawPublicKey,
+                rawPublicKey,
                 externalServerKeyShares
             };
         } catch (error) {
-            this.logger.error('Error in createWalletAccount:', error);
+            logError({
+                message: ERROR_CREATE_WALLET_ACCOUNT,
+                error: error,
+                context: {}
+            });
             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;
+        function ensure32(u8) {
+            if (u8.length !== 32) throw new Error(`Invalid pubkey length: ${u8.length}`);
+            return u8;
+        }
+        const pubKeyBytes = typeof rawPublicKey === 'string' ? new Uint8Array(Buffer.from(rawPublicKey, 'hex')) : rawPublicKey;
+        const accountAddress = new web3_js.PublicKey(ensure32(pubKeyBytes)).toBase58();
         return {
             accountAddress
         };
@@ -115,67 +186,90 @@ class DynamicSvmWalletClient extends node.DynamicWalletClient {
    * @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
-        });
+   */ async signMessage({ message, accountAddress, password = undefined, externalServerKeyShares }) {
+        // Validate inputs early
         if (!accountAddress) {
             throw new Error('Account address is required');
         }
         try {
+            // Attempt to recover key shares from backup if not provided
+            await this.ensureKeySharesRecovered({
+                accountAddress,
+                password,
+                walletOperation: node.WalletOperation.SIGN_MESSAGE,
+                externalServerKeyShares,
+                errorMessage: 'External server key shares are required to sign a message. No backup shares available for recovery.'
+            });
+            const messageBytes = typeof message === 'string' ? new TextEncoder().encode(message) : message;
+            const messageHex = toHex(messageBytes);
             const signatureEd25519 = await this.sign({
-                message,
-                accountAddress: accountAddress,
+                message: messageHex,
+                accountAddress,
                 chainName: this.chainName,
-                password
+                password,
+                externalServerKeyShares
             });
-            const base58Signature = new web3_js.PublicKey(signatureEd25519).toBase58();
-            return base58Signature;
+            return encodeBase58(signatureEd25519);
         } catch (error) {
-            this.logger.error('Error signing message:', error);
+            logError({
+                message: 'Error signing message:',
+                error: error,
+                context: {
+                    accountAddress
+                }
+            });
             throw error;
         }
     }
-    async signTransaction({ senderAddress, transaction, password = undefined }) {
+    //todo:should txn just be a string?
+    async signTransaction({ senderAddress, transaction, password = undefined, externalServerKeyShares }) {
+        // Validate inputs early
+        if (!senderAddress) {
+            throw new Error('Sender address is required');
+        }
         await this.verifyPassword({
             accountAddress: senderAddress,
             password,
             walletOperation: node.WalletOperation.SIGN_TRANSACTION
         });
         try {
+            // Attempt to recover key shares from backup if not provided
+            await this.ensureKeySharesRecovered({
+                accountAddress: senderAddress,
+                password,
+                walletOperation: node.WalletOperation.SIGN_TRANSACTION,
+                externalServerKeyShares,
+                errorMessage: 'External server key shares are required to sign transaction. No backup shares available for recovery.'
+            });
             let messageToSign;
-            if (transaction instanceof web3_js.VersionedTransaction) {
-                // For versioned transactions, we need to sign the message directly
+            if (typeof transaction === 'string') {
+                messageToSign = transaction.startsWith('0x') ? transaction.slice(2) : transaction;
+            } else if (transaction instanceof web3_js.VersionedTransaction) {
                 const messageBytes = transaction.message.serialize();
-                messageToSign = Buffer.from(messageBytes).toString('hex');
+                messageToSign = toHex(messageBytes);
             } else {
-                // For legacy transactions, serialize the message
                 const messageBytes = transaction.serializeMessage();
-                messageToSign = Buffer.from(messageBytes).toString('hex');
+                messageToSign = toHex(Buffer.isBuffer(messageBytes) ? messageBytes : messageBytes);
             }
             const signatureEd25519 = await this.sign({
                 message: messageToSign,
                 accountAddress: senderAddress,
                 chainName: this.chainName,
-                password
+                password,
+                externalServerKeyShares
             });
             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;
+            return encodeBase58(signatureEd25519);
         } catch (error) {
-            this.logger.error('Error in signTransaction:', error);
-            if (error instanceof Error) {
-                this.logger.error('Error details:', error);
-            }
+            logError({
+                message: 'Error in signTransaction:',
+                error: error,
+                context: {
+                    senderAddress
+                }
+            });
             throw error;
         }
     }
@@ -185,19 +279,17 @@ class DynamicSvmWalletClient extends node.DynamicWalletClient {
    * @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 }) {
+   */ async exportPrivateKey({ accountAddress, password = undefined, externalServerKeyShares }) {
         const { derivedPrivateKey } = await this.exportKey({
             accountAddress,
             chainName: this.chainName,
-            password
+            password,
+            externalServerKeyShares
         });
         if (!derivedPrivateKey) {
             throw new Error('Derived private key is undefined');
         }
-        const encodedPrivateKey = new web3_js.PublicKey(derivedPrivateKey).toBase58();
-        return {
-            derivedPrivateKey: encodedPrivateKey
-        };
+        return derivedPrivateKey;
     }
     /**
    * Exports the private key for a given account address
@@ -220,20 +312,19 @@ class DynamicSvmWalletClient extends node.DynamicWalletClient {
    * @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');
+        const decoded = decodeBase58(privateKey); // 64 bytes
+        if (decoded.length !== 64) throw new Error('Invalid Solana secret key length');
+        return Buffer.from(decoded.slice(0, 32)).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;
+        const secret = decodeBase58(privateKey);
+        const keypair = web3_js.Keypair.fromSecretKey(secret);
+        return keypair.publicKey.toBase58();
     }
     encodePublicKey(publicKey) {
-        const pubKey = new web3_js.PublicKey(publicKey);
-        const fromKey = pubKey.toBase58();
-        return fromKey;
+        // Ensure a plain Uint8Array is passed to PublicKey
+        const bytes = publicKey instanceof Uint8Array ? publicKey : new Uint8Array(publicKey);
+        return new web3_js.PublicKey(bytes).toBase58();
     }
     /**
    * Imports the private key for a given account address
@@ -243,7 +334,11 @@ class DynamicSvmWalletClient extends node.DynamicWalletClient {
    * @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 }) {
+   */ async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, onError, backUpToClientShareService = false }) {
+        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);
@@ -254,15 +349,23 @@ class DynamicSvmWalletClient extends node.DynamicWalletClient {
             onError,
             onCeremonyComplete: (accountAddress, walletId)=>{
                 // update wallet map
+                const chainConfig = node.getMPCChainConfig(this.chainName);
                 this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
                     accountAddress,
                     walletId,
                     chainName: this.chainName,
                     thresholdSignatureScheme,
+                    derivationPath: JSON.stringify(Object.fromEntries(chainConfig.derivationPath.map((value, index)=>[
+                            index,
+                            value
+                        ]))),
                     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');
         }
@@ -270,11 +373,11 @@ class DynamicSvmWalletClient extends node.DynamicWalletClient {
         if (accountAddress !== publicKey) {
             throw new Error(`Public key mismatch: derived address ${accountAddress} !== public key ${publicKey}`);
         }
-        // Backup the new wallet without waiting for the promise to resolve
-        void this.storeEncryptedBackupByWalletWithRetry({
+        await this.storeEncryptedBackupByWalletWithRetry({
             accountAddress,
             externalServerKeyShares,
-            password
+            password,
+            backUpToClientShareService
         });
         return {
             accountAddress,
@@ -287,17 +390,222 @@ class DynamicSvmWalletClient extends node.DynamicWalletClient {
         const svmWallets = wallets.filter((wallet)=>wallet.chainName === 'solana');
         return svmWallets;
     }
-    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl }){
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, enableMPCAccelerator }){
         super({
             environmentId,
             baseApiUrl,
-            baseMPCRelayApiUrl
-        }), this.chainName = 'SOL';
+            baseMPCRelayApiUrl,
+            enableMPCAccelerator
+        }), this.chainName = 'SVM';
+    }
+}
+
+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;
+};
+function attachSignature({ transaction, signatureBase58, senderAddress }) {
+    const sigBytes = decodeBase58(signatureBase58);
+    const signerPubkey = new web3_js.PublicKey(senderAddress);
+    return addSignatureToTransaction({
+        transaction,
+        signature: sigBytes,
+        signerPublicKey: signerPubkey
+    });
 }
+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;
+}
+
+/**
+ * Creates a delegated SVM wallet client for functional operations
+ */ const createDelegatedSvmWalletClient = ({ environmentId, baseApiUrl, baseMPCRelayApiUrl, apiKey, debug = false })=>{
+    const baseClient = node.createDelegatedWalletClient({
+        environmentId,
+        baseApiUrl,
+        baseMPCRelayApiUrl,
+        apiKey,
+        debug
+    });
+    const svmClient = _extends({}, baseClient, {
+        chainName: 'SVM'
+    });
+    return svmClient;
+};
+/**
+ * Signs a message using delegated signing for SVM
+ */ const delegatedSignMessage = async (client, { walletId, walletApiKey, keyShare, message, isFormatted = false })=>{
+    try {
+        // Use the delegated sign message function from node package
+        const signatureEd25519 = await node.delegatedSignMessage(client, {
+            walletId,
+            walletApiKey,
+            keyShare,
+            message,
+            chainName: client.chainName,
+            isFormatted
+        });
+        // Use PublicKey to encode signature as base58 (SVM format)
+        const base58Signature = encodeBase58(signatureEd25519);
+        return base58Signature;
+    } catch (error) {
+        logError({
+            message: 'Error in delegatedSignMessage',
+            error: error,
+            context: {
+                walletId
+            }
+        });
+        throw error;
+    }
+};
+/**
+ * Signs a transaction using delegated signing for SVM
+ *
+ * @param client - The delegated SVM wallet client
+ * @param options - Signing options
+ * @param options.walletId - The wallet ID
+ * @param options.walletApiKey - The wallet API key
+ * @param options.keyShare - The server key share
+ * @param options.transaction - The transaction to sign (VersionedTransaction or Transaction)
+ * @param options.signerAddress - Optional. The address that should sign the transaction.
+ *                                 If not provided, defaults to the first signer (VersionedTransaction)
+ *                                 or fee payer (Transaction). Use this for gasless transactions where
+ *                                 a separate fee payer pays the fees.
+ *
+ * @returns The partially signed transaction with the signature attached for the specified signer
+ *
+ * @example
+ * // Standard transaction where sender is also fee payer
+ * const signedTx = await delegatedSignTransaction(client, {
+ *   walletId,
+ *   walletApiKey,
+ *   keyShare,
+ *   transaction,
+ * });
+ *
+ * @example
+ * // Gasless transaction with separate fee payer
+ * const transaction = new Transaction();
+ * transaction.feePayer = feePayerPublicKey; // Set the actual fee payer
+ * transaction.add(instruction); // Instruction that requires sender signature
+ *
+ * const signedTx = await delegatedSignTransaction(client, {
+ *   walletId,
+ *   walletApiKey,
+ *   keyShare,
+ *   transaction,
+ *   signerAddress: senderAddress, // Explicitly specify who signs
+ * });
+ *
+ */ const delegatedSignTransaction = async (client, { walletId, walletApiKey, keyShare, transaction, signerAddress })=>{
+    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(Array.from(messageBytes)).toString('hex');
+        } else {
+            // For legacy transactions, serialize the message
+            const messageBytes = transaction.serializeMessage();
+            messageToSign = messageBytes.toString('hex');
+        }
+        // Use the delegated sign message function from node package
+        const signatureEd25519 = await node.delegatedSignMessage(client, {
+            walletId,
+            walletApiKey,
+            keyShare,
+            message: messageToSign,
+            chainName: client.chainName,
+            isFormatted: false
+        });
+        if (!signatureEd25519) {
+            throw new Error('Signature is undefined');
+        }
+        const resolvedSignerAddress = signerAddress != null ? signerAddress : (()=>{
+            var _transaction_feePayer;
+            if (transaction instanceof web3_js.VersionedTransaction) {
+                var _signers_;
+                const signers = transaction.message.staticAccountKeys;
+                var _signers__toBase58;
+                return (_signers__toBase58 = (_signers_ = signers[0]) == null ? void 0 : _signers_.toBase58()) != null ? _signers__toBase58 : '';
+            }
+            var _transaction_feePayer_toBase58;
+            return (_transaction_feePayer_toBase58 = (_transaction_feePayer = transaction.feePayer) == null ? void 0 : _transaction_feePayer.toBase58()) != null ? _transaction_feePayer_toBase58 : '';
+        })();
+        if (!resolvedSignerAddress) {
+            throw new Error('Could not determine signer address. Provide signerAddress explicitly or ensure transaction has a fee payer.');
+        }
+        let signerPublicKey;
+        try {
+            signerPublicKey = new web3_js.PublicKey(resolvedSignerAddress);
+        } catch (error) {
+            throw new Error(`Invalid signer address: ${resolvedSignerAddress}. ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        const signedTransaction = addSignatureToTransaction({
+            transaction,
+            signature: signatureEd25519,
+            signerPublicKey
+        });
+        return signedTransaction;
+    } catch (error) {
+        logError({
+            message: 'Error in delegatedSignTransaction',
+            error: error,
+            context: {
+                walletId
+            }
+        });
+        throw error;
+    }
+};
+/**
+ * Revoke delegation - delegates to the node package
+ */ const revokeDelegation = async (client, params)=>{
+    return node.revokeDelegation(client, params);
+};
 
 exports.DynamicSvmWalletClient = DynamicSvmWalletClient;
+exports.ERROR_CREATE_WALLET_ACCOUNT = ERROR_CREATE_WALLET_ACCOUNT;
 exports.addSignatureToTransaction = addSignatureToTransaction;
+exports.attachSignature = attachSignature;
+exports.createDelegatedSvmWalletClient = createDelegatedSvmWalletClient;
 exports.createSolanaTransaction = createSolanaTransaction;
+exports.decodeBase58 = decodeBase58;
+exports.delegatedSignMessage = delegatedSignMessage;
+exports.delegatedSignTransaction = delegatedSignTransaction;
+exports.encodeBase58 = encodeBase58;
 exports.getBalance = getBalance;
+exports.revokeDelegation = revokeDelegation;
 exports.sendTransaction = sendTransaction;