@dynamic-labs-wallet/browser 1.1.42 → 1.1.43

package/index.cjs

@@ -587,6 +587,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 +621,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 +668,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 +681,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 +708,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 +915,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'
@@ -4087,13 +4103,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 +4117,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 +4860,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 +4877,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 +5343,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 +5361,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 +5379,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 +5403,6 @@ class DynamicWalletClient {
             accountAddress,
             chainName,
             dynamicRequestId,
-            attemptCount: messages.length,
             staleShareRetry,
             roomIdRetry
         }, this.getTraceContext(traceContext)));
@@ -5389,8 +5416,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 +5442,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 +5456,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 +5465,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 +5519,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 +5529,9 @@ class DynamicWalletClient {
             const retryParams = {
                 accountAddress,
                 chainName,
-                contexts,
+                context,
                 broadcastOptions,
-                messages,
+                message,
                 password,
                 signedSessionId,
                 mfaToken,
@@ -5519,6 +5543,7 @@ class DynamicWalletClient {
                 onError,
                 traceContext,
                 onSignPhase,
+                onSignDetails,
                 onReadingShares
             };
             // The server rejected the local shares as stale before opening any room. Heal them
@@ -5550,9 +5575,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 +5600,6 @@ class DynamicWalletClient {
                 operation: 'signAndBroadcast',
                 details: {
                     stage,
-                    attemptCount: messages.length,
                     roomIdSource,
                     staleShareRetry,
                     roomIdRetry
@@ -5613,95 +5637,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 }) {
@@ -5891,7 +5887,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,
@@ -11208,6 +11211,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 +11263,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 +11380,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.