@dynamic-labs-wallet/browser 1.1.41 → 1.1.43

package/index.esm.js

@@ -588,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 AxiosError)) {
@@ -618,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';
     }
@@ -662,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
@@ -674,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,
@@ -695,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({
@@ -902,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'
@@ -3112,6 +3128,7 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
         // a reference to observe how it eventually settles.
         let taskPromise;
         let taskSettled = false;
+        const holdState = {};
         // Add to sign queue - allows concurrent signing
         const resultPromise = signQueue.add(()=>{
             this.walletsWithActiveSignOp.set(accountAddress, true);
@@ -3129,6 +3146,11 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
                         delete signDetails.forwardMpcFailure;
                     }
                     Object.assign(signDetails, details);
+                },
+                readingShares: ()=>{
+                    var _holdState;
+                    var _release;
+                    (_release = (_holdState = holdState).release) != null ? _release : _holdState.release = this.holdShares(accountAddress);
                 }
             };
             taskPromise = (async ()=>{
@@ -3136,6 +3158,7 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
                     return await callback(hooks);
                 } finally{
                     this.walletsWithActiveSignOp.delete(accountAddress);
+                    holdState.release == null ? void 0 : holdState.release.call(holdState);
                     taskSettled = true;
                 }
             })();
@@ -3149,6 +3172,8 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
             if (!isQueueTimeout) {
                 return;
             }
+            // A timed-out sign no longer counts for the queue, so it stops counting as a share holder too.
+            holdState.release == null ? void 0 : holdState.release.call(holdState);
             logError({
                 message: '[WalletQueueManager] Sign queue timed out',
                 error: error,
@@ -3266,12 +3291,50 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
         return recoveryPromise;
     }
     /**
+   * Waits for the wallet's in-flight recovery, if any.
+   * Never rejects: recovery failures are logged where they happen.
+   *
+   * @returns `none` without a recovery, `settled` once it finished
+   */ static async waitForPendingRecovery(accountAddress) {
+        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
+        ]);
+        return 'settled';
+    }
+    static getShareHolderQueue(address) {
+        const existing = this.shareHolderQueues.get(address);
+        if (existing) {
+            return existing;
+        }
+        const queue = new PQueue({
+            concurrency: Infinity
+        });
+        this.shareHolderQueues.set(address, queue);
+        return queue;
+    }
+    /** Registers a sign as holding its shares until the returned function is called. */ static holdShares(address) {
+        const hold = {
+            release: ()=>undefined
+        };
+        const held = new Promise((resolve)=>{
+            hold.release = resolve;
+        });
+        void this.getShareHolderQueue(address).add(()=>held);
+        return ()=>hold.release();
+    }
+    /**
    * Reset static state for testing purposes.
    * This clears all wallet queues and pending recovery promises.
    */ static resetForTesting() {
         this.heavyOpQueues.clear();
         this.signQueues.clear();
         this.pendingRecoveryPromises.clear();
+        this.shareHolderQueues.clear();
         this.walletsWithActiveHeavyOp.clear();
         this.walletsWithActiveSignOp.clear();
         this.signQueueTimeoutMs = 20000;
@@ -3281,6 +3344,7 @@ const createDynamicOnlyDistribution = ({ allShares })=>({
 /** 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;
 /** 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.
@@ -4040,13 +4104,7 @@ class DynamicWalletClient {
                 this.restoreWallets()
             ];
             if (this.featureFlags[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.Threshold,
-                        thresholdSignatureScheme: ThresholdSignatureScheme.TWO_OF_TWO,
-                        roomCount: ROOM_CACHE_COUNT
-                    })));
+                initializePromises.push(this.prefetchRoomPool());
             }
             await Promise.all(initializePromises);
             return {
@@ -4060,6 +4118,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.Threshold,
+                thresholdSignatureScheme: 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
@@ -4784,14 +4861,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.
@@ -4801,15 +4878,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)=>toJsonSafeContext(context)),
+            context: toJsonSafeContext(context),
             broadcastOptions,
-            messages,
-            roomIds,
+            message,
+            roomId,
             isFormatted: false,
             requestedCertainty,
             externalReference,
@@ -5247,7 +5324,7 @@ class DynamicWalletClient {
     }
     //todo: need to modify with imported flag
     async sign({ accountAddress, message, chainName, password = undefined, isFormatted = false, signedSessionId, mfaToken, elevatedAccessToken, context, approvalQuorum, onError, traceContext, bitcoinConfig }) {
-        return this.queueSign(accountAddress, ({ reportPhase, reportDetails })=>this.internalSign({
+        return this.queueSign(accountAddress, ({ reportPhase, reportDetails, readingShares })=>this.internalSign({
                 accountAddress,
                 message,
                 chainName,
@@ -5262,16 +5339,17 @@ class DynamicWalletClient {
                 traceContext,
                 bitcoinConfig,
                 onSignPhase: reportPhase,
-                onSignDetails: reportDetails
+                onSignDetails: reportDetails,
+                onReadingShares: readingShares
             }));
     }
     /**
-   * 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.
@@ -5284,18 +5362,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 = 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 })=>this.internalSignAndBroadcast({
+   */ async signAndBroadcast({ accountAddress, chainName, context, broadcastOptions, message, password = undefined, signedSessionId, mfaToken, elevatedAccessToken, approvalQuorum, requestedCertainty, externalReference, idempotencyKey = v4(), onError, traceContext }) {
+        return this.queueSign(accountAddress, ({ reportPhase, reportDetails, readingShares })=>this.internalSignAndBroadcast({
                 accountAddress,
                 chainName,
-                contexts,
+                context,
                 broadcastOptions,
-                messages,
+                message,
                 password,
                 signedSessionId,
                 mfaToken,
@@ -5306,17 +5379,22 @@ class DynamicWalletClient {
                 idempotencyKey,
                 onError,
                 traceContext,
-                onSignPhase: reportPhase
+                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, 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 = v4();
+        onSignDetails == null ? void 0 : onSignDetails({
+            dynamicRequestId
+        });
         traceContext = withTraceId(traceContext);
         let stage = 'prepareWallet';
         let roomIdSource;
@@ -5326,7 +5404,6 @@ class DynamicWalletClient {
             accountAddress,
             chainName,
             dynamicRequestId,
-            attemptCount: messages.length,
             staleShareRetry,
             roomIdRetry
         }, this.getTraceContext(traceContext)));
@@ -5335,12 +5412,20 @@ class DynamicWalletClient {
                 accountAddress,
                 password,
                 signedSessionId,
-                onSignPhase
+                onSignPhase,
+                onReadingShares
             });
             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,
@@ -5358,10 +5443,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,
@@ -5372,9 +5457,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',
@@ -5383,38 +5466,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,
@@ -5445,7 +5520,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'
@@ -5455,9 +5530,9 @@ class DynamicWalletClient {
             const retryParams = {
                 accountAddress,
                 chainName,
-                contexts,
+                context,
                 broadcastOptions,
-                messages,
+                message,
                 password,
                 signedSessionId,
                 mfaToken,
@@ -5468,7 +5543,9 @@ class DynamicWalletClient {
                 idempotencyKey,
                 onError,
                 traceContext,
-                onSignPhase
+                onSignPhase,
+                onSignDetails,
+                onReadingShares
             };
             // The server rejected the local shares as stale before opening any room. Heal them
             // from backup and retry once with the same idempotency key, as plain signing does.
@@ -5499,9 +5576,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,
@@ -5524,7 +5601,6 @@ class DynamicWalletClient {
                 operation: 'signAndBroadcast',
                 details: {
                     stage,
-                    attemptCount: messages.length,
                     roomIdSource,
                     staleShareRetry,
                     roomIdRetry
@@ -5562,95 +5638,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[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.Threshold,
-            thresholdSignatureScheme: wallet.thresholdSignatureScheme,
-            count,
-            logContext
-        });
-        if (rooms.length === 0) {
-            this.logCachedRoomsUnavailable({
-                reason: 'pool_too_small',
+        const room = await this.getRoom(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[FEATURE_FLAGS.ENABLE_ROOM_CACHE_FLAG] !== true) {
-            return undefined;
-        }
-        const logContext = _extends({
-            dynamicRequestId
-        }, this.getTraceContext(traceContext));
-        const room = await this.getRoom(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 }) {
@@ -5714,7 +5762,7 @@ class DynamicWalletClient {
             clearTimeout(warningTimer);
         }
     }
-    /** Verifies the password, loads the wallet and makes sure its client share exists: the start of every sign. */ async prepareWalletForSign({ accountAddress, password, signedSessionId, onSignPhase }) {
+    /** Verifies the password, loads the wallet and makes sure its client share exists: the start of every sign. */ async prepareWalletForSign({ accountAddress, password, signedSessionId, onSignPhase, onReadingShares }) {
         const startedAt = Date.now();
         onSignPhase == null ? void 0 : onSignPhase('verifyPassword');
         await this.verifyPassword({
@@ -5733,7 +5781,9 @@ class DynamicWalletClient {
         const walletLoadedAt = Date.now();
         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);
+        const clientKeyShares = await this.ensureClientShare(accountAddress, {
+            onReadingShares
+        });
         const sharesReadyAt = Date.now();
         return {
             wallet,
@@ -5809,7 +5859,7 @@ class DynamicWalletClient {
             }, describeErrorForLog(error), details, this.getTraceContext(traceContext))
         });
     }
-    async internalSign({ accountAddress, message, chainName, password = undefined, isFormatted = false, signedSessionId, mfaToken, elevatedAccessToken, context, approvalQuorum, onError, traceContext, bitcoinConfig, onSignPhase, onSignDetails, staleShareRetry = false, roomIdRetry = false }) {
+    async internalSign({ accountAddress, message, chainName, password = undefined, isFormatted = false, signedSessionId, mfaToken, elevatedAccessToken, context, approvalQuorum, onError, traceContext, bitcoinConfig, onSignPhase, onSignDetails, onReadingShares, staleShareRetry = false, roomIdRetry = false }) {
         const dynamicRequestId = v4();
         onSignDetails == null ? void 0 : onSignDetails({
             dynamicRequestId
@@ -5834,10 +5884,18 @@ class DynamicWalletClient {
                 accountAddress,
                 password,
                 signedSessionId,
-                onSignPhase
+                onSignPhase,
+                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,
@@ -6080,6 +6138,7 @@ class DynamicWalletClient {
                     bitcoinConfig,
                     onSignPhase,
                     onSignDetails,
+                    onReadingShares,
                     staleShareRetry: true,
                     roomIdRetry
                 });
@@ -6109,6 +6168,7 @@ class DynamicWalletClient {
                     bitcoinConfig,
                     onSignPhase,
                     onSignDetails,
+                    onReadingShares,
                     staleShareRetry,
                     roomIdRetry: true
                 });
@@ -8292,17 +8352,15 @@ 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) {
+   */ async ensureClientShare(accountAddress, { onReadingShares } = {}) {
         // 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.
-        const pendingRecovery = WalletQueueManager.getPendingRecoveryPromise(accountAddress);
-        if (pendingRecovery) {
-            const waitStartedAt = Date.now();
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            await pendingRecovery.catch(()=>{});
+        const waitStartedAt = Date.now();
+        const recoveryWait = await WalletQueueManager.waitForPendingRecovery(accountAddress);
+        if (recoveryWait === 'settled') {
             // 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.
@@ -8312,6 +8370,8 @@ class DynamicWalletClient {
                 recoveryWaitMs: Date.now() - waitStartedAt
             });
         }
+        // From here a recovery waits for this sign to finish, so it cannot replace the shares being read.
+        onReadingShares == null ? void 0 : onReadingShares();
         const shares = await this.getClientKeySharesFromStorage({
             accountAddress
         });
@@ -11152,6 +11212,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;
@@ -11193,8 +11264,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,
@@ -11311,8 +11381,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.