@bananapus/nana-sdk-react 52.0.0 → 53.0.0

package/dist/index.js

@@ -68,9 +68,9 @@ import {
 } from "@bananapus/nana-sdk-core";
 import {
   createContext as createContext8,
-  useCallback,
+  useCallback as useCallback2,
   useContext as useContext8,
-  useMemo as useMemo5
+  useMemo as useMemo8
 } from "react";
 import { isAddressEqual as isAddressEqual4, zeroAddress as zeroAddress4 } from "viem";
 
@@ -4102,9 +4102,346 @@ function useJBUpcomingRuleset({
   };
 }
 
+// src/hooks/heldWrite/HeldWritesNotice.tsx
+import { HELD_RELEASE_LABEL } from "@bananapus/nana-sdk-core/review";
+import { useState } from "react";
+import { jsx as jsx10, jsxs as jsxs2 } from "react/jsx-runtime";
+function HeldWritesNotice({
+  items,
+  className
+}) {
+  const [busy, setBusy] = useState(null);
+  const shown = items.filter(({ view }) => view.line);
+  if (!shown.length) return null;
+  return /* @__PURE__ */ jsx10("div", { role: "status", className, children: shown.map(({ key, label, view, release }) => /* @__PURE__ */ jsxs2("div", { "data-phase": view.phase, children: [
+    label ? /* @__PURE__ */ jsx10("p", { children: label }) : null,
+    /* @__PURE__ */ jsx10("p", { children: view.line }),
+    view.warning ? /* @__PURE__ */ jsx10("p", { children: view.warning }) : null,
+    view.notice ? /* @__PURE__ */ jsx10("p", { children: view.notice }) : null,
+    view.exit ? /* @__PURE__ */ jsx10(
+      "button",
+      {
+        type: "button",
+        disabled: busy === key,
+        onClick: () => {
+          setBusy(key);
+          void release().finally(() => setBusy(null));
+        },
+        children: HELD_RELEASE_LABEL
+      }
+    ) : null
+  ] }, key)) });
+}
+
+// src/hooks/heldWrite/useHeldWrite.ts
+import {
+  createHeldWriteView,
+  HELD_EXIT_LABEL,
+  HELD_SEND_AGAIN_LABEL
+} from "@bananapus/nana-sdk-core/review";
+import { useEffect, useMemo as useMemo5, useRef, useSyncExternalStore } from "react";
+var NO_CALL = {
+  to: "0x0000000000000000000000000000000000000000",
+  data: "0x"
+};
+var IDLE = {
+  phase: "clear",
+  state: null,
+  line: null,
+  exit: false,
+  adopting: false
+};
+var none = () => () => {
+};
+var keyOf = (value) => JSON.stringify(
+  value,
+  (_, field) => typeof field === "bigint" ? `${field}n` : field
+);
+var idle = () => IDLE;
+function useHeldWrite(options) {
+  const {
+    hold,
+    chainId,
+    account,
+    safe = false,
+    namespace,
+    client,
+    pollMs
+  } = options;
+  const callKey = keyOf(options.call ?? null);
+  const legacyKey = keyOf(options.legacy ?? null);
+  const latest = useRef(options);
+  latest.current = options;
+  const handle = useMemo5(() => {
+    const call = latest.current.call;
+    if (!call && !namespace) return void 0;
+    const legacy = latest.current.legacy;
+    return hold.open(
+      {
+        chainId,
+        account,
+        safe,
+        call: call ?? NO_CALL,
+        ...namespace ? { namespace } : {}
+      },
+      legacy ? { legacy } : void 0
+    );
+  }, [hold, chainId, account, safe, namespace, callKey, legacyKey]);
+  const adopts = !!options.adopt;
+  const active = useRef(void 0);
+  const view = useMemo5(() => {
+    if (!handle || !client) return void 0;
+    const own = (callback) => (...args) => {
+      if (active.current === created) callback(...args);
+    };
+    const created = createHeldWriteView(handle, {
+      client,
+      pollMs,
+      onSettled: own(
+        (settled, receipt) => latest.current.onSettled?.(settled, receipt)
+      ),
+      onReleased: own((by) => latest.current.onReleased?.(by)),
+      onAdopted: own((state) => latest.current.onAdopted?.(state)),
+      // A view made with a provider: the app's current one (a removed one
+      // makes a new view, and this one stops).
+      ...adopts ? { adopt: () => latest.current.adopt() } : {}
+    });
+    return created;
+  }, [handle, client, pollMs, adopts]);
+  useEffect(() => {
+    if (!view) return;
+    active.current = view;
+    const stop = view.start();
+    return () => {
+      if (active.current === view) active.current = void 0;
+      stop();
+    };
+  }, [view]);
+  const shown = useSyncExternalStore(
+    view?.subscribe ?? none,
+    view?.get ?? idle,
+    view?.get ?? idle
+  );
+  return {
+    ...shown,
+    exitAction: shown.exit && view ? { label: HELD_EXIT_LABEL, run: view.exit } : null,
+    sendAgainAction: shown.phase === "succeeded" && view ? { label: HELD_SEND_AGAIN_LABEL, run: view.acknowledge } : null,
+    send: (run) => {
+      if (!view)
+        return Promise.reject(
+          new Error("Connect a wallet and build the call before sending.")
+        );
+      if (!!latest.current.adopt !== adopts)
+        return Promise.reject(
+          new Error(
+            "Saved transactions are still being checked. Try again in a moment."
+          )
+        );
+      return view.send(run);
+    },
+    check: () => view ? view.check() : Promise.resolve(IDLE),
+    handle
+  };
+}
+
+// src/hooks/heldWrite/useHeldWrites.ts
+import {
+  createHeldWriteView as createHeldWriteView2
+} from "@bananapus/nana-sdk-core/review";
+import { useEffect as useEffect2, useMemo as useMemo6, useState as useState2, useSyncExternalStore as useSyncExternalStore2 } from "react";
+function useHeldViews(entries, client, pollMs) {
+  const views = useMemo6(
+    () => client ? entries.map((entry) => ({
+      entry,
+      view: createHeldWriteView2(entry.handle, { client, pollMs })
+    })) : [],
+    [entries, client, pollMs]
+  );
+  useEffect2(() => {
+    const stops = views.map(({ view }) => view.start());
+    return () => stops.forEach((stop) => stop());
+  }, [views]);
+  const store = useMemo6(() => feed(views.map(({ view }) => view)), [views]);
+  const shown = useSyncExternalStore2(store.subscribe, store.get, store.get);
+  return views.map(({ entry, view }, index) => ({
+    key: entry.key,
+    ...entry.label ? { label: entry.label } : {},
+    view: shown[index],
+    release: view.exit
+  })).filter(({ view }) => view.phase !== "clear");
+}
+function feed(views) {
+  let snapshot = views.map((view) => view.get());
+  return {
+    subscribe(listener) {
+      const stops = views.map(
+        (view) => view.subscribe(() => {
+          snapshot = views.map((each) => each.get());
+          listener();
+        })
+      );
+      return () => stops.forEach((stop) => stop());
+    },
+    get: () => snapshot
+  };
+}
+function useHeldIntents({
+  hold,
+  chainId,
+  account,
+  client,
+  intents,
+  pollMs
+}) {
+  const intentsKey = JSON.stringify(intents);
+  const entries = useMemo6(
+    () => account ? intents.map(({ namespace, label }) => ({
+      key: namespace,
+      label,
+      handle: hold.open({
+        chainId,
+        account,
+        safe: false,
+        namespace,
+        call: { to: account, data: "0x" }
+      })
+    })) : [],
+    // The intents key stands for the intents.
+    [hold, chainId, account, intentsKey]
+  );
+  return useHeldViews(entries, client, pollMs);
+}
+function useHeldWrites({
+  hold,
+  chainId,
+  account,
+  client,
+  label,
+  pollMs = 3e4
+}) {
+  const [generation, setGeneration] = useState2(0);
+  useEffect2(() => {
+    const again = () => setGeneration((value) => value + 1);
+    globalThis.addEventListener?.("storage", again);
+    const timer = setInterval(again, pollMs);
+    return () => {
+      globalThis.removeEventListener?.("storage", again);
+      clearInterval(timer);
+    };
+  }, [pollMs]);
+  const listed = useMemo6(
+    () => account ? hold.list({ account, chainId }) : [],
+    [hold, account, chainId, generation]
+  );
+  const listedKey = listed.map(({ key, record }) => `${key}:${record.id}`).join("|");
+  const entries = useMemo6(
+    () => listed.map(({ key, record, handle }) => ({
+      key,
+      label: label?.(record),
+      handle
+    })),
+    // The listed key stands for the list.
+    [listedKey]
+  );
+  return useHeldViews(entries, client, pollMs);
+}
+
+// src/hooks/heldWrite/useSavedAttempt.ts
+import {
+  checkedItLabel,
+  SAVED_ATTEMPT_CONTINUE_ANYWAY_LABEL,
+  SAVED_ATTEMPT_UNREADABLE_LINE
+} from "@bananapus/nana-sdk-core/review";
+import {
+  useCallback,
+  useEffect as useEffect3,
+  useLayoutEffect,
+  useMemo as useMemo7,
+  useRef as useRef2,
+  useState as useState3
+} from "react";
+var keyOf2 = (attempt) => attempt ? JSON.stringify(
+  { ...attempt, authenticate: void 0 },
+  (_, value) => typeof value === "bigint" ? value.toString() : value
+) : null;
+function useSavedAttempt(options) {
+  const { recovery, client, checkNext } = options;
+  const key = keyOf2(options.attempt);
+  const attempt = options.attempt;
+  const latest = useRef2(attempt);
+  latest.current = attempt;
+  const lifecycle = useMemo7(
+    () => ({ attempt, recovery, client, request: 0 }),
+    // The key stands for the attempt.
+    [key, recovery, client]
+  );
+  const current = (of) => mounted.current && rendered.current === of;
+  const rendered = useRef2(void 0);
+  rendered.current = lifecycle;
+  const mounted = useRef2(false);
+  useLayoutEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const [shown, setShown] = useState3({ outcome: null, recovering: false });
+  const [unreadable, setUnreadable] = useState3();
+  const recover = useCallback(async () => {
+    const { recovery: recovery2, client: client2 } = lifecycle;
+    const attempt2 = latest.current;
+    if (!attempt2 || !client2 || !current(lifecycle)) return null;
+    const request = ++lifecycle.request;
+    setShown((now) => ({
+      of: lifecycle,
+      outcome: now.of === lifecycle ? now.outcome : null,
+      recovering: true
+    }));
+    const outcome2 = await recovery2.recover(attempt2, client2);
+    if (!current(lifecycle) || lifecycle.request !== request) return null;
+    setShown({ of: lifecycle, outcome: outcome2, recovering: false });
+    return outcome2;
+  }, [lifecycle]);
+  useEffect3(() => {
+    void recover();
+  }, [recover]);
+  const retire = useCallback(
+    async (reason) => {
+      const { recovery: recovery2 } = lifecycle;
+      const attempt2 = latest.current;
+      if (!attempt2 || !current(lifecycle)) return { retired: false };
+      const retired = await recovery2.retire(attempt2, reason);
+      if (!current(lifecycle)) return retired;
+      if (!retired.retired && retired.reason === "unreadable")
+        setUnreadable(lifecycle);
+      await recover();
+      return retired;
+    },
+    [lifecycle, recover]
+  );
+  const outcome = shown.of === lifecycle ? shown.outcome : null;
+  return {
+    outcome,
+    recovering: shown.of === lifecycle && shown.recovering,
+    recover,
+    checkAction: outcome?.status === "check" ? {
+      line: outcome.line,
+      warning: outcome.warning,
+      label: checkedItLabel(checkNext),
+      run: () => retire({ by: "check", outcome })
+    } : null,
+    unreadableAction: outcome?.status === "check" && unreadable === lifecycle ? {
+      line: SAVED_ATTEMPT_UNREADABLE_LINE,
+      label: SAVED_ATTEMPT_CONTINUE_ANYWAY_LABEL,
+      run: () => retire({ by: "check", outcome, force: "unreadable" })
+    } : null,
+    retire
+  };
+}
+
 // src/contexts/JBContractContext/JBContractContext.tsx
 import { useReadContract as useReadContract11 } from "wagmi";
-import { jsx as jsx10 } from "react/jsx-runtime";
+import { jsx as jsx11 } from "react/jsx-runtime";
 function outsideProvider() {
   throw new Error(
     "JBContractContext was read outside a JBContractProvider. Wrap the tree in JBProjectProvider or JBContractProvider."
@@ -4164,7 +4501,7 @@ var JBContractProvider = ({
   version
 }) => {
   const chainId = useJBChainId();
-  const enabled = useCallback(
+  const enabled = useCallback2(
     (selector) => {
       if (typeof include === "undefined") return true;
       return include.some((c) => selector.includes(c));
@@ -4187,7 +4524,7 @@ var JBContractProvider = ({
     chainId,
     args: usdcAddress && enabled([1 /* PrimaryNativePaymentTerminal */]) ? [projectId, usdcAddress] : void 0
   });
-  const primaryNativeTerminal = useMemo5(() => {
+  const primaryNativeTerminal = useMemo8(() => {
     const isTerminal = (address) => address !== void 0 && !isAddressEqual4(address, zeroAddress4);
     if (isTerminal(primaryNativeTerminalEth.data))
       return primaryNativeTerminalEth;
@@ -4210,13 +4547,13 @@ var JBContractProvider = ({
       staleTime: Infinity
     }
   });
-  const controllerAddress = useMemo5(() => controller.data, [controller.data]);
-  const hasController = useMemo5(() => {
+  const controllerAddress = useMemo8(() => controller.data, [controller.data]);
+  const hasController = useMemo8(() => {
     return Boolean(
       controllerAddress && !isAddressEqual4(controllerAddress, zeroAddress4)
     );
   }, [controllerAddress]);
-  const resolvedControllerAddress = useMemo5(() => {
+  const resolvedControllerAddress = useMemo8(() => {
     return hasController ? controllerAddress : void 0;
   }, [controllerAddress, hasController]);
   const fundAccessLimits = useReadContract11({
@@ -4263,7 +4600,7 @@ var JBContractProvider = ({
     ...query,
     isLoading: Boolean(query.isLoading || controller.isLoading)
   });
-  const contractAddress = useCallback(
+  const contractAddress = useCallback2(
     (contract, _chainId) => {
       return getJBContractAddress3(contract, version, _chainId || chainId);
     },
@@ -4278,7 +4615,7 @@ var JBContractProvider = ({
     splits: dependent(splits)
   };
   debug10("JBContractContext", { projectId, contracts });
-  return /* @__PURE__ */ jsx10(
+  return /* @__PURE__ */ jsx11(
     JBContractContext.Provider,
     {
       value: {
@@ -4436,7 +4773,7 @@ function useGetRelayrTxQuote() {
 }
 
 // src/lib/relayr/hooks/useGetRelayrTxBundle.ts
-import { useCallback as useCallback2, useMemo as useMemo6, useState } from "react";
+import { useCallback as useCallback3, useMemo as useMemo9, useState as useState4 } from "react";
 import { useQuery as useQuery9 } from "wagmi/query";
 var POLL_INTERVAL = 2e3;
 var transactionSucceeded = (state) => state === "Success" || state === "Completed";
@@ -4454,14 +4791,14 @@ var fetchTxBundle = async (uuid, signal) => {
   return response.json();
 };
 function useGetRelayrTxBundle() {
-  const [uuid, setUuid] = useState();
+  const [uuid, setUuid] = useState4();
   const getRelayrTxBundle = useQuery9({
     queryKey: ["txBundle", uuid],
     queryFn: ({ signal }) => fetchTxBundle(uuid, signal),
     enabled: !!uuid,
     refetchInterval: (query) => areTransactionsComplete(query.state.data) || hasTransactionFailure(query.state.data) ? false : POLL_INTERVAL
   });
-  const startPolling = useCallback2(
+  const startPolling = useCallback3(
     (bundleUuid) => {
       if (bundleUuid === uuid) {
         void getRelayrTxBundle.refetch();
@@ -4471,11 +4808,11 @@ function useGetRelayrTxBundle() {
     },
     [getRelayrTxBundle.refetch, uuid]
   );
-  const isComplete = useMemo6(
+  const isComplete = useMemo9(
     () => areTransactionsComplete(getRelayrTxBundle.data),
     [getRelayrTxBundle.data]
   );
-  const hasFailed = useMemo6(
+  const hasFailed = useMemo9(
     () => hasTransactionFailure(getRelayrTxBundle.data),
     [getRelayrTxBundle.data]
   );
@@ -4494,13 +4831,13 @@ function useGetRelayrTxBundle() {
 }
 
 // src/lib/relayr/hooks/useSendRelayrTx.ts
-import { useCallback as useCallback3 } from "react";
+import { useCallback as useCallback4 } from "react";
 import { useChainId, useSwitchChain as useSwitchChain2, useSendTransaction } from "wagmi";
 function useSendRelayrTx() {
   const chainId = useChainId();
   const { switchChainAsync } = useSwitchChain2();
   const _sendTransaction = useSendTransaction();
-  const sendRelayrTx = useCallback3(
+  const sendRelayrTx = useCallback4(
     async (chainPayment) => {
       if (chainId !== chainPayment.chain) {
         try {
@@ -4532,6 +4869,7 @@ export {
   DASHBOARD,
   DEFAULT_ETHER_PRICE_ENDPOINT,
   DynamicContract,
+  HeldWritesNotice,
   JBChainContext,
   JBChainProvider,
   JBContractContext,
@@ -4555,6 +4893,9 @@ export {
   useFind721DataHook,
   useGetRelayrTxBundle,
   useGetRelayrTxQuote,
+  useHeldIntents,
+  useHeldWrite,
+  useHeldWrites,
   useJBChainId,
   useJBContractContext,
   useJBDataHookContext,
@@ -4573,6 +4914,7 @@ export {
   usePreparePayMetadata,
   useProjectMetadata,
   useResolveDataHook,
+  useSavedAttempt,
   useSendRelayrTx,
   useShopPurchases,
   useSuckers,