@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/react/index.js

@@ -7,22 +7,28 @@ import {
   discoverSignInWallets,
   discoverSolanaWallets,
   readSignInMethods,
-  signInOptionsFrom,
+  signInOptionsFrom
+} from "../chunk-5XLZ34PV.js";
+import {
   telegramMiniAppInitData
-} from "../chunk-24I4R732.js";
-import "../chunk-SKGTNTLF.js";
+} from "../chunk-FWLQ5XCS.js";
+import "../chunk-LZWXCBUB.js";
 import {
   createRelayAction
-} from "../chunk-QEAS4ZGS.js";
-import "../chunk-QNUHWK7R.js";
-import "../chunk-3Y3L2F54.js";
-import "../chunk-SE4PFJPT.js";
-import "../chunk-KDR2VAJP.js";
-import "../chunk-XBV2CK2H.js";
-import "../chunk-EN3M5Z4J.js";
+} from "../chunk-AQOL3SK5.js";
+import "../chunk-MTKRIQEU.js";
+import "../chunk-EHUSD3O2.js";
+import "../chunk-4NOFSGAL.js";
+import "../chunk-QR6HH4DI.js";
+import "../chunk-W7YSMSGC.js";
+import "../chunk-UYVJZR33.js";
+import "../chunk-ICXZZNPS.js";
+import "../chunk-FO2LCZTL.js";
+import "../chunk-3RFP6GT5.js";
 import {
   sessionMember
-} from "../chunk-PPB7HALD.js";
+} from "../chunk-N4BDKS6Y.js";
+import "../chunk-ID3BZXFZ.js";
 import {
   RelayError,
   RelayErrorCode,
@@ -30,11 +36,11 @@ import {
   clientError,
   isRelayError,
   isRequestError
-} from "../chunk-ZDJLPN4L.js";
+} from "../chunk-GLH6MEI2.js";
 
 // src/react/context.ts
 import { createContext, useContext } from "react";
-var StoreContext = createContext(null);
+var StoreContext = /* @__PURE__ */ (() => createContext(null))();
 function useStore() {
   const store = useContext(StoreContext);
   if (!store) {
@@ -52,12 +58,14 @@ var relayKeys = {
   experience: ["experience"],
   /** `useMe`. */
   me: ["me"],
-  /** `useAccounts`. */
+  /** `useAccounts`, `useAccount`, `useTelegramAccount`, `useCreatorAccounts`. */
   accounts: ["accounts"],
   /** `useWallets`. */
   wallets: ["wallets"],
   /** `useMyProfile`, `useProfile`, `useProfileCompletions`, `useProfileReferral`. */
   profiles: ["profiles"],
+  /** `useConsent`. */
+  consent: ["consent"],
   /** `useLeaderboard`, `useLeaderboardPlacement`, `useLeaderboardHistory`. */
   leaderboards: ["leaderboards"],
   /** `useReferralSummary`. */
@@ -114,11 +122,11 @@ var activityChanges = {
 
 // src/react/action.ts
 import { useCallback, useRef, useState } from "react";
-var IDLE = Object.freeze({
+var IDLE = /* @__PURE__ */ (() => Object.freeze({
   status: "idle",
   data: void 0,
   error: null
-});
+}))();
 function actionError(cause) {
   return isRequestError(cause) && !isRelayError(cause) ? new RelayError(cause.message, {
     kind: cause.kind,
@@ -214,11 +222,11 @@ import {
 } from "react";
 
 // src/react/cache.ts
-var LOADING = Object.freeze({
+var LOADING = /* @__PURE__ */ (() => Object.freeze({
   status: "loading",
   data: void 0,
   error: null
-});
+}))();
 var UNUSED_MS = 5 * 6e4;
 var STALE_MS = 3e4;
 var relayError = (cause, fallback) => asRelayError(cause, fallback);
@@ -624,8 +632,11 @@ var ActivityFeed = class {
 };
 
 // src/react/role-delivery.ts
+function grantsRole({ action }) {
+  return typeof action !== "string" || action === "grant-role";
+}
 function sanitizeDeliveries(deliveries) {
-  return deliveries.map(({ quest, status, revokedAt, reconciliation }) => ({
+  return deliveries.filter(grantsRole).map(({ quest, status, revokedAt, reconciliation }) => ({
     quest,
     status: reconciliation ? reconciliation.status === "granted" ? "delivered" : reconciliation.status : revokedAt ? "revoked" : status
   }));
@@ -1032,11 +1043,11 @@ function quote(value) {
 }
 
 // src/react/store.ts
-var SIGNED_OUT = Object.freeze({
+var SIGNED_OUT = /* @__PURE__ */ (() => Object.freeze({
   status: "signed-out",
   data: void 0,
   error: null
-});
+}))();
 function scopeKey(session) {
   if (!session) {
     return "visitor";
@@ -1126,12 +1137,17 @@ var RelayStore = class {
   /** The wallet the current session signed in with, while the store follows its accounts. */
   #wallet = null;
   #walletSigningOut = false;
-  constructor(client, polling = {}) {
+  /** Bumped by each `delivery.updated` the feed brings, so the role deliveries are read again. */
+  #deliveryChanges = 0;
+  /** Whether a wallet sign-in's session ends when the wallet switches account or locks. */
+  #followWallet;
+  constructor(client, polling = {}, { followWallet = true } = {}) {
     this.client = client;
     this.#polling = {
       activityMs: polling.activityMs ?? ACTIVITY_MS,
       snapshotMs: polling.snapshotMs ?? SNAPSHOT_MS
     };
+    this.#followWallet = followWallet;
   }
   /** `refreshSession` with one identity per store, for hooks to hand out as `refresh`. */
   rereadSession = () => this.refreshSession();
@@ -1150,6 +1166,10 @@ var RelayStore = class {
   get experience() {
     return this.#experienceView;
   }
+  /** How many `delivery.updated` events the feed brought; changes when a delivery did. */
+  get deliveryChanges() {
+    return this.#deliveryChanges;
+  }
   /** The first query cache of this mount, the only one a public read's `initialData` seeds. */
   get firstCache() {
     return this.#firstCache;
@@ -1386,6 +1406,9 @@ var RelayStore = class {
   /** Signs out when the wallet `session` signed in with reports another account, or none. */
   #watchWallet(signer, address, session) {
     this.#stopWallet(false);
+    if (!this.#followWallet) {
+      return;
+    }
     const signedIn = address.toLowerCase();
     const watch = { session, stop: () => {
     } };
@@ -1456,6 +1479,10 @@ var RelayStore = class {
     if (keys.size > 0) {
       void this.#scope?.cache.invalidate([...keys.values()]);
     }
+    if (events.some((event) => event.kind === "delivery.updated")) {
+      this.#deliveryChanges += 1;
+      this.#emit();
+    }
   }
   #startObserver() {
     if (this.#observer || !this.#mounted) {
@@ -1912,7 +1939,7 @@ function useBadgeCatalog() {
   const relay = useRelay();
   return useRelayQuery(
     [...relayKeys.badges, "catalog"],
-    (options) => relay.badges.list(options)
+    async (options) => (await relay.badges.catalog(options)).items
   );
 }
 function useBadges() {
@@ -2123,15 +2150,15 @@ import {
 
 // src/react/use-role-deliveries.ts
 import { useEffect as useEffect3, useState as useState4 } from "react";
-var NONE = Object.freeze([]);
-function useRoleDeliveries(relay, member, completions) {
+var NONE = /* @__PURE__ */ (() => Object.freeze([]))();
+function useRoleDeliveries(relay, member, completions, changes = 0) {
   const [state, setState] = useState4(null);
   useEffect3(() => {
     if (!member || !completions) {
       return;
     }
     const watch = watchRoleDeliveries({
-      read: async () => (await relay.me.rewardDeliveries()).deliveries,
+      read: async () => (await relay.me.rewardDeliveries()).items,
       onChange: (deliveries) => setState({ member, deliveries })
     });
     const wake = () => {
@@ -2146,13 +2173,13 @@ function useRoleDeliveries(relay, member, completions) {
       window.removeEventListener("focus", wake);
       document.removeEventListener("visibilitychange", wake);
     };
-  }, [relay, member, completions]);
+  }, [relay, member, completions, changes]);
   return member && completions && state?.member === member ? state.deliveries : NONE;
 }
 
 // src/react/experience.tsx
 import { jsx } from "react/jsx-runtime";
-var Deliveries = createContext2(Object.freeze([]));
+var Deliveries = /* @__PURE__ */ (() => createContext2(Object.freeze([])))();
 function useExperienceSnapshot() {
   const store = useStore();
   const get = () => store.experience;
@@ -2166,6 +2193,11 @@ function DeliveriesProvider({ children }) {
     () => store.scope?.member ?? null,
     () => null
   );
+  const changes = useSyncExternalStore3(
+    store.subscribe,
+    () => store.deliveryChanges,
+    () => 0
+  );
   const ready = experience.status === "ready";
   const deliveries = useRoleDeliveries(
     store.client,
@@ -2173,7 +2205,8 @@ function DeliveriesProvider({ children }) {
     ready ? completionMark([
       ...experience.data.quests,
       ...experience.data.collections.flatMap((c) => c.quests)
-    ]) : ""
+    ]) : "",
+    changes
   );
   return /* @__PURE__ */ jsx(Deliveries, { value: deliveries, children });
 }
@@ -2194,6 +2227,7 @@ function RelayProvider({
   client,
   baseUrl = "/relay",
   polling,
+  followWallet = true,
   children
 }) {
   const origin = client ? null : baseUrl;
@@ -2202,10 +2236,11 @@ function RelayProvider({
   const store = useMemo4(
     () => new RelayStore(
       client ?? createBrowserRelayClient({ baseUrl: origin ?? baseUrl }),
-      { activityMs, snapshotMs }
+      { activityMs, snapshotMs },
+      { followWallet }
     ),
     // A given client ignores `baseUrl`; `polling` is compared by value.
-    [client, origin, activityMs, snapshotMs]
+    [client, origin, activityMs, snapshotMs, followWallet]
   );
   useEffect4(() => store.mount(), [store]);
   return /* @__PURE__ */ jsx2(StoreContext, { value: store, children: /* @__PURE__ */ jsx2(DeliveriesProvider, { children }) });
@@ -2664,6 +2699,10 @@ function useSignIn() {
       sendCode,
       verifyCode,
       startOver,
+      /**
+       * Leaves for the provider's consent screen: any of `providers().signInProviders`, Telegram
+       * included.
+       */
       withProvider,
       /**
        * Signs in, or signs up, with a wallet; the wallet asks the participant to sign a message. A
@@ -2671,11 +2710,15 @@ function useSignIn() {
        * to another account in it, or locking it, signs out.
        */
       withWallet,
-      /** Leaves for Telegram Login, where the platform configured it. */
+      /**
+       * Leaves for Telegram Login, where the platform configured it.
+       *
+       * @deprecated Use `withProvider("telegram")`. Removed in 2.0.0.
+       */
       withTelegram,
       /**
        * Signs in, or signs up, inside a Telegram Mini App the project enabled, with its launch data
-       * (`telegramMiniAppInitData()`).
+       * (`telegramMiniAppInitData()` from `@domino-sdk/relay/telegram`).
        */
       withTelegramMiniApp
     }),
@@ -2739,7 +2782,7 @@ function useSignInOptions(input = {}) {
     if (!methods) {
       return null;
     }
-    if (!wallets && methods.providers.length === 0 && !methods.email && !methods.telegram?.login) {
+    if (!wallets && methods.providers.length === 0 && !methods.signInProviders?.length && !methods.email && !methods.telegram?.login) {
       return null;
     }
     return signInOptionsFrom(methods, wallets ?? [], {
@@ -2747,6 +2790,7 @@ function useSignInOptions(input = {}) {
       walletsPending: !wallets,
       actions: {
         oauth: withProvider,
+        provider: withProvider,
         sendCode,
         verifyCode,
         wallet: withWallet,
@@ -2767,6 +2811,7 @@ function useSignInOptions(input = {}) {
   return useMemo7(
     () => ({
       options: built?.options ?? null,
+      signInProviders: built?.signInProviders ?? null,
       unavailable: built?.unavailable ?? NONE_UNAVAILABLE,
       telegram: built?.telegram ?? null,
       methodsError,
@@ -2782,7 +2827,7 @@ function useSignInOptions(input = {}) {
 }
 
 // src/react/accounts.ts
-import { useMemo as useMemo8 } from "react";
+import { useCallback as useCallback8, useMemo as useMemo8 } from "react";
 function isConnected(accounts, provider) {
   return Boolean(
     accounts?.some(
@@ -2846,6 +2891,67 @@ function useAccounts() {
     ]
   );
 }
+function useAccount(provider) {
+  const relay = useRelay();
+  const invalidate = useInvalidate();
+  const session = useScopeSession();
+  const select = useCallback8(
+    (accounts) => accounts.find((account2) => account2.provider === provider) ?? null,
+    [provider]
+  );
+  const query = useMemberQuery(
+    [...relayKeys.accounts, "sign-in"],
+    (options) => relay.auth.signInAccounts(options),
+    { refetchOnFocus: true, select }
+  );
+  const { isPending, actionError: actionError2, resetAction, run, retry, settle } = useAction();
+  const actions = useMemo8(
+    () => ({
+      connect: () => run(async () => {
+        const { url } = await relay.auth.start(
+          { provider, mode: "connect" },
+          { session }
+        );
+        window.location.assign(url);
+      }),
+      disconnect: () => run(async () => {
+        await relay.auth.disconnect(provider, { session });
+        void invalidate([
+          relayKeys.accounts,
+          relayKeys.experience,
+          relayKeys.profiles
+        ]);
+      })
+    }),
+    [relay, invalidate, session, run, provider]
+  );
+  const account = query.data;
+  return useMemo8(
+    () => ({
+      ...query,
+      isPending,
+      actionError: actionError2,
+      resetAction,
+      retry,
+      settle,
+      /** True when the account can be used to verify quests right now. */
+      isConnected: Boolean(
+        account?.configured && account.status === "connected"
+      ),
+      ...actions
+    }),
+    [
+      query,
+      isPending,
+      actionError2,
+      resetAction,
+      retry,
+      settle,
+      account,
+      actions
+    ]
+  );
+}
 function useTelegramAccount() {
   const relay = useRelay();
   const invalidate = useInvalidate();
@@ -3049,8 +3155,54 @@ function useProfileCompletions(profile, options = {}) {
   );
 }
 
+// src/react/consent.ts
+import { useMemo as useMemo10 } from "react";
+function useConsent() {
+  const relay = useRelay();
+  const store = useStore();
+  const session = useScopeSession();
+  const query = useMemberQuery(
+    relayKeys.consent,
+    (options) => relay.consent.get(options)
+  );
+  const { isPending, actionError: actionError2, resetAction, run, retry, settle } = useAction();
+  const actions = useMemo10(() => {
+    const change = (channel, granted, wording) => run(async (actionId) => {
+      const cache = store.scope?.cache;
+      await relay.consent.set(
+        {
+          actionId,
+          channel,
+          granted,
+          ...wording === void 0 ? {} : { wording }
+        },
+        { session }
+      );
+      void cache?.invalidate([relayKeys.consent]);
+    });
+    return {
+      /** Records the member's opt-in on `channel`, with the wording they saw. */
+      grant: (channel, wording) => change(channel, true, wording),
+      /** Records the member's opt-out on `channel`, with the wording they saw if there was any. */
+      withdraw: (channel, wording) => change(channel, false, wording)
+    };
+  }, [relay, store, session, run]);
+  return useMemo10(
+    () => ({
+      ...query,
+      isPending,
+      actionError: actionError2,
+      resetAction,
+      retry,
+      settle,
+      ...actions
+    }),
+    [query, isPending, actionError2, resetAction, retry, settle, actions]
+  );
+}
+
 // src/react/referrals.ts
-import { useCallback as useCallback8, useEffect as useEffect7, useMemo as useMemo10, useRef as useRef7, useState as useState8 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect7, useMemo as useMemo11, useRef as useRef7, useState as useState8 } from "react";
 var PENDING = "domino:pending-referral";
 var CODE = /^[a-zA-Z0-9_-]{1,100}$/;
 function captureReferralCode(param = "ref") {
@@ -3100,7 +3252,7 @@ function useInvitation(param = "ref") {
       action: createRelayAction()
     };
   }
-  const accept = useCallback8(
+  const accept = useCallback9(
     async (code) => {
       const owner = pending.current;
       if (owner.action.busy) {
@@ -3145,7 +3297,7 @@ function useInvitation(param = "ref") {
       void accept(state.code);
     }
   }, [member, state, accept]);
-  return useMemo10(() => ({ invitation: state, accept }), [state, accept]);
+  return useMemo11(() => ({ invitation: state, accept }), [state, accept]);
 }
 function useReferralSummary(options = {}) {
   const relay = useRelay();
@@ -3155,7 +3307,7 @@ function useReferralSummary(options = {}) {
     (request) => relay.referrals.summary(request),
     { intervalMs }
   );
-  return useMemo10(() => {
+  return useMemo11(() => {
     let link = null;
     if (query.data && typeof window !== "undefined") {
       const url = new URL(path, window.location.origin);
@@ -3222,7 +3374,7 @@ function useQuestOutcomes(query = {}) {
 }
 
 // src/react/offers.ts
-import { useCallback as useCallback9, useMemo as useMemo11 } from "react";
+import { useCallback as useCallback10, useMemo as useMemo12 } from "react";
 function useOffers() {
   const relay = useRelay();
   return useRelayQuery(
@@ -3237,11 +3389,11 @@ function useRedeemOffer() {
     { invalidates: [relayKeys.offers, relayKeys.balances] }
   );
   const { mutateAsync } = mutation;
-  const redeem = useCallback9(
+  const redeem = useCallback10(
     (offer) => mutateAsync(offer).catch(() => null),
     [mutateAsync]
   );
-  return useMemo11(
+  return useMemo12(
     () => ({ ...mutation, redeem, retry: replay, busy: mutation.isPending }),
     [mutation, redeem, replay]
   );
@@ -3281,11 +3433,13 @@ export {
   roleDeliveryLabel,
   roleDeliveryStatus,
   telegramMiniAppInitData,
+  useAccount,
   useAccounts,
   useActivity,
   useBadgeCatalog,
   useBadges,
   useBalances,
+  useConsent,
   useCreatorAccounts,
   useDeliveries,
   useEntitlements,

package/dist/{action-DBzILFx9.d.ts → request-error-D_dUPLwo.d.ts}

@@ -64,34 +64,4 @@ declare class RequestError extends Error {
     constructor(message: string, details: RequestErrorDetails);
 }
 
-/** SDK input convenience; the wire request always carries a key. */
-type OptionalActionId<T> = T extends {
-    actionId: string;
-} ? Omit<T, "actionId"> & {
-    actionId?: string;
-} : never;
-/** One logical write. Keep this object until its outcome is definite. */
-type RelayAction<T> = {
-    /** The pending write's key, also available on its uncertain error as `operationId`. */
-    readonly actionId: string | undefined;
-    readonly busy: boolean;
-    readonly error: RequestError | undefined;
-    /**
-     * Starts a write with a generated key. While an uncertain write is pending, replays its saved
-     * callback instead of accepting a different write. Concurrent calls share one request.
-     * Put refreshes and other follow-up work outside the callback.
-     */
-    run(task: (actionId: string) => Promise<T>): Promise<T>;
-    /** Replays the exact pending callback and key, only when the error's recovery is `replay`. */
-    retry(): Promise<T>;
-    /** Acknowledge an authoritative, definite outcome after reconciliation. Refuses while busy. */
-    settle(): boolean;
-};
-/**
- * Owns a mutation key across uncertain answers. A definite success or refusal ends the action;
- * the next `run` gets a new key. `reconcile` failures stay pending and cannot be replayed.
- * In-memory only: persist the key yourself if recovery must survive a reload or process restart.
- */
-declare function createRelayAction<T = unknown>(): RelayAction<T>;
-
-export { type OptionalActionId as O, type RelayAction as R, RequestError as a, type RequestErrorDetails as b, type RequestErrorKind as c, type RequestRecovery as d, createRelayAction as e, isRequestError as i };
+export { RequestError as R, type RequestErrorDetails as a, type RequestErrorKind as b, type RequestRecovery as c, isRequestError as i };