@dynamic-labs-wallet/core 0.0.0-preview.112

package/index.esm.d.ts

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

package/index.esm.js

@@ -0,0 +1,686 @@
+import axios from 'axios';
+
+const DYNAMIC_AUTH_PROD_BASE_API_URL = 'https://app.dynamicauth.com';
+const DYNAMIC_AUTH_PREPROD_BASE_API_URL = 'https://app.dynamic-preprod.xyz';
+const DYNAMIC_CLIENT_RELAY_PROD_BASE_API_URL = 'https://app-dynamicauth-com-app-6e12fc400995.relay.evervault.app';
+const DYNAMIC_CLIENT_RELAY_PREPROD_BASE_API_URL = 'https://app-dynamic-preprod-xyz-app-32d15525a875.relay.evervault.app';
+const MPC_RELAY_PROD_API_URL = 'relay.dynamicauth.com';
+const MPC_RELAY_PREPROD_API_URL = 'relay.dynamic-preprod.xyz';
+const SOLANA_RPC_URL = 'https://api.devnet.solana.com';
+const chain = {
+    EVM: 'EVM',
+    SOL: 'SOL',
+    COSMOS: 'COSMOS',
+    BTC: 'BTC',
+    FLOW: 'FLOW',
+    SUI: 'SUI'
+};
+var WalletOperation = /*#__PURE__*/ function(WalletOperation) {
+    WalletOperation["REACH_THRESHOLD"] = "REACH_THRESHOLD";
+    WalletOperation["REACH_ALL_PARTIES"] = "REACH_ALL_PARTIES";
+    WalletOperation["SIGN_MESSAGE"] = "SIGN_MESSAGE";
+    WalletOperation["SIGN_TRANSACTION"] = "SIGN_TRANSACTION";
+    WalletOperation["REFRESH"] = "REFRESH";
+    WalletOperation["RESHARE"] = "RESHARE";
+    WalletOperation["EXPORT_PRIVATE_KEY"] = "EXPORT_PRIVATE_KEY";
+    WalletOperation["NO_OPERATION"] = "NO_OPERATION";
+    return WalletOperation;
+}({});
+var BackupLocation = /*#__PURE__*/ function(BackupLocation) {
+    BackupLocation["DYNAMIC"] = "dynamic";
+    BackupLocation["GOOGLE_DRIVE"] = "googleDrive";
+    BackupLocation["ICLOUD"] = "iCloud";
+    BackupLocation["USER"] = "user";
+    BackupLocation["EXTERNAL"] = "external";
+    return BackupLocation;
+}({});
+// TODO: replace with apiClient proxy and move this to apiClient when ready
+const IFRAME_DOMAIN_PREPROD = 'https://waas.dynamic-preprod.xyz';
+const IFRAME_DOMAIN_PROD = 'https://waas.dynamicauth.com';
+const ChainEnumToVerifiedCredentialName = {
+    BTC: 'bip122',
+    EVM: 'eip155',
+    FLOW: 'flow',
+    SOL: 'solana'
+};
+const VerifiedCredentialNameToChainEnum = {
+    bip122: 'BTC',
+    eip155: 'EVM',
+    solana: 'SOL'
+};
+
+var SigningAlgorithm = /*#__PURE__*/ function(SigningAlgorithm) {
+    SigningAlgorithm["ECDSA"] = "ECDSA";
+    SigningAlgorithm["ED25519"] = "ED25519";
+    SigningAlgorithm["BIP340"] = "BIP340";
+    return SigningAlgorithm;
+}({});
+const BITCOIN_DERIVATION_PATHS = {
+    LEGACY: [
+        44,
+        0,
+        0,
+        0,
+        0
+    ],
+    // m/49'/0'/0'/0/0  - SegWit (P2SH-P2WPKH)
+    NATIVE_SEGWIT: [
+        84,
+        0,
+        0,
+        0,
+        0
+    ],
+    // m/44'/0'/0'/0/0  - Legacy (P2PKH)
+    SEGWIT: [
+        49,
+        0,
+        0,
+        0,
+        0
+    ]
+};
+const MPC_CHAIN_CONFIG = {
+    EVM: {
+        // Uses secp256k1 ECDSA
+        derivationPath: [
+            44,
+            60,
+            0,
+            0,
+            0
+        ],
+        signingAlgorithm: "ECDSA"
+    },
+    SOL: {
+        // Uses Ed25519
+        derivationPath: [
+            44,
+            501,
+            0,
+            0,
+            0
+        ],
+        signingAlgorithm: "ED25519"
+    },
+    BTC: {
+        // Uses secp256k1 BIP340
+        derivationPath: BITCOIN_DERIVATION_PATHS.NATIVE_SEGWIT,
+        signingAlgorithm: "BIP340"
+    },
+    COSMOS: {
+        // Uses Ed25519
+        derivationPath: [
+            44,
+            118,
+            0,
+            0,
+            0
+        ],
+        signingAlgorithm: "ED25519"
+    },
+    FLOW: {
+        // Uses Ed25519
+        derivationPath: [
+            44,
+            539,
+            0,
+            0,
+            0
+        ],
+        signingAlgorithm: "ED25519"
+    }
+};
+var ThresholdSignatureScheme = /*#__PURE__*/ function(ThresholdSignatureScheme) {
+    ThresholdSignatureScheme["TWO_OF_TWO"] = "TWO_OF_TWO";
+    ThresholdSignatureScheme["TWO_OF_THREE"] = "TWO_OF_THREE";
+    ThresholdSignatureScheme["THREE_OF_FIVE"] = "THREE_OF_FIVE";
+    return ThresholdSignatureScheme;
+}({});
+const MPC_CONFIG = {
+    ["TWO_OF_TWO"]: {
+        numberOfParties: 2,
+        threshold: 2,
+        clientThreshold: 1,
+        dynamicServerThreshold: 1
+    },
+    ["TWO_OF_THREE"]: {
+        numberOfParties: 3,
+        threshold: 2,
+        clientThreshold: 2,
+        dynamicServerThreshold: 1
+    },
+    ["THREE_OF_FIVE"]: {
+        numberOfParties: 5,
+        threshold: 3,
+        clientThreshold: 3,
+        dynamicServerThreshold: 2
+    }
+};
+var CreateRoomPartiesOptions = /*#__PURE__*/ function(CreateRoomPartiesOptions) {
+    CreateRoomPartiesOptions["THRESHOLD"] = "threshold";
+    CreateRoomPartiesOptions["FULL"] = "full";
+    return CreateRoomPartiesOptions;
+}({});
+
+const getMPCChainConfig = (chainName)=>{
+    const chainConfig = MPC_CHAIN_CONFIG[chainName];
+    if (!chainConfig) {
+        throw new Error(`Chain ${chainName} not supported`);
+    }
+    return chainConfig;
+};
+const getTSSConfig = (thresholdSignatureScheme)=>{
+    const { threshold, numberOfParties } = MPC_CONFIG[thresholdSignatureScheme];
+    return {
+        threshold,
+        numberOfParties
+    };
+};
+const getClientThreshold = (thresholdSignatureScheme)=>{
+    return MPC_CONFIG[thresholdSignatureScheme].clientThreshold;
+};
+const getDynamicServerThreshold = (thresholdSignatureScheme)=>{
+    return MPC_CONFIG[thresholdSignatureScheme].dynamicServerThreshold;
+};
+/**
+ * Helper function to get the reshare config for client and server shares
+ * @param {ThresholdSignatureScheme} oldThresholdSignatureScheme - The current threshold signature scheme
+ * @param {ThresholdSignatureScheme} newThresholdSignatureScheme - The target threshold signature scheme
+ * @returns {{
+ *   existingClientShareCount: number,
+ *   newClientShareCount: number,
+ *   existingServerShareCount: number,
+ *   newServerShareCount: number
+ * }} The number of existing and new client and server shares needed
+ */ const getReshareConfig = ({ oldThresholdSignatureScheme, newThresholdSignatureScheme })=>{
+    switch(true){
+        // 2-of-2 -> 2-of-2:
+        // -- dynamic server shares: 1 existing, 0 new
+        // -- client shares: 1 existing, 0 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO:
+            return {
+                existingClientShareCount: 1,
+                newClientShareCount: 0,
+                existingServerShareCount: 1,
+                newServerShareCount: 0
+            };
+        // 2-of-3 -> 2-of-3:
+        // -- dynamic server shares: 1 existing, 0 new
+        // -- client shares: 1 existing, 1 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE:
+            return {
+                existingClientShareCount: 1,
+                newClientShareCount: 1,
+                existingServerShareCount: 1,
+                newServerShareCount: 0
+            };
+        // 3-of-5 -> 3-of-5:
+        // -- dynamic server shares: 2 existing, 0 new
+        // -- client shares: 1 existing, 2 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE && newThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE:
+            return {
+                existingClientShareCount: 1,
+                newClientShareCount: 2,
+                existingServerShareCount: 2,
+                newServerShareCount: 0
+            };
+        // 2-of-2 -> 2-of-3:
+        // -- dynamic server shares: 1 existing, 0 new
+        // -- client shares: 1 existing, 1 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE:
+            return {
+                existingClientShareCount: 1,
+                newClientShareCount: 1,
+                existingServerShareCount: 1,
+                newServerShareCount: 0
+            };
+        // 2-of-2 -> 3-of-5:
+        // -- dynamic server shares: 1 existing, 1 new
+        // -- client shares: 1 existing, 2 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO && newThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE:
+            return {
+                existingClientShareCount: 1,
+                newClientShareCount: 2,
+                existingServerShareCount: 1,
+                newServerShareCount: 1
+            };
+        // 2-of-3 -> 3-of-5:
+        // -- dynamic server shares: 1 existing, 1 new
+        // -- client shares: 1 existing, 2 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE && newThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE:
+            return {
+                existingClientShareCount: 1,
+                newClientShareCount: 2,
+                existingServerShareCount: 1,
+                newServerShareCount: 1
+            };
+        // 2-of-3 -> 2-of-2:
+        // -- dynamic server shares: 1 existing, 0 new
+        // -- client shares: 1 existing, 0 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO:
+            return {
+                existingClientShareCount: 1,
+                newClientShareCount: 0,
+                existingServerShareCount: 1,
+                newServerShareCount: 0
+            };
+        // 3-of-5 -> 2-of-3:
+        // -- dynamic server shares: 1 existing, 0 new
+        // -- client shares: 2 existing, 0 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE:
+            return {
+                existingClientShareCount: 2,
+                newClientShareCount: 0,
+                existingServerShareCount: 1,
+                newServerShareCount: 0
+            };
+        default:
+            throw new Error(`Unsupported reshare from ${oldThresholdSignatureScheme} to ${newThresholdSignatureScheme}`);
+    }
+};
+/**
+ * Helper function to get the reshare config for client and server shares
+ * @param {ThresholdSignatureScheme} oldThresholdSignatureScheme - The current threshold signature scheme
+ * @param {ThresholdSignatureScheme} newThresholdSignatureScheme - The target threshold signature scheme
+ * @returns {{
+ *   existingServerShareCount: number,
+ *   newServerhareCount: number,
+ *   existingDynamicServerShareCount: number,
+ *   newDynamicServerShareCount: number
+ * }} The number of existing and new client and server shares needed
+ */ const getServerWalletReshareConfig = ({ oldThresholdSignatureScheme, newThresholdSignatureScheme })=>{
+    switch(true){
+        // 2-of-2 -> 2-of-2:
+        // -- dyanmic server shares: 1 existing, 0 new
+        // -- external server shares: 1 existing, 0 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO:
+            return {
+                existingExternalServerShareCount: 1,
+                newExternalServerShareCount: 0,
+                existingDynamicServerShareCount: 1,
+                newDynamicServerShareCount: 0
+            };
+        // 2-of-3 -> 2-of-3:
+        // -- dyanmic server shares: 1 existing, 0 new
+        // -- external server shares: 1 existing, 1 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE:
+            return {
+                existingExternalServerShareCount: 1,
+                newExternalServerShareCount: 1,
+                existingDynamicServerShareCount: 1,
+                newDynamicServerShareCount: 0
+            };
+        // 3-of-5 -> 3-of-5:
+        // -- dyanmic server shares: 2 existing, 0 new
+        // -- external server shares: 1 existing, 2 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE && newThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE:
+            return {
+                existingExternalServerShareCount: 1,
+                newExternalServerShareCount: 2,
+                existingDynamicServerShareCount: 2,
+                newDynamicServerShareCount: 0
+            };
+        // 2-of-2 -> 2-of-3:
+        // -- dyanmic server shares: 1 existing, 0 new
+        // -- external server shares: 1 existing, 1 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE:
+            return {
+                existingExternalServerShareCount: 1,
+                newExternalServerShareCount: 1,
+                existingDynamicServerShareCount: 1,
+                newDynamicServerShareCount: 0
+            };
+        // 2-of-2 -> 3-of-5:
+        // -- dyanmic server shares: 1 existing, 1 new
+        // -- external server shares: 1 existing, 2 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO && newThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE:
+            return {
+                existingExternalServerShareCount: 1,
+                newExternalServerShareCount: 2,
+                existingDynamicServerShareCount: 1,
+                newDynamicServerShareCount: 1
+            };
+        // 2-of-3 -> 3-of-5:
+        // -- dyanmic server shares: 1 existing, 1 new
+        // -- external server shares: 1 existing, 2 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE && newThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE:
+            return {
+                existingExternalServerShareCount: 1,
+                newExternalServerShareCount: 2,
+                existingDynamicServerShareCount: 1,
+                newDynamicServerShareCount: 1
+            };
+        // 2-of-3 -> 2-of-2:
+        // -- dyanmic server shares: 1 existing, 0 new
+        // -- external server shares: 1 existing, 0 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_TWO:
+            return {
+                existingExternalServerShareCount: 1,
+                newExternalServerShareCount: 0,
+                existingDynamicServerShareCount: 1,
+                newDynamicServerShareCount: 0
+            };
+        // 3-of-5 -> 2-of-3:
+        // -- dyanmic server shares: 1 existing, 0 new
+        // -- external server shares: 2 existing, 0 new
+        case oldThresholdSignatureScheme === ThresholdSignatureScheme.THREE_OF_FIVE && newThresholdSignatureScheme === ThresholdSignatureScheme.TWO_OF_THREE:
+            return {
+                existingExternalServerShareCount: 2,
+                newExternalServerShareCount: 0,
+                existingDynamicServerShareCount: 1,
+                newDynamicServerShareCount: 0
+            };
+        default:
+            throw new Error(`Unsupported reshare from ${oldThresholdSignatureScheme} to ${newThresholdSignatureScheme}`);
+    }
+};
+
+class BaseClient {
+    constructor({ environmentId, baseApiUrl, authToken, baseClientRelayApiUrl }){
+        const headers = {};
+        headers['Authorization'] = authToken ? `Bearer ${authToken}` : undefined;
+        this.environmentId = environmentId;
+        const isProd = typeof baseApiUrl === 'undefined' || DYNAMIC_AUTH_PROD_BASE_API_URL === baseApiUrl;
+        this.baseApiUrl = isProd ? DYNAMIC_AUTH_PROD_BASE_API_URL : baseApiUrl || DYNAMIC_AUTH_PREPROD_BASE_API_URL;
+        this.apiClient = axios.create({
+            baseURL: this.baseApiUrl,
+            headers
+        });
+        this.clientRelayBaseApiUrl = isProd ? DYNAMIC_CLIENT_RELAY_PROD_BASE_API_URL : baseClientRelayApiUrl || DYNAMIC_CLIENT_RELAY_PREPROD_BASE_API_URL;
+        this.clientRelayApiClient = axios.create({
+            baseURL: this.clientRelayBaseApiUrl,
+            headers
+        });
+    }
+}
+
+var SuccessEventType = /*#__PURE__*/ function(SuccessEventType) {
+    SuccessEventType["KeygenComplete"] = "keygen_complete";
+    SuccessEventType["RoomCreated"] = "room_created";
+    SuccessEventType["CeremonyComplete"] = "ceremony_complete";
+    return SuccessEventType;
+}({});
+
+/**
+ * Creates a promise that resolves when a specific event is received from an event stream.
+ * Adds a timeout to prevent hanging and races the two promises.
+ *
+ * @template T The expected type of the response data
+ * @param apiClient The axios instance to use for API calls
+ * @param options The configuration options
+ * @returns A promise that resolves with the event data or rejects on timeout
+ */ const createEventStreamPromise = ({ apiClient, endpoint, body, successEventType, timeoutMs = 30000, timeoutMessage, onError, onCeremonyComplete })=>{
+    // Create a promise that will resolve when the success event is received
+    const eventPromise = new Promise((resolve, reject)=>{
+        apiClient.post(endpoint, body, {
+            responseType: 'stream',
+            headers: {
+                Accept: 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive'
+            },
+            adapter: 'fetch'
+        }).then(createSuccessErrorEventStreamHandler({
+            onError,
+            reject,
+            resolve,
+            successEventType,
+            onCeremonyComplete
+        })).catch(reject);
+    });
+    // Add a timeout to prevent hanging
+    const timeoutPromise = new Promise((_, reject)=>{
+        setTimeout(()=>reject(new Error(timeoutMessage)), timeoutMs);
+    });
+    // Return the event data as soon as it's available
+    return Promise.race([
+        eventPromise,
+        timeoutPromise
+    ]);
+};
+/**
+ * Creates a handler function for processing server-sent events (SSE) streams.
+ * This utility manages asynchronous event-based communication with the server,
+ * particularly for long-running operations like wallet creation or key generation.
+ *
+ * @template T - The expected type of the successful response data
+ * @param {function} resolve - Promise resolution function to call when the success event is received
+ * @param {function} reject - Promise rejection function to call when an error occurs
+ * @param {string} successEventType - The event type string that indicates a successful operation
+ * @param {function} [onError] - Optional callback for error handling, allowing custom error processing
+ * @returns {function} A response handler function that processes the event stream
+ */ const createSuccessErrorEventStreamHandler = ({ resolve, reject, successEventType, onError, onCeremonyComplete })=>{
+    return (response)=>{
+        const reader = response.data.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const processStream = async ()=>{
+            try {
+                const { value, done } = await reader.read();
+                if (done) return;
+                buffer += decoder.decode(value, {
+                    stream: true
+                });
+                const events = parseEventStream(buffer);
+                for (const event of events){
+                    if (event.type === successEventType) {
+                        resolve(event.data);
+                    }
+                    if (event.type === SuccessEventType.CeremonyComplete) {
+                        const { accountAddress, walletId } = event.data;
+                        onCeremonyComplete == null ? void 0 : onCeremonyComplete(accountAddress, walletId);
+                    }
+                    if (event.type === 'error') {
+                        reject(createErrorFromEventData(event.data));
+                        onError == null ? void 0 : onError(createErrorFromEventData(event.data));
+                    }
+                }
+                processStream();
+            } catch (err) {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        };
+        processStream();
+    };
+};
+/**
+ * Creates an error object from event stream error data.
+ *
+ * @param data - The error data received from the event stream
+ * @returns A standardized Error object with properties from the error data
+ */ const createErrorFromEventData = (data)=>{
+    const error = new Error(typeof data === 'object' && data !== null && 'error' in data ? String(data.error) : 'Unknown error');
+    if (typeof data === 'object' && data !== null) {
+        Object.assign(error, data);
+    }
+    return error;
+};
+/**
+ * Parses a Server-Sent Events (SSE) stream into structured event objects.
+ *
+ * @param input - Raw string data from an event stream
+ * @returns Array of parsed events with type and data properties
+ */ const parseEventStream = (input)=>{
+    const lines = input.split('\n');
+    const events = [];
+    let currentEvent = {};
+    let inEvent = false;
+    for (const line of lines){
+        // Empty line marks the end of an event
+        if (line === '') {
+            if (currentEvent.type && currentEvent.data) {
+                events.push({
+                    type: currentEvent.type,
+                    data: JSON.parse(currentEvent.data)
+                });
+                currentEvent = {};
+                inEvent = false;
+            }
+            continue;
+        }
+        // Process event fields
+        if (line.startsWith('event:')) {
+            currentEvent.type = line.substring(6).trim();
+            inEvent = true;
+        } else if (line.startsWith('data:')) {
+            currentEvent.data = line.substring(5).trim();
+            inEvent = true;
+        } else if (inEvent && currentEvent.data) {
+            currentEvent.data += line;
+        }
+    }
+    return events;
+};
+
+class DynamicApiClient extends BaseClient {
+    async authenticateApiToken({ environmentId }) {
+        return this.apiClient.post(`/api/v0/environments/${environmentId}/waas/authenticate`);
+    }
+    async createWalletAccount({ chainName, clientKeygenIds, thresholdSignatureScheme, onError, onCeremonyComplete }) {
+        return createEventStreamPromise({
+            apiClient: this.apiClient,
+            endpoint: `/api/v0/sdk/${this.environmentId}/waas/create`,
+            body: {
+                chain: chainName,
+                clientKeygenIds,
+                thresholdSignatureScheme
+            },
+            successEventType: SuccessEventType.KeygenComplete,
+            timeoutMessage: 'Wallet creation timed out',
+            onError,
+            onCeremonyComplete
+        });
+    }
+    async signMessage({ walletId, message, onError }) {
+        return createEventStreamPromise({
+            apiClient: this.apiClient,
+            endpoint: `/api/v0/sdk/${this.environmentId}/waas/${walletId}/signMessage`,
+            body: {
+                message
+            },
+            successEventType: SuccessEventType.RoomCreated,
+            timeoutMessage: 'Message signing timed out',
+            onError
+        });
+    }
+    async refreshWalletAccountShares({ walletId, onError }) {
+        return createEventStreamPromise({
+            apiClient: this.apiClient,
+            endpoint: `/api/v0/sdk/${this.environmentId}/waas/${walletId}/refresh`,
+            body: undefined,
+            successEventType: SuccessEventType.RoomCreated,
+            timeoutMessage: 'Refresh timed out',
+            onError
+        });
+    }
+    async reshare({ walletId, clientKeygenIds, oldThresholdSignatureScheme, newThresholdSignatureScheme, onError }) {
+        return createEventStreamPromise({
+            apiClient: this.apiClient,
+            endpoint: `/api/v0/sdk/${this.environmentId}/waas/${walletId}/reshare`,
+            body: {
+                clientKeygenIds,
+                oldThresholdSignatureScheme,
+                newThresholdSignatureScheme
+            },
+            successEventType: SuccessEventType.RoomCreated,
+            timeoutMessage: 'Reshare timed out',
+            onError
+        });
+    }
+    async exportKey({ walletId, exportId, onError }) {
+        return createEventStreamPromise({
+            apiClient: this.apiClient,
+            endpoint: `/api/v0/sdk/${this.environmentId}/waas/${walletId}/privateKey/export`,
+            body: {
+                exportId
+            },
+            successEventType: SuccessEventType.RoomCreated,
+            timeoutMessage: 'Key export timed out',
+            onError
+        });
+    }
+    async storeEncryptedBackupByWallet({ walletId, encryptedKeyShares, passwordEncrypted }) {
+        const { data } = await this.clientRelayApiClient.post(`/api/v0/sdk/${this.environmentId}/waas/${walletId}/keyShares/backup`, {
+            // TODO: decide on whether to store encryptedAccountCredentials or encryptedKeyShares as backup
+            encryptedAccountCredentials: encryptedKeyShares,
+            passwordEncrypted
+        });
+        return data;
+    }
+    async markKeySharesAsBackedUpGoogleDrive({ walletId }) {
+        const { data } = await this.clientRelayApiClient.post(`/api/v0/sdk/${this.environmentId}/waas/${walletId}/keyShares/backup/googleDrive`, {});
+        return data;
+    }
+    async recoverEncryptedBackupByWallet({ walletId, keyShareIds }) {
+        const { data } = await this.clientRelayApiClient.post(`/api/v0/sdk/${this.environmentId}/waas/${walletId}/keyShares/recover`, keyShareIds ? {
+            keyShareIds
+        } : undefined);
+        return data;
+    }
+    async getAccessToken({ oauthAccountId }) {
+        const { data } = await this.apiClient.get(`/api/v0/sdk/${this.environmentId}/oauthAccounts/${oauthAccountId}/accessToken`);
+        return data.accessToken;
+    }
+    // TODO: return array instead considering cases where server has multiple parties
+    async importPrivateKey({ chainName, clientKeygenIds, thresholdSignatureScheme, onError, onCeremonyComplete }) {
+        return createEventStreamPromise({
+            apiClient: this.apiClient,
+            endpoint: `/api/v0/sdk/${this.environmentId}/waas/privateKey/import`,
+            body: {
+                chain: chainName,
+                clientKeygenIds,
+                thresholdSignatureScheme
+            },
+            successEventType: SuccessEventType.KeygenComplete,
+            timeoutMessage: 'Key import timed out',
+            onError,
+            onCeremonyComplete
+        });
+    }
+    // TODO: consider removing the retry logics if we switch to server-sent events
+    async getUser() {
+        let attempts = 0;
+        const maxAttempts = 5;
+        const retryInterval = 1000; // 1 second interval for each retry
+        while(attempts < maxAttempts){
+            try {
+                const { data } = await this.apiClient.get(`/api/v0/sdk/${this.environmentId}/users`);
+                return data;
+            } catch (error) {
+                attempts++;
+                if (attempts === maxAttempts) {
+                    throw error;
+                }
+                await new Promise((resolve)=>setTimeout(resolve, retryInterval));
+            }
+        }
+    }
+    // TODO: consider removing the retry logics if we switch to server-sent events
+    async refreshUser() {
+        let attempts = 0;
+        const maxAttempts = 5;
+        const retryInterval = 1000; // 1 second interval for each retry
+        while(attempts < maxAttempts){
+            try {
+                const { data } = await this.apiClient.post(`/api/v0/sdk/${this.environmentId}/refresh`, undefined);
+                return data;
+            } catch (error) {
+                attempts++;
+                if (attempts === maxAttempts) {
+                    throw error;
+                }
+                await new Promise((resolve)=>setTimeout(resolve, retryInterval));
+            }
+        }
+    }
+    constructor({ environmentId, authToken, baseApiUrl }){
+        super({
+            environmentId,
+            authToken,
+            baseApiUrl
+        });
+    }
+}
+
+export { BITCOIN_DERIVATION_PATHS, BackupLocation, ChainEnumToVerifiedCredentialName, CreateRoomPartiesOptions, DYNAMIC_AUTH_PREPROD_BASE_API_URL, DYNAMIC_AUTH_PROD_BASE_API_URL, DYNAMIC_CLIENT_RELAY_PREPROD_BASE_API_URL, DYNAMIC_CLIENT_RELAY_PROD_BASE_API_URL, DynamicApiClient, IFRAME_DOMAIN_PREPROD, IFRAME_DOMAIN_PROD, MPC_CHAIN_CONFIG, MPC_CONFIG, MPC_RELAY_PREPROD_API_URL, MPC_RELAY_PROD_API_URL, SOLANA_RPC_URL, SigningAlgorithm, SuccessEventType, ThresholdSignatureScheme, VerifiedCredentialNameToChainEnum, WalletOperation, chain, getClientThreshold, getDynamicServerThreshold, getMPCChainConfig, getReshareConfig, getServerWalletReshareConfig, getTSSConfig };