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

package/index.cjs.js

@@ -1,9 +1,10 @@
 'use strict';
 
 var browser = require('@dynamic-labs-wallet/browser');
-var ed25519 = require('@mysten/sui/keypairs/ed25519');
 var cryptography = require('@mysten/sui/cryptography');
+var ed25519 = require('@mysten/sui/keypairs/ed25519');
 var verify = require('@mysten/sui/verify');
+var converter = require('bech32-converting');
 var bcs = require('@mysten/sui/bcs');
 var blake2b = require('@noble/hashes/blake2b');
 
@@ -18,11 +19,6 @@ function _extends() {
     return _extends.apply(this, arguments);
 }
 
-const ERROR_KEYGEN_FAILED = 'Error with keygen';
-const ERROR_CREATE_WALLET_ACCOUNT = 'Error creating sui wallet account';
-const ERROR_VERIFY_MESSAGE_SIGNATURE = 'Error verifying message signature';
-const ERROR_VERIFY_TRANSACTION_SIGNATURE = 'Error verifying transaction signature';
-
 const formatMessage = (message, intentScope)=>{
     if (intentScope === 'TransactionData') {
         const txBytes = Uint8Array.from(Buffer.from(message, 'hex'));
@@ -41,8 +37,12 @@ const formatMessage = (message, intentScope)=>{
 };
 
 class DynamicSuiWalletClient extends browser.DynamicWalletClient {
-    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError }) {
+    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError, signedSessionId }) {
         try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
             // Generate key shares for given threshold signature scheme (TSS)
             const { rawPublicKey, clientKeyShares } = await this.keyGen({
                 chainName: this.chainName,
@@ -57,37 +57,45 @@ class DynamicSuiWalletClient extends browser.DynamicWalletClient {
                         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(ERROR_KEYGEN_FAILED);
+                throw new Error(browser.ERROR_KEYGEN_FAILED);
             }
             const { accountAddress, publicKeyHex } = this.deriveAccountAddress({
                 rawPublicKey: 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,
-                publicKeyHex,
-                clientKeyShares
+                rawPublicKey: rawPublicKey,
+                publicKeyHex
             };
         } 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);
         }
     }
     async getRawPublicKeyFromClientKeyShares({ chainName, clientKeyShare }) {
@@ -103,22 +111,28 @@ class DynamicSuiWalletClient extends browser.DynamicWalletClient {
     /**
    * Format Ed25519 signature to string that satisfies Sui signature standard
    */ async formatSignature(signatureEd25519, accountAddress) {
-        // get public key from keyshare
-        // TODO: handle this more gracefully from the client key shares if possible
-        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
-            accountAddress
-        });
-        const rawPublicKey = await this.getRawPublicKeyFromClientKeyShares({
-            chainName: this.chainName,
-            clientKeyShare: clientKeyShares[0]
-        });
-        const suiPublicKey = new ed25519.Ed25519PublicKey(rawPublicKey);
-        const serializedSignature = cryptography.toSerializedSignature({
-            signature: signatureEd25519,
-            signatureScheme: 'ED25519',
-            publicKey: suiPublicKey
-        });
-        return serializedSignature;
+        try {
+            // get public key from keyshare
+            // TODO: handle this more gracefully from the client key shares if possible
+            const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            const rawPublicKey = await this.getRawPublicKeyFromClientKeyShares({
+                chainName: this.chainName,
+                clientKeyShare: clientKeyShares[0]
+            });
+            const rawPublicKeyBytes = Uint8Array.from(Buffer.from(rawPublicKey, 'hex'));
+            const suiPublicKey = new ed25519.Ed25519PublicKey(rawPublicKeyBytes);
+            const serializedSignature = cryptography.toSerializedSignature({
+                signature: signatureEd25519,
+                signatureScheme: 'ED25519',
+                publicKey: suiPublicKey
+            });
+            return serializedSignature;
+        } catch (error) {
+            this.logger.error('Error formatting signature:', error);
+            throw error;
+        }
     }
     async verifyMessageSignature({ message, signature, accountAddress }) {
         try {
@@ -126,29 +140,29 @@ class DynamicSuiWalletClient extends browser.DynamicWalletClient {
             const verifiedPublicKey = await verify.verifyPersonalMessageSignature(messageBytes, signature);
             const isVerified = verifiedPublicKey.toSuiAddress().toLowerCase() === accountAddress.toLowerCase();
             if (!isVerified) {
-                throw new Error(ERROR_VERIFY_MESSAGE_SIGNATURE);
+                throw new Error(browser.ERROR_VERIFY_MESSAGE_SIGNATURE);
             }
         } catch (error) {
             this.logger.error('Error verifying signature:', error);
             throw error;
         }
     }
-    async verifyTransactionSignature({ message, signature, accountAddress }) {
+    async verifyTransactionSignature({ transaction, signature, senderAddress }) {
         try {
-            const txBytes = Uint8Array.from(Buffer.from(message, 'hex'));
+            const txBytes = Uint8Array.from(Buffer.from(transaction, 'hex'));
             const verifiedPublicKey = await verify.verifyTransactionSignature(txBytes, signature);
-            const isVerified = verifiedPublicKey.toSuiAddress().toLowerCase() === accountAddress.toLowerCase();
+            const isVerified = verifiedPublicKey.toSuiAddress().toLowerCase() === senderAddress.toLowerCase();
             if (!isVerified) {
-                throw new Error(ERROR_VERIFY_TRANSACTION_SIGNATURE);
+                throw new Error(browser.ERROR_VERIFY_TRANSACTION_SIGNATURE);
             }
         } catch (error) {
             this.logger.error('Error verifying signature:', error);
             throw error;
         }
     }
-    async signMessage({ message, accountAddress, password = undefined }) {
+    async signMessage({ message, accountAddress, password = undefined, signedSessionId, mfaToken, onError }) {
         if (!accountAddress) {
-            throw new Error('Account address is required');
+            throw new Error(browser.ERROR_ACCOUNT_ADDRESS_REQUIRED);
         }
         try {
             const formattedMessage = formatMessage(message, 'PersonalMessage');
@@ -156,7 +170,13 @@ class DynamicSuiWalletClient extends browser.DynamicWalletClient {
                 message: formattedMessage,
                 accountAddress: accountAddress,
                 chainName: this.chainName,
-                password
+                password,
+                signedSessionId,
+                mfaToken,
+                context: {
+                    suiMessage: message
+                },
+                onError
             });
             const formattedSignature = await this.formatSignature(signatureEd25519, accountAddress);
             await this.verifyMessageSignature({
@@ -166,27 +186,36 @@ class DynamicSuiWalletClient extends browser.DynamicWalletClient {
             });
             return formattedSignature;
         } 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({ message, accountAddress, password = undefined }) {
-        if (!accountAddress) {
-            throw new Error('Account address is required');
+    async signTransaction({ transaction, senderAddress, password = undefined, signedSessionId, mfaToken, context, onError }) {
+        if (!senderAddress) {
+            throw new Error(browser.ERROR_ACCOUNT_ADDRESS_REQUIRED);
         }
         try {
-            const formattedMessage = formatMessage(message, 'TransactionData');
+            const formattedMessage = formatMessage(transaction, 'TransactionData');
             const signatureEd25519 = await this.sign({
                 message: formattedMessage,
-                accountAddress: accountAddress,
+                accountAddress: senderAddress,
                 chainName: this.chainName,
-                password
+                password,
+                signedSessionId,
+                mfaToken,
+                context: _extends({}, context, {
+                    suiTransaction: {
+                        chainId: '0x2',
+                        serializedTransaction: transaction
+                    }
+                }),
+                onError
             });
-            const formattedSignature = await this.formatSignature(signatureEd25519, accountAddress);
+            const formattedSignature = await this.formatSignature(signatureEd25519, senderAddress);
             await this.verifyTransactionSignature({
-                message,
+                transaction,
                 signature: formattedSignature,
-                accountAddress
+                senderAddress
             });
             return formattedSignature;
         } catch (error) {
@@ -195,26 +224,185 @@ class DynamicSuiWalletClient extends browser.DynamicWalletClient {
         }
     }
     deriveAccountAddress({ rawPublicKey }) {
-        const publicKey = new ed25519.Ed25519PublicKey(rawPublicKey);
+        const pubKeyBytes = Buffer.from(rawPublicKey, 'hex');
+        const publicKey = new ed25519.Ed25519PublicKey(pubKeyBytes);
         const accountAddress = publicKey.toSuiAddress();
         return {
             accountAddress,
-            publicKeyHex: Buffer.from(rawPublicKey).toString('hex')
+            publicKeyHex: rawPublicKey
         };
     }
+    /**
+   * Converts a Sui private key from Bech32 format to a 64-character hex string.
+   * The output is compatible with RFC8032 Ed25519 private key format.
+   *
+   * @param suiPrivateKey - The Sui private key in Bech32 format starting with "suiprivkey1"
+   * @returns An object containing the private key and the private key bytes
+   * @throws Error if the input is not a valid Sui private key format
+   */ convertSuiPrivateKey(suiPrivateKey) {
+        if (!suiPrivateKey.startsWith('suiprivkey1')) {
+            this.logger.debug('Sui private key not in Bech32 format');
+            return {
+                privateKey: suiPrivateKey,
+                privateKeyBytes: Buffer.from(suiPrivateKey, 'hex')
+            };
+        }
+        try {
+            const suiConverter = converter('suiprivkey');
+            const hexKey = suiConverter.toHex(suiPrivateKey);
+            let cleanHex = hexKey.startsWith('0x00') ? hexKey.slice(4) : hexKey.startsWith('0x') ? hexKey.slice(2) : hexKey;
+            if (cleanHex.length > 64) {
+                cleanHex = cleanHex.slice(cleanHex.length - 64);
+            }
+            if (cleanHex.length !== 64) {
+                throw new Error(`Invalid output: Expected 64 characters, got ${cleanHex.length}`);
+            }
+            return {
+                privateKey: cleanHex.toLowerCase(),
+                privateKeyBytes: Buffer.from(cleanHex, 'hex')
+            };
+        } catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to convert Sui private key: ${error.message}`);
+            }
+            throw new Error('Failed to convert Sui private key: Unknown error');
+        }
+    }
+    /**
+   * Gets the public key for a given private key
+   * @param privateKeyBytes A Buffer containing the Ed25519 private key bytes
+   * @returns The public key (Sui address) derived from the private key
+   */ getPublicKeyFromPrivateKey(privateKeyBytes) {
+        try {
+            const keypair = ed25519.Ed25519Keypair.fromSecretKey(privateKeyBytes);
+            const publicKey = keypair.getPublicKey();
+            const publicKeyBase58 = publicKey.toSuiAddress();
+            return publicKeyBase58;
+        } catch (error) {
+            this.logger.error('Unable to derive public key from private key. Check private key format', error instanceof Error ? error.message : 'Unknown error');
+            throw error;
+        }
+    }
+    /**
+   * Imports the private key for a given account address
+   *
+   * @param privateKey The private key to import, accepts both Bech32 and hex formats
+   * @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, signedSessionId, onError, publicAddressCheck }) {
+        try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            const { privateKey: formattedPrivateKey, privateKeyBytes } = await this.convertSuiPrivateKey(privateKey);
+            const publicKey = this.getPublicKeyFromPrivateKey(privateKeyBytes);
+            if (publicAddressCheck && publicKey !== publicAddressCheck) {
+                throw new Error(`Public address mismatch: derived address ${publicKey} !== public address ${publicAddressCheck}`);
+            }
+            const { rawPublicKey, clientKeyShares } = await this.importRawPrivateKey({
+                chainName,
+                privateKey: formattedPrivateKey,
+                thresholdSignatureScheme,
+                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);
+                },
+                onError
+            });
+            // Wait for the ceremony to complete before proceeding
+            await ceremonyCompletePromise;
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(browser.ERROR_IMPORT_PRIVATE_KEY);
+            }
+            const { accountAddress } = await this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            if (accountAddress !== publicKey) {
+                throw new Error(`Public key mismatch: derived address ${accountAddress} !== public key ${publicKey}`);
+            }
+            // Update client key shares in wallet map
+            // warning: this might result in race condition if `onCeremonyComplete` executes at the same time
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password,
+                signedSessionId
+            });
+            return {
+                accountAddress,
+                rawPublicKey: rawPublicKey,
+                clientKeyShares
+            };
+        } catch (error) {
+            this.logger.error(browser.ERROR_IMPORT_PRIVATE_KEY, error);
+            onError == null ? void 0 : onError(error);
+            throw new Error(browser.ERROR_IMPORT_PRIVATE_KEY);
+        }
+    }
+    /**
+   * 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 in hex format
+   */ async exportPrivateKey({ accountAddress, password = undefined, signedSessionId, mfaToken }) {
+        try {
+            const { derivedPrivateKey } = await this.exportKey({
+                accountAddress,
+                chainName: this.chainName,
+                password,
+                signedSessionId,
+                mfaToken
+            });
+            if (!derivedPrivateKey) {
+                throw new Error('Derived private key is undefined');
+            }
+            const privateScalarHex = derivedPrivateKey.slice(0, 64);
+            return privateScalarHex;
+        } catch (error) {
+            this.logger.error(browser.ERROR_EXPORT_PRIVATE_KEY, error);
+            throw new Error(browser.ERROR_EXPORT_PRIVATE_KEY);
+        }
+    }
     async getSuiWallets() {
         const wallets = await this.getWallets();
         const suiWallets = wallets.filter((wallet)=>wallet.chainName === 'sui');
         return suiWallets;
     }
-    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug }){
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, authMode = browser.AuthMode.HEADER, sdkVersion, forwardMPCClient }){
         super({
             environmentId,
             authToken,
             baseApiUrl,
             baseMPCRelayApiUrl,
             storageKey,
-            debug
+            debug,
+            featureFlags,
+            authMode,
+            sdkVersion,
+            forwardMPCClient
         }), this.chainName = 'SUI';
     }
 }

package/index.esm.js

@@ -1,7 +1,8 @@
-import { DynamicWalletClient, getClientKeyShareBackupInfo, getMPCChainConfig } from '@dynamic-labs-wallet/browser';
-import { Ed25519PublicKey } from '@mysten/sui/keypairs/ed25519';
+import { DynamicWalletClient, getClientKeyShareBackupInfo, ERROR_KEYGEN_FAILED, ERROR_CREATE_WALLET_ACCOUNT, getMPCChainConfig, ERROR_VERIFY_MESSAGE_SIGNATURE, ERROR_VERIFY_TRANSACTION_SIGNATURE, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_SIGN_MESSAGE, ERROR_IMPORT_PRIVATE_KEY, ERROR_EXPORT_PRIVATE_KEY, AuthMode } from '@dynamic-labs-wallet/browser';
 import { messageWithIntent, toSerializedSignature } from '@mysten/sui/cryptography';
+import { Ed25519PublicKey, Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { verifyPersonalMessageSignature, verifyTransactionSignature } from '@mysten/sui/verify';
+import converter from 'bech32-converting';
 import { bcs } from '@mysten/sui/bcs';
 import { blake2b } from '@noble/hashes/blake2b';
 
@@ -16,11 +17,6 @@ function _extends() {
     return _extends.apply(this, arguments);
 }
 
-const ERROR_KEYGEN_FAILED = 'Error with keygen';
-const ERROR_CREATE_WALLET_ACCOUNT = 'Error creating sui wallet account';
-const ERROR_VERIFY_MESSAGE_SIGNATURE = 'Error verifying message signature';
-const ERROR_VERIFY_TRANSACTION_SIGNATURE = 'Error verifying transaction signature';
-
 const formatMessage = (message, intentScope)=>{
     if (intentScope === 'TransactionData') {
         const txBytes = Uint8Array.from(Buffer.from(message, 'hex'));
@@ -39,8 +35,12 @@ const formatMessage = (message, intentScope)=>{
 };
 
 class DynamicSuiWalletClient extends DynamicWalletClient {
-    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError }) {
+    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError, signedSessionId }) {
         try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
             // Generate key shares for given threshold signature scheme (TSS)
             const { rawPublicKey, clientKeyShares } = await this.keyGen({
                 chainName: this.chainName,
@@ -55,8 +55,18 @@ class DynamicSuiWalletClient extends DynamicWalletClient {
                         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_KEYGEN_FAILED);
             }
@@ -65,23 +75,21 @@ class DynamicSuiWalletClient extends DynamicWalletClient {
             });
             // 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,
-                publicKeyHex,
-                clientKeyShares
+                rawPublicKey: rawPublicKey,
+                publicKeyHex
             };
         } catch (error) {
             this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
@@ -101,22 +109,28 @@ class DynamicSuiWalletClient extends DynamicWalletClient {
     /**
    * Format Ed25519 signature to string that satisfies Sui signature standard
    */ async formatSignature(signatureEd25519, accountAddress) {
-        // get public key from keyshare
-        // TODO: handle this more gracefully from the client key shares if possible
-        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
-            accountAddress
-        });
-        const rawPublicKey = await this.getRawPublicKeyFromClientKeyShares({
-            chainName: this.chainName,
-            clientKeyShare: clientKeyShares[0]
-        });
-        const suiPublicKey = new Ed25519PublicKey(rawPublicKey);
-        const serializedSignature = toSerializedSignature({
-            signature: signatureEd25519,
-            signatureScheme: 'ED25519',
-            publicKey: suiPublicKey
-        });
-        return serializedSignature;
+        try {
+            // get public key from keyshare
+            // TODO: handle this more gracefully from the client key shares if possible
+            const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            const rawPublicKey = await this.getRawPublicKeyFromClientKeyShares({
+                chainName: this.chainName,
+                clientKeyShare: clientKeyShares[0]
+            });
+            const rawPublicKeyBytes = Uint8Array.from(Buffer.from(rawPublicKey, 'hex'));
+            const suiPublicKey = new Ed25519PublicKey(rawPublicKeyBytes);
+            const serializedSignature = toSerializedSignature({
+                signature: signatureEd25519,
+                signatureScheme: 'ED25519',
+                publicKey: suiPublicKey
+            });
+            return serializedSignature;
+        } catch (error) {
+            this.logger.error('Error formatting signature:', error);
+            throw error;
+        }
     }
     async verifyMessageSignature({ message, signature, accountAddress }) {
         try {
@@ -131,11 +145,11 @@ class DynamicSuiWalletClient extends DynamicWalletClient {
             throw error;
         }
     }
-    async verifyTransactionSignature({ message, signature, accountAddress }) {
+    async verifyTransactionSignature({ transaction, signature, senderAddress }) {
         try {
-            const txBytes = Uint8Array.from(Buffer.from(message, 'hex'));
+            const txBytes = Uint8Array.from(Buffer.from(transaction, 'hex'));
             const verifiedPublicKey = await verifyTransactionSignature(txBytes, signature);
-            const isVerified = verifiedPublicKey.toSuiAddress().toLowerCase() === accountAddress.toLowerCase();
+            const isVerified = verifiedPublicKey.toSuiAddress().toLowerCase() === senderAddress.toLowerCase();
             if (!isVerified) {
                 throw new Error(ERROR_VERIFY_TRANSACTION_SIGNATURE);
             }
@@ -144,9 +158,9 @@ class DynamicSuiWalletClient extends DynamicWalletClient {
             throw error;
         }
     }
-    async signMessage({ message, accountAddress, password = undefined }) {
+    async signMessage({ message, accountAddress, password = undefined, signedSessionId, mfaToken, onError }) {
         if (!accountAddress) {
-            throw new Error('Account address is required');
+            throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
         }
         try {
             const formattedMessage = formatMessage(message, 'PersonalMessage');
@@ -154,7 +168,13 @@ class DynamicSuiWalletClient extends DynamicWalletClient {
                 message: formattedMessage,
                 accountAddress: accountAddress,
                 chainName: this.chainName,
-                password
+                password,
+                signedSessionId,
+                mfaToken,
+                context: {
+                    suiMessage: message
+                },
+                onError
             });
             const formattedSignature = await this.formatSignature(signatureEd25519, accountAddress);
             await this.verifyMessageSignature({
@@ -164,27 +184,36 @@ class DynamicSuiWalletClient extends DynamicWalletClient {
             });
             return formattedSignature;
         } 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({ message, accountAddress, password = undefined }) {
-        if (!accountAddress) {
-            throw new Error('Account address is required');
+    async signTransaction({ transaction, senderAddress, password = undefined, signedSessionId, mfaToken, context, onError }) {
+        if (!senderAddress) {
+            throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
         }
         try {
-            const formattedMessage = formatMessage(message, 'TransactionData');
+            const formattedMessage = formatMessage(transaction, 'TransactionData');
             const signatureEd25519 = await this.sign({
                 message: formattedMessage,
-                accountAddress: accountAddress,
+                accountAddress: senderAddress,
                 chainName: this.chainName,
-                password
+                password,
+                signedSessionId,
+                mfaToken,
+                context: _extends({}, context, {
+                    suiTransaction: {
+                        chainId: '0x2',
+                        serializedTransaction: transaction
+                    }
+                }),
+                onError
             });
-            const formattedSignature = await this.formatSignature(signatureEd25519, accountAddress);
+            const formattedSignature = await this.formatSignature(signatureEd25519, senderAddress);
             await this.verifyTransactionSignature({
-                message,
+                transaction,
                 signature: formattedSignature,
-                accountAddress
+                senderAddress
             });
             return formattedSignature;
         } catch (error) {
@@ -193,26 +222,185 @@ class DynamicSuiWalletClient extends DynamicWalletClient {
         }
     }
     deriveAccountAddress({ rawPublicKey }) {
-        const publicKey = new Ed25519PublicKey(rawPublicKey);
+        const pubKeyBytes = Buffer.from(rawPublicKey, 'hex');
+        const publicKey = new Ed25519PublicKey(pubKeyBytes);
         const accountAddress = publicKey.toSuiAddress();
         return {
             accountAddress,
-            publicKeyHex: Buffer.from(rawPublicKey).toString('hex')
+            publicKeyHex: rawPublicKey
         };
     }
+    /**
+   * Converts a Sui private key from Bech32 format to a 64-character hex string.
+   * The output is compatible with RFC8032 Ed25519 private key format.
+   *
+   * @param suiPrivateKey - The Sui private key in Bech32 format starting with "suiprivkey1"
+   * @returns An object containing the private key and the private key bytes
+   * @throws Error if the input is not a valid Sui private key format
+   */ convertSuiPrivateKey(suiPrivateKey) {
+        if (!suiPrivateKey.startsWith('suiprivkey1')) {
+            this.logger.debug('Sui private key not in Bech32 format');
+            return {
+                privateKey: suiPrivateKey,
+                privateKeyBytes: Buffer.from(suiPrivateKey, 'hex')
+            };
+        }
+        try {
+            const suiConverter = converter('suiprivkey');
+            const hexKey = suiConverter.toHex(suiPrivateKey);
+            let cleanHex = hexKey.startsWith('0x00') ? hexKey.slice(4) : hexKey.startsWith('0x') ? hexKey.slice(2) : hexKey;
+            if (cleanHex.length > 64) {
+                cleanHex = cleanHex.slice(cleanHex.length - 64);
+            }
+            if (cleanHex.length !== 64) {
+                throw new Error(`Invalid output: Expected 64 characters, got ${cleanHex.length}`);
+            }
+            return {
+                privateKey: cleanHex.toLowerCase(),
+                privateKeyBytes: Buffer.from(cleanHex, 'hex')
+            };
+        } catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to convert Sui private key: ${error.message}`);
+            }
+            throw new Error('Failed to convert Sui private key: Unknown error');
+        }
+    }
+    /**
+   * Gets the public key for a given private key
+   * @param privateKeyBytes A Buffer containing the Ed25519 private key bytes
+   * @returns The public key (Sui address) derived from the private key
+   */ getPublicKeyFromPrivateKey(privateKeyBytes) {
+        try {
+            const keypair = Ed25519Keypair.fromSecretKey(privateKeyBytes);
+            const publicKey = keypair.getPublicKey();
+            const publicKeyBase58 = publicKey.toSuiAddress();
+            return publicKeyBase58;
+        } catch (error) {
+            this.logger.error('Unable to derive public key from private key. Check private key format', error instanceof Error ? error.message : 'Unknown error');
+            throw error;
+        }
+    }
+    /**
+   * Imports the private key for a given account address
+   *
+   * @param privateKey The private key to import, accepts both Bech32 and hex formats
+   * @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, signedSessionId, onError, publicAddressCheck }) {
+        try {
+            let ceremonyCeremonyCompleteResolver;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            const { privateKey: formattedPrivateKey, privateKeyBytes } = await this.convertSuiPrivateKey(privateKey);
+            const publicKey = this.getPublicKeyFromPrivateKey(privateKeyBytes);
+            if (publicAddressCheck && publicKey !== publicAddressCheck) {
+                throw new Error(`Public address mismatch: derived address ${publicKey} !== public address ${publicAddressCheck}`);
+            }
+            const { rawPublicKey, clientKeyShares } = await this.importRawPrivateKey({
+                chainName,
+                privateKey: formattedPrivateKey,
+                thresholdSignatureScheme,
+                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);
+                },
+                onError
+            });
+            // Wait for the ceremony to complete before proceeding
+            await ceremonyCompletePromise;
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(ERROR_IMPORT_PRIVATE_KEY);
+            }
+            const { accountAddress } = await this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            if (accountAddress !== publicKey) {
+                throw new Error(`Public key mismatch: derived address ${accountAddress} !== public key ${publicKey}`);
+            }
+            // Update client key shares in wallet map
+            // warning: this might result in race condition if `onCeremonyComplete` executes at the same time
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password,
+                signedSessionId
+            });
+            return {
+                accountAddress,
+                rawPublicKey: rawPublicKey,
+                clientKeyShares
+            };
+        } catch (error) {
+            this.logger.error(ERROR_IMPORT_PRIVATE_KEY, error);
+            onError == null ? void 0 : onError(error);
+            throw new Error(ERROR_IMPORT_PRIVATE_KEY);
+        }
+    }
+    /**
+   * 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 in hex format
+   */ async exportPrivateKey({ accountAddress, password = undefined, signedSessionId, mfaToken }) {
+        try {
+            const { derivedPrivateKey } = await this.exportKey({
+                accountAddress,
+                chainName: this.chainName,
+                password,
+                signedSessionId,
+                mfaToken
+            });
+            if (!derivedPrivateKey) {
+                throw new Error('Derived private key is undefined');
+            }
+            const privateScalarHex = derivedPrivateKey.slice(0, 64);
+            return privateScalarHex;
+        } catch (error) {
+            this.logger.error(ERROR_EXPORT_PRIVATE_KEY, error);
+            throw new Error(ERROR_EXPORT_PRIVATE_KEY);
+        }
+    }
     async getSuiWallets() {
         const wallets = await this.getWallets();
         const suiWallets = wallets.filter((wallet)=>wallet.chainName === 'sui');
         return suiWallets;
     }
-    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug }){
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, authMode = AuthMode.HEADER, sdkVersion, forwardMPCClient }){
         super({
             environmentId,
             authToken,
             baseApiUrl,
             baseMPCRelayApiUrl,
             storageKey,
-            debug
+            debug,
+            featureFlags,
+            authMode,
+            sdkVersion,
+            forwardMPCClient
         }), this.chainName = 'SUI';
     }
 }

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@dynamic-labs-wallet/sui",
-  "version": "0.0.0-preview.160.0",
+  "version": "0.0.1-paolo.1",
   "license": "MIT",
+  "type": "module",
   "dependencies": {
-    "@dynamic-labs-wallet/browser": "0.0.0-preview.160.0",
+    "@dynamic-labs-wallet/browser": "0.0.1-paolo.1",
     "@mysten/sui": "1.26.0",
-    "@noble/hashes": "1.7.1"
+    "@noble/hashes": "1.7.1",
+    "bech32-converting": "^1.0.9",
+    "@dynamic-labs/sdk-api-core": "^0.0.801"
   },
   "publishConfig": {
     "access": "public"
@@ -27,7 +30,7 @@
       "types": "./index.esm.d.ts",
       "import": "./index.esm.js",
       "require": "./index.cjs.js",
-      "default": "./index.cjs.js"
+      "default": "./index.esm.js"
     }
   }
 }

package/src/client/client.d.ts

@@ -1,43 +1,104 @@
-import { ClientKeyShare, DynamicWalletClient, EcdsaPublicKey, ThresholdSignatureScheme, DynamicWalletClientProps } from '@dynamic-labs-wallet/browser';
+import { type ClientKeyShare, DynamicWalletClient, type DynamicWalletClientProps, type ThresholdSignatureScheme } from '@dynamic-labs-wallet/browser';
+import type { SignMessageContext } from '@dynamic-labs/sdk-api-core';
 export declare class DynamicSuiWalletClient extends DynamicWalletClient {
     readonly chainName = "SUI";
-    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, }: DynamicWalletClientProps);
-    createWalletAccount({ thresholdSignatureScheme, password, onError, }: {
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, authMode, sdkVersion, forwardMPCClient, }: DynamicWalletClientProps);
+    createWalletAccount({ thresholdSignatureScheme, password, onError, signedSessionId, }: {
         thresholdSignatureScheme: ThresholdSignatureScheme;
         password?: string;
         onError?: (error: Error) => void;
+        signedSessionId: string;
     }): Promise<{
         accountAddress: string;
         publicKeyHex: string;
-        rawPublicKey: EcdsaPublicKey | Uint8Array | undefined;
-        clientKeyShares: ClientKeyShare[];
+        rawPublicKey: string | undefined;
     }>;
     getRawPublicKeyFromClientKeyShares({ chainName, clientKeyShare, }: {
         chainName: string;
         clientKeyShare: ClientKeyShare;
-    }): Promise<any>;
+    }): Promise<string | import("#internal/core").EcdsaPublicKey | Uint8Array | undefined>;
     /**
      * Format Ed25519 signature to string that satisfies Sui signature standard
      */
     private formatSignature;
     private verifyMessageSignature;
     private verifyTransactionSignature;
-    signMessage({ message, accountAddress, password, }: {
+    signMessage({ message, accountAddress, password, signedSessionId, mfaToken, onError, }: {
         message: string;
         accountAddress: string;
         password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+        onError?: (error: Error) => void;
     }): Promise<string>;
-    signTransaction({ message, accountAddress, password, }: {
-        message: string;
-        accountAddress: string;
+    signTransaction({ transaction, senderAddress, password, signedSessionId, mfaToken, context, onError, }: {
+        transaction: string;
+        senderAddress: string;
         password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+        context?: SignMessageContext;
+        onError?: (error: Error) => void;
     }): Promise<string>;
     deriveAccountAddress({ rawPublicKey }: {
-        rawPublicKey: Uint8Array;
+        rawPublicKey: string;
     }): {
         accountAddress: string;
         publicKeyHex: string;
     };
+    /**
+     * Converts a Sui private key from Bech32 format to a 64-character hex string.
+     * The output is compatible with RFC8032 Ed25519 private key format.
+     *
+     * @param suiPrivateKey - The Sui private key in Bech32 format starting with "suiprivkey1"
+     * @returns An object containing the private key and the private key bytes
+     * @throws Error if the input is not a valid Sui private key format
+     */
+    convertSuiPrivateKey(suiPrivateKey: string): {
+        privateKey: string;
+        privateKeyBytes: Buffer;
+    };
+    /**
+     * Gets the public key for a given private key
+     * @param privateKeyBytes A Buffer containing the Ed25519 private key bytes
+     * @returns The public key (Sui address) derived from the private key
+     */
+    getPublicKeyFromPrivateKey(privateKeyBytes: Buffer): string;
+    /**
+     * Imports the private key for a given account address
+     *
+     * @param privateKey The private key to import, accepts both Bech32 and hex formats
+     * @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, signedSessionId, onError, publicAddressCheck, }: {
+        privateKey: string;
+        chainName: string;
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        signedSessionId: string;
+        onError?: (error: Error) => void;
+        publicAddressCheck?: string;
+    }): Promise<{
+        accountAddress: string;
+        rawPublicKey: string | undefined;
+        clientKeyShares: ClientKeyShare[];
+    }>;
+    /**
+     * 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 in hex format
+     */
+    exportPrivateKey({ accountAddress, password, signedSessionId, mfaToken, }: {
+        accountAddress: string;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+    }): Promise<string>;
     getSuiWallets(): Promise<any>;
 }
 //# sourceMappingURL=client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EAGzB,MAAM,8BAA8B,CAAC;AAetC,qBAAa,sBAAuB,SAAQ,mBAAmB;IAC7D,QAAQ,CAAC,SAAS,SAAS;gBAEf,EACV,aAAa,EACb,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,UAAU,EACV,KAAK,GACN,EAAE,wBAAwB;IAWrB,mBAAmB,CAAC,EACxB,wBAAwB,EACxB,QAAoB,EACpB,OAAO,GACR,EAAE;QACD,wBAAwB,EAAE,wBAAwB,CAAC;QACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;KAClC,GAAG,OAAO,CAAC;QACV,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,cAAc,GAAG,UAAU,GAAG,SAAS,CAAC;QACtD,eAAe,EAAE,cAAc,EAAE,CAAC;KACnC,CAAC;IAwDI,kCAAkC,CAAC,EACvC,SAAS,EACT,cAAc,GACf,EAAE;QACD,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,cAAc,CAAC;KAChC;IAYD;;OAEG;YACW,eAAe;YAyBf,sBAAsB;YA6BtB,0BAA0B;IA6BlC,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,GAAG,OAAO,CAAC,MAAM,CAAC;IAiCb,eAAe,CAAC,EACpB,OAAO,EACP,cAAc,EACd,QAAoB,GACrB,EAAE;QACD,OAAO,EAAE,MAAM,CAAC;QAChB,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,MAAM,CAAC;IAgCnB,oBAAoB,CAAC,EAAE,YAAY,EAAE,EAAE;QAAE,YAAY,EAAE,UAAU,CAAA;KAAE;;;;IAU7D,aAAa;CAOpB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"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"}

package/src/client/constants.d.ts

@@ -1,5 +1,7 @@
 export declare const ERROR_KEYGEN_FAILED = "Error with keygen";
 export declare const ERROR_CREATE_WALLET_ACCOUNT = "Error creating sui wallet account";
+export declare const ERROR_IMPORT_PRIVATE_KEY = "Error importing private key";
+export declare const ERROR_EXPORT_PRIVATE_KEY = "Error exporting private key";
 export declare const ERROR_SIGN_MESSAGE = "Error signing message";
 export declare const ERROR_ACCOUNT_ADDRESS_REQUIRED = "Account address is required";
 export declare const ERROR_VERIFY_MESSAGE_SIGNATURE = "Error verifying message signature";

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/client/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,sCAAsC,CAAC;AAE/E,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAE1D,eAAO,MAAM,8BAA8B,gCAAgC,CAAC;AAE5E,eAAO,MAAM,8BAA8B,sCACN,CAAC;AAEtC,eAAO,MAAM,kCAAkC,0CACN,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/client/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,sCAAsC,CAAC;AAE/E,eAAO,MAAM,wBAAwB,gCAAgC,CAAC;AAEtE,eAAO,MAAM,wBAAwB,gCAAgC,CAAC;AAEtE,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAE1D,eAAO,MAAM,8BAA8B,gCAAgC,CAAC;AAE5E,eAAO,MAAM,8BAA8B,sCACN,CAAC;AAEtC,eAAO,MAAM,kCAAkC,0CACN,CAAC"}

package/src/client/index.d.ts

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

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

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

package/src/index.d.ts

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

package/src/index.d.ts.map

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

package/src/utils.d.ts

@@ -1,3 +1,3 @@
-import { IntentScope } from '@mysten/sui/cryptography';
+import { type IntentScope } from '@mysten/sui/cryptography';
 export declare const formatMessage: (message: string, intentScope: IntentScope) => Uint8Array;
 //# sourceMappingURL=utils.d.ts.map

package/src/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../packages/src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAqB,MAAM,0BAA0B,CAAC;AAG1E,eAAO,MAAM,aAAa,YACf,MAAM,eACF,WAAW,KACvB,UAeF,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../packages/src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,0BAA0B,CAAC;AAG/E,eAAO,MAAM,aAAa,YACf,MAAM,eACF,WAAW,KACvB,UAeF,CAAC"}