@domino-sdk/relay 1.11.1 → 1.15.0

package/dist/{chunk-XK5E4HAS.js → chunk-PJXBW754.js}

@@ -1,7 +1,7 @@
 import {
   createRelayAction,
   withActionId
-} from "./chunk-X7ECZ3AK.js";
+} from "./chunk-XMBM2XD5.js";
 import {
   collectionPassSchema,
   participantActivityQuerySchema,
@@ -16,25 +16,19 @@ import {
   questOutcomeQuerySchema,
   questOutcomeSchema,
   rewardDeliveriesSchema
-} from "./chunk-T657WO56.js";
+} from "./chunk-LLMJ2SUT.js";
 import {
   AVATAR_UPLOAD_LIMIT,
-  RelayError,
-  RelayErrorCode,
   avatarUploadTypes,
-  clientError,
   engagementBoundaryPageSchema,
   engagementPageQuerySchema,
   engagementPageSchema,
-  isRelayError,
   leaderboardDefinitionResponseSchema,
   leaderboardPageSchema,
   leaderboardPlacementSchema,
   leaderboardQuerySchema,
-  linkedWalletSchema,
   offerSchema,
   ownProfileSchema,
-  parseInput,
   pointBalancesSchema,
   pointHistoryPageSchema,
   pointHistoryQuerySchema,
@@ -48,14 +42,22 @@ import {
   referralAcceptSchema,
   referralDefinitionSchema,
   referralHistorySchema,
-  referralSummarySchema,
+  referralSummarySchema
+} from "./chunk-UJACD6K2.js";
+import {
+  RelayError,
+  RelayErrorCode,
+  clientError,
+  isRelayError,
+  linkedWalletSchema,
+  parseInput,
   walletAddressInput,
   walletAddressInputSchema,
   walletMessageChallengeSchema,
   walletSignInNetworksSchema,
   walletSignatureSchema,
   walletUnlinkInputSchema
-} from "./chunk-ZFABFKIY.js";
+} from "./chunk-2UAVZCMH.js";
 import {
   PARTICIPANT_TIMEOUT,
   lifetime,
@@ -63,9 +65,12 @@ import {
   retrying,
   validTimeout
 } from "./chunk-6QJ3LADK.js";
+import {
+  isRequestError
+} from "./chunk-NPGENI7K.js";
 import {
   clientIdentity
-} from "./chunk-AGFUDCNM.js";
+} from "./chunk-3PPEXDWR.js";
 import {
   exchangeResultSchema,
   exchangeSchema,
@@ -488,13 +493,18 @@ var QuestUpdatedError = class extends RelayError {
 import { z as z2 } from "zod";
 
 // src/progress.ts
+function sessionEnded(error) {
+  return isRequestError(error) && (error.code === RelayErrorCode.StaleSession || error.code === RelayErrorCode.NotSignedIn);
+}
 function observeProgress(transport, listener, options = {}, onDispose = () => {
 }) {
   const interval = options.intervalMs ?? 1500;
   const maximum = options.maxBackoffMs ?? 3e4;
-  if (!Number.isFinite(interval) || interval <= 0 || !Number.isFinite(maximum) || maximum < interval) {
+  const bound = options.bound ?? false;
+  const retry = options.retryMs ?? interval * 2;
+  if (!Number.isFinite(interval) || interval <= 0 || !Number.isFinite(maximum) || !Number.isFinite(retry) || retry <= 0 || maximum < interval) {
     throw clientError(
-      "Progress polling requires a positive interval and a maximum at least as large",
+      "Progress polling requires a positive interval and retry wait, and a maximum at least as large as the interval",
       RelayErrorCode.InvalidInput
     );
   }
@@ -502,16 +512,23 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
   let controller;
   let timer;
   let sessionId;
+  let reusable;
+  let reread = false;
   let failures = 0;
+  let settledAt = 0;
+  let delay = interval;
   const visible = () => typeof document === "undefined" || document.visibilityState !== "hidden";
   const visibility = () => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
     if (visible()) {
-      void refresh();
+      timer = setTimeout(
+        () => void refresh(),
+        Math.max(0, settledAt + delay - Date.now())
+      );
     } else {
       controller?.abort();
-      if (timer !== void 0) {
-        clearTimeout(timer);
-      }
     }
   };
   if (typeof document !== "undefined") {
@@ -523,6 +540,8 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
       clearTimeout(timer);
     }
     sessionId = void 0;
+    reusable = void 0;
+    settledAt = 0;
     if (!disposed) {
       listener({ kind: "loading" });
     }
@@ -538,8 +557,9 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
     const request = new AbortController();
     controller = request;
     const current = () => !disposed && !request.signal.aborted;
+    let readSessionNow = false;
     try {
-      const session = await transport.session(request.signal);
+      const session = (bound ? reusable : void 0) ?? await transport.session(request.signal);
       if (!current()) {
         return;
       }
@@ -549,44 +569,69 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
       }
       const member = sessionMember(session);
       if (session && member) {
-        const progress = await transport.progress(session.id, request.signal);
+        let progress;
+        try {
+          progress = await transport.progress(session.id, request.signal);
+        } catch (error) {
+          if (bound && !reread && sessionEnded(error) && current()) {
+            sessionId = void 0;
+            reusable = void 0;
+            reread = true;
+            readSessionNow = true;
+            listener({ kind: "loading" });
+            return;
+          }
+          throw error;
+        }
         if (!current()) {
           return;
         }
-        const confirmed = await transport.session(request.signal);
+        const confirmed = bound ? session : await transport.session(request.signal);
         if (!current()) {
           return;
         }
         if (confirmed?.id !== session.id || progress.member !== member) {
           sessionId = void 0;
+          reusable = void 0;
           listener({ kind: "loading" });
           return;
         }
+        reusable = bound ? confirmed : void 0;
         listener({ kind: "ready", session: confirmed, progress });
+      } else {
+        reusable = void 0;
       }
       failures = 0;
+      reread = false;
     } catch (error) {
       if (!current()) {
         return;
       }
       failures = Math.min(failures + 1, 20);
       sessionId = void 0;
+      reusable = void 0;
+      reread = false;
       listener({
         kind: "error",
         error: error instanceof Error ? error : new Error("Could not refresh progress")
       });
     } finally {
       if (current()) {
-        timer = setTimeout(
-          () => void refresh(),
-          Math.min(maximum, interval * 2 ** failures)
-        );
+        settledAt = Date.now();
+        delay = readSessionNow ? 0 : failures === 0 ? interval : Math.min(maximum, retry * 2 ** (failures - 1));
+        timer = setTimeout(() => void refresh(), delay);
       }
     }
   }
   const observer = {
     refresh,
     clear,
+    /** A bound observer's next poll uses `session`, already read, instead of reading it. */
+    reuse(session) {
+      if (bound && sessionMember(session)) {
+        reusable = session;
+      }
+    },
     dispose() {
       if (disposed) {
         return;
@@ -1366,7 +1411,7 @@ function relayClient(options) {
             })
           },
           listener,
-          observeOptions,
+          { ...observeOptions, bound: true },
           () => observers.delete(observer)
         );
         observers.add(observer);
@@ -1584,7 +1629,10 @@ function relayClient(options) {
             {
               session: (signal) => readSession({ signal }),
               progress: (session, signal) => request(
-                withQuery("/v1/me/activity", { cursor }),
+                withQuery(
+                  "/v1/me/activity",
+                  cursor === void 0 && options2.start ? { start: options2.start } : { cursor }
+                ),
                 participantActivitySchema,
                 { options: { session, signal } }
               )
@@ -1609,12 +1657,16 @@ function relayClient(options) {
             },
             {
               intervalMs: options2.intervalMs ?? 5e3,
-              maxBackoffMs: options2.maxBackoffMs
+              maxBackoffMs: options2.maxBackoffMs,
+              bound: true
             },
             () => observers.delete(observer)
           );
           observers.add(observer);
           observer.clear();
+          if (options2.session) {
+            observer.reuse(options2.session);
+          }
           void observer.refresh();
           return { refresh: observer.refresh, dispose: observer.dispose };
         }
@@ -1630,7 +1682,7 @@ function relayClient(options) {
             })
           },
           listener,
-          observeOptions,
+          { ...observeOptions, bound: true },
           () => observers.delete(observer)
         );
         observers.add(observer);

package/dist/{chunk-PUDL4JBY.js → chunk-PUY35TH3.js}

@@ -1,12 +1,12 @@
 import {
   createRelayClient
-} from "./chunk-XK5E4HAS.js";
+} from "./chunk-PJXBW754.js";
 import {
   RelayErrorCode,
   asRelayError,
   clientError,
   cosmosChain
-} from "./chunk-ZFABFKIY.js";
+} from "./chunk-2UAVZCMH.js";
 
 // src/base58.ts
 var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";