@accesly/react 1.1.3 → 1.2.0

package/dist/index.cjs

@@ -11,6 +11,7 @@ var AcceslyContext = react.createContext(null);
 var ENVIRONMENT_DEFAULTS = {
   dev: {
     apiUrl: "https://3fki7eiio5.execute-api.us-east-1.amazonaws.com/dev",
+    walletStreamUrl: "https://ajlmn37thw7fxen3oyykbfmlrm0eecue.lambda-url.us-east-1.on.aws/",
     cognito: {
       region: "us-east-1",
       userPoolId: "us-east-1_K2Nag1tB1",
@@ -28,6 +29,7 @@ var ENVIRONMENT_DEFAULTS = {
   },
   staging: {
     apiUrl: "https://api-staging.accesly.xyz",
+    walletStreamUrl: "",
     cognito: {
       region: "us-east-1",
       userPoolId: "TBD-staging",
@@ -43,6 +45,7 @@ var ENVIRONMENT_DEFAULTS = {
   },
   prod: {
     apiUrl: "https://api.accesly.xyz",
+    walletStreamUrl: "",
     cognito: {
       region: "us-east-1",
       userPoolId: "TBD-prod",
@@ -928,8 +931,133 @@ function base64ToBytes(s) {
   for (let i = 0; i < bin.length; i += 1) arr[i] = bin.charCodeAt(i);
   return arr;
 }
+
+// src/hooks/walletSubscription.ts
+var ACTIVITY_BUFFER_MAX = 50;
+var subscriptions = /* @__PURE__ */ new Map();
+function buildSubscriptionUrl(streamUrl, walletAddress) {
+  const base = streamUrl.replace(/\/$/, "");
+  return `${base}/?walletAddress=${encodeURIComponent(walletAddress)}`;
+}
+function openConnection(state) {
+  if (state.eventSource) return;
+  if (typeof EventSource === "undefined") return;
+  let es;
+  try {
+    es = new EventSource(state.url, { withCredentials: false });
+  } catch (err) {
+    console.warn("[walletSubscription] EventSource construction failed", err);
+    return;
+  }
+  state.eventSource = es;
+  es.addEventListener("status", (ev) => {
+    try {
+      const data = JSON.parse(ev.data);
+      state.lastStatus = data;
+      for (const listener of state.listeners.status) listener(data);
+    } catch {
+    }
+  });
+  es.addEventListener("balance", (ev) => {
+    try {
+      const data = JSON.parse(ev.data);
+      state.lastBalance = data;
+      for (const listener of state.listeners.balance) listener(data);
+    } catch {
+    }
+  });
+  es.addEventListener("activity", (ev) => {
+    try {
+      const data = JSON.parse(ev.data);
+      const merged = [...data.events, ...state.activityBuffer];
+      const seen = /* @__PURE__ */ new Set();
+      const deduped = [];
+      for (const item of merged) {
+        const key = `${item.txHash}:${item.ledger}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        deduped.push(item);
+        if (deduped.length >= ACTIVITY_BUFFER_MAX) break;
+      }
+      state.activityBuffer = deduped;
+      for (const listener of state.listeners.activity) {
+        listener({ events: state.activityBuffer });
+      }
+    } catch {
+    }
+  });
+  es.addEventListener("close", () => {
+  });
+  es.onerror = () => {
+  };
+}
+function closeConnection(state) {
+  if (!state.eventSource) return;
+  state.eventSource.close();
+  state.eventSource = null;
+}
+function getOrCreateSubscription(streamUrl, walletAddress) {
+  const existing = subscriptions.get(walletAddress);
+  if (existing) return existing;
+  const state = {
+    walletAddress,
+    url: buildSubscriptionUrl(streamUrl, walletAddress),
+    eventSource: null,
+    listeners: {
+      status: /* @__PURE__ */ new Set(),
+      balance: /* @__PURE__ */ new Set(),
+      activity: /* @__PURE__ */ new Set()
+    },
+    lastStatus: null,
+    lastBalance: null,
+    activityBuffer: [],
+    refCount: 0
+  };
+  subscriptions.set(walletAddress, state);
+  return state;
+}
+function subscribeToWalletEvent(streamUrl, walletAddress, eventType, listener) {
+  if (!streamUrl || typeof EventSource === "undefined") return null;
+  const state = getOrCreateSubscription(streamUrl, walletAddress);
+  state.refCount += 1;
+  state.listeners[eventType].add(listener);
+  if (eventType === "status" && state.lastStatus) {
+    listener(state.lastStatus);
+  } else if (eventType === "balance" && state.lastBalance) {
+    listener(state.lastBalance);
+  } else if (eventType === "activity" && state.activityBuffer.length > 0) {
+    listener({
+      events: state.activityBuffer
+    });
+  }
+  if (!state.eventSource) openConnection(state);
+  return () => {
+    state.listeners[eventType].delete(listener);
+    state.refCount -= 1;
+    if (state.refCount <= 0) {
+      closeConnection(state);
+      subscriptions.delete(walletAddress);
+    }
+  };
+}
+function closeAllWalletSubscriptions() {
+  for (const state of subscriptions.values()) closeConnection(state);
+  subscriptions.clear();
+}
+
+// src/hooks/useWalletStatus.ts
 var POLL_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
 var STALE_THRESHOLD_MS = 6e4;
+function useStableRef(value) {
+  const ref = react.useRef(value);
+  ref.current = value;
+  return ref;
+}
+function deriveStatus(onChain) {
+  if (onChain === true) return "on-chain";
+  if (onChain === false) return "pending-deploy";
+  return "unknown";
+}
 function useWalletStatus() {
   const { wallet, _internal } = useAccesly();
   const username = _internal.username;
@@ -938,147 +1066,75 @@ function useWalletStatus() {
   const [onChain, setOnChain] = react.useState(null);
   const [lastSuccessAt, setLastSuccessAt] = react.useState(0);
   const [isStale, setIsStale] = react.useState(false);
-  const refreshRef = react.useRef(() => Promise.resolve());
-  const apply = react.useCallback((res) => {
-    if (res.kind === "not-found") {
-      setStatus("no-wallet");
-      setWalletAddress(null);
-      setOnChain(null);
-      setLastSuccessAt(Date.now());
-      setIsStale(false);
-      return "no-wallet";
-    }
-    const next = res.onChain === true ? "on-chain" : res.onChain === false ? "pending-deploy" : "unknown";
-    setStatus(next);
-    setWalletAddress(res.walletAddress);
-    setOnChain(res.onChain);
-    setLastSuccessAt(Date.now());
-    setIsStale(false);
-    return next;
-  }, []);
+  const envDefaults = ENVIRONMENT_DEFAULTS[_internal.env];
+  const streamUrl = envDefaults.walletStreamUrl;
+  const walletRef = useStableRef(wallet);
   const doFetch = react.useCallback(async () => {
     if (!username) return null;
     try {
-      const remote = await wallet.fetchRemote();
-      if (!remote) return apply({ kind: "not-found" });
-      return apply({
-        kind: "ok",
-        walletAddress: remote.walletAddress,
-        onChain: remote.onChain
-      });
+      const remote = await walletRef.current.fetchRemote();
+      if (!remote) {
+        setStatus("no-wallet");
+        setWalletAddress(null);
+        setOnChain(null);
+        setLastSuccessAt(Date.now());
+        setIsStale(false);
+        return "no-wallet";
+      }
+      const next = deriveStatus(remote.onChain);
+      setStatus(next);
+      setWalletAddress(remote.walletAddress);
+      setOnChain(remote.onChain);
+      setLastSuccessAt(Date.now());
+      setIsStale(false);
+      return next;
     } catch {
       return null;
     }
-  }, [username, wallet, apply]);
-  react.useEffect(() => {
-    if (!username || typeof BroadcastChannel === "undefined") return void 0;
-    const channel = new BroadcastChannel(`accesly:wallet:${username}`);
-    channel.onmessage = (ev) => {
-      const data = ev.data;
-      if (data && (data.kind === "ok" || data.kind === "not-found")) {
-        apply(data);
-      }
-    };
-    return () => channel.close();
-  }, [username, apply]);
-  const broadcastIfAvailable = react.useCallback(
-    (res) => {
-      if (!username || typeof BroadcastChannel === "undefined") return;
-      try {
-        const channel = new BroadcastChannel(`accesly:wallet:${username}`);
-        channel.postMessage(res);
-        channel.close();
-      } catch {
-      }
-    },
-    [username]
-  );
+  }, [username, walletRef]);
+  const doFetchRef = useStableRef(doFetch);
   react.useEffect(() => {
     if (!username) {
       setStatus("unknown");
       return void 0;
     }
     let cancelled = false;
+    let unsubscribe = null;
     let pollTimer = null;
     let backoffIndex = 0;
-    let eventSource = null;
     const schedulePoll = (delayMs) => {
       if (cancelled) return;
       pollTimer = setTimeout(async () => {
         if (cancelled) return;
-        if (typeof document !== "undefined" && document.hidden) {
-          return;
-        }
-        const next = await doFetch();
-        if (next !== null) {
-          broadcastIfAvailable({
-            kind: next === "no-wallet" ? "not-found" : "ok",
-            walletAddress: walletAddress ?? "",
-            onChain
-          });
-        }
-        if (next !== "on-chain" && next !== "no-wallet") {
-          backoffIndex = Math.min(backoffIndex + 1, POLL_BACKOFF_MS.length - 1);
-          schedulePoll(POLL_BACKOFF_MS[backoffIndex]);
-        }
+        if (typeof document !== "undefined" && document.hidden) return;
+        const next = await doFetchRef.current();
+        if (next === "on-chain" || next === "no-wallet") return;
+        backoffIndex = Math.min(backoffIndex + 1, POLL_BACKOFF_MS.length - 1);
+        schedulePoll(POLL_BACKOFF_MS[backoffIndex]);
       }, delayMs);
     };
-    const startPolling = () => {
-      backoffIndex = 0;
-      schedulePoll(POLL_BACKOFF_MS[0]);
-    };
-    const stopPolling = () => {
-      if (pollTimer) {
-        clearTimeout(pollTimer);
-        pollTimer = null;
-      }
-    };
-    const tryOpenSse = () => {
-      if (typeof EventSource === "undefined") return false;
-      try {
-        const url = `${_internal.apiUrl.replace(/\/$/, "")}/wallets/stream`;
-        eventSource = new EventSource(url, { withCredentials: false });
-        eventSource.onmessage = (ev) => {
-          try {
-            const data = JSON.parse(ev.data);
-            if (typeof data.walletAddress === "string") {
-              const res = {
-                kind: "ok",
-                walletAddress: data.walletAddress,
-                onChain: data.onChain ?? null
-              };
-              apply(res);
-              broadcastIfAvailable(res);
-            }
-          } catch {
-          }
-        };
-        eventSource.onerror = () => {
-          eventSource?.close();
-          eventSource = null;
-          startPolling();
-        };
-        return true;
-      } catch {
-        return false;
-      }
-    };
     void (async () => {
-      const next = await doFetch();
+      const initial = await doFetchRef.current();
       if (cancelled) return;
-      if (next === "on-chain" || next === "no-wallet") {
-        return;
+      if (initial === "on-chain" || initial === "no-wallet") return;
+      if (walletAddress) {
+        unsubscribe = subscribeToWalletEvent(streamUrl, walletAddress, "status", (data) => {
+          setWalletAddress(data.walletAddress);
+          setOnChain(data.onChain);
+          setStatus(deriveStatus(data.onChain));
+          setLastSuccessAt(Date.now());
+          setIsStale(false);
+        });
+      }
+      if (!unsubscribe) {
+        backoffIndex = 0;
+        schedulePoll(POLL_BACKOFF_MS[0]);
       }
-      const sseOpen = tryOpenSse();
-      if (!sseOpen) startPolling();
     })();
     const onVisibilityChange = () => {
       if (typeof document === "undefined") return;
-      if (document.hidden) {
-        stopPolling();
-      } else if (!eventSource && status !== "on-chain" && status !== "no-wallet") {
-        void doFetch();
-        startPolling();
+      if (!document.hidden && !unsubscribe) {
+        void doFetchRef.current();
       }
     };
     if (typeof document !== "undefined") {
@@ -1089,33 +1145,23 @@ function useWalletStatus() {
         setIsStale(true);
       }
     }, 3e4);
-    refreshRef.current = async () => {
-      const next = await doFetch();
-      if (next === "on-chain" || next === "no-wallet") {
-        stopPolling();
-      } else {
-        backoffIndex = 0;
-        stopPolling();
-        startPolling();
-      }
-    };
     return () => {
       cancelled = true;
-      stopPolling();
+      if (unsubscribe) unsubscribe();
+      if (pollTimer) clearTimeout(pollTimer);
       clearInterval(staleTimer);
-      eventSource?.close();
       if (typeof document !== "undefined") {
         document.removeEventListener("visibilitychange", onVisibilityChange);
       }
     };
-  }, [username, _internal.apiUrl, doFetch, apply, broadcastIfAvailable]);
+  }, [username, streamUrl, walletAddress]);
   const refresh = react.useCallback(async () => {
-    await refreshRef.current();
-  }, []);
+    await doFetchRef.current();
+  }, [doFetchRef]);
   return { status, walletAddress, onChain, isStale, refresh };
 }
-var POLL_INTERVAL_MS = 8e3;
-function useStableRef(value) {
+var POLL_FALLBACK_MS = 1e4;
+function useStableRef2(value) {
   const ref = react.useRef(value);
   ref.current = value;
   return ref;
@@ -1130,8 +1176,7 @@ function useBalance(walletAddress) {
   const [xlm, setXlm] = react.useState(null);
   const [isLoading, setIsLoading] = react.useState(true);
   const [error, setError] = react.useState(null);
-  const fetchInFlight = react.useRef(false);
-  const walletRef = useStableRef(wallet);
+  const walletRef = useStableRef2(wallet);
   react.useEffect(() => {
     if (walletAddress) {
       setResolvedAddress(walletAddress);
@@ -1155,11 +1200,11 @@ function useBalance(walletAddress) {
       cancelled = true;
     };
   }, [walletAddress, username, walletRef]);
-  const endpointsRef = useStableRef(_internal.endpoints);
-  const doFetch = react.useCallback(async () => {
+  const envDefaults = ENVIRONMENT_DEFAULTS[_internal.env];
+  const streamUrl = envDefaults.walletStreamUrl;
+  const endpointsRef = useStableRef2(_internal.endpoints);
+  const doFetchOnce = react.useCallback(async () => {
     if (!resolvedAddress) return;
-    if (fetchInFlight.current) return;
-    fetchInFlight.current = true;
     try {
       const res = await endpointsRef.current.walletBalance(resolvedAddress);
       setStroops(res.xlm.stroops);
@@ -1169,58 +1214,56 @@ function useBalance(walletAddress) {
       setError(err);
     } finally {
       setIsLoading(false);
-      fetchInFlight.current = false;
     }
   }, [resolvedAddress, endpointsRef]);
-  const doFetchRef = useStableRef(doFetch);
+  const doFetchRef = useStableRef2(doFetchOnce);
   react.useEffect(() => {
     if (!resolvedAddress) {
       setIsLoading(false);
       return void 0;
     }
-    void doFetchRef.current();
-    let interval = null;
-    const startInterval = () => {
-      if (interval) return;
-      interval = setInterval(() => {
-        if (typeof document !== "undefined" && document.hidden) return;
-        void doFetchRef.current();
-      }, POLL_INTERVAL_MS);
-    };
-    const stopInterval = () => {
-      if (interval) {
-        clearInterval(interval);
-        interval = null;
+    const unsubscribe = subscribeToWalletEvent(
+      streamUrl,
+      resolvedAddress,
+      "balance",
+      (data) => {
+        setStroops(data.stroops);
+        setXlm(data.xlm);
+        setError(null);
+        setIsLoading(false);
       }
-    };
-    startInterval();
+    );
+    if (unsubscribe) {
+      void doFetchRef.current();
+      return unsubscribe;
+    }
+    void doFetchRef.current();
+    const interval = setInterval(() => {
+      if (typeof document !== "undefined" && document.hidden) return;
+      void doFetchRef.current();
+    }, POLL_FALLBACK_MS);
     const onVisibilityChange = () => {
       if (typeof document === "undefined") return;
-      if (document.hidden) {
-        stopInterval();
-      } else {
-        void doFetchRef.current();
-        startInterval();
-      }
+      if (!document.hidden) void doFetchRef.current();
     };
     if (typeof document !== "undefined") {
       document.addEventListener("visibilitychange", onVisibilityChange);
     }
     return () => {
-      stopInterval();
+      clearInterval(interval);
       if (typeof document !== "undefined") {
         document.removeEventListener("visibilitychange", onVisibilityChange);
       }
     };
-  }, [resolvedAddress, doFetchRef]);
+  }, [resolvedAddress, streamUrl, doFetchRef]);
   const refresh = react.useCallback(async () => {
     await doFetchRef.current();
   }, [doFetchRef]);
   return { stroops, xlm, isLoading, error, refresh };
 }
-var POLL_INTERVAL_MS2 = 2e4;
+var POLL_FALLBACK_MS2 = 25e3;
 var DEFAULT_LIMIT = 20;
-function useStableRef2(value) {
+function useStableRef3(value) {
   const ref = react.useRef(value);
   ref.current = value;
   return ref;
@@ -1235,8 +1278,7 @@ function useWalletActivity(walletAddress, opts = {}) {
   const [events, setEvents] = react.useState([]);
   const [isLoading, setIsLoading] = react.useState(true);
   const [error, setError] = react.useState(null);
-  const fetchInFlight = react.useRef(false);
-  const walletRef = useStableRef2(wallet);
+  const walletRef = useStableRef3(wallet);
   react.useEffect(() => {
     if (walletAddress) {
       setResolvedAddress(walletAddress);
@@ -1260,67 +1302,72 @@ function useWalletActivity(walletAddress, opts = {}) {
       cancelled = true;
     };
   }, [walletAddress, username, walletRef]);
-  const endpointsRef = useStableRef2(_internal.endpoints);
-  const doFetch = react.useCallback(async () => {
+  const envDefaults = ENVIRONMENT_DEFAULTS[_internal.env];
+  const streamUrl = envDefaults.walletStreamUrl;
+  const endpointsRef = useStableRef3(_internal.endpoints);
+  const doFetchOnce = react.useCallback(async () => {
     if (!resolvedAddress) return;
-    if (fetchInFlight.current) return;
-    fetchInFlight.current = true;
     try {
       const res = await endpointsRef.current.walletActivity(resolvedAddress, limit);
-      setEvents(res.events);
+      const adapted = [];
+      for (const ev of res.events) {
+        const conv = adaptRestEvent(ev);
+        if (conv) adapted.push(conv);
+      }
+      setEvents(adapted.slice(0, limit));
       setError(null);
     } catch (err) {
       setError(err);
     } finally {
       setIsLoading(false);
-      fetchInFlight.current = false;
     }
   }, [resolvedAddress, limit, endpointsRef]);
-  const doFetchRef = useStableRef2(doFetch);
+  const doFetchRef = useStableRef3(doFetchOnce);
   react.useEffect(() => {
     if (!resolvedAddress) {
       setIsLoading(false);
       return void 0;
     }
-    void doFetchRef.current();
-    let interval = null;
-    const start = () => {
-      if (interval) return;
-      interval = setInterval(() => {
-        if (typeof document !== "undefined" && document.hidden) return;
-        void doFetchRef.current();
-      }, POLL_INTERVAL_MS2);
-    };
-    const stop = () => {
-      if (interval) {
-        clearInterval(interval);
-        interval = null;
-      }
-    };
-    start();
-    const onVisibilityChange = () => {
-      if (typeof document === "undefined") return;
-      if (document.hidden) stop();
-      else {
-        void doFetchRef.current();
-        start();
+    const unsubscribe = subscribeToWalletEvent(
+      streamUrl,
+      resolvedAddress,
+      "activity",
+      (data) => {
+        setEvents(data.events.slice(0, limit));
+        setError(null);
+        setIsLoading(false);
       }
-    };
-    if (typeof document !== "undefined") {
-      document.addEventListener("visibilitychange", onVisibilityChange);
+    );
+    if (unsubscribe) {
+      void doFetchRef.current();
+      return unsubscribe;
     }
-    return () => {
-      stop();
-      if (typeof document !== "undefined") {
-        document.removeEventListener("visibilitychange", onVisibilityChange);
-      }
-    };
-  }, [resolvedAddress, doFetchRef]);
+    void doFetchRef.current();
+    const interval = setInterval(() => {
+      if (typeof document !== "undefined" && document.hidden) return;
+      void doFetchRef.current();
+    }, POLL_FALLBACK_MS2);
+    return () => clearInterval(interval);
+  }, [resolvedAddress, streamUrl, limit, doFetchRef]);
   const refresh = react.useCallback(async () => {
     await doFetchRef.current();
   }, [doFetchRef]);
   return { events, isLoading, error, refresh };
 }
+function adaptRestEvent(ev) {
+  const t0 = ev.topics[0];
+  if (typeof t0 !== "string") return null;
+  if (t0 === "SignerRotated") {
+    return {
+      type: "signer-rotated",
+      txHash: ev.txHash,
+      ledger: ev.ledger,
+      timestamp: ev.timestamp,
+      newOwnerEd25519Hex: typeof ev.value === "string" ? ev.value : ""
+    };
+  }
+  return null;
+}
 
 // src/index.ts
 var REACT_ADAPTER_VERSION = "0.0.0";
@@ -1330,6 +1377,8 @@ exports.AcceslyProvider = AcceslyProvider;
 exports.ENVIRONMENT_DEFAULTS = ENVIRONMENT_DEFAULTS;
 exports.NotImplementedYetError = NotImplementedYetError;
 exports.REACT_ADAPTER_VERSION = REACT_ADAPTER_VERSION;
+exports.closeAllWalletSubscriptions = closeAllWalletSubscriptions;
+exports.subscribeToWalletEvent = subscribeToWalletEvent;
 exports.useAccesly = useAccesly;
 exports.useBalance = useBalance;
 exports.useWalletActivity = useWalletActivity;