@cfxdevkit/defi-react 0.1.0

package/dist/index.cjs

@@ -0,0 +1,720 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AUTOMATION_MANAGER_ABI: () => AUTOMATION_MANAGER_ABI,
+  AUTOMATION_MANAGER_ADDRESS: () => AUTOMATION_MANAGER_ADDRESS,
+  CFX_NATIVE_ADDRESS: () => CFX_NATIVE_ADDRESS,
+  ERC20_ABI: () => ERC20_ABI,
+  MAX_UINT256: () => MAX_UINT256,
+  WCFX_ABI: () => WCFX_ABI,
+  getPairedTokens: () => getPairedTokens,
+  resolveTokenInAddress: () => resolveTokenInAddress,
+  usePoolTokens: () => usePoolTokens,
+  wcfxAddress: () => wcfxAddress
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/contracts.ts
+var AUTOMATION_MANAGER_ADDRESS = process.env.NEXT_PUBLIC_AUTOMATION_MANAGER_ADDRESS ?? "0x0000000000000000000000000000000000000000";
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var WCFX_ABI = [
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "deposit",
+    stateMutability: "payable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "withdraw",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "wad", type: "uint256" }],
+    outputs: []
+  }
+];
+var MAX_UINT256 = 2n ** 256n - 1n;
+var AUTOMATION_MANAGER_ABI = [
+  // ─── Custom Errors ─────────────────────────────────────────────────────────
+  {
+    type: "error",
+    name: "DCACompleted",
+    inputs: [{ name: "jobId", type: "bytes32" }]
+  },
+  {
+    type: "error",
+    name: "DCAIntervalNotReached",
+    inputs: [{ name: "nextExecution", type: "uint256" }]
+  },
+  { type: "error", name: "EnforcedPause", inputs: [] },
+  { type: "error", name: "ExpectedPause", inputs: [] },
+  {
+    type: "error",
+    name: "InvalidParams",
+    inputs: [{ name: "reason", type: "string" }]
+  },
+  {
+    type: "error",
+    name: "JobExpiredError",
+    inputs: [{ name: "jobId", type: "bytes32" }]
+  },
+  {
+    type: "error",
+    name: "JobNotActive",
+    inputs: [{ name: "jobId", type: "bytes32" }]
+  },
+  {
+    type: "error",
+    name: "JobNotFound",
+    inputs: [{ name: "jobId", type: "bytes32" }]
+  },
+  {
+    type: "error",
+    name: "OwnableInvalidOwner",
+    inputs: [{ name: "owner", type: "address" }]
+  },
+  {
+    type: "error",
+    name: "OwnableUnauthorizedAccount",
+    inputs: [{ name: "account", type: "address" }]
+  },
+  {
+    type: "error",
+    name: "PriceConditionNotMet",
+    inputs: [{ name: "jobId", type: "bytes32" }]
+  },
+  { type: "error", name: "ReentrancyGuardReentrantCall", inputs: [] },
+  {
+    type: "error",
+    name: "SafeERC20FailedOperation",
+    inputs: [{ name: "token", type: "address" }]
+  },
+  {
+    type: "error",
+    name: "SlippageTooHigh",
+    inputs: [
+      { name: "requested", type: "uint256" },
+      { name: "maxAllowed", type: "uint256" }
+    ]
+  },
+  {
+    type: "error",
+    name: "TooManyJobs",
+    inputs: [{ name: "user", type: "address" }]
+  },
+  { type: "error", name: "Unauthorized", inputs: [] },
+  { type: "error", name: "ZeroAddress", inputs: [] },
+  // ─── Events ────────────────────────────────────────────────────────────────
+  {
+    type: "event",
+    name: "JobCreated",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "jobId", type: "bytes32" },
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: false, name: "jobType", type: "uint8" }
+    ]
+  },
+  // ─── createLimitOrder ──────────────────────────────────────────────────────
+  {
+    type: "function",
+    name: "createLimitOrder",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "minAmountOut", type: "uint256" },
+          { name: "targetPrice", type: "uint256" },
+          { name: "triggerAbove", type: "bool" }
+        ]
+      },
+      { name: "slippageBps", type: "uint256" },
+      { name: "expiresAt", type: "uint256" }
+    ],
+    outputs: [{ name: "jobId", type: "bytes32" }]
+  },
+  // ─── createDCAJob ──────────────────────────────────────────────────────────
+  {
+    type: "function",
+    name: "createDCAJob",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "amountPerSwap", type: "uint256" },
+          { name: "intervalSeconds", type: "uint256" },
+          { name: "totalSwaps", type: "uint256" },
+          { name: "swapsCompleted", type: "uint256" },
+          { name: "nextExecution", type: "uint256" }
+        ]
+      },
+      { name: "slippageBps", type: "uint256" },
+      { name: "expiresAt", type: "uint256" }
+    ],
+    outputs: [{ name: "jobId", type: "bytes32" }]
+  },
+  // ─── cancelJob ─────────────────────────────────────────────────────────────
+  {
+    type: "function",
+    name: "cancelJob",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "jobId", type: "bytes32" }],
+    outputs: []
+  },
+  // ─── JobCancelled event ────────────────────────────────────────────────────
+  {
+    type: "event",
+    name: "JobCancelled",
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "jobId", type: "bytes32" },
+      { indexed: true, name: "canceller", type: "address" }
+    ]
+  }
+];
+
+// src/usePoolTokens.ts
+var import_react = require("react");
+var import_viem = require("viem");
+var import_chains = require("viem/chains");
+var CFX_NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var WCFX_ADDRESSES = {
+  testnet: "0x2ED3dddae5B2F321AF0806181FBFA6D049Be47d8",
+  mainnet: "0x14b2D3bC65e74DAE1030EAFd8ac30c533c976A9b"
+  // EIP-55 checksum: last char is lowercase b
+};
+function wcfxAddress(network = process.env.NEXT_PUBLIC_NETWORK ?? "testnet") {
+  return WCFX_ADDRESSES[network] ?? WCFX_ADDRESSES.testnet;
+}
+function resolveTokenInAddress(address) {
+  if (address.toLowerCase() === CFX_NATIVE_ADDRESS.toLowerCase()) {
+    return wcfxAddress();
+  }
+  return address;
+}
+var CACHE_KEY = "cas_pool_meta_v2";
+var CACHE_TTL = 10 * 60 * 1e3;
+function readCache() {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = localStorage.getItem(CACHE_KEY);
+    if (!raw) return null;
+    const c = JSON.parse(raw);
+    c.tokens = c.tokens.map((t) => ({
+      ...t,
+      address: t.address.toLowerCase()
+    }));
+    c.pairs = c.pairs.map((p) => ({
+      ...p,
+      address: p.address.toLowerCase(),
+      token0: p.token0.toLowerCase(),
+      token1: p.token1.toLowerCase()
+    }));
+    if (Date.now() - c.cachedAt > CACHE_TTL) return null;
+    return c;
+  } catch {
+    return null;
+  }
+}
+function readCacheIgnoreTTL() {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = localStorage.getItem(CACHE_KEY);
+    if (!raw) return null;
+    const c = JSON.parse(raw);
+    c.tokens = c.tokens.map((t) => ({
+      ...t,
+      address: t.address.toLowerCase()
+    }));
+    c.pairs = c.pairs.map((p) => ({
+      ...p,
+      address: p.address.toLowerCase(),
+      token0: p.token0.toLowerCase(),
+      token1: p.token1.toLowerCase()
+    }));
+    return c;
+  } catch {
+    return null;
+  }
+}
+function writeCache(tokens, pairs) {
+  try {
+    localStorage.setItem(
+      CACHE_KEY,
+      JSON.stringify({
+        tokens,
+        pairs,
+        cachedAt: Date.now()
+      })
+    );
+  } catch {
+  }
+}
+function mergeTokens(known, fresh) {
+  for (const t of fresh) {
+    known.set(t.address.toLowerCase(), {
+      ...t,
+      address: t.address.toLowerCase()
+    });
+  }
+}
+function mergePairs(known, fresh) {
+  for (const p of fresh) {
+    const t0 = p.token0.toLowerCase();
+    const t1 = p.token1.toLowerCase();
+    const key = [t0, t1].sort().join("|");
+    known.set(key, {
+      address: p.address.toLowerCase(),
+      token0: t0,
+      token1: t1
+    });
+  }
+}
+var BALANCE_OF_ABI = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function getPairedTokens(pairs, allTokens, tokenInAddress) {
+  if (!tokenInAddress) return allTokens;
+  const incoming = tokenInAddress.toLowerCase();
+  const wcfx = wcfxAddress().toLowerCase();
+  const cfxNative = CFX_NATIVE_ADDRESS.toLowerCase();
+  const resolved = incoming === cfxNative ? wcfx : incoming;
+  const counterparts = /* @__PURE__ */ new Set();
+  for (const p of pairs) {
+    const t0 = p.token0.toLowerCase();
+    const t1 = p.token1.toLowerCase();
+    if (t0 === resolved) counterparts.add(t1);
+    if (t1 === resolved) counterparts.add(t0);
+  }
+  const wCfxPaired = counterparts.has(wcfx);
+  counterparts.delete(wcfx);
+  counterparts.delete(cfxNative);
+  const results = allTokens.filter(
+    (t) => counterparts.has(t.address.toLowerCase()) && t.address.toLowerCase() !== cfxNative && t.address.toLowerCase() !== wcfx
+  );
+  if (wCfxPaired && incoming !== cfxNative) {
+    const cfxEntry = allTokens.find(
+      (t) => t.address.toLowerCase() === cfxNative
+    );
+    if (cfxEntry) return [cfxEntry, ...results];
+  }
+  return results;
+}
+function metaToTokens(rawTokens) {
+  const wcfx = wcfxAddress().toLowerCase();
+  return rawTokens.map((t) => ({
+    ...t,
+    address: t.address.toLowerCase(),
+    symbol: t.address.toLowerCase() === wcfx ? "wCFX" : t.symbol,
+    name: t.address.toLowerCase() === wcfx ? "Wrapped CFX" : t.name,
+    logoURI: t.logoURI,
+    balanceWei: "0",
+    balanceFormatted: "0"
+  }));
+}
+var CFX_ENTRY_ZERO = {
+  address: CFX_NATIVE_ADDRESS,
+  symbol: "CFX",
+  name: "Conflux (native)",
+  decimals: 18,
+  balanceWei: "0",
+  balanceFormatted: "0"
+};
+function cfxEntryFrom(knownTokens) {
+  const wcfx = wcfxAddress().toLowerCase();
+  const logo = knownTokens.get(wcfx)?.logoURI;
+  return logo ? { ...CFX_ENTRY_ZERO, logoURI: logo } : CFX_ENTRY_ZERO;
+}
+function withTimeout(promise, ms, silent = false) {
+  return new Promise((resolve) => {
+    const t = setTimeout(() => {
+      if (!silent)
+        console.warn("[usePoolTokens] RPC call timed out after", ms, "ms");
+      resolve(null);
+    }, ms);
+    promise.then(
+      (v) => {
+        clearTimeout(t);
+        resolve(v);
+      },
+      (err) => {
+        clearTimeout(t);
+        if (!silent) {
+          const msg = err?.message ?? String(err);
+          console.warn("[usePoolTokens] RPC call rejected:", msg);
+        }
+        resolve(null);
+      }
+    );
+  });
+}
+function usePoolTokens(userAddress) {
+  const [tokens, setTokens] = (0, import_react.useState)([]);
+  const [pairs, setPairs] = (0, import_react.useState)([]);
+  const [loading, setLoading] = (0, import_react.useState)(true);
+  const [balancesLoading, setBalancesLoading] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [rpcWarning, setRpcWarning] = (0, import_react.useState)(null);
+  const [_tick, setTick] = (0, import_react.useState)(0);
+  const refresh = (0, import_react.useCallback)(() => setTick((t) => t + 1), []);
+  (0, import_react.useEffect)(() => {
+    if (!userAddress) return;
+    const id = setInterval(() => setTick((t) => t + 1), 3e4);
+    return () => clearInterval(id);
+  }, [userAddress]);
+  const knownTokensRef = (0, import_react.useRef)(/* @__PURE__ */ new Map());
+  const knownPairsRef = (0, import_react.useRef)(/* @__PURE__ */ new Map());
+  const applyKnown = (0, import_react.useCallback)(() => {
+    const tokenArr = Array.from(knownTokensRef.current.values());
+    const pairArr = Array.from(knownPairsRef.current.values());
+    setPairs(pairArr);
+    return { tokenArr, pairArr };
+  }, []);
+  const fetchBalances = (0, import_react.useCallback)(
+    async (owner, signal) => {
+      const pairAddrs = new Set(
+        Array.from(knownPairsRef.current.values()).map(
+          (p) => p.address.toLowerCase()
+        )
+      );
+      const rawTokens = Array.from(knownTokensRef.current.values()).filter(
+        (t) => !pairAddrs.has(t.address.toLowerCase())
+      );
+      setBalancesLoading(true);
+      try {
+        const network = process.env.NEXT_PUBLIC_NETWORK ?? "testnet";
+        const rpcUrl = network === "testnet" ? "https://evmtestnet.confluxrpc.com" : "https://evm.confluxrpc.com";
+        const chain = network === "testnet" ? import_chains.confluxESpaceTestnet : import_chains.confluxESpace;
+        const client = (0, import_viem.createPublicClient)({ chain, transport: (0, import_viem.http)(rpcUrl) });
+        const CALL_TIMEOUT = 3e4;
+        console.log("[usePoolTokens] fetchBalances start", {
+          owner,
+          network,
+          rpcUrl,
+          ercTokenCount: rawTokens.length
+        });
+        const nativeResult = await withTimeout(
+          client.getBalance({ address: owner }),
+          CALL_TIMEOUT
+        );
+        if (signal.aborted) return;
+        console.log(
+          "[usePoolTokens] fetchBalances nativeResult:",
+          nativeResult?.toString() ?? "null (failed)"
+        );
+        const MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+        let ercResults = [];
+        let multicallResult = null;
+        if (rawTokens.length > 0) {
+          multicallResult = await withTimeout(
+            client.multicall({
+              contracts: rawTokens.map((t) => ({
+                address: t.address,
+                abi: BALANCE_OF_ABI,
+                functionName: "balanceOf",
+                args: [owner]
+              })),
+              allowFailure: true,
+              multicallAddress: MULTICALL3
+            }),
+            CALL_TIMEOUT,
+            /* silent */
+            true
+          );
+          ercResults = multicallResult ? multicallResult.map(
+            (r) => r.status === "success" ? r.result : null
+          ) : rawTokens.map(() => null);
+          const successCount = ercResults.filter((r) => r !== null).length;
+          console.log(
+            `[usePoolTokens] fetchBalances multicall: ${successCount}/${rawTokens.length} succeeded, full timeout: ${multicallResult === null}`
+          );
+        }
+        if (signal.aborted) return;
+        if (nativeResult === null) {
+          const msg = "CFX balance fetch failed \u2014 RPC may be unavailable.";
+          console.warn("[usePoolTokens] fetchBalances:", msg);
+          setRpcWarning(msg);
+        } else if (rawTokens.length > 0 && multicallResult === null) {
+          const msg = "Token balance fetch timed out \u2014 RPC may be overloaded. Showing last known balances.";
+          console.warn("[usePoolTokens] fetchBalances:", msg);
+          setRpcWarning(msg);
+        } else {
+          setRpcWarning(null);
+        }
+        const wcfx = wcfxAddress().toLowerCase();
+        const enriched = rawTokens.map((t, i) => {
+          const raw = ercResults[i];
+          return {
+            ...t,
+            symbol: t.address.toLowerCase() === wcfx ? "wCFX" : t.symbol,
+            name: t.address.toLowerCase() === wcfx ? "Wrapped CFX" : t.name,
+            // null means the call timed out — balanceWei stays '0' for now;
+            // the merge step below reinstates any previously-known balance.
+            balanceWei: raw !== null ? raw.toString() : "0",
+            balanceFormatted: raw !== null ? (0, import_viem.formatUnits)(raw, t.decimals ?? 18) : "0"
+          };
+        });
+        enriched.sort((a, b) => {
+          const diff = BigInt(b.balanceWei) - BigInt(a.balanceWei);
+          return diff > 0n ? 1 : diff < 0n ? -1 : a.symbol.localeCompare(b.symbol);
+        });
+        const nativeBal = nativeResult ?? 0n;
+        const cfxWithBalance = {
+          ...cfxEntryFrom(knownTokensRef.current),
+          balanceWei: nativeBal.toString(),
+          balanceFormatted: (0, import_viem.formatUnits)(nativeBal, 18)
+        };
+        if (!signal.aborted) {
+          setTokens((prev) => {
+            const prevMap = new Map(
+              prev.map((t) => [t.address.toLowerCase(), t.balanceWei])
+            );
+            const timedOut = ercResults.map((r) => r === null);
+            const merged = [
+              // CFX: keep previous balance if native call timed out
+              nativeResult !== null ? cfxWithBalance : prev.find((t) => t.address === CFX_NATIVE_ADDRESS) ?? cfxWithBalance,
+              ...enriched.map((t, i) => {
+                if (timedOut[i]) {
+                  const prevBal = prevMap.get(t.address.toLowerCase()) ?? "0";
+                  if (prevBal !== "0") {
+                    return {
+                      ...t,
+                      balanceWei: prevBal,
+                      balanceFormatted: (0, import_viem.formatUnits)(
+                        BigInt(prevBal),
+                        t.decimals ?? 18
+                      )
+                    };
+                  }
+                }
+                return t;
+              })
+            ];
+            const [cfxEntry, ...rest] = merged;
+            rest.sort((a, b) => {
+              const diff = BigInt(b.balanceWei) - BigInt(a.balanceWei);
+              return diff > 0n ? 1 : diff < 0n ? -1 : a.symbol.localeCompare(b.symbol);
+            });
+            return [cfxEntry, ...rest];
+          });
+        }
+      } catch (err) {
+        console.error(
+          "[usePoolTokens] fetchBalances threw:",
+          err?.message ?? err
+        );
+        setRpcWarning("Balance fetch failed \u2014 see browser console for details");
+      } finally {
+        if (!signal.aborted) setBalancesLoading(false);
+      }
+    },
+    []
+  );
+  const tickMountedRef = (0, import_react.useRef)(false);
+  (0, import_react.useEffect)(() => {
+    if (!tickMountedRef.current) {
+      tickMountedRef.current = true;
+      return;
+    }
+    if (!userAddress) return;
+    const ctrl = new AbortController();
+    void fetchBalances(userAddress, ctrl.signal);
+    return () => ctrl.abort();
+  }, [_tick, userAddress, fetchBalances]);
+  (0, import_react.useEffect)(() => {
+    const abortCtrl = new AbortController();
+    const { signal } = abortCtrl;
+    const persisted = readCacheIgnoreTTL();
+    if (persisted) {
+      mergeTokens(knownTokensRef.current, persisted.tokens);
+      mergePairs(knownPairsRef.current, persisted.pairs);
+    }
+    const cached = readCache();
+    if (cached) {
+      const { tokenArr } = applyKnown();
+      const cfxBase = cfxEntryFrom(knownTokensRef.current);
+      const freshMeta = metaToTokens(tokenArr);
+      setTokens((prev) => {
+        if (prev.length === 0) {
+          return [cfxBase, ...freshMeta];
+        }
+        const existing = new Map(prev.map((t) => [t.address.toLowerCase(), t]));
+        const prevCfx = existing.get(CFX_NATIVE_ADDRESS.toLowerCase());
+        const cfxEntry = prevCfx ? {
+          ...cfxBase,
+          balanceWei: prevCfx.balanceWei,
+          balanceFormatted: prevCfx.balanceFormatted
+        } : cfxBase;
+        const rest = freshMeta.map(
+          (t) => existing.get(t.address.toLowerCase()) ?? t
+        );
+        rest.sort((a, b) => {
+          const diff = BigInt(b.balanceWei) - BigInt(a.balanceWei);
+          return diff > 0n ? 1 : diff < 0n ? -1 : a.symbol.localeCompare(b.symbol);
+        });
+        return [cfxEntry, ...rest];
+      });
+      setLoading(false);
+      if (userAddress) {
+        fetchBalances(userAddress, signal);
+      }
+    }
+    (async () => {
+      try {
+        const res = await fetch("/api/pools", { signal });
+        if (!res.ok) throw new Error(`Backend returned ${res.status}`);
+        const data = await res.json();
+        if (signal.aborted) return;
+        mergeTokens(knownTokensRef.current, data.tokens);
+        mergePairs(knownPairsRef.current, data.pairs);
+        const mergedTokens = Array.from(knownTokensRef.current.values());
+        const mergedPairs = Array.from(knownPairsRef.current.values());
+        writeCache(mergedTokens, mergedPairs);
+        setPairs(mergedPairs);
+        const freshMeta = metaToTokens(mergedTokens);
+        const cfxBase = cfxEntryFrom(knownTokensRef.current);
+        setTokens((prev) => {
+          if (prev.length === 0) {
+            return [cfxBase, ...freshMeta];
+          }
+          const existing = new Map(
+            prev.map((t) => [t.address.toLowerCase(), t])
+          );
+          const prevCfx = existing.get(CFX_NATIVE_ADDRESS.toLowerCase());
+          const cfxEntry = prevCfx ? {
+            ...cfxBase,
+            balanceWei: prevCfx.balanceWei,
+            balanceFormatted: prevCfx.balanceFormatted
+          } : cfxBase;
+          const rest = freshMeta.map(
+            (t) => existing.get(t.address.toLowerCase()) ?? t
+          );
+          rest.sort((a, b) => {
+            const diff = BigInt(b.balanceWei) - BigInt(a.balanceWei);
+            return diff > 0n ? 1 : diff < 0n ? -1 : a.symbol.localeCompare(b.symbol);
+          });
+          return [cfxEntry, ...rest];
+        });
+        setLoading(false);
+        if (!userAddress) return;
+        await fetchBalances(userAddress, signal);
+      } catch (err) {
+        if (signal.aborted) return;
+        const msg = err?.message ?? String(err);
+        console.warn("[usePoolTokens] /api/pools fetch failed:", msg);
+        if (cached || persisted) {
+          setLoading(false);
+        } else {
+          setError(msg);
+          setLoading(false);
+        }
+      }
+    })();
+    return () => abortCtrl.abort();
+  }, [userAddress, applyKnown, fetchBalances]);
+  return {
+    tokens,
+    pairs,
+    loading,
+    balancesLoading,
+    error,
+    rpcWarning,
+    refresh
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTOMATION_MANAGER_ABI,
+  AUTOMATION_MANAGER_ADDRESS,
+  CFX_NATIVE_ADDRESS,
+  ERC20_ABI,
+  MAX_UINT256,
+  WCFX_ABI,
+  getPairedTokens,
+  resolveTokenInAddress,
+  usePoolTokens,
+  wcfxAddress
+});
+//# sourceMappingURL=index.cjs.map