@accesly/react 1.1.3 → 1.3.0

package/dist/index.cjs

@@ -1,155 +1,526 @@
 'use strict';
 
-var core = require('@accesly/core');
 var react = require('react');
+var core = require('@accesly/core');
 var jsxRuntime = require('react/jsx-runtime');
 
-// src/provider.tsx
-var AcceslyContext = react.createContext(null);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+exports.AcceslyContext = void 0;
+var init_context = __esm({
+  "src/context.ts"() {
+    exports.AcceslyContext = react.createContext(null);
+  }
+});
 
 // src/config.ts
-var ENVIRONMENT_DEFAULTS = {
-  dev: {
-    apiUrl: "https://3fki7eiio5.execute-api.us-east-1.amazonaws.com/dev",
-    cognito: {
-      region: "us-east-1",
-      userPoolId: "us-east-1_K2Nag1tB1",
-      userPoolClientId: "6r64diep7pne50sender4557jt"
-    },
-    stellar: {
-      networkPassphrase: "Test SDF Network ; September 2015",
-      horizonUrl: "https://horizon-testnet.stellar.org",
-      sorobanRpcUrl: "https://soroban-testnet.stellar.org",
-      // OZ Relayer channels-fund — see CloudServices-accesly/docs/Deployed_Resources_dev.md
-      deployerAddress: "GDRHSVLY3VCEHCHCSR5MZR2ALYLCERDDFT3ULCUIELGFVYHTZFCMNU4E",
-      // accesly-contracts Phase 1 deploy on Stellar testnet.
-      ed25519VerifierAddress: "CALVIIGIOMODZMWTMKZLSD4PZFFEPWQBSYERHUFM6MH5FLWKCHW4E4G5"
+exports.ENVIRONMENT_DEFAULTS = void 0;
+var init_config = __esm({
+  "src/config.ts"() {
+    exports.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",
+          userPoolClientId: "6r64diep7pne50sender4557jt"
+        },
+        stellar: {
+          networkPassphrase: "Test SDF Network ; September 2015",
+          horizonUrl: "https://horizon-testnet.stellar.org",
+          sorobanRpcUrl: "https://soroban-testnet.stellar.org",
+          // OZ Relayer channels-fund — see CloudServices-accesly/docs/Deployed_Resources_dev.md
+          deployerAddress: "GDRHSVLY3VCEHCHCSR5MZR2ALYLCERDDFT3ULCUIELGFVYHTZFCMNU4E",
+          // accesly-contracts Phase 1 deploy on Stellar testnet.
+          ed25519VerifierAddress: "CALVIIGIOMODZMWTMKZLSD4PZFFEPWQBSYERHUFM6MH5FLWKCHW4E4G5"
+        }
+      },
+      staging: {
+        apiUrl: "https://api-staging.accesly.xyz",
+        walletStreamUrl: "",
+        cognito: {
+          region: "us-east-1",
+          userPoolId: "TBD-staging",
+          userPoolClientId: "TBD-staging"
+        },
+        stellar: {
+          networkPassphrase: "Test SDF Network ; September 2015",
+          horizonUrl: "https://horizon-testnet.stellar.org",
+          sorobanRpcUrl: "https://soroban-testnet.stellar.org",
+          deployerAddress: "GDRHSVLY3VCEHCHCSR5MZR2ALYLCERDDFT3ULCUIELGFVYHTZFCMNU4E",
+          ed25519VerifierAddress: "CALVIIGIOMODZMWTMKZLSD4PZFFEPWQBSYERHUFM6MH5FLWKCHW4E4G5"
+        }
+      },
+      prod: {
+        apiUrl: "https://api.accesly.xyz",
+        walletStreamUrl: "",
+        cognito: {
+          region: "us-east-1",
+          userPoolId: "TBD-prod",
+          userPoolClientId: "TBD-prod"
+        },
+        stellar: {
+          networkPassphrase: "Public Global Stellar Network ; September 2015",
+          horizonUrl: "https://horizon.stellar.org",
+          sorobanRpcUrl: "https://soroban-rpc.mainnet.stellar.org",
+          deployerAddress: "TBD-prod",
+          ed25519VerifierAddress: "TBD-prod"
+        }
+      }
+    };
+  }
+});
+function isSorobanDeployPendingError(err) {
+  if (!(err instanceof core.AccesslyApiError)) return false;
+  const haystack = `${err.message ?? ""} ${err.code ?? ""}`.toLowerCase();
+  return haystack.includes("txsorobaninvalid") || haystack.includes("soroban sendtransaction") || haystack.includes("soroban submit failed") || haystack.includes("scecexceededlimit") || haystack.includes("exceededlimit");
+}
+var init_sorobanDeployStatus = __esm({
+  "src/hooks/sorobanDeployStatus.ts"() {
+  }
+});
+
+// src/hooks/stellarExpert.ts
+async function fetchContractEvents(contractId, opts) {
+  const params = new URLSearchParams();
+  params.set("limit", String(opts.limit ?? 50));
+  params.set("order", opts.order ?? "desc");
+  if (opts.cursor) params.set("cursor", opts.cursor);
+  if (opts.topics) params.set("topics", opts.topics);
+  const url = `${SE_BASE}/${opts.network}/contract/${contractId}/events?${params.toString()}`;
+  const res = await fetch(url, opts.signal ? { signal: opts.signal } : {});
+  if (!res.ok) {
+    throw new Error(`StellarExpert ${res.status} ${res.statusText}`);
+  }
+  return await res.json();
+}
+async function fetchContractMeta(contractId, network, signal) {
+  const url = `${SE_BASE}/${network}/contract/${contractId}`;
+  try {
+    const res = await fetch(url, signal ? { signal } : {});
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function decodeTransferAmount(bodyXdr) {
+  if (!bodyXdr) return "0";
+  try {
+    const bytes = base64ToBytes(bodyXdr);
+    if (bytes.length < 20) return "0";
+    let hi = 0n;
+    for (let i = 8; i < 16; i += 1) hi = hi << 8n | BigInt(bytes[i] ?? 0);
+    let lo = 0n;
+    for (let i = 16; i < 24; i += 1) lo = lo << 8n | BigInt(bytes[i] ?? 0);
+    const value = hi << 64n | lo;
+    return value.toString();
+  } catch {
+    return "0";
+  }
+}
+function base64ToBytes(s) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(s, "base64"));
+  const bin = globalThis.atob(s);
+  const arr = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i += 1) arr[i] = bin.charCodeAt(i);
+  return arr;
+}
+function decodeSEEvent(ev, walletAddress, xlmSac, txHashByEventId) {
+  const t0 = ev.topics[0];
+  if (!t0) return null;
+  const timestamp = new Date(ev.ts * 1e3).toISOString();
+  const txHash = txHashByEventId.get(ev.id) ?? ev.id.split("-")[0] ?? "";
+  if (ev.contract === walletAddress) {
+    if (t0 === "signer_rotated") {
+      return {
+        type: "signer-rotated",
+        txHash,
+        ledger: ev.ts,
+        // SE no expone ledger directamente — usamos timestamp
+        timestamp,
+        newOwnerEd25519Hex: ""
+      };
     }
-  },
-  staging: {
-    apiUrl: "https://api-staging.accesly.xyz",
-    cognito: {
-      region: "us-east-1",
-      userPoolId: "TBD-staging",
-      userPoolClientId: "TBD-staging"
-    },
-    stellar: {
-      networkPassphrase: "Test SDF Network ; September 2015",
-      horizonUrl: "https://horizon-testnet.stellar.org",
-      sorobanRpcUrl: "https://soroban-testnet.stellar.org",
-      deployerAddress: "GDRHSVLY3VCEHCHCSR5MZR2ALYLCERDDFT3ULCUIELGFVYHTZFCMNU4E",
-      ed25519VerifierAddress: "CALVIIGIOMODZMWTMKZLSD4PZFFEPWQBSYERHUFM6MH5FLWKCHW4E4G5"
+    return null;
+  }
+  if (ev.contract === xlmSac && t0 === "transfer") {
+    const from = ev.topics[1];
+    const to = ev.topics[2];
+    if (!from || !to) return null;
+    const amountStroops = decodeTransferAmount(ev.bodyXdr);
+    if (from === walletAddress && to !== walletAddress) {
+      return {
+        type: "transfer-out",
+        txHash,
+        ledger: ev.ts,
+        timestamp,
+        to,
+        amountStroops
+      };
     }
-  },
-  prod: {
-    apiUrl: "https://api.accesly.xyz",
-    cognito: {
-      region: "us-east-1",
-      userPoolId: "TBD-prod",
-      userPoolClientId: "TBD-prod"
-    },
-    stellar: {
-      networkPassphrase: "Public Global Stellar Network ; September 2015",
-      horizonUrl: "https://horizon.stellar.org",
-      sorobanRpcUrl: "https://soroban-rpc.mainnet.stellar.org",
-      deployerAddress: "TBD-prod",
-      ed25519VerifierAddress: "TBD-prod"
+    if (to === walletAddress && from !== walletAddress) {
+      return {
+        type: "transfer-in",
+        txHash,
+        ledger: ev.ts,
+        timestamp,
+        from,
+        amountStroops
+      };
     }
   }
-};
-function AcceslyProvider(props) {
-  const defaults = ENVIRONMENT_DEFAULTS[props.env];
-  const apiUrl = props.apiUrl ?? defaults.apiUrl;
-  const cognitoConfig = props.cognitoConfig ?? defaults.cognito;
-  const telemetry = props.telemetry;
-  const instances = react.useMemo(() => {
-    const authClient = props.overrides?.authClient ?? new core.CognitoAuthClient(cognitoConfig);
-    const sessionStorage = props.overrides?.sessionStorage ?? core.defaultSessionStorage();
-    const deviceStore = props.overrides?.deviceStore ?? new core.InMemoryDeviceStore();
-    const tokenManager = new core.TokenManager({ authClient, storage: sessionStorage });
-    const apiClient = new core.AccesslyApiClient({
-      baseUrl: apiUrl,
-      getIdToken: () => tokenManager.getValidIdToken(),
-      ...telemetry ? { telemetry } : {}
-    });
-    const endpoints = new core.AccesslyEndpoints(apiClient);
-    return { authClient, sessionStorage, deviceStore, tokenManager, endpoints };
-  }, [
-    apiUrl,
-    cognitoConfig.region,
-    cognitoConfig.userPoolId,
-    cognitoConfig.userPoolClientId,
-    props.overrides?.authClient,
-    props.overrides?.sessionStorage,
-    props.overrides?.deviceStore
+  return null;
+}
+async function fetchWalletHistory(walletAddress, opts) {
+  const xlmSac = opts.network === "mainnet" ? XLM_SAC_MAINNET : XLM_SAC_TESTNET;
+  const limit = 50;
+  const transferLimit = opts.transferScanLimit ?? 50;
+  const [smartAccountResp, transfersResp] = await Promise.all([
+    fetchContractEvents(walletAddress, {
+      network: opts.network,
+      limit,
+      order: "desc",
+      ...opts.smartAccountCursor ? { cursor: opts.smartAccountCursor } : {},
+      ...opts.signal ? { signal: opts.signal } : {}
+    }).catch((err) => {
+      console.warn("[stellarExpert] smart account events failed", err);
+      return { _embedded: { records: [] } };
+    }),
+    fetchContractEvents(xlmSac, {
+      network: opts.network,
+      limit: transferLimit,
+      order: "desc",
+      topics: "transfer",
+      ...opts.signal ? { signal: opts.signal } : {}
+    }).catch((err) => {
+      console.warn("[stellarExpert] xlm sac events failed", err);
+      return { _embedded: { records: [] } };
+    })
   ]);
-  const [status, setStatus] = react.useState(() => initialStatus(instances.sessionStorage));
-  const [username, setUsername] = react.useState(
-    () => initialUsername(instances.sessionStorage)
-  );
-  const mountedRef = react.useRef(true);
-  const refreshStatus = react.useCallback(async () => {
-    const next = await instances.tokenManager.getStatus();
-    const tokens = await Promise.resolve(instances.sessionStorage.load());
-    if (mountedRef.current) {
-      setStatus(next);
-      setUsername(tokens?.username ?? null);
+  const txHashByEventId = /* @__PURE__ */ new Map();
+  const items = [];
+  const saRecords = smartAccountResp._embedded?.records ?? [];
+  const txRecords = transfersResp._embedded?.records ?? [];
+  for (const ev of saRecords) {
+    const decoded = decodeSEEvent(ev, walletAddress, xlmSac, txHashByEventId);
+    if (decoded) items.push(decoded);
+  }
+  for (const ev of txRecords) {
+    const decoded = decodeSEEvent(ev, walletAddress, xlmSac, txHashByEventId);
+    if (decoded) items.push(decoded);
+  }
+  if (!opts.smartAccountCursor) {
+    const meta = await fetchContractMeta(walletAddress, opts.network, opts.signal);
+    if (meta) {
+      items.push({
+        type: "wallet-created",
+        txHash: "",
+        ledger: meta.created,
+        timestamp: new Date(meta.created * 1e3).toISOString()
+      });
     }
-  }, [instances]);
+  }
+  items.sort((a, b) => (b.ledger ?? 0) - (a.ledger ?? 0));
+  return {
+    items,
+    cursors: {
+      smartAccount: extractCursor(smartAccountResp),
+      transfers: extractCursor(transfersResp)
+    }
+  };
+}
+function extractCursor(resp) {
+  const records = resp._embedded?.records;
+  if (!records || records.length === 0) return null;
+  return records[records.length - 1]?.paging_token ?? records[records.length - 1]?.id ?? null;
+}
+var SE_BASE, XLM_SAC_TESTNET, XLM_SAC_MAINNET;
+var init_stellarExpert = __esm({
+  "src/hooks/stellarExpert.ts"() {
+    SE_BASE = "https://api.stellar.expert/explorer";
+    XLM_SAC_TESTNET = "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC";
+    XLM_SAC_MAINNET = "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA";
+  }
+});
+
+// src/hooks/useWalletHistory.ts
+var useWalletHistory_exports = {};
+__export(useWalletHistory_exports, {
+  historyClearOptimistic: () => historyClearOptimistic,
+  historyOptimisticPush: () => historyOptimisticPush,
+  useWalletHistory: () => useWalletHistory
+});
+function useStableRef(value) {
+  const ref = react.useRef(value);
+  ref.current = value;
+  return ref;
+}
+function loadCache(walletAddress) {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    const raw = localStorage.getItem(CACHE_KEY_PREFIX + walletAddress);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (Date.now() - parsed.storedAt > CACHE_TTL_MS) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveCache(walletAddress, entry) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(CACHE_KEY_PREFIX + walletAddress, JSON.stringify(entry));
+  } catch {
+  }
+}
+function historyOptimisticPush(walletAddress, item) {
+  const current = optimisticItems.get(walletAddress) ?? [];
+  optimisticItems.set(walletAddress, [item, ...current]);
+  const listeners = optimisticListeners.get(walletAddress);
+  if (listeners) {
+    for (const fn of listeners) fn(optimisticItems.get(walletAddress) ?? []);
+  }
+}
+function historyClearOptimistic(walletAddress) {
+  optimisticItems.delete(walletAddress);
+  const listeners = optimisticListeners.get(walletAddress);
+  if (listeners) {
+    for (const fn of listeners) fn([]);
+  }
+}
+function subscribeOptimistic(walletAddress, listener) {
+  let set = optimisticListeners.get(walletAddress);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    optimisticListeners.set(walletAddress, set);
+  }
+  set.add(listener);
+  return () => {
+    set?.delete(listener);
+    if (set && set.size === 0) optimisticListeners.delete(walletAddress);
+  };
+}
+function useWalletHistory(walletAddress, opts = {}) {
+  const { wallet, _internal } = useAccesly();
+  const username = _internal.username;
+  const network = opts.network ?? inferNetwork(_internal.env);
+  const [resolvedAddress, setResolvedAddress] = react.useState(walletAddress ?? null);
+  const [events, setEvents] = react.useState([]);
+  const [optimistic, setOptimistic] = react.useState([]);
+  const [cursors, setCursors] = react.useState({
+    smartAccount: null,
+    transfers: null
+  });
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [hasMore, setHasMore] = react.useState(true);
+  const walletRef = useStableRef(wallet);
   react.useEffect(() => {
-    mountedRef.current = true;
-    void refreshStatus();
+    if (walletAddress) {
+      setResolvedAddress(walletAddress);
+      return;
+    }
+    if (!username) {
+      setResolvedAddress(null);
+      return;
+    }
+    let cancelled = false;
+    void (async () => {
+      try {
+        const stored = await walletRef.current.getStoredCredential(username);
+        if (cancelled) return;
+        setResolvedAddress(stored?.walletAddress ?? null);
+      } catch {
+        if (!cancelled) setResolvedAddress(null);
+      }
+    })();
     return () => {
-      mountedRef.current = false;
+      cancelled = true;
     };
-  }, [instances]);
-  const value = react.useMemo(
-    () => ({
-      appId: props.appId,
-      env: props.env,
-      apiUrl,
-      cognitoConfig,
-      authClient: instances.authClient,
-      sessionStorage: instances.sessionStorage,
-      tokenManager: instances.tokenManager,
-      endpoints: instances.endpoints,
-      deviceStore: instances.deviceStore,
-      status,
-      username,
-      refreshStatus
-    }),
-    [props.appId, props.env, apiUrl, cognitoConfig, instances, status, username, refreshStatus]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(AcceslyContext.Provider, { value, children: props.children });
+  }, [walletAddress, username, walletRef]);
+  react.useEffect(() => {
+    if (!resolvedAddress) return void 0;
+    setOptimistic(optimisticItems.get(resolvedAddress) ?? []);
+    return subscribeOptimistic(resolvedAddress, setOptimistic);
+  }, [resolvedAddress]);
+  react.useEffect(() => {
+    if (!resolvedAddress) {
+      setIsLoading(false);
+      return void 0;
+    }
+    const cached = loadCache(resolvedAddress);
+    if (cached) {
+      setEvents(cached.items);
+      setCursors(cached.cursors);
+      setIsLoading(false);
+    }
+    let cancelled = false;
+    const channel = typeof BroadcastChannel !== "undefined" ? new BroadcastChannel(BROADCAST_CHANNEL_PREFIX + resolvedAddress) : null;
+    if (channel) {
+      channel.onmessage = (ev) => {
+        const data = ev.data;
+        if (data && !cancelled) {
+          setEvents(data.items);
+          setCursors(data.cursors);
+          setIsLoading(false);
+        }
+      };
+    }
+    void (async () => {
+      try {
+        const result = await fetchWalletHistory(resolvedAddress, {
+          network,
+          ...opts.transferScanLimit ? { transferScanLimit: opts.transferScanLimit } : {}
+        });
+        if (cancelled) return;
+        const deduped = dedupItems(result.items);
+        setEvents(deduped);
+        setCursors(result.cursors);
+        setIsLoading(false);
+        setError(null);
+        setHasMore(result.cursors.smartAccount !== null || result.cursors.transfers !== null);
+        const entry = {
+          items: deduped,
+          cursors: result.cursors,
+          storedAt: Date.now()
+        };
+        saveCache(resolvedAddress, entry);
+        channel?.postMessage(entry);
+      } catch (err) {
+        if (!cancelled) {
+          setError(err);
+          setIsLoading(false);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+      channel?.close();
+    };
+  }, [resolvedAddress, network, opts.transferScanLimit]);
+  const interval = opts.pollIntervalMs ?? POLL_INTERVAL_MS;
+  react.useEffect(() => {
+    if (!resolvedAddress || interval === 0) return void 0;
+    const tick = async () => {
+      if (typeof document !== "undefined" && document.hidden) return;
+      try {
+        const result = await fetchWalletHistory(resolvedAddress, {
+          network,
+          ...opts.transferScanLimit ? { transferScanLimit: opts.transferScanLimit } : {}
+        });
+        setEvents((prev) => mergeAndDedup(prev, result.items));
+        if (resolvedAddress) {
+          const realTxHashes = new Set(result.items.map((it) => it.txHash));
+          const optimisticsRemaining = (optimisticItems.get(resolvedAddress) ?? []).filter(
+            (it) => !realTxHashes.has(it.txHash)
+          );
+          if (optimisticsRemaining.length !== (optimisticItems.get(resolvedAddress)?.length ?? 0)) {
+            optimisticItems.set(resolvedAddress, optimisticsRemaining);
+            const listeners = optimisticListeners.get(resolvedAddress);
+            if (listeners) for (const fn of listeners) fn(optimisticsRemaining);
+          }
+        }
+      } catch {
+      }
+    };
+    const id = setInterval(tick, interval);
+    return () => clearInterval(id);
+  }, [resolvedAddress, network, interval]);
+  const loadMoreImpl = react.useCallback(async () => {
+    if (!resolvedAddress) return;
+    if (!cursors.smartAccount && !cursors.transfers) {
+      setHasMore(false);
+      return;
+    }
+    try {
+      const result = await fetchWalletHistory(resolvedAddress, {
+        network,
+        ...cursors.smartAccount ? { smartAccountCursor: cursors.smartAccount } : {},
+        ...opts.transferScanLimit ? { transferScanLimit: opts.transferScanLimit } : {}
+      });
+      setEvents((prev) => mergeAndDedup(prev, result.items));
+      setCursors(result.cursors);
+      setHasMore(result.cursors.smartAccount !== null || result.cursors.transfers !== null);
+    } catch (err) {
+      setError(err);
+    }
+  }, [resolvedAddress, network, cursors, opts.transferScanLimit]);
+  const refreshImpl = react.useCallback(async () => {
+    if (!resolvedAddress) return;
+    setIsLoading(true);
+    try {
+      const result = await fetchWalletHistory(resolvedAddress, {
+        network,
+        ...opts.transferScanLimit ? { transferScanLimit: opts.transferScanLimit } : {}
+      });
+      const deduped = dedupItems(result.items);
+      setEvents(deduped);
+      setCursors(result.cursors);
+      setError(null);
+      saveCache(resolvedAddress, {
+        items: deduped,
+        cursors: result.cursors,
+        storedAt: Date.now()
+      });
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [resolvedAddress, network, opts.transferScanLimit]);
+  const combined = [...optimistic, ...events];
+  return {
+    events: combined,
+    isLoading,
+    error,
+    hasMore,
+    loadMore: loadMoreImpl,
+    refresh: refreshImpl
+  };
 }
-function initialStatus(storage) {
-  const tokens = storage.load();
-  if (tokens instanceof Promise) return "bootstrapping";
-  if (!tokens) return "anonymous";
-  return Date.now() + 5 * 60 * 1e3 >= tokens.expiresAt ? "expired" : "authenticated";
+function inferNetwork(env) {
+  return env === "prod" ? "mainnet" : "testnet";
 }
-function initialUsername(storage) {
-  const tokens = storage.load();
-  if (tokens instanceof Promise) return null;
-  return tokens?.username ?? null;
+function dedupItems(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of items) {
+    const key = `${item.type}:${item.txHash}:${item.ledger}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(item);
+  }
+  out.sort((a, b) => (b.ledger ?? 0) - (a.ledger ?? 0));
+  return out;
 }
-function isSorobanDeployPendingError(err) {
-  if (!(err instanceof core.AccesslyApiError)) return false;
-  const haystack = `${err.message ?? ""} ${err.code ?? ""}`.toLowerCase();
-  return haystack.includes("txsorobaninvalid") || haystack.includes("soroban sendtransaction") || haystack.includes("soroban submit failed") || haystack.includes("scecexceededlimit") || haystack.includes("exceededlimit");
+function mergeAndDedup(prev, fresh) {
+  return dedupItems([...fresh, ...prev]);
 }
-
-// src/hooks/useAccesly.ts
-var NotImplementedYetError = class extends Error {
-  constructor(namespace, method) {
-    super(
-      `${namespace}.${method}() is not implemented yet. This namespace ships in a later release; see docs/Handoff_Fase7.md for the roadmap.`
-    );
-    this.name = "NotImplementedYetError";
+var POLL_INTERVAL_MS, CACHE_TTL_MS, CACHE_KEY_PREFIX, BROADCAST_CHANNEL_PREFIX, optimisticItems, optimisticListeners;
+var init_useWalletHistory = __esm({
+  "src/hooks/useWalletHistory.ts"() {
+    init_useAccesly();
+    init_stellarExpert();
+    POLL_INTERVAL_MS = 3e4;
+    CACHE_TTL_MS = 12 * 60 * 60 * 1e3;
+    CACHE_KEY_PREFIX = "accesly:history:";
+    BROADCAST_CHANNEL_PREFIX = "accesly:history:";
+    optimisticItems = /* @__PURE__ */ new Map();
+    optimisticListeners = /* @__PURE__ */ new Map();
   }
-};
+});
 function useAccesly() {
-  const ctx = react.useContext(AcceslyContext);
+  const ctx = react.useContext(exports.AcceslyContext);
   if (!ctx) {
     throw new Error(
       "useAccesly: missing <AcceslyProvider>. Wrap your app with <AcceslyProvider appId env>."
@@ -181,7 +552,7 @@ function useAccesly() {
     [ctx]
   );
   const { hexToBytes, hexFromBytes } = react.useMemo(() => coderHelpers(), []);
-  const stellarConfig = ENVIRONMENT_DEFAULTS[ctx.env].stellar;
+  const stellarConfig = exports.ENVIRONMENT_DEFAULTS[ctx.env].stellar;
   const wallet = react.useMemo(() => {
     const c = ctx;
     const postWallet = async (params) => {
@@ -612,8 +983,8 @@ function useAccesly() {
         const sessionPlaintext = core.unwrapSessionFragment2(wrappedF2, ephemeral.privateKey).plaintext;
         const fragmentF2Wire = JSON.parse(new TextDecoder().decode(sessionPlaintext));
         const fragmentF2Envelope = {
-          nonce: base64ToBytes(fragmentF2Wire.nonce),
-          ciphertext: base64ToBytes(fragmentF2Wire.ciphertext)
+          nonce: base64ToBytes2(fragmentF2Wire.nonce),
+          ciphertext: base64ToBytes2(fragmentF2Wire.ciphertext)
         };
         const reconstructed = core.reconstructFromPlainAndEncrypted({
           fragmentF1Plain: input.fragmentF1Plain,
@@ -631,6 +1002,24 @@ function useAccesly() {
           unsignedXdr: sim.unsignedXdr,
           signedAuthEntryXdr
         });
+        try {
+          const username = ctx.username;
+          if (username) {
+            const stored = await ctx.deviceStore.loadCredential(username);
+            if (stored?.walletAddress) {
+              const { historyOptimisticPush: historyOptimisticPush2 } = await Promise.resolve().then(() => (init_useWalletHistory(), useWalletHistory_exports));
+              historyOptimisticPush2(stored.walletAddress, {
+                type: "transfer-out",
+                txHash: submit.txHash,
+                ledger: Math.floor(Date.now() / 1e3),
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                to: input.destinationAddress,
+                amountStroops: input.amountStroops
+              });
+            }
+          }
+        } catch {
+        }
         return {
           txHash: submit.txHash,
           status: submit.status,
@@ -674,18 +1063,18 @@ function useAccesly() {
             "recovery.reconstructSeed: la wallet fue creada antes de Fase 1 y no tiene F2 cipher-bound a recoveryKey. No es recuperable v\xEDa OTP."
           );
         }
-        const recoverySalt = base64ToBytes(frag.recoverySalt);
+        const recoverySalt = base64ToBytes2(frag.recoverySalt);
         const recoveryKey = core.deriveRecoveryKey({
           password: input.cognitoPassword,
           salt: recoverySalt
         });
         const f2Envelope = {
-          ciphertext: base64ToBytes(frag.fragmentF2Recovery.ciphertext),
-          nonce: base64ToBytes(frag.fragmentF2Recovery.nonce)
+          ciphertext: base64ToBytes2(frag.fragmentF2Recovery.ciphertext),
+          nonce: base64ToBytes2(frag.fragmentF2Recovery.nonce)
         };
         const f3Envelope = {
-          ciphertext: base64ToBytes(frag.fragmentF3Encrypted.ciphertext),
-          nonce: base64ToBytes(frag.fragmentF3Encrypted.nonce)
+          ciphertext: base64ToBytes2(frag.fragmentF3Encrypted.ciphertext),
+          nonce: base64ToBytes2(frag.fragmentF3Encrypted.nonce)
         };
         const seedResult = core.reconstructKey({
           fragments: [
@@ -848,10 +1237,10 @@ function useAccesly() {
   const session = react.useMemo(
     () => ({
       async create() {
-        throw new NotImplementedYetError("session", "create");
+        throw new exports.NotImplementedYetError("session", "create");
       },
       async revoke() {
-        throw new NotImplementedYetError("session", "revoke");
+        throw new exports.NotImplementedYetError("session", "revoke");
       }
     }),
     []
@@ -859,16 +1248,16 @@ function useAccesly() {
   const settings = react.useMemo(
     () => ({
       async addDevice() {
-        throw new NotImplementedYetError("settings", "addDevice");
+        throw new exports.NotImplementedYetError("settings", "addDevice");
       },
       async removeDevice() {
-        throw new NotImplementedYetError("settings", "removeDevice");
+        throw new exports.NotImplementedYetError("settings", "removeDevice");
       },
       async listDevices() {
-        throw new NotImplementedYetError("settings", "listDevices");
+        throw new exports.NotImplementedYetError("settings", "listDevices");
       },
       async updateSpendingLimit() {
-        throw new NotImplementedYetError("settings", "updateSpendingLimit");
+        throw new exports.NotImplementedYetError("settings", "updateSpendingLimit");
       }
     }),
     []
@@ -876,13 +1265,13 @@ function useAccesly() {
   const yieldOps = react.useMemo(
     () => ({
       async invest() {
-        throw new NotImplementedYetError("yield", "invest");
+        throw new exports.NotImplementedYetError("yield", "invest");
       },
       async redeem() {
-        throw new NotImplementedYetError("yield", "redeem");
+        throw new exports.NotImplementedYetError("yield", "redeem");
       },
       async position() {
-        throw new NotImplementedYetError("yield", "position");
+        throw new exports.NotImplementedYetError("yield", "position");
       }
     }),
     []
@@ -921,15 +1310,245 @@ function base64FromBytes(bytes) {
   for (let i = 0; i < bytes.length; i += 1) bin += String.fromCharCode(bytes[i] ?? 0);
   return globalThis.btoa(bin);
 }
-function base64ToBytes(s) {
+function base64ToBytes2(s) {
   if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(s, "base64"));
   const bin = globalThis.atob(s);
   const arr = new Uint8Array(bin.length);
   for (let i = 0; i < bin.length; i += 1) arr[i] = bin.charCodeAt(i);
   return arr;
 }
+exports.NotImplementedYetError = void 0;
+var init_useAccesly = __esm({
+  "src/hooks/useAccesly.ts"() {
+    init_context();
+    init_config();
+    init_sorobanDeployStatus();
+    exports.NotImplementedYetError = class extends Error {
+      constructor(namespace, method) {
+        super(
+          `${namespace}.${method}() is not implemented yet. This namespace ships in a later release; see docs/Handoff_Fase7.md for the roadmap.`
+        );
+        this.name = "NotImplementedYetError";
+      }
+    };
+  }
+});
+
+// src/provider.tsx
+init_context();
+init_config();
+function AcceslyProvider(props) {
+  const defaults = exports.ENVIRONMENT_DEFAULTS[props.env];
+  const apiUrl = props.apiUrl ?? defaults.apiUrl;
+  const cognitoConfig = props.cognitoConfig ?? defaults.cognito;
+  const telemetry = props.telemetry;
+  const instances = react.useMemo(() => {
+    const authClient = props.overrides?.authClient ?? new core.CognitoAuthClient(cognitoConfig);
+    const sessionStorage = props.overrides?.sessionStorage ?? core.defaultSessionStorage();
+    const deviceStore = props.overrides?.deviceStore ?? new core.InMemoryDeviceStore();
+    const tokenManager = new core.TokenManager({ authClient, storage: sessionStorage });
+    const apiClient = new core.AccesslyApiClient({
+      baseUrl: apiUrl,
+      getIdToken: () => tokenManager.getValidIdToken(),
+      ...telemetry ? { telemetry } : {}
+    });
+    const endpoints = new core.AccesslyEndpoints(apiClient);
+    return { authClient, sessionStorage, deviceStore, tokenManager, endpoints };
+  }, [
+    apiUrl,
+    cognitoConfig.region,
+    cognitoConfig.userPoolId,
+    cognitoConfig.userPoolClientId,
+    props.overrides?.authClient,
+    props.overrides?.sessionStorage,
+    props.overrides?.deviceStore
+  ]);
+  const [status, setStatus] = react.useState(() => initialStatus(instances.sessionStorage));
+  const [username, setUsername] = react.useState(
+    () => initialUsername(instances.sessionStorage)
+  );
+  const mountedRef = react.useRef(true);
+  const refreshStatus = react.useCallback(async () => {
+    const next = await instances.tokenManager.getStatus();
+    const tokens = await Promise.resolve(instances.sessionStorage.load());
+    if (mountedRef.current) {
+      setStatus(next);
+      setUsername(tokens?.username ?? null);
+    }
+  }, [instances]);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    void refreshStatus();
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [instances]);
+  const value = react.useMemo(
+    () => ({
+      appId: props.appId,
+      env: props.env,
+      apiUrl,
+      cognitoConfig,
+      authClient: instances.authClient,
+      sessionStorage: instances.sessionStorage,
+      tokenManager: instances.tokenManager,
+      endpoints: instances.endpoints,
+      deviceStore: instances.deviceStore,
+      status,
+      username,
+      refreshStatus
+    }),
+    [props.appId, props.env, apiUrl, cognitoConfig, instances, status, username, refreshStatus]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(exports.AcceslyContext.Provider, { value, children: props.children });
+}
+function initialStatus(storage) {
+  const tokens = storage.load();
+  if (tokens instanceof Promise) return "bootstrapping";
+  if (!tokens) return "anonymous";
+  return Date.now() + 5 * 60 * 1e3 >= tokens.expiresAt ? "expired" : "authenticated";
+}
+function initialUsername(storage) {
+  const tokens = storage.load();
+  if (tokens instanceof Promise) return null;
+  return tokens?.username ?? null;
+}
+
+// src/index.ts
+init_context();
+init_config();
+init_useAccesly();
+
+// src/hooks/useWalletStatus.ts
+init_useAccesly();
+init_config();
+
+// 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 useStableRef2(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 +1557,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 = exports.ENVIRONMENT_DEFAULTS[_internal.env];
+  const streamUrl = envDefaults.walletStreamUrl;
+  const walletRef = useStableRef2(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 = useStableRef2(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 +1636,27 @@ 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) {
+
+// src/hooks/useBalance.ts
+init_useAccesly();
+init_config();
+var POLL_FALLBACK_MS = 1e4;
+function useStableRef3(value) {
   const ref = react.useRef(value);
   ref.current = value;
   return ref;
@@ -1130,8 +1671,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 = useStableRef3(wallet);
   react.useEffect(() => {
     if (walletAddress) {
       setResolvedAddress(walletAddress);
@@ -1155,11 +1695,11 @@ function useBalance(walletAddress) {
       cancelled = true;
     };
   }, [walletAddress, username, walletRef]);
-  const endpointsRef = useStableRef(_internal.endpoints);
-  const doFetch = react.useCallback(async () => {
+  const envDefaults = exports.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.walletBalance(resolvedAddress);
       setStroops(res.xlm.stroops);
@@ -1169,58 +1709,60 @@ function useBalance(walletAddress) {
       setError(err);
     } finally {
       setIsLoading(false);
-      fetchInFlight.current = false;
     }
   }, [resolvedAddress, endpointsRef]);
-  const doFetchRef = useStableRef(doFetch);
+  const doFetchRef = useStableRef3(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;
+
+// src/hooks/useWalletActivity.ts
+init_useAccesly();
+init_config();
+var POLL_FALLBACK_MS2 = 25e3;
 var DEFAULT_LIMIT = 20;
-function useStableRef2(value) {
+function useStableRef4(value) {
   const ref = react.useRef(value);
   ref.current = value;
   return ref;
@@ -1235,8 +1777,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 = useStableRef4(wallet);
   react.useEffect(() => {
     if (walletAddress) {
       setResolvedAddress(walletAddress);
@@ -1260,79 +1801,87 @@ function useWalletActivity(walletAddress, opts = {}) {
       cancelled = true;
     };
   }, [walletAddress, username, walletRef]);
-  const endpointsRef = useStableRef2(_internal.endpoints);
-  const doFetch = react.useCallback(async () => {
+  const envDefaults = exports.ENVIRONMENT_DEFAULTS[_internal.env];
+  const streamUrl = envDefaults.walletStreamUrl;
+  const endpointsRef = useStableRef4(_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 = useStableRef4(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;
+    const unsubscribe = subscribeToWalletEvent(
+      streamUrl,
+      resolvedAddress,
+      "activity",
+      (data) => {
+        setEvents(data.events.slice(0, limit));
+        setError(null);
+        setIsLoading(false);
       }
-    };
-    start();
-    const onVisibilityChange = () => {
-      if (typeof document === "undefined") return;
-      if (document.hidden) stop();
-      else {
-        void doFetchRef.current();
-        start();
-      }
-    };
-    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
+init_useWalletHistory();
 var REACT_ADAPTER_VERSION = "0.0.0";
 
-exports.AcceslyContext = AcceslyContext;
 exports.AcceslyProvider = AcceslyProvider;
-exports.ENVIRONMENT_DEFAULTS = ENVIRONMENT_DEFAULTS;
-exports.NotImplementedYetError = NotImplementedYetError;
 exports.REACT_ADAPTER_VERSION = REACT_ADAPTER_VERSION;
+exports.closeAllWalletSubscriptions = closeAllWalletSubscriptions;
+exports.historyClearOptimistic = historyClearOptimistic;
+exports.historyOptimisticPush = historyOptimisticPush;
+exports.subscribeToWalletEvent = subscribeToWalletEvent;
 exports.useAccesly = useAccesly;
 exports.useBalance = useBalance;
 exports.useWalletActivity = useWalletActivity;
+exports.useWalletHistory = useWalletHistory;
 exports.useWalletStatus = useWalletStatus;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map