@accesly/react 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -1,158 +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",
-    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"
+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",
-    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"
+    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",
-    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"
+    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>."
@@ -184,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) => {
@@ -615,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,
@@ -634,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,
@@ -677,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: [
@@ -851,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");
       }
     }),
     []
@@ -862,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");
       }
     }),
     []
@@ -879,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");
       }
     }),
     []
@@ -924,13 +1310,118 @@ 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;
@@ -1048,7 +1539,7 @@ function closeAllWalletSubscriptions() {
 // src/hooks/useWalletStatus.ts
 var POLL_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
 var STALE_THRESHOLD_MS = 6e4;
-function useStableRef(value) {
+function useStableRef2(value) {
   const ref = react.useRef(value);
   ref.current = value;
   return ref;
@@ -1066,9 +1557,9 @@ function useWalletStatus() {
   const [onChain, setOnChain] = react.useState(null);
   const [lastSuccessAt, setLastSuccessAt] = react.useState(0);
   const [isStale, setIsStale] = react.useState(false);
-  const envDefaults = ENVIRONMENT_DEFAULTS[_internal.env];
+  const envDefaults = exports.ENVIRONMENT_DEFAULTS[_internal.env];
   const streamUrl = envDefaults.walletStreamUrl;
-  const walletRef = useStableRef(wallet);
+  const walletRef = useStableRef2(wallet);
   const doFetch = react.useCallback(async () => {
     if (!username) return null;
     try {
@@ -1092,7 +1583,7 @@ function useWalletStatus() {
       return null;
     }
   }, [username, walletRef]);
-  const doFetchRef = useStableRef(doFetch);
+  const doFetchRef = useStableRef2(doFetch);
   react.useEffect(() => {
     if (!username) {
       setStatus("unknown");
@@ -1160,8 +1651,12 @@ function useWalletStatus() {
   }, [doFetchRef]);
   return { status, walletAddress, onChain, isStale, refresh };
 }
+
+// src/hooks/useBalance.ts
+init_useAccesly();
+init_config();
 var POLL_FALLBACK_MS = 1e4;
-function useStableRef2(value) {
+function useStableRef3(value) {
   const ref = react.useRef(value);
   ref.current = value;
   return ref;
@@ -1176,7 +1671,7 @@ function useBalance(walletAddress) {
   const [xlm, setXlm] = react.useState(null);
   const [isLoading, setIsLoading] = react.useState(true);
   const [error, setError] = react.useState(null);
-  const walletRef = useStableRef2(wallet);
+  const walletRef = useStableRef3(wallet);
   react.useEffect(() => {
     if (walletAddress) {
       setResolvedAddress(walletAddress);
@@ -1200,9 +1695,9 @@ function useBalance(walletAddress) {
       cancelled = true;
     };
   }, [walletAddress, username, walletRef]);
-  const envDefaults = ENVIRONMENT_DEFAULTS[_internal.env];
+  const envDefaults = exports.ENVIRONMENT_DEFAULTS[_internal.env];
   const streamUrl = envDefaults.walletStreamUrl;
-  const endpointsRef = useStableRef2(_internal.endpoints);
+  const endpointsRef = useStableRef3(_internal.endpoints);
   const doFetchOnce = react.useCallback(async () => {
     if (!resolvedAddress) return;
     try {
@@ -1216,7 +1711,7 @@ function useBalance(walletAddress) {
       setIsLoading(false);
     }
   }, [resolvedAddress, endpointsRef]);
-  const doFetchRef = useStableRef2(doFetchOnce);
+  const doFetchRef = useStableRef3(doFetchOnce);
   react.useEffect(() => {
     if (!resolvedAddress) {
       setIsLoading(false);
@@ -1261,9 +1756,13 @@ function useBalance(walletAddress) {
   }, [doFetchRef]);
   return { stroops, xlm, isLoading, error, refresh };
 }
+
+// src/hooks/useWalletActivity.ts
+init_useAccesly();
+init_config();
 var POLL_FALLBACK_MS2 = 25e3;
 var DEFAULT_LIMIT = 20;
-function useStableRef3(value) {
+function useStableRef4(value) {
   const ref = react.useRef(value);
   ref.current = value;
   return ref;
@@ -1278,7 +1777,7 @@ function useWalletActivity(walletAddress, opts = {}) {
   const [events, setEvents] = react.useState([]);
   const [isLoading, setIsLoading] = react.useState(true);
   const [error, setError] = react.useState(null);
-  const walletRef = useStableRef3(wallet);
+  const walletRef = useStableRef4(wallet);
   react.useEffect(() => {
     if (walletAddress) {
       setResolvedAddress(walletAddress);
@@ -1302,9 +1801,9 @@ function useWalletActivity(walletAddress, opts = {}) {
       cancelled = true;
     };
   }, [walletAddress, username, walletRef]);
-  const envDefaults = ENVIRONMENT_DEFAULTS[_internal.env];
+  const envDefaults = exports.ENVIRONMENT_DEFAULTS[_internal.env];
   const streamUrl = envDefaults.walletStreamUrl;
-  const endpointsRef = useStableRef3(_internal.endpoints);
+  const endpointsRef = useStableRef4(_internal.endpoints);
   const doFetchOnce = react.useCallback(async () => {
     if (!resolvedAddress) return;
     try {
@@ -1322,7 +1821,7 @@ function useWalletActivity(walletAddress, opts = {}) {
       setIsLoading(false);
     }
   }, [resolvedAddress, limit, endpointsRef]);
-  const doFetchRef = useStableRef3(doFetchOnce);
+  const doFetchRef = useStableRef4(doFetchOnce);
   react.useEffect(() => {
     if (!resolvedAddress) {
       setIsLoading(false);
@@ -1370,18 +1869,19 @@ function adaptRestEvent(ev) {
 }
 
 // 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