@dynamic-labs-wallet/browser 1.1.42 → 1.1.44

package/index.cjs

@@ -10,6 +10,7 @@ var axios = require('axios');
 var gte = require('semver/functions/gte');
 var ProviderEnum = require('@dynamic-labs/sdk-api-core/models/ProviderEnum');
 var PQueue = require('p-queue');
+var pTimeout = require('p-timeout');
 var redaction = require('@dynamic-labs/redaction');
 var ed25519 = require('@noble/curves/ed25519');
 var utils = require('@noble/curves/abstract/utils');
@@ -587,6 +588,10 @@ function meetsMinVersion(sdkVersion, { minVersionByNamespace, fallbackMinVersion
     'invalid_nonce_signature',
     'invalid_session_signature'
 ]);
+/** Reasons a fresh nonce fixes, so they may refresh on every attempt, not just once. */ const REFRESHABLE_NONCE_FAILURE_REASONS = new Set([
+    'nonce_already_used',
+    'nonce_not_found_or_expired'
+]);
 /** Best-effort extraction of the server error `code`/`message` from a 4xx body. */ const readErrorBody = (error)=>{
     var _error_response;
     if (!(error instanceof axios.AxiosError)) {
@@ -617,6 +622,9 @@ function meetsMinVersion(sdkVersion, { minVersionByNamespace, fallbackMinVersion
 };
 /** 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('not_found_or_expired') || haystack.includes('not found or expired')) {
+        return 'nonce_not_found_or_expired';
+    }
     if (haystack.includes('already_used') || haystack.includes('already used') || haystack.includes('consumption failed')) {
         return 'nonce_already_used';
     }
@@ -661,7 +669,8 @@ function meetsMinVersion(sdkVersion, { minVersionByNamespace, fallbackMinVersion
     }
     /**
    * Builds a `retryPromise` `shouldRetry` predicate that refreshes a consumed
-   * single-use nonce via the reverse channel on a replay 400 and retries once.
+   * single-use nonce via the reverse channel on a replay 400 and retries once
+   * (on every attempt when the body says the nonce was consumed or expired).
    * 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
@@ -673,18 +682,24 @@ function meetsMinVersion(sdkVersion, { minVersionByNamespace, fallbackMinVersion
         // triggered an `alsoRetry`), so the replay 400 can land on any attempt, not
         // just the first. Refresh on the first such 400 seen, whichever attempt
         // it's on, and never again — preserves the single-refresh-per-operation limit.
+        // A consumed or expired nonce is the exception: each fresh session may still
+        // pop a stale pooled nonce, so it refreshes on every attempt (bounded by the
+        // caller's maxAttempts).
         let hasRefreshed = false;
         return async (error, attempt)=>{
             const status = getHttpStatus(error);
+            const reason = status === 400 || status === 403 ? classifyNonceFailure(readErrorBody(error)) : undefined;
             // A 400 is a refreshable replay nonce; a 403 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 403s
             // (e.g. an exhausted add-signer grant) don't pollute the DYNT-1599 metric.
             // Only the 400 can actually refresh.
-            const isSessionSignatureFailure = status === 403 && SESSION_SIGNATURE_FAILURE_REASONS.has(classifyNonceFailure(readErrorBody(error)));
+            const isSessionSignatureFailure = status === 403 && reason !== undefined && SESSION_SIGNATURE_FAILURE_REASONS.has(reason);
+            const isRefreshableNonceFailure = status === 400 && reason !== undefined && REFRESHABLE_NONCE_FAILURE_REASONS.has(reason);
+            const canRefreshNow = isRefreshableNonceFailure || !hasRefreshed;
             const shouldInstrument = status === 400 || isSessionSignatureFailure;
             if (shouldInstrument) {
-                const willRefresh = status === 400 && !hasRefreshed && this.canRefresh && this.supportsReverseChannel();
+                const willRefresh = status === 400 && canRefreshNow && this.canRefresh && this.supportsReverseChannel();
                 this.instrumentNonceFailure({
                     error,
                     attempt,
@@ -694,7 +709,7 @@ function meetsMinVersion(sdkVersion, { minVersionByNamespace, fallbackMinVersion
                     logContext
                 });
             }
-            if (status === 400 && !hasRefreshed && this.canRefresh) {
+            if (status === 400 && canRefreshNow && 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({
@@ -901,6 +916,8 @@ const SESSION_KEY_MISMATCH_REASONS = new Set([
 ]);
 const NONCE_REASON_TO_BACKUP_REASON = {
     nonce_already_used: 'nonce_already_used',
+    // Same dashboard bucket as before CKS split this code out of nonce_already_used.
+    nonce_not_found_or_expired: 'nonce_already_used',
     invalid_nonce_signature: 'invalid_nonce_signature',
     invalid_session_signature: 'invalid_session_signature',
     other: 'signed_session'
@@ -2945,6 +2962,15 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
  * Queue manager for wallet operations.
  * Manages heavy operation queues (refresh/reshare/recover) and sign queues per wallet.
  */ class WalletQueueManager {
+    static releaseActiveSign(accountAddress) {
+        var _this_activeSignCounts_get;
+        const remaining = ((_this_activeSignCounts_get = this.activeSignCounts.get(accountAddress)) != null ? _this_activeSignCounts_get : 1) - 1;
+        if (remaining > 0) {
+            this.activeSignCounts.set(accountAddress, remaining);
+        } else {
+            this.activeSignCounts.delete(accountAddress);
+        }
+    }
     /**
    * Get or create the heavy operation queue for a wallet.
    * Heavy operations (refresh/reshare/recover) run with concurrency=1.
@@ -3114,7 +3140,8 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
         const holdState = {};
         // Add to sign queue - allows concurrent signing
         const resultPromise = signQueue.add(()=>{
-            this.walletsWithActiveSignOp.set(accountAddress, true);
+            var _this_activeSignCounts_get;
+            this.activeSignCounts.set(accountAddress, ((_this_activeSignCounts_get = this.activeSignCounts.get(accountAddress)) != null ? _this_activeSignCounts_get : 0) + 1);
             const hooks = {
                 reportPhase: (phase)=>{
                     currentPhase = phase;
@@ -3140,7 +3167,7 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
                 try {
                     return await callback(hooks);
                 } finally{
-                    this.walletsWithActiveSignOp.delete(accountAddress);
+                    this.releaseActiveSign(accountAddress);
                     holdState.release == null ? void 0 : holdState.release.call(holdState);
                     taskSettled = true;
                 }
@@ -3239,7 +3266,7 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
         const logRecoveryFinished = ()=>core.Logger.info(`[WalletQueueManager] Recovery finished for ${accountAddress} after ${Date.now() - recoveryStartedAt}ms`);
         // If we're already inside a heavy or sign operation for this wallet, execute directly
         // to avoid deadlock (heavy queue has concurrency=1, sign queue waits for idle)
-        if (this.walletsWithActiveHeavyOp.get(accountAddress) || this.walletsWithActiveSignOp.get(accountAddress)) {
+        if (this.walletsWithActiveHeavyOp.get(accountAddress) || this.activeSignCounts.get(accountAddress)) {
             core.Logger.debug(`[WalletQueueManager] Recovery called from within active op for ${accountAddress}, executing directly`);
             const directPromise = (async ()=>{
                 try {
@@ -3274,20 +3301,26 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
         return recoveryPromise;
     }
     /**
-   * Waits for the wallet's in-flight recovery, if any.
+   * Waits for the wallet's in-flight recovery, if any. With `bounded`, for at most `recoveryWaitCapMs`.
    * Never rejects: recovery failures are logged where they happen.
    *
-   * @returns `none` without a recovery, `settled` once it finished
-   */ static async waitForPendingRecovery(accountAddress) {
+   * @returns `none` without a recovery, `settled` once it finished, `capped` when the cap hit first
+   */ static async waitForPendingRecovery(accountAddress, { bounded = false } = {}) {
         const pending = this.pendingRecoveryPromises.get(normalizeAddress(accountAddress));
         if (!pending) {
             return 'none';
         }
-        // `pending` may reject; allSettled waits for it to end either way.
-        await Promise.allSettled([
+        // `pending` may reject; allSettled turns either outcome into "the recovery is over".
+        const recoveryOver = Promise.allSettled([
             pending
-        ]);
-        return 'settled';
+        ]).then(()=>'settled');
+        if (!bounded) {
+            return recoveryOver;
+        }
+        return pTimeout(recoveryOver, {
+            milliseconds: this.recoveryWaitCapMs,
+            fallback: ()=>'capped'
+        });
     }
     static getShareHolderQueue(address) {
         const existing = this.shareHolderQueues.get(address);
@@ -3319,19 +3352,21 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
         this.pendingRecoveryPromises.clear();
         this.shareHolderQueues.clear();
         this.walletsWithActiveHeavyOp.clear();
-        this.walletsWithActiveSignOp.clear();
+        this.activeSignCounts.clear();
         this.signQueueTimeoutMs = 20000;
+        this.recoveryWaitCapMs = 10000;
     }
 }
 /** Heavy operation queues per wallet address. These run with concurrency=1. */ WalletQueueManager.heavyOpQueues = new Map();
 /** Sign queues per wallet address. These allow concurrent operations. */ WalletQueueManager.signQueues = new Map();
 /** Timeout applied to new sign queues. Mutable for tests via resetForTesting. */ WalletQueueManager.signQueueTimeoutMs = 20000;
+/** Longest a bounded wait on an in-flight recovery lasts before the sign carries on with the shares it has. */ WalletQueueManager.recoveryWaitCapMs = 10000;
 /** Track pending recovery promises for deduplication */ WalletQueueManager.pendingRecoveryPromises = new Map();
 /** Per wallet, the signs that have loaded their key shares and not finished. */ WalletQueueManager.shareHolderQueues = new Map();
 /** Track which wallets are currently executing inside a heavy operation.
    * Used to prevent deadlocks when recovery is called from within a heavy op. */ WalletQueueManager.walletsWithActiveHeavyOp = new Map();
-/** 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();
+/** Count of signs currently running per wallet (a boolean is cleared by the first sign to finish).
+   * Used to prevent deadlocks when recovery is called from within a sign op. */ WalletQueueManager.activeSignCounts = new Map();
 
 const FLAP_WINDOW_MS = 60000;
 // Bounds memory on a socket that flaps indefinitely; the count saturates here.
@@ -4087,13 +4122,7 @@ class DynamicWalletClient {
                 this.restoreWallets()
             ];
             if (this.featureFlags[core.FEATURE_FLAGS.ENABLE_ROOM_CACHE_FLAG] === true) {
-                // Restore rooms first, then create rooms if needed (in series, but not blocking other initialization)
-                initializePromises.push(this.restoreRooms().then(()=>// assume two of two threshold signature scheme
-                    this.createRooms({
-                        roomType: RoomTypeEnum.RoomTypeEnum.Threshold,
-                        thresholdSignatureScheme: core.ThresholdSignatureScheme.TWO_OF_TWO,
-                        roomCount: ROOM_CACHE_COUNT
-                    })));
+                initializePromises.push(this.prefetchRoomPool());
             }
             await Promise.all(initializePromises);
             return {
@@ -4107,6 +4136,25 @@ class DynamicWalletClient {
             };
         }
     }
+    /**
+   * Restores the cached rooms, then creates more if the pool is low. Best effort: the pool is only a
+   * prefetch, and takeRooms() falls back and refills it later, so a failure (e.g. a dropped request)
+   * must not fail init. createRooms already logs its own error.
+   */ async prefetchRoomPool() {
+        try {
+            await this.restoreRooms();
+            // assume two of two threshold signature scheme
+            await this.createRooms({
+                roomType: RoomTypeEnum.RoomTypeEnum.Threshold,
+                thresholdSignatureScheme: core.ThresholdSignatureScheme.TWO_OF_TWO,
+                roomCount: ROOM_CACHE_COUNT
+            });
+        } catch (error) {
+            this.logger.debug('[DynamicWaasWalletClient] Room cache prefetch failed during init', {
+                error
+            });
+        }
+    }
     async serverInitializeKeyGen({ chainName, clientKeygenIds, dynamicRequestId, thresholdSignatureScheme, bitcoinConfig, businessAccountId, idempotencyKey, traceContext, onError, onCeremonyComplete }) {
         // Initialize keygen, create room, and create the wallet account on the server.
         // HTTP transport (flag on + idempotency key present) uses a single JSON
@@ -4831,14 +4879,14 @@ class DynamicWalletClient {
         return data;
     }
     /**
-   * The server half of `signAndBroadcast`: asks Dynamic to open the signing rooms and returns the transaction record.
+   * The server half of `signAndBroadcast`: asks Dynamic to open the signing room and returns the transaction record.
    *
    * @param params.walletId - The wallet that signs.
    * @param params.shareSetId - Which of the wallet's key sets to use. Defaults to its active one.
-   * @param params.messages - The transaction once per fee attempt, in fee order, as the bytes to sign (RLP hex on EVM, message bytes on Solana). Not hashed.
-   * @param params.contexts - What each message does in readable form (chain, recipient, amount), one per message in the same order. Dynamic checks each against the wallet and its policies.
+   * @param params.message - The transaction as the bytes to sign (RLP hex on EVM, message bytes on Solana). Not hashed.
+   * @param params.context - What the message does in readable form (chain, recipient, amount). Dynamic checks it against the wallet and its policies.
    * @param params.broadcastOptions - Solana send settings: other required signers' signatures, and skipping the pre-send dry run.
-   * @param params.roomIds - Signing rooms you already opened, one per message. Send all or none; Dynamic opens them when omitted.
+   * @param params.roomId - A signing room you already opened; Dynamic opens one when omitted.
    * @param params.requestedCertainty - How sure to be before calling it confirmed: `fast`, `safe` or `final`, or `chain:` plus a chain-specific value. Defaults to `safe`.
    * @param params.externalReference - Your own label, returned on every event. Not unique.
    * @param params.idempotencyKey - Makes a retry safe: the same key replays the stored answer instead of sending twice.
@@ -4848,15 +4896,15 @@ class DynamicWalletClient {
    * @param params.onError - Called with the failure's message, never the raw error.
    * @param params.dynamicRequestId - Id of this one request, to match client and server logs.
    * @param params.traceContext - Ties this call's logs to the server's, across retries. Created when omitted.
-   */ async serverSignAndBroadcast({ walletId, shareSetId, contexts, broadcastOptions, messages, roomIds, requestedCertainty, externalReference, idempotencyKey, mfaToken, elevatedAccessToken, approvalQuorum, onError, dynamicRequestId, traceContext }) {
-        // Opens one signing room per message, unless `roomIds` names them, and returns the transaction record.
+   */ async serverSignAndBroadcast({ walletId, shareSetId, context, broadcastOptions, message, roomId, requestedCertainty, externalReference, idempotencyKey, mfaToken, elevatedAccessToken, approvalQuorum, onError, dynamicRequestId, traceContext }) {
+        // Opens a signing room, unless `roomId` names one, and returns the transaction record.
         return await this.apiClient.signAndBroadcast({
             walletId,
             shareSetId,
-            contexts: contexts.map((context)=>core.toJsonSafeContext(context)),
+            context: core.toJsonSafeContext(context),
             broadcastOptions,
-            messages,
-            roomIds,
+            message,
+            roomId,
             isFormatted: false,
             requestedCertainty,
             externalReference,
@@ -5314,12 +5362,12 @@ class DynamicWalletClient {
             }));
     }
     /**
-   * Signs a transaction for Dynamic to broadcast, one signing ceremony per message. The signature stays on the server.
+   * Signs a transaction for Dynamic to broadcast. The signature stays on the server.
    *
    * @param params.accountAddress - The wallet's address.
    * @param params.chainName - The wallet's chain, e.g. `EVM`.
-   * @param params.messages - The transaction once per fee attempt, in fee order, as the bytes to sign (RLP hex on EVM, message bytes on Solana). Not hashed.
-   * @param params.contexts - What each message does in readable form (chain, recipient, amount), one per message in the same order. Dynamic checks each against the wallet and its policies.
+   * @param params.message - The transaction as the bytes to sign (RLP hex on EVM, message bytes on Solana). Not hashed.
+   * @param params.context - What the message does in readable form (chain, recipient, amount). Dynamic checks it against the wallet and its policies.
    * @param params.broadcastOptions - Solana send settings: other required signers' signatures, and skipping the pre-send dry run.
    * @param params.password - The wallet's backup password, if it has one.
    * @param params.signedSessionId - The signed-in session, used to unlock the wallet's key share.
@@ -5332,18 +5380,13 @@ class DynamicWalletClient {
    * @param params.onError - Called with the failure's message, never the raw error.
    * @param params.traceContext - Ties this call's logs to the server's, across retries. Created when omitted.
    * @returns The transaction record. A finished one comes back without signing again.
-   * @throws Error when `contexts` and `messages` differ in length.
-   */ async signAndBroadcast({ accountAddress, chainName, contexts, broadcastOptions, messages, password = undefined, signedSessionId, mfaToken, elevatedAccessToken, approvalQuorum, requestedCertainty, externalReference, idempotencyKey = uuid.v4(), onError, traceContext }) {
-        // Each fee attempt is one message and one context; a mismatch is the caller's, so it is named here, before any ceremony.
-        if (messages.length === 0 || contexts.length !== messages.length) {
-            throw new Error(`Sign and broadcast needs one signing context per message, got ${contexts.length} contexts for ${messages.length} messages`);
-        }
-        return this.queueSign(accountAddress, ({ reportPhase, readingShares })=>this.internalSignAndBroadcast({
+   */ async signAndBroadcast({ accountAddress, chainName, context, broadcastOptions, message, password = undefined, signedSessionId, mfaToken, elevatedAccessToken, approvalQuorum, requestedCertainty, externalReference, idempotencyKey = uuid.v4(), onError, traceContext }) {
+        return this.queueSign(accountAddress, ({ reportPhase, reportDetails, readingShares })=>this.internalSignAndBroadcast({
                 accountAddress,
                 chainName,
-                contexts,
+                context,
                 broadcastOptions,
-                messages,
+                message,
                 password,
                 signedSessionId,
                 mfaToken,
@@ -5355,17 +5398,21 @@ class DynamicWalletClient {
                 onError,
                 traceContext,
                 onSignPhase: reportPhase,
+                onSignDetails: reportDetails,
                 onReadingShares: readingShares
             }));
     }
     /**
-   * Does the work of `signAndBroadcast` once it has its turn in the wallet queue: loads the wallet, asks Dynamic to open the rooms, then signs in each.
+   * Does the work of `signAndBroadcast` once it has its turn in the wallet queue: loads the wallet, asks Dynamic to open the room, then signs in it.
    *
    * Takes the same fields as `signAndBroadcast`.
    *
    * @param params.onSignPhase - Reports which step it is on, so the queue can tell which step used up the time.
-   */ async internalSignAndBroadcast({ accountAddress, chainName, contexts, broadcastOptions, messages, password, signedSessionId, mfaToken, elevatedAccessToken, approvalQuorum, requestedCertainty, externalReference, idempotencyKey, onError, traceContext, onSignPhase, onReadingShares, staleShareRetry = false, roomIdRetry = false }) {
+   */ async internalSignAndBroadcast({ accountAddress, chainName, context, broadcastOptions, message, password, signedSessionId, mfaToken, elevatedAccessToken, approvalQuorum, requestedCertainty, externalReference, idempotencyKey, onError, traceContext, onSignPhase, onSignDetails, onReadingShares, staleShareRetry = false, roomIdRetry = false }) {
         const dynamicRequestId = uuid.v4();
+        onSignDetails == null ? void 0 : onSignDetails({
+            dynamicRequestId
+        });
         traceContext = core.withTraceId(traceContext);
         let stage = 'prepareWallet';
         let roomIdSource;
@@ -5375,7 +5422,6 @@ class DynamicWalletClient {
             accountAddress,
             chainName,
             dynamicRequestId,
-            attemptCount: messages.length,
             staleShareRetry,
             roomIdRetry
         }, this.getTraceContext(traceContext)));
@@ -5389,8 +5435,15 @@ class DynamicWalletClient {
             });
             stage = 'resolveCachedRoom';
             onSignPhase == null ? void 0 : onSignPhase('resolveCachedRoom');
-            const roomIds = roomIdRetry ? undefined : await this.getCachedRoomsForSignAndBroadcast(wallet, accountAddress, chainName, messages.length, dynamicRequestId, traceContext);
-            roomIdSource = roomIds ? 'cache' : 'server';
+            const cachedRoomId = roomIdRetry ? undefined : await this.getCachedRoom({
+                wallet,
+                accountAddress,
+                chainName,
+                key: 'signAndBroadcast',
+                dynamicRequestId,
+                traceContext
+            });
+            roomIdSource = cachedRoomId ? 'cache' : 'server';
             const roomsResolvedAt = Date.now();
             this.logSlowSignPreflight({
                 accountAddress,
@@ -5408,10 +5461,10 @@ class DynamicWalletClient {
             const record = await this.serverSignAndBroadcast({
                 walletId: wallet.walletId,
                 shareSetId: wallet.shareSetId,
-                contexts,
+                context,
                 broadcastOptions,
-                messages,
-                roomIds,
+                message,
+                roomId: cachedRoomId,
                 requestedCertainty,
                 externalReference,
                 idempotencyKey,
@@ -5422,9 +5475,7 @@ class DynamicWalletClient {
                 dynamicRequestId,
                 traceContext
             });
-            var _record_rooms;
-            const rooms = (_record_rooms = record.rooms) != null ? _record_rooms : [];
-            var _roomIds_length;
+            const room = record.room;
             this.logger.info('[DynamicWaasWalletClient] Sign and broadcast accepted', _extends({
                 key: 'signAndBroadcast',
                 operation: 'accepted',
@@ -5433,38 +5484,30 @@ class DynamicWalletClient {
                 dynamicRequestId,
                 transactionId: record.transactionId,
                 transactionStatus: record.status,
-                attemptCount: messages.length,
-                roomIdSource,
-                roomsSent: (_roomIds_length = roomIds == null ? void 0 : roomIds.length) != null ? _roomIds_length : 0,
-                roomsReturned: rooms.length,
-                // A retry of an existing row names that row's rooms, not the ones just sent.
-                returnedRoomsMatchSent: roomIds ? roomIds.every((roomId, index)=>{
-                    var _rooms_index;
-                    return ((_rooms_index = rooms[index]) == null ? void 0 : _rooms_index.roomId) === roomId;
-                }) : undefined
+                roomIdSource
             }, this.getTraceContext(traceContext)));
-            // A retry of a finished request returns the record without rooms.
+            // A retry of a finished request returns the record without a room.
             if (record.status !== 'pending_signature') {
                 return record;
             }
-            if (rooms.length !== messages.length) {
-                throw new Error(`Expected ${messages.length} signing rooms, got ${rooms.length} for transaction ${record.transactionId}`);
+            if (!room) {
+                throw new Error(`Expected a signing room for transaction ${record.transactionId}`);
             }
             stage = 'ceremony';
             onSignPhase == null ? void 0 : onSignPhase('ceremony');
-            const ceremonies = Promise.all(rooms.map((room, index)=>this.clientSign({
-                    chainName,
-                    message: messages[index],
-                    roomId: room.roomId,
-                    keyShare: clientKeyShares[0],
-                    derivationPath,
-                    isFormatted: false,
-                    dynamicRequestId,
-                    traceContext,
-                    variant: wallet.variant,
-                    // Nothing mints a replacement room for a broadcast attempt.
-                    skipForwardMPC: true
-                })));
+            const ceremonies = this.clientSign({
+                chainName,
+                message,
+                roomId: room.roomId,
+                keyShare: clientKeyShares[0],
+                derivationPath,
+                isFormatted: false,
+                dynamicRequestId,
+                traceContext,
+                variant: wallet.variant,
+                // Nothing mints a replacement room for a broadcast.
+                skipForwardMPC: true
+            });
             const getClientSignMismatch = this.trackClientSignMismatch(ceremonies, {
                 accountAddress,
                 chainName,
@@ -5495,7 +5538,7 @@ class DynamicWalletClient {
             this.logger.info('[DynamicWaasWalletClient] Client sign completed', _extends({
                 accountAddress,
                 chainName,
-                roomIds: rooms.map((room)=>room.roomId),
+                roomId: room.roomId,
                 dynamicRequestId,
                 key: 'signAndBroadcast',
                 operation: 'clientSign'
@@ -5505,9 +5548,9 @@ class DynamicWalletClient {
             const retryParams = {
                 accountAddress,
                 chainName,
-                contexts,
+                context,
                 broadcastOptions,
-                messages,
+                message,
                 password,
                 signedSessionId,
                 mfaToken,
@@ -5519,6 +5562,7 @@ class DynamicWalletClient {
                 onError,
                 traceContext,
                 onSignPhase,
+                onSignDetails,
                 onReadingShares
             };
             // The server rejected the local shares as stale before opening any room. Heal them
@@ -5550,9 +5594,9 @@ class DynamicWalletClient {
                 }));
             }
             // A cached room was already claimed by an earlier ceremony. Retry once with the same
-            // idempotency key and no cached rooms, so the server opens fresh ones.
+            // idempotency key and no cached room, so the server opens a fresh one.
             if (!roomIdRetry && isRoomIdAlreadyUsedError(error)) {
-                this.logger.info('[RoomCache] retrying sign and broadcast without cached rooms after 409 ROOM_ID_ALREADY_USED', _extends({
+                this.logger.info('[RoomCache] retrying sign and broadcast without a cached room after 409 ROOM_ID_ALREADY_USED', _extends({
                     key: 'signAndBroadcast',
                     operation: 'roomIdRetry',
                     accountAddress,
@@ -5575,7 +5619,6 @@ class DynamicWalletClient {
                 operation: 'signAndBroadcast',
                 details: {
                     stage,
-                    attemptCount: messages.length,
                     roomIdSource,
                     staleShareRetry,
                     roomIdRetry
@@ -5613,95 +5656,67 @@ class DynamicWalletClient {
         }, this.getTraceContext(traceContext)));
     }
     /**
-   * Takes one already-opened room per message from the local pool, or none: a partial set saves nothing, so the server opens them all instead.
+   * Takes one already-opened room from the local pool for a sign or a sign-and-broadcast, or none when the cache is off or empty, so the server opens one instead.
    *
-   * @param wallet - The wallet signing; its key scheme decides which rooms fit.
-   * @param accountAddress - The wallet's address, for logs.
-   * @param chainName - The wallet's chain, for logs.
-   * @param count - How many rooms are needed: one per message.
-   * @param dynamicRequestId - Id of this request, so the pool's logs join the sign's.
-   * @param traceContext - Trace ids for the same reason.
-   * @returns The room ids, or `undefined` when the pool cannot cover every message.
-   */ async getCachedRoomsForSignAndBroadcast(wallet, accountAddress, chainName, count, dynamicRequestId, traceContext) {
+   * @param params.wallet - The wallet signing; its key scheme decides which room fits.
+   * @param params.accountAddress - The wallet's address, for logs.
+   * @param params.chainName - The wallet's chain, for logs.
+   * @param params.key - Which operation is asking, for logs.
+   * @param params.dynamicRequestId - Id of this request, so the pool's logs join the operation's.
+   * @param params.traceContext - Trace ids for the same reason.
+   * @returns The room id, or `undefined`.
+   */ async getCachedRoom({ wallet, accountAddress, chainName, key, dynamicRequestId, traceContext }) {
         const logContext = _extends({
             dynamicRequestId
         }, this.getTraceContext(traceContext));
         if (this.featureFlags[core.FEATURE_FLAGS.ENABLE_ROOM_CACHE_FLAG] !== true) {
-            this.logCachedRoomsUnavailable({
+            this.logCachedRoomUnavailable({
                 reason: 'cache_disabled',
+                key,
                 accountAddress,
                 chainName,
-                count,
                 logContext
             });
             return undefined;
         }
-        const rooms = await this.takeRooms({
-            roomType: RoomTypeEnum.RoomTypeEnum.Threshold,
-            thresholdSignatureScheme: wallet.thresholdSignatureScheme,
-            count,
-            logContext
-        });
-        if (rooms.length === 0) {
-            this.logCachedRoomsUnavailable({
-                reason: 'pool_too_small',
+        const room = await this.getRoom(RoomTypeEnum.RoomTypeEnum.Threshold, wallet.thresholdSignatureScheme, logContext);
+        if (!room) {
+            this.logCachedRoomUnavailable({
+                reason: 'pool_empty',
+                key,
                 accountAddress,
                 chainName,
-                count,
                 logContext
             });
             return undefined;
         }
-        const roomIds = rooms.map((room)=>room.roomId);
-        this.logger.info('[DynamicWaasWalletClient] Using cached rooms', _extends({
-            key: 'signAndBroadcast',
-            operation: 'cachedRoomsFound',
+        this.logger.info('[DynamicWaasWalletClient] Using cached room', _extends({
+            key,
+            operation: 'cachedRoomFound',
             accountAddress,
             chainName,
             walletId: wallet.walletId,
-            roomIds
+            roomId: room.roomId
         }, logContext));
-        return roomIds;
+        return room.roomId;
     }
     /**
-   * Logs why no cached rooms were sent, so how often the cache covers a request can be measured.
+   * Logs why no cached room was sent, so how often the cache covers a request can be measured.
    *
-   * @param params.reason - `cache_disabled` or `pool_too_small`.
+   * @param params.reason - `cache_disabled` or `pool_empty`.
+   * @param params.key - Which operation asked.
    * @param params.accountAddress - The wallet's address.
    * @param params.chainName - The wallet's chain.
-   * @param params.count - How many rooms were needed.
    * @param params.logContext - Request and trace ids to attach.
-   */ logCachedRoomsUnavailable({ reason, accountAddress, chainName, count, logContext }) {
-        this.logger.info('[DynamicWaasWalletClient] Cached rooms unavailable; the server opens them', _extends({
-            key: 'signAndBroadcast',
-            operation: 'cachedRoomsUnavailable',
+   */ logCachedRoomUnavailable({ reason, key, accountAddress, chainName, logContext }) {
+        this.logger.info('[DynamicWaasWalletClient] Cached room unavailable; the server opens one', _extends({
+            key,
+            operation: 'cachedRoomUnavailable',
             reason,
             accountAddress,
-            chainName,
-            requestedCount: count
+            chainName
         }, logContext));
     }
-    async getCachedRoomForSign(wallet, accountAddress, chainName, dynamicRequestId, traceContext) {
-        if (this.featureFlags[core.FEATURE_FLAGS.ENABLE_ROOM_CACHE_FLAG] !== true) {
-            return undefined;
-        }
-        const logContext = _extends({
-            dynamicRequestId
-        }, this.getTraceContext(traceContext));
-        const room = await this.getRoom(RoomTypeEnum.RoomTypeEnum.Threshold, wallet.thresholdSignatureScheme, logContext);
-        const roomId = room == null ? void 0 : room.roomId;
-        if (roomId) {
-            this.logger.info('[DynamicWaasWalletClient] Using cached room', _extends({
-                key: 'sign',
-                operation: 'cachedRoomFound',
-                accountAddress,
-                chainName,
-                walletId: wallet.walletId,
-                roomId
-            }, logContext));
-        }
-        return roomId;
-    }
     // Without a cached room the client depends on the server reporting one
     // before it can join the ceremony.
     async resolveSignRoom({ cachedRoomId, serverSignPromise, accountAddress, chainName, walletId, dynamicRequestId, traceContext }) {
@@ -5785,7 +5800,8 @@ class DynamicWalletClient {
         const derivationPath = wallet.derivationPath && wallet.derivationPath != '' ? new Uint32Array(Object.values(JSON.parse(wallet.derivationPath))) : undefined;
         onSignPhase == null ? void 0 : onSignPhase('ensureClientShare');
         const clientKeyShares = await this.ensureClientShare(accountAddress, {
-            onReadingShares
+            onReadingShares,
+            boundRecoveryWait: true
         });
         const sharesReadyAt = Date.now();
         return {
@@ -5891,7 +5907,14 @@ class DynamicWalletClient {
                 onReadingShares
             });
             onSignPhase == null ? void 0 : onSignPhase('resolveCachedRoom');
-            const cachedRoomId = roomIdRetry ? undefined : await this.getCachedRoomForSign(wallet, accountAddress, chainName, dynamicRequestId, traceContext);
+            const cachedRoomId = roomIdRetry ? undefined : await this.getCachedRoom({
+                wallet,
+                accountAddress,
+                chainName,
+                key: 'sign',
+                dynamicRequestId,
+                traceContext
+            });
             const roomResolvedAt = Date.now();
             this.logSlowSignPreflight({
                 accountAddress,
@@ -8348,22 +8371,26 @@ class DynamicWalletClient {
    * Note: This method only checks for existing shares in storage.
    * Auto-recovery logic has been removed in favor of the queue pattern.
    * Callers should handle recovery explicitly if needed.
-   */ async ensureClientShare(accountAddress, { onReadingShares } = {}) {
+   */ async ensureClientShare(accountAddress, { onReadingShares, boundRecoveryWait = false } = {}) {
         // A recovery may be in flight (e.g. a stale-share heal scheduled when a
         // previous sign hit a public-key mismatch). Wait for it so this operation
         // reads the recovered shares instead of the superseded ones. Recovery
         // failures are logged where they happen; this operation should proceed
-        // with whatever shares exist rather than fail on the recovery.
+        // with whatever shares exist rather than fail on the recovery. A sign bounds the wait so a slow recovery cannot
+        // eat its whole queue budget; after the cap it continues with the stored shares (a stale one is retried).
         const waitStartedAt = Date.now();
-        const recoveryWait = await WalletQueueManager.waitForPendingRecovery(accountAddress);
-        if (recoveryWait === 'settled') {
+        const recoveryWait = await WalletQueueManager.waitForPendingRecovery(accountAddress, {
+            bounded: boundRecoveryWait
+        });
+        if (recoveryWait !== 'none') {
             // Every concurrent sign awaits this same promise, so it releases them all
             // at once. One line per waiter: the count is the size of the herd and the
             // shared finish timestamp is when it was released.
             this.logger.info('[SignPreflight] sign waited on in-flight recovery', {
                 accountAddress,
                 environmentId: this.environmentId,
-                recoveryWaitMs: Date.now() - waitStartedAt
+                recoveryWaitMs: Date.now() - waitStartedAt,
+                recoveryWaitCapped: recoveryWait === 'capped'
             });
         }
         // From here a recovery waits for this sign to finish, so it cannot replace the shares being read.
@@ -11208,6 +11235,17 @@ class DynamicWalletClient {
         }
         this.apiClient.syncAuthToken(authToken);
     }
+    /** Reads the persisted room pool. A corrupt value counts as empty, so the next write replaces it. */ async readStoredRooms() {
+        const rawData = await this.storage.getItem(`${this.storageKey}-rooms`);
+        if (!rawData) {
+            return {};
+        }
+        try {
+            return JSON.parse(rawData);
+        } catch (e) {
+            return {};
+        }
+    }
     async createRooms({ roomType, thresholdSignatureScheme, roomCount = 5 }) {
         const numberOfParties = this.getNumberOfParties(roomType, thresholdSignatureScheme);
         const generation = DynamicWalletClient.roomsGeneration;
@@ -11249,8 +11287,7 @@ class DynamicWalletClient {
                 // Re-read from storage under the lock so we don't clobber rooms another
                 // tab just wrote, and so we don't lose rooms consumed by getRoom() calls
                 // that ran while our API request was in-flight.
-                const rawData = await this.storage.getItem(`${this.storageKey}-rooms`);
-                const storedRooms = rawData ? JSON.parse(rawData) : {};
+                const storedRooms = await this.readStoredRooms();
                 const currentRooms = storedRooms[numberOfParties] || [];
                 await this.setRooms(numberOfParties, [
                     ...newRooms,
@@ -11367,8 +11404,7 @@ class DynamicWalletClient {
             // already consumed by other tabs. Combined with the Web Locks API below, this
             // makes room consumption atomic across tabs and prevents two tabs from both
             // receiving the same cached room.
-            const rawData = await this.storage.getItem(`${this.storageKey}-rooms`);
-            const storedRooms = rawData ? JSON.parse(rawData) : {};
+            const storedRooms = await this.readStoredRooms();
             const now = Date.now();
             const schemeRooms = storedRooms[numberOfParties] || [];
             // Filter out expired rooms and remove the next available room.