@dynamic-labs-wallet/svm 0.0.0-preview.57 → 0.0.1

package/index.cjs.js

@@ -1,8 +1,8 @@
 'use strict';
 
 var browser = require('@dynamic-labs-wallet/browser');
-var bs58 = require('bs58');
 var web3_js = require('@solana/web3.js');
+var bs58 = require('bs58');
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -15,21 +15,18 @@ function _extends() {
     return _extends.apply(this, arguments);
 }
 
-const addSignatureToTransaction = ({ transaction, signature, signerPublicKey })=>{
-    transaction.addSignature(signerPublicKey, Buffer.from(signature));
-    return transaction;
-};
-
-const ERROR_CREATE_WALLET_ACCOUNT = 'Error creating svm wallet account';
-
 class DynamicSvmWalletClient extends browser.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 }) {
+   */ async createWalletAccount({ thresholdSignatureScheme, password = undefined, signedSessionId }) {
         try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
             const { rawPublicKey, clientKeyShares } = await this.keyGen({
                 chainName: this.chainName,
                 thresholdSignatureScheme,
@@ -42,42 +39,49 @@ class DynamicSvmWalletClient extends browser.DynamicWalletClient {
                         thresholdSignatureScheme,
                         clientKeySharesBackupInfo: browser.getClientKeyShareBackupInfo()
                     });
+                    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 (!clientKeyShares) {
-                throw new Error('Error creating wallet account');
+                throw new Error(browser.ERROR_KEYGEN_FAILED);
             }
             const { accountAddress } = await this.deriveAccountAddress(rawPublicKey);
             // Update client key shares in wallet map
-            // warning: this might result in race condition if `onCeremonyComplete` executes at the same time
-            // TODO: remove this once iframe handling for secret shares is implemented
             await this.setClientKeySharesToLocalStorage({
                 accountAddress,
                 clientKeyShares,
                 overwriteOrMerge: 'overwrite'
             });
-            // Backup the new wallet without waiting for the promise to resolve
-            void this.storeEncryptedBackupByWalletWithRetry({
+            await this.storeEncryptedBackupByWalletWithRetry({
                 accountAddress,
                 clientKeyShares,
-                password
+                password,
+                signedSessionId
             });
             return {
                 accountAddress,
-                rawPublicKey: rawPublicKey,
-                clientKeyShares
+                rawPublicKey
             };
         } catch (error) {
-            this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
-            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+            this.logger.error(browser.ERROR_CREATE_WALLET_ACCOUNT, error);
+            throw new Error(browser.ERROR_CREATE_WALLET_ACCOUNT);
         }
     }
-    // Function to properly derive account address
     async deriveAccountAddress(rawPublicKey) {
-        const accountAddress = bs58.encode(rawPublicKey);
+        const pubKeyBytes = typeof rawPublicKey === 'string' ? new Uint8Array(Buffer.from(rawPublicKey, 'hex')) : rawPublicKey;
+        const accountAddress = bs58.encode(pubKeyBytes);
         return {
             accountAddress
         };
@@ -88,62 +92,55 @@ class DynamicSvmWalletClient extends browser.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 }) {
+   */ async signMessage({ message, accountAddress, password = undefined, signedSessionId, mfaToken }) {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: browser.WalletOperation.SIGN_MESSAGE
+            walletOperation: browser.WalletOperation.SIGN_MESSAGE,
+            signedSessionId
         });
         if (!accountAddress) {
-            throw new Error('Account address is required');
+            throw new Error(browser.ERROR_ACCOUNT_ADDRESS_REQUIRED);
         }
         try {
             const signatureEd25519 = await this.sign({
                 message,
                 accountAddress: accountAddress,
                 chainName: this.chainName,
-                password
+                password,
+                signedSessionId,
+                mfaToken
             });
             const base58Signature = bs58.encode(signatureEd25519);
             return base58Signature;
         } catch (error) {
-            this.logger.error('Error signing message:', error);
-            throw error;
+            this.logger.error(browser.ERROR_SIGN_MESSAGE, error);
+            throw new Error(browser.ERROR_SIGN_MESSAGE);
         }
     }
-    async signTransaction({ senderAddress, transaction, password = undefined }) {
+    async signTransaction({ senderAddress, transaction, password = undefined, signedSessionId, mfaToken, chainId }) {
         await this.verifyPassword({
             accountAddress: senderAddress,
             password,
-            walletOperation: browser.WalletOperation.SIGN_TRANSACTION
+            walletOperation: browser.WalletOperation.SIGN_TRANSACTION,
+            signedSessionId
         });
         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
+            const base58SerializedTransaction = this.prepareTransactionForSigning(transaction);
+            const signParams = this.buildSignParams({
+                transaction,
+                senderAddress,
+                password,
+                signedSessionId,
+                mfaToken,
+                chainId,
+                base58SerializedTransaction
             });
+            const signatureEd25519 = await this.sign(signParams);
             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 Buffer.from(signatureEd25519).toString('hex');
         } catch (error) {
             this.logger.error('Error in signTransaction:', error);
             if (error instanceof Error) {
@@ -152,33 +149,59 @@ class DynamicSvmWalletClient extends browser.DynamicWalletClient {
             throw error;
         }
     }
+    prepareTransactionForSigning(transaction) {
+        const transactionBytes = new Uint8Array(Buffer.from(transaction, 'hex'));
+        const deserializedTransaction = web3_js.VersionedMessage.deserialize(transactionBytes);
+        const versionedTransaction = new web3_js.VersionedTransaction(deserializedTransaction);
+        const serializedTransaction = versionedTransaction.serialize();
+        return bs58.encode(serializedTransaction);
+    }
+    buildSignParams({ transaction, senderAddress, password, signedSessionId, mfaToken, chainId, base58SerializedTransaction }) {
+        const signParams = {
+            message: transaction,
+            accountAddress: senderAddress,
+            chainName: this.chainName,
+            password,
+            signedSessionId,
+            mfaToken
+        };
+        if (chainId !== undefined) {
+            signParams.context = {
+                svmTransaction: {
+                    chainId,
+                    method: 'signAndSendTransaction',
+                    serializedTransactions: [
+                        base58SerializedTransaction
+                    ]
+                }
+            };
+        }
+        return signParams;
+    }
     /**
    * 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, displayContainer, password = undefined }) {
+   */ async exportPrivateKey({ accountAddress, password = undefined, signedSessionId, mfaToken }) {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: browser.WalletOperation.EXPORT_PRIVATE_KEY
+            walletOperation: browser.WalletOperation.EXPORT_PRIVATE_KEY,
+            signedSessionId
         });
         const { derivedPrivateKey } = await this.exportKey({
             accountAddress,
             chainName: this.chainName,
             password,
-            displayContainer
+            signedSessionId,
+            mfaToken
         });
         if (!derivedPrivateKey) {
             throw new Error('Derived private key is undefined');
         }
-        const encodedPrivateKey = bs58.encode(Buffer.from(derivedPrivateKey));
-        // Display the private key in the container via iframe
-        const { iframeDisplay } = await this.initializeIframeDisplayForContainer({
-            container: displayContainer
-        });
-        iframeDisplay.displayPrivateKey(accountAddress, encodedPrivateKey);
+        return derivedPrivateKey;
     }
     /**
    * Exports the private key for a given account address
@@ -222,65 +245,89 @@ class DynamicSvmWalletClient extends browser.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 }) {
-        //get public key from private key
-        const publicKey = this.getPublicKeyFromPrivateKey(privateKey);
-        const formattedPrivateKey = await this.decodePrivateKeyForSolana(privateKey);
-        const { rawPublicKey, clientKeyShares } = 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,
-                    clientKeySharesBackupInfo: browser.getClientKeyShareBackupInfo()
-                });
+   */ async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, onError, signedSessionId }) {
+        try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            //get public key from private key
+            const publicKey = this.getPublicKeyFromPrivateKey(privateKey);
+            const formattedPrivateKey = this.decodePrivateKeyForSolana(privateKey);
+            const { rawPublicKey, clientKeyShares } = await this.importRawPrivateKey({
+                chainName,
+                privateKey: formattedPrivateKey,
+                thresholdSignatureScheme,
+                onError: (error)=>{
+                    this.logger.error(browser.ERROR_IMPORT_PRIVATE_KEY, error);
+                    onError == null ? void 0 : onError(error);
+                },
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
+                        accountAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        clientKeySharesBackupInfo: browser.getClientKeyShareBackupInfo()
+                    });
+                    this.logger.debug('walletMap updated for wallet', {
+                        context: {
+                            accountAddress,
+                            walletId,
+                            walletMap: this.walletMap
+                        }
+                    });
+                    ceremonyCeremonyCompleteResolver(undefined);
+                }
+            });
+            // Wait for the ceremony to complete before proceeding
+            await ceremonyCompletePromise;
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(browser.ERROR_IMPORT_PRIVATE_KEY);
             }
-        });
-        if (!rawPublicKey || !clientKeyShares) {
-            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}`);
+            const { accountAddress } = await this.deriveAccountAddress(rawPublicKey);
+            if (accountAddress !== publicKey) {
+                throw new Error(`Public key mismatch: derived address ${accountAddress} !== public key ${publicKey}`);
+            }
+            // Update client key shares in wallet map
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password,
+                signedSessionId
+            });
+            return {
+                accountAddress,
+                rawPublicKey: rawPublicKey
+            };
+        } catch (error) {
+            this.logger.error(browser.ERROR_IMPORT_PRIVATE_KEY, error);
+            throw new Error(browser.ERROR_IMPORT_PRIVATE_KEY);
         }
-        // Update client key shares in wallet map
-        // warning: this might result in race condition if `onCeremonyComplete` executes at the same time
-        // TODO: remove this once iframe handling for secret shares is implemented
-        await this.setClientKeySharesToLocalStorage({
-            accountAddress,
-            clientKeyShares,
-            overwriteOrMerge: 'overwrite'
-        });
-        // Backup the new wallet without waiting for the promise to resolve
-        void this.storeEncryptedBackupByWalletWithRetry({
-            accountAddress,
-            clientKeyShares,
-            password
-        });
-        return {
-            accountAddress,
-            rawPublicKey: rawPublicKey,
-            clientKeyShares
-        };
     }
     async getSvmWallets() {
         const wallets = await this.getWallets();
         const svmWallets = wallets.filter((wallet)=>wallet.chainName === 'solana');
         return svmWallets;
     }
-    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl }){
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, authMode = browser.AuthMode.HEADER, sdkVersion }){
         super({
             environmentId,
             authToken,
             baseApiUrl,
-            baseMPCRelayApiUrl
-        }), this.chainName = 'SOL';
+            baseMPCRelayApiUrl,
+            storageKey,
+            debug,
+            featureFlags,
+            authMode,
+            sdkVersion
+        }), this.chainName = 'SVM';
     }
 }
 

package/index.esm.js

@@ -1,6 +1,6 @@
-import { DynamicWalletClient, getClientKeyShareBackupInfo, WalletOperation } from '@dynamic-labs-wallet/browser';
+import { DynamicWalletClient, getClientKeyShareBackupInfo, ERROR_KEYGEN_FAILED, ERROR_CREATE_WALLET_ACCOUNT, WalletOperation, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_SIGN_MESSAGE, ERROR_IMPORT_PRIVATE_KEY, AuthMode } from '@dynamic-labs-wallet/browser';
+import { VersionedMessage, VersionedTransaction, Keypair } from '@solana/web3.js';
 import bs58 from 'bs58';
-import { VersionedTransaction, PublicKey, Keypair } from '@solana/web3.js';
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -13,21 +13,18 @@ function _extends() {
     return _extends.apply(this, arguments);
 }
 
-const addSignatureToTransaction = ({ transaction, signature, signerPublicKey })=>{
-    transaction.addSignature(signerPublicKey, Buffer.from(signature));
-    return transaction;
-};
-
-const ERROR_CREATE_WALLET_ACCOUNT = 'Error creating svm wallet account';
-
 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 }) {
+   */ async createWalletAccount({ thresholdSignatureScheme, password = undefined, signedSessionId }) {
         try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
             const { rawPublicKey, clientKeyShares } = await this.keyGen({
                 chainName: this.chainName,
                 thresholdSignatureScheme,
@@ -40,42 +37,49 @@ class DynamicSvmWalletClient extends DynamicWalletClient {
                         thresholdSignatureScheme,
                         clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
                     });
+                    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 (!clientKeyShares) {
-                throw new Error('Error creating wallet account');
+                throw new Error(ERROR_KEYGEN_FAILED);
             }
             const { accountAddress } = await this.deriveAccountAddress(rawPublicKey);
             // Update client key shares in wallet map
-            // warning: this might result in race condition if `onCeremonyComplete` executes at the same time
-            // TODO: remove this once iframe handling for secret shares is implemented
             await this.setClientKeySharesToLocalStorage({
                 accountAddress,
                 clientKeyShares,
                 overwriteOrMerge: 'overwrite'
             });
-            // Backup the new wallet without waiting for the promise to resolve
-            void this.storeEncryptedBackupByWalletWithRetry({
+            await this.storeEncryptedBackupByWalletWithRetry({
                 accountAddress,
                 clientKeyShares,
-                password
+                password,
+                signedSessionId
             });
             return {
                 accountAddress,
-                rawPublicKey: rawPublicKey,
-                clientKeyShares
+                rawPublicKey
             };
         } catch (error) {
             this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
             throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
         }
     }
-    // Function to properly derive account address
     async deriveAccountAddress(rawPublicKey) {
-        const accountAddress = bs58.encode(rawPublicKey);
+        const pubKeyBytes = typeof rawPublicKey === 'string' ? new Uint8Array(Buffer.from(rawPublicKey, 'hex')) : rawPublicKey;
+        const accountAddress = bs58.encode(pubKeyBytes);
         return {
             accountAddress
         };
@@ -86,62 +90,55 @@ class DynamicSvmWalletClient extends 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 }) {
+   */ async signMessage({ message, accountAddress, password = undefined, signedSessionId, mfaToken }) {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: WalletOperation.SIGN_MESSAGE
+            walletOperation: WalletOperation.SIGN_MESSAGE,
+            signedSessionId
         });
         if (!accountAddress) {
-            throw new Error('Account address is required');
+            throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
         }
         try {
             const signatureEd25519 = await this.sign({
                 message,
                 accountAddress: accountAddress,
                 chainName: this.chainName,
-                password
+                password,
+                signedSessionId,
+                mfaToken
             });
             const base58Signature = bs58.encode(signatureEd25519);
             return base58Signature;
         } catch (error) {
-            this.logger.error('Error signing message:', error);
-            throw error;
+            this.logger.error(ERROR_SIGN_MESSAGE, error);
+            throw new Error(ERROR_SIGN_MESSAGE);
         }
     }
-    async signTransaction({ senderAddress, transaction, password = undefined }) {
+    async signTransaction({ senderAddress, transaction, password = undefined, signedSessionId, mfaToken, chainId }) {
         await this.verifyPassword({
             accountAddress: senderAddress,
             password,
-            walletOperation: WalletOperation.SIGN_TRANSACTION
+            walletOperation: WalletOperation.SIGN_TRANSACTION,
+            signedSessionId
         });
         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
+            const base58SerializedTransaction = this.prepareTransactionForSigning(transaction);
+            const signParams = this.buildSignParams({
+                transaction,
+                senderAddress,
+                password,
+                signedSessionId,
+                mfaToken,
+                chainId,
+                base58SerializedTransaction
             });
+            const signatureEd25519 = await this.sign(signParams);
             if (!signatureEd25519) {
                 throw new Error('Signature is undefined');
             }
-            const senderPublicKey = new PublicKey(senderAddress);
-            const signedTransaction = addSignatureToTransaction({
-                transaction,
-                signature: signatureEd25519,
-                signerPublicKey: senderPublicKey
-            });
-            return signedTransaction;
+            return Buffer.from(signatureEd25519).toString('hex');
         } catch (error) {
             this.logger.error('Error in signTransaction:', error);
             if (error instanceof Error) {
@@ -150,33 +147,59 @@ class DynamicSvmWalletClient extends DynamicWalletClient {
             throw error;
         }
     }
+    prepareTransactionForSigning(transaction) {
+        const transactionBytes = new Uint8Array(Buffer.from(transaction, 'hex'));
+        const deserializedTransaction = VersionedMessage.deserialize(transactionBytes);
+        const versionedTransaction = new VersionedTransaction(deserializedTransaction);
+        const serializedTransaction = versionedTransaction.serialize();
+        return bs58.encode(serializedTransaction);
+    }
+    buildSignParams({ transaction, senderAddress, password, signedSessionId, mfaToken, chainId, base58SerializedTransaction }) {
+        const signParams = {
+            message: transaction,
+            accountAddress: senderAddress,
+            chainName: this.chainName,
+            password,
+            signedSessionId,
+            mfaToken
+        };
+        if (chainId !== undefined) {
+            signParams.context = {
+                svmTransaction: {
+                    chainId,
+                    method: 'signAndSendTransaction',
+                    serializedTransactions: [
+                        base58SerializedTransaction
+                    ]
+                }
+            };
+        }
+        return signParams;
+    }
     /**
    * 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, displayContainer, password = undefined }) {
+   */ async exportPrivateKey({ accountAddress, password = undefined, signedSessionId, mfaToken }) {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY
+            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY,
+            signedSessionId
         });
         const { derivedPrivateKey } = await this.exportKey({
             accountAddress,
             chainName: this.chainName,
             password,
-            displayContainer
+            signedSessionId,
+            mfaToken
         });
         if (!derivedPrivateKey) {
             throw new Error('Derived private key is undefined');
         }
-        const encodedPrivateKey = bs58.encode(Buffer.from(derivedPrivateKey));
-        // Display the private key in the container via iframe
-        const { iframeDisplay } = await this.initializeIframeDisplayForContainer({
-            container: displayContainer
-        });
-        iframeDisplay.displayPrivateKey(accountAddress, encodedPrivateKey);
+        return derivedPrivateKey;
     }
     /**
    * Exports the private key for a given account address
@@ -220,65 +243,89 @@ class DynamicSvmWalletClient extends 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 }) {
-        //get public key from private key
-        const publicKey = this.getPublicKeyFromPrivateKey(privateKey);
-        const formattedPrivateKey = await this.decodePrivateKeyForSolana(privateKey);
-        const { rawPublicKey, clientKeyShares } = 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,
-                    clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
-                });
+   */ async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, onError, signedSessionId }) {
+        try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            //get public key from private key
+            const publicKey = this.getPublicKeyFromPrivateKey(privateKey);
+            const formattedPrivateKey = this.decodePrivateKeyForSolana(privateKey);
+            const { rawPublicKey, clientKeyShares } = await this.importRawPrivateKey({
+                chainName,
+                privateKey: formattedPrivateKey,
+                thresholdSignatureScheme,
+                onError: (error)=>{
+                    this.logger.error(ERROR_IMPORT_PRIVATE_KEY, error);
+                    onError == null ? void 0 : onError(error);
+                },
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
+                        accountAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
+                    });
+                    this.logger.debug('walletMap updated for wallet', {
+                        context: {
+                            accountAddress,
+                            walletId,
+                            walletMap: this.walletMap
+                        }
+                    });
+                    ceremonyCeremonyCompleteResolver(undefined);
+                }
+            });
+            // Wait for the ceremony to complete before proceeding
+            await ceremonyCompletePromise;
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(ERROR_IMPORT_PRIVATE_KEY);
             }
-        });
-        if (!rawPublicKey || !clientKeyShares) {
-            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}`);
+            const { accountAddress } = await this.deriveAccountAddress(rawPublicKey);
+            if (accountAddress !== publicKey) {
+                throw new Error(`Public key mismatch: derived address ${accountAddress} !== public key ${publicKey}`);
+            }
+            // Update client key shares in wallet map
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password,
+                signedSessionId
+            });
+            return {
+                accountAddress,
+                rawPublicKey: rawPublicKey
+            };
+        } catch (error) {
+            this.logger.error(ERROR_IMPORT_PRIVATE_KEY, error);
+            throw new Error(ERROR_IMPORT_PRIVATE_KEY);
         }
-        // Update client key shares in wallet map
-        // warning: this might result in race condition if `onCeremonyComplete` executes at the same time
-        // TODO: remove this once iframe handling for secret shares is implemented
-        await this.setClientKeySharesToLocalStorage({
-            accountAddress,
-            clientKeyShares,
-            overwriteOrMerge: 'overwrite'
-        });
-        // Backup the new wallet without waiting for the promise to resolve
-        void this.storeEncryptedBackupByWalletWithRetry({
-            accountAddress,
-            clientKeyShares,
-            password
-        });
-        return {
-            accountAddress,
-            rawPublicKey: rawPublicKey,
-            clientKeyShares
-        };
     }
     async getSvmWallets() {
         const wallets = await this.getWallets();
         const svmWallets = wallets.filter((wallet)=>wallet.chainName === 'solana');
         return svmWallets;
     }
-    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl }){
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, authMode = AuthMode.HEADER, sdkVersion }){
         super({
             environmentId,
             authToken,
             baseApiUrl,
-            baseMPCRelayApiUrl
-        }), this.chainName = 'SOL';
+            baseMPCRelayApiUrl,
+            storageKey,
+            debug,
+            featureFlags,
+            authMode,
+            sdkVersion
+        }), this.chainName = 'SVM';
     }
 }
 

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@dynamic-labs-wallet/svm",
-  "version": "0.0.0-preview.57",
+  "version": "0.0.1",
   "license": "MIT",
+  "type": "commonjs",
   "dependencies": {
-    "@dynamic-labs-wallet/browser": "0.0.0-preview.57",
-    "@solana/web3.js": "^1.98.0",
+    "@dynamic-labs-wallet/browser": "0.0.1",
+    "@dynamic-labs/sdk-api-core": "^0.0.753",
+    "@solana/web3.js": "^1.98.2",
     "bs58": "^6.0.0"
   },
   "nx": {
@@ -15,7 +17,6 @@
       "build": {}
     }
   },
-  "type": "module",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",
   "types": "./index.esm.d.ts",
@@ -25,7 +26,7 @@
       "types": "./index.esm.d.ts",
       "import": "./index.esm.js",
       "require": "./index.cjs.js",
-      "default": "./index.cjs.js"
+      "default": "./index.esm.js"
     }
   }
 }

package/src/svm/{svm.d.ts → client.d.ts}

@@ -1,29 +1,23 @@
-import { ClientKeyShare, DynamicWalletClient, Ed25519KeygenResult, ThresholdSignatureScheme } from '@dynamic-labs-wallet/browser';
-import { Transaction, VersionedTransaction } from '@solana/web3.js';
+import { DynamicWalletClient, DynamicWalletClientProps, Ed25519KeygenResult, ThresholdSignatureScheme } from '@dynamic-labs-wallet/browser';
 export declare class DynamicSvmWalletClient extends DynamicWalletClient {
-    readonly chainName = "SOL";
+    readonly chainName = "SVM";
     accountAddress?: string;
-    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, }: {
-        environmentId: string;
-        authToken: string;
-        baseApiUrl?: string;
-        baseMPCRelayApiUrl?: string;
-    });
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, authMode, sdkVersion, }: DynamicWalletClientProps);
     /**
      * 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, }: {
+    createWalletAccount({ thresholdSignatureScheme, password, signedSessionId, }: {
         thresholdSignatureScheme: ThresholdSignatureScheme;
         password?: string;
+        signedSessionId: string;
     }): Promise<{
         accountAddress: string;
-        rawPublicKey: Uint8Array;
-        clientKeyShares: ClientKeyShare[];
+        rawPublicKey: Uint8Array | string;
     }>;
-    deriveAccountAddress(rawPublicKey: Uint8Array): Promise<{
+    deriveAccountAddress(rawPublicKey: string | Uint8Array): Promise<{
         accountAddress: string;
     }>;
     /**
@@ -33,16 +27,23 @@ export declare class DynamicSvmWalletClient extends DynamicWalletClient {
      * @param accountAddress Solana address (base58 encoded)
      * @param password The password for encrypted backup shares
      */
-    signMessage({ message, accountAddress, password, }: {
+    signMessage({ message, accountAddress, password, signedSessionId, mfaToken, }: {
         message: string;
         accountAddress: string;
         password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
     }): Promise<string>;
-    signTransaction({ senderAddress, transaction, password, }: {
+    signTransaction({ senderAddress, transaction, password, signedSessionId, mfaToken, chainId, }: {
         senderAddress: string;
-        transaction: VersionedTransaction | Transaction;
+        transaction: string;
         password?: string;
-    }): Promise<VersionedTransaction | Transaction>;
+        signedSessionId: string;
+        mfaToken?: string;
+        chainId?: string;
+    }): Promise<string>;
+    private prepareTransactionForSigning;
+    private buildSignParams;
     /**
      * Exports the private key for a given account address
      *
@@ -50,11 +51,12 @@ export declare class DynamicSvmWalletClient extends DynamicWalletClient {
      * @param password The password for encrypted backup shares
      * @returns The private key
      */
-    exportPrivateKey({ accountAddress, displayContainer, password, }: {
+    exportPrivateKey({ accountAddress, password, signedSessionId, mfaToken, }: {
         accountAddress: string;
-        displayContainer: HTMLElement;
         password?: string;
-    }): Promise<void>;
+        signedSessionId: string;
+        mfaToken?: string;
+    }): Promise<string>;
     /**
      * Exports the private key for a given account address
      *
@@ -85,17 +87,17 @@ export declare class DynamicSvmWalletClient extends DynamicWalletClient {
      * @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, }: {
+    importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password, onError, signedSessionId, }: {
         privateKey: string;
         chainName: string;
         thresholdSignatureScheme: ThresholdSignatureScheme;
         password?: string;
         onError?: (error: Error) => void;
+        signedSessionId: string;
     }): Promise<{
         accountAddress: string;
         rawPublicKey: Uint8Array | undefined;
-        clientKeyShares: ClientKeyShare[];
     }>;
     getSvmWallets(): Promise<any>;
 }
-//# sourceMappingURL=svm.d.ts.map
+//# sourceMappingURL=client.d.ts.map

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

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

package/src/svm/index.d.ts

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

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

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

package/src/svm/svm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"svm.d.ts","sourceRoot":"","sources":["../../src/svm/svm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,wBAAwB,EAGzB,MAAM,8BAA8B,CAAC;AAEtC,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,SAAS,EACT,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;IASD;;;;;OAKG;IACG,mBAAmB,CAAC,EACxB,wBAAwB,EACxB,QAAoB,GACrB,EAAE;QACD,wBAAwB,EAAE,wBAAwB,CAAC;QACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC;QACV,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,UAAU,CAAC;QACzB,eAAe,EAAE,cAAc,EAAE,CAAC;KACnC,CAAC;IA0DI,oBAAoB,CAAC,YAAY,EAAE,UAAU;;;IAOnD;;;;;;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;IA2BK,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,gBAAgB,EAChB,QAAoB,GACrB,EAAE;QACD,cAAc,EAAE,MAAM,CAAC;QACvB,gBAAgB,EAAE,WAAW,CAAC;QAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAyBD;;;;;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;IAI9C;;;;;;;;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,eAAe,EAAE,cAAc,EAAE,CAAC;KACnC,CAAC;IA6DI,aAAa;CAOpB"}