@domino-sdk/relay 1.7.0 → 1.10.0

package/dist/react/index.js

@@ -8,20 +8,27 @@ import {
   discoverSolanaWallets,
   readSignInMethods,
   signInOptionsFrom
-} from "../chunk-BFZHJA2B.js";
-import "../chunk-ZOUEEK5L.js";
-import "../chunk-C25TDFHN.js";
+} from "../chunk-GEPSEVQO.js";
+import "../chunk-7BRHUUVB.js";
 import {
+  createRelayAction
+} from "../chunk-GFAFH7XR.js";
+import "../chunk-BKLGWPPD.js";
+import {
+  RelayError,
   RelayErrorCode,
   asRelayError,
   isRelayError
-} from "../chunk-GMPPLZKH.js";
+} from "../chunk-UIR6NSYZ.js";
 import "../chunk-6QJ3LADK.js";
-import "../chunk-NPGENI7K.js";
+import {
+  isRequestError
+} from "../chunk-NPGENI7K.js";
+import "../chunk-N2HXMTVA.js";
 import {
   sessionMember
-} from "../chunk-6ON4RMEN.js";
-import "../chunk-KGJSKGKI.js";
+} from "../chunk-BUXNTVER.js";
+import "../chunk-23JUD56J.js";
 
 // src/react/activity.ts
 import {
@@ -385,13 +392,82 @@ function useActivity(options = {}) {
   return { ...value, refresh };
 }
 
+// src/react/action.ts
+import { useCallback as useCallback2, useRef as useRef2, useState as useState2 } from "react";
+function useRelayAction(scope) {
+  const owner = useRef2({ scope, action: createRelayAction() });
+  const [state, setState] = useState2({
+    owner: owner.current,
+    busy: false,
+    error: null
+  });
+  if (owner.current.scope !== scope) {
+    owner.current = { scope, action: createRelayAction() };
+  }
+  const execute = useCallback2(
+    async (task) => {
+      const current2 = owner.current;
+      if (current2.action.busy) {
+        return { ok: false };
+      }
+      const result = task ? current2.action.run(task) : current2.action.retry();
+      setState({ owner: current2, busy: true, error: null });
+      try {
+        const value = await result;
+        if (owner.current === current2) {
+          setState({ owner: current2, busy: false, error: null });
+        }
+        return { ok: true, value };
+      } catch (caught) {
+        if (owner.current === current2) {
+          const cause = current2.action.error ?? caught;
+          const error = isRequestError(cause) && !isRelayError(cause) ? new RelayError(cause.message, {
+            kind: cause.kind,
+            status: cause.status,
+            code: cause.code,
+            uncertain: cause.uncertain,
+            operationId: cause.operationId,
+            replaySafe: cause.recovery === "replay",
+            retryAfter: cause.retryAfter,
+            cause
+          }) : asRelayError(cause);
+          setState({
+            owner: current2,
+            busy: false,
+            error
+          });
+        }
+        return { ok: false };
+      }
+    },
+    []
+  );
+  const retry = useCallback2(() => execute(), [execute]);
+  const settle = useCallback2(() => {
+    const current2 = owner.current;
+    if (!current2.action.settle()) {
+      return false;
+    }
+    setState({ owner: current2, busy: false, error: null });
+    return true;
+  }, []);
+  const current = state.owner === owner.current ? state : { busy: false, error: null };
+  return {
+    run: execute,
+    retry,
+    settle,
+    busy: current.busy,
+    error: current.error
+  };
+}
+
 // src/react/provider.tsx
 import { useEffect as useEffect3, useMemo as useMemo2 } from "react";
 
 // src/react/experience.tsx
 import {
   createContext as createContext2,
-  useCallback as useCallback2,
+  useCallback as useCallback3,
   useContext as useContext2,
   useMemo,
   useSyncExternalStore as useSyncExternalStore2
@@ -503,10 +579,10 @@ function watchRoleDeliveries(options) {
 }
 
 // src/react/use-role-deliveries.ts
-import { useEffect as useEffect2, useState as useState2 } from "react";
+import { useEffect as useEffect2, useState as useState3 } from "react";
 var NONE = Object.freeze([]);
 function useRoleDeliveries(relay, member, completions) {
-  const [state, setState] = useState2(null);
+  const [state, setState] = useState3(null);
   useEffect2(() => {
     if (!member || !completions) {
       return;
@@ -562,7 +638,7 @@ function useExperience() {
   const store = useStore();
   const experience = useExperienceSnapshot();
   const deliveries = useContext2(Deliveries);
-  const refresh = useCallback2(() => store.refreshExperience(), [store]);
+  const refresh = useCallback3(() => store.refreshExperience(), [store]);
   return useMemo(
     () => ({ ...experience, refresh, deliveries }),
     [experience, refresh, deliveries]
@@ -1175,16 +1251,16 @@ function RelayProvider({
 
 // src/react/query.ts
 import {
-  useCallback as useCallback3,
+  useCallback as useCallback4,
   useEffect as useEffect4,
   useLayoutEffect as useLayoutEffect2,
   useMemo as useMemo3,
-  useRef as useRef2,
-  useState as useState3,
+  useRef as useRef3,
+  useState as useState4,
   useSyncExternalStore as useSyncExternalStore3
 } from "react";
 function useLatest(value) {
-  const ref = useRef2(value);
+  const ref = useRef3(value);
   useLayoutEffect2(() => {
     ref.current = value;
   });
@@ -1202,7 +1278,7 @@ function useCached(cache, key, read, options) {
   const hash = key ? hashKey(key) : null;
   const { intervalMs, refetchOnFocus } = options;
   const latest = useLatest({ key, read });
-  const subscribe = useCallback3(
+  const subscribe = useCallback4(
     (listener) => {
       const { key: current } = latest.current;
       if (!cache || !current) {
@@ -1221,7 +1297,7 @@ function useCached(cache, key, read, options) {
   );
   const get = () => cache && key ? cache.snapshot(key) : LOADING;
   const snapshot = useSyncExternalStore3(subscribe, get, get);
-  const refresh = useCallback3(
+  const refresh = useCallback4(
     () => cache && latest.current.key ? cache.refresh(latest.current.key) : Promise.resolve(),
     [cache, hash]
   );
@@ -1269,8 +1345,8 @@ function usePages(cache, key, read, options) {
     (context) => read(context),
     options
   );
-  const [more, setMore] = useState3(null);
-  const busy = useRef2(null);
+  const [more, setMore] = useState4(null);
+  const busy = useRef3(null);
   const latest = useLatest({ key, read, query });
   useEffect4(
     () => () => {
@@ -1279,7 +1355,7 @@ function usePages(cache, key, read, options) {
     },
     [cache, hash]
   );
-  const loadMore = useCallback3(async () => {
+  const loadMore = useCallback4(async () => {
     const { key: current, read: reader, query: shown } = latest.current;
     if (!cache || !current || busy.current || shown.status !== "ready" || shown.data.nextCursor === null) {
       return;
@@ -1353,7 +1429,7 @@ function useMemberPages(key, read, options = {}) {
 }
 function useInvalidate() {
   const store = useStore();
-  return useCallback3((keys = []) => store.invalidate(keys), [store]);
+  return useCallback4((keys = []) => store.invalidate(keys), [store]);
 }
 function useSession() {
   const store = useStore();
@@ -1369,22 +1445,22 @@ function useSession() {
   );
 }
 function useAction() {
-  const [busy, setBusy] = useState3(false);
-  const [actionError, setActionError] = useState3(null);
-  const run = useCallback3(async (task) => {
-    setBusy(true);
-    setActionError(null);
-    try {
-      await task();
-      return true;
-    } catch (cause) {
-      setActionError(relayError(cause));
-      return false;
-    } finally {
-      setBusy(false);
-    }
-  }, []);
-  return { busy, actionError, run };
+  const session = useScopeSession();
+  const store = useStore();
+  const scope = useMemo3(() => ({ store, session }), [store, session]);
+  const {
+    run: execute,
+    retry: replay,
+    busy,
+    error: actionError,
+    settle
+  } = useRelayAction(scope);
+  const run = useCallback4(
+    async (task) => (await execute(task)).ok,
+    [execute]
+  );
+  const retry = useCallback4(async () => (await replay()).ok, [replay]);
+  return { busy, actionError, run, retry, settle };
 }
 function useScopeSession() {
   const store = useStore();
@@ -1431,26 +1507,27 @@ function questGroups(experience, order = []) {
 
 // src/react/use-quest.ts
 import {
-  useCallback as useCallback4,
+  useCallback as useCallback5,
   useEffect as useEffect5,
   useLayoutEffect as useLayoutEffect3,
   useMemo as useMemo4,
-  useRef as useRef3,
-  useState as useState4
+  useRef as useRef4,
+  useState as useState5
 } from "react";
 function useQuest(observed) {
   const store = useStore();
   const relay = store.client;
-  const [latest, setLatest] = useState4(null);
-  const [draft, setDraft] = useState4(null);
-  const [notice, setNotice] = useState4(null);
-  const [error, setError] = useState4(null);
-  const [busy, setBusy] = useState4(false);
-  const [discardedAttempt, setDiscardedAttempt] = useState4(null);
-  const [saved, setSaved] = useState4("none");
-  const [recoveryRevision, setRecoveryRevision] = useState4(0);
-  const [retired, setRetired] = useState4(false);
-  const [receipt, setReceipt] = useState4(null);
+  const [latest, setLatest] = useState5(null);
+  const [draft, setDraft] = useState5(null);
+  const [notice, setNotice] = useState5(null);
+  const [error, setError] = useState5(null);
+  const [busy, setBusy] = useState5(false);
+  const lock = useRef4(false);
+  const [discardedAttempt, setDiscardedAttempt] = useState5(null);
+  const [saved, setSaved] = useState5("none");
+  const [recoveryRevision, setRecoveryRevision] = useState5(0);
+  const [retired, setRetired] = useState5(false);
+  const [receipt, setReceipt] = useState5(null);
   useEffect5(() => setLatest(null), [observed.release]);
   const view = latest ?? observed;
   const { quest, release } = view;
@@ -1474,8 +1551,12 @@ function useQuest(observed) {
       active = false;
     };
   }, [relay, quest, release, completed, attempt, busy, recoveryRevision]);
-  const run = useCallback4(
+  const run = useCallback5(
     async (action) => {
+      if (lock.current) {
+        return;
+      }
+      lock.current = true;
       setBusy(true);
       setError(null);
       setNotice(null);
@@ -1494,19 +1575,24 @@ function useQuest(observed) {
       } catch (cause) {
         setError(asRelayError(cause, "Something went wrong."));
       } finally {
+        lock.current = false;
         setBusy(false);
         setRecoveryRevision((revision) => revision + 1);
       }
     },
     [store]
   );
-  const shown = useRef3(view);
+  const shown = useRef4(view);
   useLayoutEffect3(() => {
     shown.current = view;
   });
   const actions = useMemo4(
     () => ({
       restart: async () => {
+        if (lock.current) {
+          return;
+        }
+        lock.current = true;
         const current = shown.current;
         setBusy(true);
         setError(null);
@@ -1520,6 +1606,7 @@ function useQuest(observed) {
         } catch (cause) {
           setError(asRelayError(cause, "Could not start a new submission."));
         } finally {
+          lock.current = false;
           setBusy(false);
           setRecoveryRevision((revision) => revision + 1);
         }
@@ -1605,10 +1692,10 @@ function useQuest(observed) {
 }
 
 // src/react/auth.ts
-import { useCallback as useCallback5, useMemo as useMemo6, useRef as useRef4, useState as useState6 } from "react";
+import { useCallback as useCallback6, useMemo as useMemo6, useRef as useRef5, useState as useState7 } from "react";
 
 // src/react/wallets.ts
-import { useEffect as useEffect6, useMemo as useMemo5, useState as useState5 } from "react";
+import { useEffect as useEffect6, useMemo as useMemo5, useState as useState6 } from "react";
 function useWallets() {
   const relay = useRelay();
   const invalidate = useInvalidate();
@@ -1618,7 +1705,7 @@ function useWallets() {
     (options) => relay.wallets.list(options),
     { refetchOnFocus: true }
   );
-  const { busy, actionError, run } = useAction();
+  const { busy, actionError, run, retry, settle } = useAction();
   const actions = useMemo5(() => {
     const changed = () => void invalidate([relayKeys.wallets, relayKeys.experience]);
     return {
@@ -1637,8 +1724,8 @@ function useWallets() {
     };
   }, [relay, invalidate, session, run]);
   return useMemo5(
-    () => ({ ...query, busy, actionError, ...actions }),
-    [query, busy, actionError, actions]
+    () => ({ ...query, busy, actionError, retry, settle, ...actions }),
+    [query, busy, actionError, retry, settle, actions]
   );
 }
 function discoverChains(key) {
@@ -1648,7 +1735,7 @@ function discoverChains(key) {
 }
 function useWalletDiscovery(options = {}) {
   const chains = JSON.stringify(cosmosChainList(options.cosmos));
-  const [found, setFound] = useState5({ evm: [], solana: [], cosmos: [] });
+  const [found, setFound] = useState6({ evm: [], solana: [], cosmos: [] });
   useEffect6(() => {
     let active = true;
     const solana = discoverSolanaWallets();
@@ -1671,7 +1758,7 @@ function useSignInWallets(networks, options = {}) {
   );
   const key = networks ? `${networks.join(" ")}
 ${chains}` : null;
-  const [found, setFound] = useState5(null);
+  const [found, setFound] = useState6(null);
   useEffect6(() => {
     if (key === null) {
       return;
@@ -1705,16 +1792,21 @@ function useMe() {
 }
 function useSignIn() {
   const relay = useRelay();
-  const [challenge, setChallengeState] = useState6(null);
-  const latest = useRef4(null);
-  const [busy, setBusy] = useState6(false);
-  const [error, setError] = useState6(null);
-  const setChallenge = useCallback5((value) => {
+  const [challenge, setChallengeState] = useState7(null);
+  const latest = useRef5(null);
+  const [busy, setBusy] = useState7(false);
+  const lock = useRef5(false);
+  const [error, setError] = useState7(null);
+  const setChallenge = useCallback6((value) => {
     latest.current = value;
     setChallengeState(value);
   }, []);
-  const run = useCallback5(
+  const run = useCallback6(
     async (task, fallback) => {
+      if (lock.current) {
+        return;
+      }
+      lock.current = true;
       setBusy(true);
       setError(null);
       try {
@@ -1722,19 +1814,20 @@ function useSignIn() {
       } catch (cause) {
         setError(asRelayError(cause, fallback));
       } finally {
+        lock.current = false;
         setBusy(false);
       }
     },
     []
   );
-  const sendCode = useCallback5(
+  const sendCode = useCallback6(
     (email) => run(async () => {
       setChallenge(null);
       setChallenge((await relay.auth.emailStart(email)).challenge);
     }, "Couldn't send a code. Check the address and try again."),
     [relay, run, setChallenge]
   );
-  const verifyCode = useCallback5(
+  const verifyCode = useCallback6(
     (code) => run(async () => {
       const sent = latest.current;
       if (!sent) {
@@ -1745,18 +1838,18 @@ function useSignIn() {
     }, "That code didn't work. Check it, or request a new one."),
     [relay, run, setChallenge]
   );
-  const startOver = useCallback5(() => {
+  const startOver = useCallback6(() => {
     setChallenge(null);
     setError(null);
   }, [setChallenge]);
-  const withProvider = useCallback5(
+  const withProvider = useCallback6(
     (provider) => run(async () => {
       const { url } = await relay.auth.start(provider, "sign-in");
       window.location.assign(url);
     }, "Couldn't start sign-in. Try again."),
     [relay, run]
   );
-  const withWallet = useCallback5(
+  const withWallet = useCallback6(
     (signer) => run(async () => {
       await relay.auth.wallet.signIn(signer);
       setChallenge(null);
@@ -1791,12 +1884,18 @@ function useSignIn() {
 }
 function useSignOut() {
   const store = useStore();
-  const [busy, setBusy] = useState6(false);
-  const signOut = useCallback5(async () => {
+  const [busy, setBusy] = useState7(false);
+  const lock = useRef5(false);
+  const signOut = useCallback6(async () => {
+    if (lock.current) {
+      return;
+    }
+    lock.current = true;
     setBusy(true);
     try {
       await store.signOut();
     } finally {
+      lock.current = false;
       setBusy(false);
     }
   }, [store]);
@@ -1871,7 +1970,7 @@ function useAccounts() {
     (options) => relay.auth.accounts(options),
     { refetchOnFocus: true }
   );
-  const { busy, actionError, run } = useAction();
+  const { busy, actionError, run, retry, settle } = useAction();
   const actions = useMemo7(
     () => ({
       connect: (provider) => run(async () => {
@@ -1897,10 +1996,12 @@ function useAccounts() {
       ...query,
       busy,
       actionError,
+      retry,
+      settle,
       isConnected: (provider) => isConnected(accounts, provider),
       ...actions
     }),
-    [query, busy, actionError, accounts, actions]
+    [query, busy, actionError, retry, settle, accounts, actions]
   );
 }
 
@@ -1916,11 +2017,11 @@ function useMyProfile() {
     (options) => relay.profiles.mine(options),
     { refetchOnFocus: true }
   );
-  const { busy, actionError, run } = useAction();
+  const { busy, actionError, run, retry, settle } = useAction();
   const actions = useMemo8(() => {
-    const change = (task) => run(async () => {
+    const change = (task) => run(async (actionId) => {
       const cache = store.scope?.cache;
-      const saved = await task();
+      const saved = await task(actionId);
       cache?.set(MINE, saved);
       void cache?.invalidate([
         [...relayKeys.profiles, "get"],
@@ -1928,19 +2029,21 @@ function useMyProfile() {
       ]);
     });
     return {
-      update: (input) => change(() => relay.profiles.update(input, { session })),
+      update: (input) => change(
+        (actionId) => relay.profiles.update({ ...input, actionId }, { session })
+      ),
       /** Uploads a JPEG, PNG or WebP of at most 5 MB as the avatar. */
       uploadAvatar: (file) => change(
-        () => relay.profiles.uploadAvatar(file, {
-          uploadId: crypto.randomUUID(),
+        (actionId) => relay.profiles.uploadAvatar(file, {
+          actionId,
           session
         })
       )
     };
   }, [relay, store, session, run]);
   return useMemo8(
-    () => ({ ...query, busy, actionError, ...actions }),
-    [query, busy, actionError, actions]
+    () => ({ ...query, busy, actionError, retry, settle, ...actions }),
+    [query, busy, actionError, retry, settle, actions]
   );
 }
 function useProfile(id, options = {}) {
@@ -1981,7 +2084,7 @@ function useProfileCompletions(profile, options = {}) {
 }
 
 // src/react/referrals.ts
-import { useCallback as useCallback6, useEffect as useEffect7, useMemo as useMemo9, useRef as useRef5, useState as useState7 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect7, useMemo as useMemo9, useRef as useRef6, useState as useState8 } from "react";
 var PENDING = "domino:pending-referral";
 var CODE = /^[a-zA-Z0-9_-]{1,100}$/;
 function captureReferralCode(param = "ref") {
@@ -2007,33 +2110,68 @@ function forgetReferralCode() {
 function useInvitation(param = "ref") {
   const relay = useRelay();
   const invalidate = useInvalidate();
-  const { member } = useSession();
-  const [state, setState] = useState7(() => {
+  const signed = useSession();
+  const { member } = signed;
+  const session = signed.data?.id;
+  const [state, setState] = useState8(() => {
     const code = captureReferralCode(param);
     return code ? { status: "pending", code } : { status: "none" };
   });
-  const started = useRef5(null);
-  const accept = useCallback6(
+  const started = useRef6(null);
+  const pending = useRef6({
+    member,
+    relay,
+    session,
+    code: "",
+    action: createRelayAction()
+  });
+  if (pending.current.member !== member || pending.current.relay !== relay || pending.current.session !== session) {
+    pending.current = {
+      member,
+      relay,
+      session,
+      code: "",
+      action: createRelayAction()
+    };
+  }
+  const accept = useCallback7(
     async (code) => {
-      setState({ status: "accepting", code });
+      const owner = pending.current;
+      if (owner.action.busy) {
+        return;
+      }
+      if (!owner.action.error) {
+        owner.code = code;
+      }
+      const logicalCode = owner.code;
+      setState({ status: "accepting", code: logicalCode });
       try {
-        await relay.referrals.accept({ code, actionId: `accept-${code}` });
+        await owner.action.run(
+          (actionId) => relay.referrals.accept({ code, actionId }, { session })
+        );
+        if (pending.current !== owner) {
+          return;
+        }
         forgetReferralCode();
-        setState({ status: "accepted", code });
+        setState({ status: "accepted", code: logicalCode });
         void invalidate([relayKeys.referrals, relayKeys.profiles]);
-      } catch (cause) {
+      } catch (caught) {
+        if (pending.current !== owner) {
+          return;
+        }
+        const cause = owner.action.error ?? caught;
         const refused = isRelayError(cause) && (cause.kind === "http" && cause.status !== void 0 && cause.status >= 400 && cause.status < 500 && cause.status !== 429 || cause.code === RelayErrorCode.InvalidInput);
         if (refused) {
           forgetReferralCode();
         }
         setState({
           status: refused ? "rejected" : "failed",
-          code,
+          code: logicalCode,
           error: asRelayError(cause, "That invitation code couldn't be used.")
         });
       }
     },
-    [relay, invalidate]
+    [relay, invalidate, session]
   );
   useEffect7(() => {
     if (member && state.status === "pending" && started.current !== `${member}:${state.code}`) {
@@ -2108,7 +2246,7 @@ function useQuestOutcomes(query = {}) {
 }
 
 // src/react/offers.ts
-import { useCallback as useCallback7, useState as useState8 } from "react";
+import { useCallback as useCallback8, useMemo as useMemo10 } from "react";
 function useOffers() {
   const relay = useRelay();
   return useRelayQuery(
@@ -2119,29 +2257,33 @@ function useOffers() {
 function useRedeemOffer() {
   const relay = useRelay();
   const invalidate = useInvalidate();
-  const [busy, setBusy] = useState8(false);
-  const [error, setError] = useState8(null);
-  const redeem = useCallback7(
-    async (offer) => {
-      if (busy) {
-        return null;
-      }
-      setBusy(true);
-      setError(null);
-      try {
-        const redemption = await relay.offers.redeem(offer);
+  const session = useScopeSession();
+  const scope = useMemo10(() => ({ relay, session }), [relay, session]);
+  const {
+    run,
+    retry: replay,
+    settle,
+    busy,
+    error
+  } = useRelayAction(scope);
+  const refresh = useCallback8(
+    async (result) => {
+      const redemption = result.ok ? result.value : null;
+      if (redemption) {
         await invalidate([relayKeys.offers, relayKeys.balances]);
-        return redemption;
-      } catch (cause) {
-        setError(asRelayError(cause, "This offer could not be redeemed."));
-        return null;
-      } finally {
-        setBusy(false);
       }
+      return redemption;
     },
-    [busy, invalidate, relay]
+    [invalidate]
+  );
+  const redeem = useCallback8(
+    (offer) => run(
+      (actionId) => relay.offers.redeem(offer, { actionId }, { session })
+    ).then(refresh),
+    [run, relay, session, refresh]
   );
-  return { redeem, busy, error };
+  const retry = useCallback8(() => replay().then(refresh), [replay, refresh]);
+  return { redeem, retry, settle, busy, error };
 }
 
 // src/react/references.ts
@@ -2200,6 +2342,7 @@ export {
   useRedeemOffer,
   useReferralSummary,
   useRelay,
+  useRelayAction,
   useRelayPages,
   useRelayQuery,
   useSession,