@domino-sdk/relay 1.60.0 → 1.62.0

package/dist/react/index.js

@@ -7,22 +7,26 @@ import {
   discoverSignInWallets,
   discoverSolanaWallets,
   readSignInMethods,
-  signInOptionsFrom,
+  signInOptionsFrom
+} from "../chunk-UW5232GG.js";
+import {
   telegramMiniAppInitData
-} from "../chunk-2FHNY52R.js";
-import "../chunk-VVRQQRMQ.js";
+} from "../chunk-FWLQ5XCS.js";
+import "../chunk-GKIFABGN.js";
 import {
   createRelayAction
-} from "../chunk-4OFH4BNX.js";
-import "../chunk-XQKUJL7H.js";
-import "../chunk-MJEJQH5A.js";
-import "../chunk-YNW2ZUUP.js";
+} from "../chunk-Y322OTCH.js";
+import "../chunk-6WCIWXUV.js";
+import "../chunk-CICDIBOF.js";
+import "../chunk-D26YNACF.js";
+import "../chunk-GTDW453U.js";
+import "../chunk-WSBYWVTZ.js";
 import "../chunk-KDR2VAJP.js";
-import "../chunk-6ZG7WNYX.js";
-import "../chunk-N7YOS4ZU.js";
+import "../chunk-3PYYGFSB.js";
 import {
   sessionMember
-} from "../chunk-422J3QRW.js";
+} from "../chunk-XJFYAXET.js";
+import "../chunk-MK425RXJ.js";
 import {
   RelayError,
   RelayErrorCode,
@@ -30,7 +34,7 @@ import {
   clientError,
   isRelayError,
   isRequestError
-} from "../chunk-GBSDAD3N.js";
+} from "../chunk-K2KS3JLY.js";
 
 // src/react/context.ts
 import { createContext, useContext } from "react";
@@ -52,12 +56,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`. */
@@ -624,8 +630,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
   }));
@@ -1055,6 +1064,40 @@ var TEST_STATE_CHANGED_EVENT = "domino:test-state-changed";
 function isVisible() {
   return typeof document === "undefined" || document.visibilityState !== "hidden";
 }
+var WALLET_SIGN_IN_KEY = "domino:wallet-sign-in";
+function readWalletSignIn() {
+  try {
+    const value = JSON.parse(
+      window.sessionStorage.getItem(WALLET_SIGN_IN_KEY) ?? "null"
+    );
+    return typeof value?.session === "string" && typeof value.address === "string" && typeof value.chain === "string" ? value : null;
+  } catch {
+    return null;
+  }
+}
+function writeWalletSignIn(value) {
+  try {
+    if (value) {
+      window.sessionStorage.setItem(WALLET_SIGN_IN_KEY, JSON.stringify(value));
+    } else {
+      window.sessionStorage.removeItem(WALLET_SIGN_IN_KEY);
+    }
+  } catch {
+  }
+}
+function reportingSigner(signer, signed) {
+  return {
+    chain: signer.chain,
+    network: signer.network,
+    name: signer.name,
+    address: () => signer.address(),
+    ...signer.chainId ? { chainId: () => signer.chainId() } : {},
+    sign: (message, address) => {
+      signed(address);
+      return signer.sign(message, address);
+    }
+  };
+}
 var ACTIVITY_MS = 5e3;
 var SNAPSHOT_MS = 3e4;
 var FOCUS_GAP_MS = 2e3;
@@ -1089,6 +1132,9 @@ var RelayStore = class {
   /** The first cache of this mount: a public read's `initialData` seeds only it. */
   #firstCache = null;
   #settled = null;
+  /** The wallet the current session signed in with, while the store follows its accounts. */
+  #wallet = null;
+  #walletSigningOut = false;
   constructor(client, polling = {}) {
     this.client = client;
     this.#polling = {
@@ -1167,6 +1213,7 @@ var RelayStore = class {
       this.#observer?.dispose();
       this.#observer = null;
       this.#stopFeed();
+      this.#stopWallet(false);
       this.#sessionRead?.abort();
       this.#sessionRead = null;
       this.#sessionVersion++;
@@ -1226,6 +1273,32 @@ var RelayStore = class {
     this.#setSession({ status: "ready", data: null, error: null });
     this.#emit();
   }
+  /**
+   * Signs in with a wallet through the client, then follows the wallet's accounts when the signer
+   * can watch them: a switch to another account, or an empty list, signs out.
+   */
+  async signInWithWallet(signer) {
+    if (!signer.watchAccounts) {
+      await this.client.auth.wallet.signIn(signer);
+      return;
+    }
+    let address;
+    const session = await this.client.auth.wallet.signIn(
+      reportingSigner(signer, (signed) => {
+        address = signed;
+      })
+    );
+    if (!this.#mounted || !address || typeof session?.id !== "string") {
+      return;
+    }
+    writeWalletSignIn({
+      session: session.id,
+      chain: signer.chain,
+      address,
+      ...signer.name ? { name: signer.name } : {}
+    });
+    this.#watchWallet(signer, address, session.id);
+  }
   /**
    * Reads the experience again. With a feed, it is read first: the events it finds read the
    * experience and whatever else they changed, so a change the participant just made shows its
@@ -1319,6 +1392,63 @@ var RelayStore = class {
     this.#feed = null;
     feed?.dispose();
   }
+  /** Signs out when the wallet `session` signed in with reports another account, or none. */
+  #watchWallet(signer, address, session) {
+    this.#stopWallet(false);
+    const signedIn = address.toLowerCase();
+    const watch = { session, stop: () => {
+    } };
+    this.#wallet = watch;
+    watch.stop = signer.watchAccounts((accounts) => {
+      if (this.#wallet === watch && accounts[0]?.toLowerCase() !== signedIn) {
+        void this.#walletSwitched();
+      }
+    });
+  }
+  async #walletSwitched() {
+    if (this.#walletSigningOut) {
+      return;
+    }
+    this.#walletSigningOut = true;
+    try {
+      await this.signOut();
+    } catch {
+    } finally {
+      this.#walletSigningOut = false;
+    }
+  }
+  #stopWallet(forget) {
+    const watch = this.#wallet;
+    this.#wallet = null;
+    watch?.stop();
+    if (forget) {
+      writeWalletSignIn(null);
+    }
+  }
+  /** Follows the wallet a session restored after a reload signed in with, if it is installed. */
+  async #restoreWallet(record) {
+    const wallets = await discoverEvmWallets();
+    const wallet = record.name ? wallets.find((candidate) => candidate.name === record.name) : wallets.length === 1 ? wallets[0] : void 0;
+    if (wallet?.signer.watchAccounts && this.#mounted && !this.#wallet && this.#scope?.session?.id === record.session) {
+      this.#watchWallet(wallet.signer, record.address, record.session);
+    }
+  }
+  /** Stops following a wallet once its session ended; resumes after a reload or remount. */
+  #syncWallet(session) {
+    const id = session?.id ?? null;
+    if (this.#wallet && this.#wallet.session !== id) {
+      this.#stopWallet(true);
+    }
+    if (this.#wallet || !id) {
+      return;
+    }
+    const record = readWalletSignIn();
+    if (record?.session === id && record.chain === "eip155") {
+      void this.#restoreWallet(record);
+    } else if (record) {
+      writeWalletSignIn(null);
+    }
+  }
   /** Reads again, once each, the queries the events change. */
   #applyEvents(events) {
     const keys = /* @__PURE__ */ new Map();
@@ -1457,6 +1587,9 @@ var RelayStore = class {
     };
     this.#firstCache ??= this.#scope.cache;
     this.#syncFeed();
+    if (next.status === "ready") {
+      this.#syncWallet(session);
+    }
   }
   #deriveExperience() {
     const session = this.#session;
@@ -1788,7 +1921,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() {
@@ -2444,7 +2577,8 @@ function useMe() {
   return useMemberQuery(relayKeys.me, (options) => relay.me.get(options));
 }
 function useSignIn() {
-  const relay = useRelay();
+  const store = useStore();
+  const relay = store.client;
   const [challenge, setChallengeState] = useState7(null);
   const latest = useRef6(null);
   const [busy, setBusy] = useState7(false);
@@ -2519,10 +2653,10 @@ function useSignIn() {
   );
   const withWallet = useCallback7(
     (signer) => run(async () => {
-      await relay.auth.wallet.signIn(signer);
+      await store.signInWithWallet(signer);
       setChallenge(null);
     }, "Couldn't sign in with this wallet. Try again."),
-    [relay, run, setChallenge]
+    [store, run, setChallenge]
   );
   const codeSent = challenge !== null;
   return useMemo7(
@@ -2539,14 +2673,26 @@ 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. */
+      /**
+       * Signs in, or signs up, with a wallet; the wallet asks the participant to sign a message. A
+       * wallet that can watch its accounts, such as an EVM browser wallet, is followed: switching
+       * 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
     }),
@@ -2610,7 +2756,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 ?? [], {
@@ -2618,6 +2764,7 @@ function useSignInOptions(input = {}) {
       walletsPending: !wallets,
       actions: {
         oauth: withProvider,
+        provider: withProvider,
         sendCode,
         verifyCode,
         wallet: withWallet,
@@ -2638,6 +2785,7 @@ function useSignInOptions(input = {}) {
   return useMemo7(
     () => ({
       options: built?.options ?? null,
+      signInProviders: built?.signInProviders ?? null,
       unavailable: built?.unavailable ?? NONE_UNAVAILABLE,
       telegram: built?.telegram ?? null,
       methodsError,
@@ -2653,7 +2801,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(
@@ -2717,6 +2865,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();
@@ -2920,8 +3129,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") {
@@ -2971,7 +3226,7 @@ function useInvitation(param = "ref") {
       action: createRelayAction()
     };
   }
-  const accept = useCallback8(
+  const accept = useCallback9(
     async (code) => {
       const owner = pending.current;
       if (owner.action.busy) {
@@ -3016,7 +3271,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();
@@ -3026,7 +3281,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);
@@ -3093,7 +3348,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(
@@ -3108,11 +3363,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]
   );
@@ -3152,11 +3407,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 };