@dynamic-labs-wallet/browser 1.0.80 → 1.0.82

package/index.cjs

@@ -7,8 +7,8 @@ var primitives = require('@dynamic-labs-wallet/primitives');
 var sdkApiCore = require('@dynamic-labs/sdk-api-core');
 var loadArgon2idWasm = require('argon2id');
 var axios = require('axios');
-var PQueue = require('p-queue');
 var gte = require('semver/functions/gte');
+var PQueue = require('p-queue');
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -463,6 +463,237 @@ class EncryptionSelfTestFailedError extends Error {
     }
 }
 
+/**
+ * Extracts the HTTP status from an `AxiosError`, or `undefined` for non-HTTP
+ * errors. Lives in its own leaf module (no `#internal/web` / WASM imports) so
+ * lightweight consumers like `services/signedSession.ts` can use it without
+ * pulling the MPC WASM bundle that `utils.ts` loads.
+ */ const getHttpStatus = (error)=>{
+    var _error_response;
+    return error instanceof axios.AxiosError ? (_error_response = error.response) == null ? void 0 : _error_response.status : undefined;
+};
+
+const STORAGE_KEY = 'dynamic-waas-wallet-client';
+const BACKUP_FILENAME = 'dynamicWalletKeyShareBackup.json';
+const CLIENT_KEYSHARE_EXPORT_FILENAME_PREFIX = 'dynamicWalletKeyShareBackup';
+const SIGNED_SESSION_ID_MIN_VERSION = '4.25.4';
+// Namespace-specific version requirements
+const SIGNED_SESSION_ID_MIN_VERSION_BY_NAMESPACE = {
+    WalletKit: '4.25.4',
+    ClientSDK: '0.1.0-alpha.0'
+};
+// Minimum SDK version that forwards `getSignedSessionId` to the iframe's postMessage
+// reverse channel, distinct from SIGNED_SESSION_ID_MIN_VERSION above (which only
+// gates whether a signed session value is sent at all).
+// WalletKit: dynamic-auth#10577 (v4.74.0). ClientSDK: dynamic-js-sdk#1937 (v1.12.1).
+const SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION = '4.74.0';
+const SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION_BY_NAMESPACE = {
+    WalletKit: SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION,
+    ClientSDK: '1.12.1'
+};
+const ROOM_EXPIRATION_TIME = 1000 * 60 * 10; // 10 minutes
+const ROOM_CACHE_COUNT = 5;
+const ENVIRONMENT_SETTINGS_STORAGE_KEY = 'dynamic_environment_settings';
+
+function meetsMinVersion(sdkVersion, { minVersionByNamespace, fallbackMinVersion, label }, logger) {
+    if (!sdkVersion) {
+        return false;
+    }
+    try {
+        const parsedVersion = core.parseNamespacedVersion(sdkVersion);
+        if (!parsedVersion) {
+            return false;
+        }
+        const { namespace, version } = parsedVersion;
+        var _minVersionByNamespace_namespace;
+        return gte(version, (_minVersionByNamespace_namespace = minVersionByNamespace[namespace]) != null ? _minVersionByNamespace_namespace : fallbackMinVersion);
+    } catch (error) {
+        logger.warn(`[DynamicWaasWalletClient] Error checking ${label} for version ${sdkVersion}`, {
+            error: error instanceof Error ? error.message : String(error)
+        });
+        return false;
+    }
+}
+/** Whether the given SDK version requires a signed session ID to be sent at all. */ function isRequiresSignedSessionId(sdkVersion, logger) {
+    return meetsMinVersion(sdkVersion, {
+        minVersionByNamespace: SIGNED_SESSION_ID_MIN_VERSION_BY_NAMESPACE,
+        fallbackMinVersion: SIGNED_SESSION_ID_MIN_VERSION,
+        label: 'requiresSignedSessionId'
+    }, logger);
+}
+/**
+ * Whether the SDK version is known to forward `getSignedSessionId` to the iframe's
+ * postMessage reverse channel — stricter than {@link isRequiresSignedSessionId},
+ * which only checks whether a session value is sent at all.
+ */ function isReverseChannelSupported(sdkVersion, logger) {
+    return meetsMinVersion(sdkVersion, {
+        minVersionByNamespace: SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION_BY_NAMESPACE,
+        fallbackMinVersion: SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION,
+        label: 'supportsReverseChannel'
+    }, logger);
+}
+
+/**
+ * Datadog event name emitted on every signed-session nonce rejection (a 400 or
+ * 401 from the backup/recovery endpoints). Log-only: lets us split the failure
+ * bucket by `reason` and measure the true per-wallet unrecoverable rate
+ * without changing any retry behavior. See DYNT-1599.
+ */ const NONCE_FAILURE_EVENT = 'waas.signed_session.nonce_failure';
+/**
+ * Reasons that represent a genuine session-key signature mismatch (the 401 the
+ * server returns per DYNT-1282). Used to gate 401 instrumentation so callers
+ * that reuse 401 for unrelated rejections don't pollute the failure metric.
+ */ const SESSION_SIGNATURE_FAILURE_REASONS = new Set([
+    'invalid_nonce_signature',
+    'invalid_session_signature'
+]);
+/** Best-effort extraction of the server error `code`/`message` from a 4xx body. */ const readErrorBody = (error)=>{
+    var _error_response;
+    if (!(error instanceof axios.AxiosError)) {
+        return {};
+    }
+    const data = (_error_response = error.response) == null ? void 0 : _error_response.data;
+    if (typeof data === 'string') {
+        return {
+            message: data
+        };
+    }
+    if (!data || typeof data !== 'object') {
+        return {};
+    }
+    const record = data;
+    // Prefer a string `code`, else fall back to `error_code` (the field the Key
+    // Share Service emits, see KSS #271) or a bare `error`.
+    const code = [
+        record['code'],
+        record['error_code'],
+        record['error']
+    ].find((value)=>typeof value === 'string');
+    const message = typeof record['message'] === 'string' ? record['message'] : undefined;
+    return {
+        code,
+        message
+    };
+};
+/** Maps the server error `code`/`message` onto a {@link NonceFailureReason}. */ const classifyNonceFailure = ({ code, message })=>{
+    const haystack = `${code != null ? code : ''} ${message != null ? message : ''}`.toLowerCase();
+    if (haystack.includes('already_used') || haystack.includes('already used') || haystack.includes('consumption failed')) {
+        return 'nonce_already_used';
+    }
+    if (haystack.includes('invalid_nonce_signature') || haystack.includes('invalid nonce signature')) {
+        return 'invalid_nonce_signature';
+    }
+    if (haystack.includes('invalid_session_signature') || haystack.includes('invalid session public key') || haystack.includes('invalid session signature')) {
+        return 'invalid_session_signature';
+    }
+    return 'other';
+};
+/**
+ * Owns everything about signed sessions and their single-use replay nonces:
+ * resolving a session from an explicit value or the host reverse channel,
+ * deciding whether the SDK version requires one, and building the
+ * refresh-on-replay-400 retry predicate shared by the backup and recovery
+ * flows.
+ *
+ * Extracted from `DynamicWalletClient` so this logic can be exercised in
+ * isolation. The host callback is read lazily (`getCallback`) so it stays in
+ * sync with the owning client even if reassigned after construction.
+ */ class SignedSessionManager {
+    /** True when a reverse channel is configured to mint fresh signed sessions. */ get canRefresh() {
+        return this.getCallback() !== undefined;
+    }
+    /**
+   * Resolves the signed session ID from an explicit value or falls back to the
+   * host reverse channel. Throws if neither source provides a value.
+   */ async resolve(signedSessionId) {
+        const callback = this.getCallback();
+        const resolved = signedSessionId != null ? signedSessionId : await (callback == null ? void 0 : callback());
+        if (!resolved) {
+            throw new Error(signedSessionId === undefined && callback ? 'signedSessionId callback returned an invalid value' : 'signedSessionId is required for backup but was not provided and no callback is configured');
+        }
+        return resolved;
+    }
+    /** Whether the configured SDK version requires a signed session ID. */ isRequired() {
+        return this.required;
+    }
+    /** Whether the host SDK version supports the getSignedSessionId reverse channel (see version-check.ts). */ supportsReverseChannel() {
+        return this.reverseChannelSupported;
+    }
+    /**
+   * Builds a `retryPromise` `shouldRetry` predicate that refreshes a consumed
+   * single-use nonce via the reverse channel on a replay 400 and retries once.
+   * The signed session carries a single-use replay nonce: it is valid on its
+   * first use, but once consumed (e.g. by a preceding operation) the server
+   * rejects with a 400, at which point a fresh session is fetched and the call
+   * retried. `alsoRetry` lets callers opt into additional retryable statuses
+   * (e.g. 429 / 5xx) on top of the nonce refresh.
+   */ refreshShouldRetry({ onRefreshed, operationName, logContext, alsoRetry }) {
+        return async (error, attempt)=>{
+            const status = getHttpStatus(error);
+            // A 400 is a refreshable replay nonce; a 401 is a session-key mismatch the
+            // server returns to break the refresh loop (DYNT-1282) — logged only when the
+            // body classifies as a genuine session-signature failure so unrelated 401s
+            // (e.g. an exhausted add-signer grant) don't pollute the DYNT-1599 metric.
+            // Only the 400 can actually refresh.
+            const isSessionSignatureFailure = status === 401 && SESSION_SIGNATURE_FAILURE_REASONS.has(classifyNonceFailure(readErrorBody(error)));
+            const shouldInstrument = status === 400 || isSessionSignatureFailure;
+            if (shouldInstrument) {
+                const willRefresh = status === 400 && attempt === 1 && this.canRefresh && this.supportsReverseChannel();
+                this.instrumentNonceFailure({
+                    error,
+                    attempt,
+                    status,
+                    operationName,
+                    willRefresh,
+                    logContext
+                });
+            }
+            if (status === 400 && attempt === 1 && this.canRefresh) {
+                // canRefresh only proves a local callback exists, not that the host answers it.
+                if (!this.supportsReverseChannel()) {
+                    this.logger.warn(`[${operationName}] host SDK version predates the signed-session reverse channel, declining nonce refresh`, _extends({
+                        status
+                    }, logContext));
+                    return alsoRetry ? alsoRetry(status) : false;
+                }
+                onRefreshed(await this.resolve());
+                this.logger.info(`[${operationName}] refreshed signed session, retrying`, _extends({
+                    status
+                }, logContext));
+                return true;
+            }
+            return alsoRetry ? alsoRetry(status) : false;
+        };
+    }
+    /**
+   * Emits a single Datadog log per signed-session nonce rejection so the
+   * failure bucket can be split by `reason` and correlated per wallet/request.
+   * Purely observational — it never alters the retry decision.
+   */ instrumentNonceFailure({ error, attempt, status, operationName, willRefresh, logContext }) {
+        const body = readErrorBody(error);
+        this.logger.info(NONCE_FAILURE_EVENT, _extends({}, logContext, {
+            operationName,
+            attempt,
+            status,
+            reason: classifyNonceFailure(body),
+            errorCode: body.code,
+            errorMessage: body.message,
+            willRefresh,
+            canRefresh: this.canRefresh,
+            reverseChannelSupported: this.reverseChannelSupported,
+            required: this.required,
+            sdkVersion: this.sdkVersion
+        }));
+    }
+    constructor({ logger, sdkVersion, getCallback }){
+        this.logger = logger;
+        this.getCallback = getCallback;
+        this.sdkVersion = sdkVersion;
+        this.required = isRequiresSignedSessionId(sdkVersion, this.logger);
+        this.reverseChannelSupported = isReverseChannelSupported(sdkVersion, this.logger);
+    }
+}
+
 const ERROR_NO_KEY_SHARES_BACKED_UP = 'No key shares were backed up to Dynamic backend';
 const ERROR_KEYGEN_FAILED = '[DynamicWaasWalletClient]: Error with keygen';
 const ERROR_CREATE_WALLET_ACCOUNT = '[DynamicWaasWalletClient]: Error creating wallet account';
@@ -555,6 +786,10 @@ const ERROR_WALLETS_ALREADY_ENCRYPTED = '[DynamicWaasWalletClient]: Cannot set p
  */ const USER_ACTIONABLE_PASSWORD_BACKUP_ERROR_REASONS = {
     wrong_password: true,
     stale_local_shares: false,
+    nonce_already_used: false,
+    invalid_nonce_signature: false,
+    invalid_session_signature: false,
+    signed_session: false,
     encryption_failure: false,
     decryption_failure: false,
     upload_failure: false,
@@ -577,6 +812,30 @@ const FETCH_NETWORK_ERROR_REGEX = /failed to fetch|networkerror|load failed|netw
 const ENCRYPTION_FAILURE_MESSAGE_PREFIX = 'Error encrypting data:';
 const DECRYPTION_FAILURE_MESSAGE_PREFIX = 'Decryption failed:';
 const isStaleSharesError = (error)=>error instanceof StaleLocalSharesError || error instanceof Error && error.name === 'StaleLocalSharesError';
+// The backup/recovery endpoints reject the chaining signature with a 400
+// (stale signed session / replay nonce) or 401 (session-key mismatch,
+// DYNT-1282); the preserved backend code splits those into their precise
+// cause so the failure is actionable instead of a generic `unknown`.
+const SIGNED_SESSION_FAILURE_STATUSES = new Set([
+    400,
+    401
+]);
+const NONCE_REASON_TO_BACKUP_REASON = {
+    nonce_already_used: 'nonce_already_used',
+    invalid_nonce_signature: 'invalid_nonce_signature',
+    invalid_session_signature: 'invalid_session_signature',
+    other: 'signed_session'
+};
+const classifyWalletApiError = (error)=>{
+    if (!SIGNED_SESSION_FAILURE_STATUSES.has(error.status)) {
+        return 'upload_failure';
+    }
+    const nonceReason = classifyNonceFailure({
+        code: error.code,
+        message: error.message
+    });
+    return NONCE_REASON_TO_BACKUP_REASON[nonceReason];
+};
 const isNetworkLikeError = (error)=>{
     if (typeof error !== 'object' || error === null) {
         return false;
@@ -628,6 +887,12 @@ const computeReason = (error)=>{
     if (isStaleSharesError(error)) {
         return 'stale_local_shares';
     }
+    // WalletApiError is a wrapped HTTP failure carrying the resolved status; its
+    // message is a generic status string ('Invalid request', etc.) so classify
+    // by status ahead of the message-based checks below.
+    if (error instanceof core.WalletApiError) {
+        return classifyWalletApiError(error);
+    }
     if (error instanceof Error) {
         if (error.message.includes(ERROR_PASSWORD_MISMATCH) || error.message.includes(ERROR_INCORRECT_PASSWORD)) {
             return 'wrong_password';
@@ -995,38 +1260,6 @@ const downloadFileFromGoogleDrive = async ({ accessToken, fileName })=>{
     }
 };
 
-/**
- * Extracts the HTTP status from an `AxiosError`, or `undefined` for non-HTTP
- * errors. Lives in its own leaf module (no `#internal/web` / WASM imports) so
- * lightweight consumers like `services/signedSession.ts` can use it without
- * pulling the MPC WASM bundle that `utils.ts` loads.
- */ const getHttpStatus = (error)=>{
-    var _error_response;
-    return error instanceof axios.AxiosError ? (_error_response = error.response) == null ? void 0 : _error_response.status : undefined;
-};
-
-const STORAGE_KEY = 'dynamic-waas-wallet-client';
-const BACKUP_FILENAME = 'dynamicWalletKeyShareBackup.json';
-const CLIENT_KEYSHARE_EXPORT_FILENAME_PREFIX = 'dynamicWalletKeyShareBackup';
-const SIGNED_SESSION_ID_MIN_VERSION = '4.25.4';
-// Namespace-specific version requirements
-const SIGNED_SESSION_ID_MIN_VERSION_BY_NAMESPACE = {
-    WalletKit: '4.25.4',
-    ClientSDK: '0.1.0-alpha.0'
-};
-// Minimum SDK version that forwards `getSignedSessionId` to the iframe's postMessage
-// reverse channel, distinct from SIGNED_SESSION_ID_MIN_VERSION above (which only
-// gates whether a signed session value is sent at all).
-// WalletKit: dynamic-auth#10577 (v4.74.0). ClientSDK: dynamic-js-sdk#1937 (v1.12.1).
-const SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION = '4.74.0';
-const SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION_BY_NAMESPACE = {
-    WalletKit: SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION,
-    ClientSDK: '1.12.1'
-};
-const ROOM_EXPIRATION_TIME = 1000 * 60 * 10; // 10 minutes
-const ROOM_CACHE_COUNT = 5;
-const ENVIRONMENT_SETTINGS_STORAGE_KEY = 'dynamic_environment_settings';
-
 /**
  * Normalizes an address to lowercase for consistent map key lookups.
  * This ensures that addresses with different casing (e.g., EIP-55 checksummed vs lowercase)
@@ -2412,6 +2645,22 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
 /** Track which wallets are currently executing inside a sign operation.
    * Used to prevent deadlocks when recovery is called from within a sign op. */ WalletQueueManager.walletsWithActiveSignOp = new Map();
 
+// A DYNAMIC backup can persist multiple shares (e.g. 2-of-3); the singular
+// externalKeyShareId is a fallback for older single-id shapes.
+const collectDynamicKeyShareIds = (locations)=>{
+    return locations.filter((loc)=>loc.location === core.BackupLocation.DYNAMIC).flatMap((loc)=>{
+        if (loc.externalKeyShareIds && loc.externalKeyShareIds.length > 0) {
+            return loc.externalKeyShareIds;
+        }
+        if (loc.externalKeyShareId) {
+            return [
+                loc.externalKeyShareId
+            ];
+        }
+        return [];
+    });
+};
+
 // Pure routing helper: maps a completed reshare ceremony's results into the
 // ShareDistribution that storage/publish should follow. Lives outside the
 // client class so it's straightforward to reason about and unit-test
@@ -2612,184 +2861,6 @@ const readEnvironmentSettings = ()=>{
         }
     });
 
-function meetsMinVersion(sdkVersion, { minVersionByNamespace, fallbackMinVersion, label }, logger) {
-    if (!sdkVersion) {
-        return false;
-    }
-    try {
-        const parsedVersion = core.parseNamespacedVersion(sdkVersion);
-        if (!parsedVersion) {
-            return false;
-        }
-        const { namespace, version } = parsedVersion;
-        var _minVersionByNamespace_namespace;
-        return gte(version, (_minVersionByNamespace_namespace = minVersionByNamespace[namespace]) != null ? _minVersionByNamespace_namespace : fallbackMinVersion);
-    } catch (error) {
-        logger.warn(`[DynamicWaasWalletClient] Error checking ${label} for version ${sdkVersion}`, {
-            error: error instanceof Error ? error.message : String(error)
-        });
-        return false;
-    }
-}
-/** Whether the given SDK version requires a signed session ID to be sent at all. */ function isRequiresSignedSessionId(sdkVersion, logger) {
-    return meetsMinVersion(sdkVersion, {
-        minVersionByNamespace: SIGNED_SESSION_ID_MIN_VERSION_BY_NAMESPACE,
-        fallbackMinVersion: SIGNED_SESSION_ID_MIN_VERSION,
-        label: 'requiresSignedSessionId'
-    }, logger);
-}
-/**
- * Whether the SDK version is known to forward `getSignedSessionId` to the iframe's
- * postMessage reverse channel — stricter than {@link isRequiresSignedSessionId},
- * which only checks whether a session value is sent at all.
- */ function isReverseChannelSupported(sdkVersion, logger) {
-    return meetsMinVersion(sdkVersion, {
-        minVersionByNamespace: SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION_BY_NAMESPACE,
-        fallbackMinVersion: SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION,
-        label: 'supportsReverseChannel'
-    }, logger);
-}
-
-/**
- * Datadog event name emitted on every signed-session nonce rejection (a 400
- * from the backup/recovery endpoints). Log-only: lets us split the failure
- * bucket by `reason` and measure the true per-wallet unrecoverable rate
- * without changing any retry behavior. See DYNT-1599.
- */ const NONCE_FAILURE_EVENT = 'waas.signed_session.nonce_failure';
-/** Best-effort extraction of the server error `code`/`message` from a 400 body. */ const readErrorBody = (error)=>{
-    var _error_response;
-    if (!(error instanceof axios.AxiosError)) {
-        return {};
-    }
-    const data = (_error_response = error.response) == null ? void 0 : _error_response.data;
-    if (typeof data === 'string') {
-        return {
-            message: data
-        };
-    }
-    if (!data || typeof data !== 'object') {
-        return {};
-    }
-    const record = data;
-    // Prefer a string `code`, else fall back to a string `error`.
-    const code = [
-        record['code'],
-        record['error']
-    ].find((value)=>typeof value === 'string');
-    const message = typeof record['message'] === 'string' ? record['message'] : undefined;
-    return {
-        code,
-        message
-    };
-};
-/** Maps the server error `code`/`message` onto a {@link NonceFailureReason}. */ const classifyNonceFailure = ({ code, message })=>{
-    const haystack = `${code != null ? code : ''} ${message != null ? message : ''}`.toLowerCase();
-    if (haystack.includes('already_used') || haystack.includes('already used') || haystack.includes('consumption failed')) {
-        return 'nonce_already_used';
-    }
-    if (haystack.includes('invalid_nonce_signature') || haystack.includes('invalid nonce signature')) {
-        return 'invalid_nonce_signature';
-    }
-    return 'other';
-};
-/**
- * Owns everything about signed sessions and their single-use replay nonces:
- * resolving a session from an explicit value or the host reverse channel,
- * deciding whether the SDK version requires one, and building the
- * refresh-on-replay-400 retry predicate shared by the backup and recovery
- * flows.
- *
- * Extracted from `DynamicWalletClient` so this logic can be exercised in
- * isolation. The host callback is read lazily (`getCallback`) so it stays in
- * sync with the owning client even if reassigned after construction.
- */ class SignedSessionManager {
-    /** True when a reverse channel is configured to mint fresh signed sessions. */ get canRefresh() {
-        return this.getCallback() !== undefined;
-    }
-    /**
-   * Resolves the signed session ID from an explicit value or falls back to the
-   * host reverse channel. Throws if neither source provides a value.
-   */ async resolve(signedSessionId) {
-        const callback = this.getCallback();
-        const resolved = signedSessionId != null ? signedSessionId : await (callback == null ? void 0 : callback());
-        if (!resolved) {
-            throw new Error(signedSessionId === undefined && callback ? 'signedSessionId callback returned an invalid value' : 'signedSessionId is required for backup but was not provided and no callback is configured');
-        }
-        return resolved;
-    }
-    /** Whether the configured SDK version requires a signed session ID. */ isRequired() {
-        return this.required;
-    }
-    /** Whether the host SDK version supports the getSignedSessionId reverse channel (see version-check.ts). */ supportsReverseChannel() {
-        return this.reverseChannelSupported;
-    }
-    /**
-   * Builds a `retryPromise` `shouldRetry` predicate that refreshes a consumed
-   * single-use nonce via the reverse channel on a replay 400 and retries once.
-   * The signed session carries a single-use replay nonce: it is valid on its
-   * first use, but once consumed (e.g. by a preceding operation) the server
-   * rejects with a 400, at which point a fresh session is fetched and the call
-   * retried. `alsoRetry` lets callers opt into additional retryable statuses
-   * (e.g. 429 / 5xx) on top of the nonce refresh.
-   */ refreshShouldRetry({ onRefreshed, operationName, logContext, alsoRetry }) {
-        return async (error, attempt)=>{
-            const status = getHttpStatus(error);
-            if (status === 400) {
-                const willRefresh = attempt === 1 && this.canRefresh && this.supportsReverseChannel();
-                this.instrumentNonceFailure({
-                    error,
-                    attempt,
-                    operationName,
-                    willRefresh,
-                    logContext
-                });
-                if (attempt === 1 && this.canRefresh) {
-                    // canRefresh only proves a local callback exists, not that the host answers it.
-                    if (!this.supportsReverseChannel()) {
-                        this.logger.warn(`[${operationName}] host SDK version predates the signed-session reverse channel, declining nonce refresh`, _extends({
-                            status
-                        }, logContext));
-                        return alsoRetry ? alsoRetry(status) : false;
-                    }
-                    onRefreshed(await this.resolve());
-                    this.logger.info(`[${operationName}] refreshed signed session, retrying`, _extends({
-                        status
-                    }, logContext));
-                    return true;
-                }
-            }
-            return alsoRetry ? alsoRetry(status) : false;
-        };
-    }
-    /**
-   * Emits a single Datadog log per signed-session nonce rejection so the
-   * failure bucket can be split by `reason` and correlated per wallet/request.
-   * Purely observational — it never alters the retry decision.
-   */ instrumentNonceFailure({ error, attempt, operationName, willRefresh, logContext }) {
-        const body = readErrorBody(error);
-        this.logger.info(NONCE_FAILURE_EVENT, _extends({}, logContext, {
-            operationName,
-            attempt,
-            status: 400,
-            reason: classifyNonceFailure(body),
-            errorCode: body.code,
-            errorMessage: body.message,
-            willRefresh,
-            canRefresh: this.canRefresh,
-            reverseChannelSupported: this.reverseChannelSupported,
-            required: this.required,
-            sdkVersion: this.sdkVersion
-        }));
-    }
-    constructor({ logger, sdkVersion, getCallback }){
-        this.logger = logger;
-        this.getCallback = getCallback;
-        this.sdkVersion = sdkVersion;
-        this.required = isRequiresSignedSessionId(sdkVersion, this.logger);
-        this.reverseChannelSupported = isReverseChannelSupported(sdkVersion, this.logger);
-    }
-}
-
 /**
  * Determines the recovery state of a wallet based on backup info and local shares.
  *
@@ -6351,6 +6422,7 @@ class DynamicWalletClient {
         return {
             location: core.BackupLocation.DYNAMIC,
             externalKeyShareId: data.keyShareIds[0],
+            externalKeyShareIds: data.keyShareIds,
             passwordEncrypted: isPasswordEncrypted,
             keygenId
         };
@@ -6647,7 +6719,7 @@ class DynamicWalletClient {
             // aborts the backup before activation, so an unrecoverable share is never
             // marked active; the local share is never touched.
             if (this.featureFlags[core.FEATURE_FLAGS.VERIFY_BACKUP_RECOVERABILITY_FLAG] === true) {
-                const dynamicKeyShareIds = locations.filter((loc)=>loc.location === core.BackupLocation.DYNAMIC && loc.externalKeyShareId).map((loc)=>loc.externalKeyShareId);
+                const dynamicKeyShareIds = collectDynamicKeyShareIds(locations);
                 await this.assertServerCopyRecoverable({
                     walletId: walletData.walletId,
                     shareSetId: targetShareSetId,