@t2000/engine 0.54.1 → 0.55.0

package/dist/index.js

@@ -532,12 +532,219 @@ function resetDefiCacheStore() {
   activeStore = new InMemoryDefiCacheStore();
 }
 
+// src/wallet-cache.ts
+var InMemoryWalletCacheStore = class {
+  store = /* @__PURE__ */ new Map();
+  async get(address) {
+    const slot = this.store.get(address.toLowerCase());
+    if (!slot) return null;
+    if (Date.now() >= slot.expiresAt) {
+      this.store.delete(address.toLowerCase());
+      return null;
+    }
+    return slot.entry;
+  }
+  async set(address, entry, ttlSec) {
+    this.store.set(address.toLowerCase(), {
+      entry,
+      expiresAt: Date.now() + ttlSec * 1e3
+    });
+  }
+  async delete(address) {
+    this.store.delete(address.toLowerCase());
+  }
+  async clear() {
+    this.store.clear();
+  }
+};
+var activeStore2 = new InMemoryWalletCacheStore();
+function setWalletCacheStore(store) {
+  activeStore2 = store;
+}
+function getWalletCacheStore() {
+  return activeStore2;
+}
+function resetWalletCacheStore() {
+  activeStore2 = new InMemoryWalletCacheStore();
+}
+
+// src/cross-instance-lock.ts
+var InMemoryFetchLock = class {
+  held = /* @__PURE__ */ new Map();
+  async acquire(key, leaseSec) {
+    const now = Date.now();
+    const expiry = this.held.get(key);
+    if (expiry !== void 0 && expiry > now) return false;
+    this.held.set(key, now + leaseSec * 1e3);
+    return true;
+  }
+  async release(key) {
+    this.held.delete(key);
+  }
+};
+var activeLock = new InMemoryFetchLock();
+function setFetchLock(lock) {
+  activeLock = lock;
+}
+function getFetchLock() {
+  return activeLock;
+}
+function resetFetchLock() {
+  activeLock = new InMemoryFetchLock();
+}
+var DEFAULT_LEASE_SEC = 15;
+var DEFAULT_POLL_BUDGET_MS = 4500;
+var DEFAULT_POLL_INTERVAL_MS = 100;
+async function awaitOrFetch(key, fetcher, opts = {}) {
+  const lock = opts.lock ?? getFetchLock();
+  const leaseSec = opts.leaseSec ?? DEFAULT_LEASE_SEC;
+  const pollBudgetMs = opts.pollBudgetMs ?? DEFAULT_POLL_BUDGET_MS;
+  const pollIntervalMs = opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const rng = opts.rng ?? Math.random;
+  const now = opts.now ?? Date.now;
+  const sleep2 = opts.sleep ?? ((ms) => new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    if (opts.signal) {
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      };
+      if (opts.signal.aborted) onAbort();
+      else opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+  }));
+  let acquired = false;
+  try {
+    acquired = await lock.acquire(key, leaseSec);
+  } catch (err) {
+    console.warn(`[fetch-lock] acquire(${key}) threw; falling through to direct fetch:`, err);
+    return fetcher();
+  }
+  if (acquired) {
+    try {
+      return await fetcher();
+    } finally {
+      try {
+        await lock.release(key);
+      } catch (err) {
+        console.warn(`[fetch-lock] release(${key}) failed (non-fatal):`, err);
+      }
+    }
+  }
+  if (!opts.pollCache) {
+    return fetcher();
+  }
+  const deadline = now() + pollBudgetMs;
+  while (now() < deadline) {
+    const jitterPx = (rng() * 0.4 - 0.2) * pollIntervalMs;
+    const wait = Math.max(0, pollIntervalMs + jitterPx);
+    try {
+      await sleep2(wait);
+    } catch (err) {
+      if (err?.name === "AbortError") throw err;
+      return fetcher();
+    }
+    let cached = null;
+    try {
+      cached = await opts.pollCache();
+    } catch (err) {
+      console.warn(`[fetch-lock] pollCache(${key}) threw; continuing to poll:`, err);
+    }
+    if (cached !== null) return cached;
+  }
+  return fetcher();
+}
+
 // src/blockvision-prices.ts
 var BLOCKVISION_BASE = "https://api.blockvision.org/v2/sui";
 var PORTFOLIO_TIMEOUT_MS = 4e3;
 var PRICES_TIMEOUT_MS = 3e3;
 var CACHE_TTL_MS = 6e4;
-var DEGRADED_CACHE_TTL_MS = 15e3;
+var WALLET_FRESH_TTL_MS_BLOCKVISION = 6e4;
+var WALLET_FRESH_TTL_MS_DEGRADED = 15e3;
+var WALLET_STICKY_TTL_SEC = 30 * 60;
+var WALLET_LOCK_KEY = (address) => `bv-lock:wallet:${address.toLowerCase()}`;
+var DEFI_LOCK_KEY = (address) => `bv-lock:defi:${address.toLowerCase()}`;
+var BV_RETRY_MAX_ATTEMPTS = 3;
+var BV_RETRY_BASE_DELAY_MS = 250;
+var BV_RETRY_BACKOFF_FACTOR = 3;
+var BV_RETRY_JITTER = 0.25;
+var BV_RETRY_AFTER_CAP_MS = 5e3;
+var CB_WINDOW_MS = 5e3;
+var CB_THRESHOLD = 10;
+var CB_COOLDOWN_MS = 3e4;
+var cb429Timestamps = [];
+var cbOpenUntil = 0;
+function cbIsOpen(now) {
+  return now < cbOpenUntil;
+}
+function cbRecord429(now) {
+  cb429Timestamps.push(now);
+  cb429Timestamps = cb429Timestamps.filter((t) => now - t < CB_WINDOW_MS);
+  if (cb429Timestamps.length >= CB_THRESHOLD && !cbIsOpen(now)) {
+    cbOpenUntil = now + CB_COOLDOWN_MS;
+    console.warn(
+      `[blockvision] circuit breaker OPEN \u2014 ${CB_THRESHOLD} 429s in ${CB_WINDOW_MS}ms, retries disabled for ${CB_COOLDOWN_MS / 1e3}s`
+    );
+    cb429Timestamps = [];
+  }
+}
+async function fetchBlockVisionWithRetry(url, init, opts = {}) {
+  const rng = opts.rng ?? Math.random;
+  const sleep2 = opts.sleep ?? ((ms) => new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    if (opts.signal) {
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      };
+      if (opts.signal.aborted) onAbort();
+      else opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+  }));
+  let lastError = null;
+  let lastResponse = null;
+  for (let attempt = 0; attempt < BV_RETRY_MAX_ATTEMPTS; attempt++) {
+    if (attempt > 0) {
+      let waitMs = BV_RETRY_BASE_DELAY_MS * Math.pow(BV_RETRY_BACKOFF_FACTOR, attempt - 1);
+      const retryAfter = lastResponse?.headers.get("retry-after");
+      if (retryAfter) {
+        const secs = Number(retryAfter);
+        if (Number.isFinite(secs) && secs > 0) {
+          waitMs = Math.min(secs * 1e3, BV_RETRY_AFTER_CAP_MS);
+        }
+      }
+      const jitterPx = (rng() * 2 - 1) * BV_RETRY_JITTER * waitMs;
+      const delay = Math.max(0, waitMs + jitterPx);
+      try {
+        await sleep2(delay);
+      } catch (err) {
+        if (lastResponse) return lastResponse;
+        throw err;
+      }
+    }
+    try {
+      lastResponse = await fetch(url, init);
+    } catch (err) {
+      lastError = err;
+      if (err?.name === "AbortError") throw err;
+      continue;
+    }
+    if (lastResponse.ok) return lastResponse;
+    if (lastResponse.status !== 429 && lastResponse.status < 500) {
+      return lastResponse;
+    }
+    if (lastResponse.status === 429) {
+      const now = (opts.now ?? Date.now)();
+      cbRecord429(now);
+      if (cbIsOpen(now)) {
+        return lastResponse;
+      }
+    }
+  }
+  if (lastResponse) return lastResponse;
+  throw lastError ?? new Error("fetch failed after retries");
+}
 var PRICE_LIST_CHUNK = 10;
 var STABLE_USD_PRICES = {
   "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC": 1,
@@ -547,47 +754,117 @@ var STABLE_USD_PRICES = {
   "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN": 1,
   "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN": 1
 };
-var portfolioCache = /* @__PURE__ */ new Map();
 var portfolioInflight = /* @__PURE__ */ new Map();
 var priceMapCache = null;
+function walletFreshTtlMs(source) {
+  switch (source) {
+    case "blockvision":
+      return WALLET_FRESH_TTL_MS_BLOCKVISION;
+    case "sui-rpc-degraded":
+      return WALLET_FRESH_TTL_MS_DEGRADED;
+  }
+}
+async function safeWalletStoreSet(store, address, entry, ttlSec) {
+  try {
+    await store.set(address, entry, ttlSec);
+  } catch (err) {
+    console.warn("[wallet] cache set failed (non-fatal):", err);
+  }
+}
+async function safeWalletStoreGet(store, address) {
+  try {
+    return await store.get(address);
+  } catch (err) {
+    console.warn("[wallet] cache get failed (continuing as cache miss):", err);
+    return null;
+  }
+}
 async function fetchAddressPortfolio(address, apiKey, fallbackRpcUrl) {
-  const now = Date.now();
-  const cached = portfolioCache.get(address);
-  if (cached && now - cached.ts < CACHE_TTL_MS) {
-    return cached.data;
+  const store = getWalletCacheStore();
+  const cachedEntry = await safeWalletStoreGet(store, address);
+  if (cachedEntry) {
+    const ageMs = Date.now() - cachedEntry.pricedAt;
+    if (ageMs < walletFreshTtlMs(cachedEntry.data.source)) {
+      return cachedEntry.data;
+    }
   }
-  let inflight = portfolioInflight.get(address);
-  if (inflight) return inflight;
-  inflight = (async () => {
+  const existing = portfolioInflight.get(address);
+  if (existing) return existing;
+  const promise = (async () => {
     try {
-      if (apiKey && apiKey.trim().length > 0) {
-        const blockvision = await fetchPortfolioFromBlockVision(address, apiKey);
-        if (blockvision) {
-          portfolioCache.set(address, { data: blockvision, ts: Date.now() });
-          return blockvision;
+      return await awaitOrFetch(
+        WALLET_LOCK_KEY(address),
+        // ----------------------------------------------------------
+        // Leader path — runs after we've won the cross-instance lock.
+        // Re-checks the cache (small window where another leader on a
+        // different process just wrote) before paying for the BV call.
+        // ----------------------------------------------------------
+        async () => {
+          const recheck = await safeWalletStoreGet(store, address);
+          if (recheck) {
+            const ageMs = Date.now() - recheck.pricedAt;
+            if (ageMs < walletFreshTtlMs(recheck.data.source)) {
+              return recheck.data;
+            }
+          }
+          if (apiKey && apiKey.trim().length > 0) {
+            const blockvision = await fetchPortfolioFromBlockVision(address, apiKey);
+            if (blockvision) {
+              await safeWalletStoreSet(
+                store,
+                address,
+                { data: blockvision, pricedAt: Date.now() },
+                WALLET_STICKY_TTL_SEC
+              );
+              return blockvision;
+            }
+          }
+          const degraded = await fetchPortfolioFromSuiRpc(address, apiKey, fallbackRpcUrl);
+          const stickyCandidate = recheck && recheck.data.source === "blockvision" && recheck.data.totalUsd > 0 ? recheck : cachedEntry && cachedEntry.data.source === "blockvision" && cachedEntry.data.totalUsd > 0 ? cachedEntry : null;
+          const stickyFresh = stickyCandidate && Date.now() - stickyCandidate.pricedAt < WALLET_STICKY_TTL_SEC * 1e3;
+          if (stickyFresh) {
+            return stickyCandidate.data;
+          }
+          await safeWalletStoreSet(
+            store,
+            address,
+            { data: degraded, pricedAt: Date.now() },
+            Math.ceil(WALLET_FRESH_TTL_MS_DEGRADED / 1e3)
+          );
+          return degraded;
+        },
+        {
+          // Followers poll the wallet cache while the leader fetches.
+          // Returns non-null only when the leader has written a
+          // fresh-for-source entry — stale entries keep the poll going.
+          pollCache: async () => {
+            const e = await safeWalletStoreGet(store, address);
+            if (!e) return null;
+            const ageMs = Date.now() - e.pricedAt;
+            return ageMs < walletFreshTtlMs(e.data.source) ? e.data : null;
+          }
         }
-      }
-      const degraded = await fetchPortfolioFromSuiRpc(address, apiKey, fallbackRpcUrl);
-      portfolioCache.set(address, {
-        data: degraded,
-        ts: Date.now() - (CACHE_TTL_MS - DEGRADED_CACHE_TTL_MS)
-      });
-      return degraded;
+      );
     } finally {
       portfolioInflight.delete(address);
     }
   })();
-  portfolioInflight.set(address, inflight);
-  return inflight;
+  portfolioInflight.set(address, promise);
+  return promise;
 }
 async function fetchPortfolioFromBlockVision(address, apiKey) {
   const url = `${BLOCKVISION_BASE}/account/coins?account=${encodeURIComponent(address)}`;
+  const signal = AbortSignal.timeout(PORTFOLIO_TIMEOUT_MS);
   let res;
   try {
-    res = await fetch(url, {
-      headers: { "x-api-key": apiKey, accept: "application/json" },
-      signal: AbortSignal.timeout(PORTFOLIO_TIMEOUT_MS)
-    });
+    res = await fetchBlockVisionWithRetry(
+      url,
+      {
+        headers: { "x-api-key": apiKey, accept: "application/json" },
+        signal
+      },
+      { signal }
+    );
   } catch (err) {
     console.warn("[blockvision-prices] portfolio fetch threw, degrading:", err);
     return null;
@@ -718,12 +995,17 @@ async function fetchPricesFromBlockVision(coinTypes, apiKey) {
     const chunk = longForms.slice(i, i + PRICE_LIST_CHUNK);
     const tokenIds = encodeURIComponent(chunk.join(","));
     const url = `${BLOCKVISION_BASE}/coin/price/list?tokenIds=${tokenIds}&show24hChange=true`;
+    const signal = AbortSignal.timeout(PRICES_TIMEOUT_MS);
     let res;
     try {
-      res = await fetch(url, {
-        headers: { "x-api-key": apiKey, accept: "application/json" },
-        signal: AbortSignal.timeout(PRICES_TIMEOUT_MS)
-      });
+      res = await fetchBlockVisionWithRetry(
+        url,
+        {
+          headers: { "x-api-key": apiKey, accept: "application/json" },
+          signal
+        },
+        { signal }
+      );
     } catch (err) {
       console.warn("[blockvision-prices] price chunk threw, skipping:", err);
       continue;
@@ -799,6 +1081,14 @@ async function safeStoreSet(store, address, entry) {
     console.warn("[defi] cache set failed (non-fatal):", err);
   }
 }
+async function safeDefiStoreGet(store, address) {
+  try {
+    return await store.get(address);
+  } catch (err) {
+    console.warn("[defi] cache get failed (continuing as cache miss):", err);
+    return null;
+  }
+}
 var warnedMissingApiKey = false;
 async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
   if (!apiKey || apiKey.trim().length === 0) {
@@ -811,15 +1101,9 @@ async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
     return { totalUsd: 0, perProtocol: {}, pricedAt: Date.now(), source: "degraded" };
   }
   const store = getDefiCacheStore();
-  const now = Date.now();
-  let cachedEntry = null;
-  try {
-    cachedEntry = await store.get(address);
-  } catch (err) {
-    console.warn("[defi] cache get failed (continuing as cache miss):", err);
-  }
+  const cachedEntry = await safeDefiStoreGet(store, address);
   if (cachedEntry) {
-    const ageMs = now - cachedEntry.pricedAt;
+    const ageMs = Date.now() - cachedEntry.pricedAt;
     const freshTtlMs = freshTtlForSource(cachedEntry.data.source);
     if (ageMs < freshTtlMs) {
       return cachedEntry.data;
@@ -829,82 +1113,108 @@ async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
   if (inflight) return inflight;
   inflight = (async () => {
     try {
-      const settled = await Promise.allSettled(
-        DEFI_PROTOCOLS.map((p) => fetchOneDefiProtocol(address, p, apiKey))
-      );
-      const seen = /* @__PURE__ */ new Set();
-      for (const s of settled) {
-        if (s.status === "fulfilled" && s.value) collectCoinTypes(s.value, seen);
-      }
-      const normalizedHints = {};
-      for (const [k, v] of Object.entries(priceHints)) {
-        normalizedHints[normalizeCoinType(k)] = v;
-      }
-      const missing = Array.from(seen).filter((ct) => {
-        const norm = normalizeCoinType(ct);
-        return !normalizedHints[norm] && !STABLE_USD_PRICES[norm];
-      });
-      let fetchedPrices = {};
-      if (missing.length > 0) {
-        try {
-          fetchedPrices = await fetchTokenPrices(missing, apiKey);
-        } catch (err) {
-          console.warn("[defi] fill-missing-prices failed:", err);
-        }
-      }
-      const prices = { ...normalizedHints };
-      for (const [ct, v] of Object.entries(fetchedPrices)) {
-        prices[normalizeCoinType(ct)] ??= v.price;
-      }
-      for (const [ct, p] of Object.entries(STABLE_USD_PRICES)) {
-        prices[normalizeCoinType(ct)] ??= p;
-      }
-      let totalUsd = 0;
-      let failures = 0;
-      const perProtocol = {};
-      for (let i = 0; i < DEFI_PROTOCOLS.length; i++) {
-        const proto = DEFI_PROTOCOLS[i];
-        const s = settled[i];
-        if (s.status !== "fulfilled" || !s.value) {
-          failures++;
-          continue;
-        }
-        try {
-          const usd = normalizeProtocol(proto, s.value, prices);
-          if (Number.isFinite(usd) && usd !== 0) {
-            perProtocol[proto] = usd;
-            totalUsd += usd;
+      return await awaitOrFetch(
+        DEFI_LOCK_KEY(address),
+        // Leader path — runs after acquiring the lock.
+        async () => {
+          const recheck = await safeDefiStoreGet(store, address);
+          if (recheck) {
+            const ageMs = Date.now() - recheck.pricedAt;
+            if (ageMs < freshTtlForSource(recheck.data.source)) {
+              return recheck.data;
+            }
+          }
+          const stickyBasis = recheck ?? cachedEntry;
+          const fanoutAt = Date.now();
+          const settled = await Promise.allSettled(
+            DEFI_PROTOCOLS.map((p) => fetchOneDefiProtocol(address, p, apiKey))
+          );
+          const seen = /* @__PURE__ */ new Set();
+          for (const s of settled) {
+            if (s.status === "fulfilled" && s.value) collectCoinTypes(s.value, seen);
+          }
+          const normalizedHints = {};
+          for (const [k, v] of Object.entries(priceHints)) {
+            normalizedHints[normalizeCoinType(k)] = v;
+          }
+          const missing = Array.from(seen).filter((ct) => {
+            const norm = normalizeCoinType(ct);
+            return !normalizedHints[norm] && !STABLE_USD_PRICES[norm];
+          });
+          let fetchedPrices = {};
+          if (missing.length > 0) {
+            try {
+              fetchedPrices = await fetchTokenPrices(missing, apiKey);
+            } catch (err) {
+              console.warn("[defi] fill-missing-prices failed:", err);
+            }
+          }
+          const prices = { ...normalizedHints };
+          for (const [ct, v] of Object.entries(fetchedPrices)) {
+            prices[normalizeCoinType(ct)] ??= v.price;
+          }
+          for (const [ct, p] of Object.entries(STABLE_USD_PRICES)) {
+            prices[normalizeCoinType(ct)] ??= p;
+          }
+          let totalUsd = 0;
+          let failures = 0;
+          const perProtocol = {};
+          for (let i = 0; i < DEFI_PROTOCOLS.length; i++) {
+            const proto = DEFI_PROTOCOLS[i];
+            const s = settled[i];
+            if (s.status !== "fulfilled" || !s.value) {
+              failures++;
+              continue;
+            }
+            try {
+              const usd = normalizeProtocol(proto, s.value, prices);
+              if (Number.isFinite(usd) && usd !== 0) {
+                perProtocol[proto] = usd;
+                totalUsd += usd;
+              }
+            } catch (err) {
+              console.warn(`[defi] ${proto} normaliser threw:`, err);
+              failures++;
+            }
+          }
+          if (totalUsd < 0) totalUsd = 0;
+          const fetchedAt = Date.now();
+          const summary = {
+            totalUsd,
+            perProtocol,
+            pricedAt: fetchedAt,
+            source: failures === DEFI_PROTOCOLS.length ? "degraded" : failures > 0 ? "partial" : "blockvision"
+          };
+          const cachedPositive = stickyBasis && stickyBasis.data.totalUsd > 0 && fanoutAt - stickyBasis.pricedAt < DEFI_STICKY_TTL_SEC * 1e3;
+          if (summary.source === "blockvision") {
+            await safeStoreSet(store, address, { data: summary, pricedAt: fetchedAt });
+            return summary;
+          }
+          if (summary.source === "partial" && summary.totalUsd > 0) {
+            await safeStoreSet(store, address, { data: summary, pricedAt: fetchedAt });
+            return summary;
+          }
+          if (cachedPositive) {
+            const stale = {
+              ...stickyBasis.data,
+              source: "partial-stale"
+            };
+            return stale;
+          }
+          return summary;
+        },
+        {
+          // Followers poll the DeFi cache while the leader fans out.
+          // Returns non-null only when the leader has written a
+          // fresh-for-source entry — stale entries keep the poll going.
+          pollCache: async () => {
+            const e = await safeDefiStoreGet(store, address);
+            if (!e) return null;
+            const ageMs = Date.now() - e.pricedAt;
+            return ageMs < freshTtlForSource(e.data.source) ? e.data : null;
           }
-        } catch (err) {
-          console.warn(`[defi] ${proto} normaliser threw:`, err);
-          failures++;
         }
-      }
-      if (totalUsd < 0) totalUsd = 0;
-      const fetchedAt = Date.now();
-      const summary = {
-        totalUsd,
-        perProtocol,
-        pricedAt: fetchedAt,
-        source: failures === DEFI_PROTOCOLS.length ? "degraded" : failures > 0 ? "partial" : "blockvision"
-      };
-      const cachedPositive = cachedEntry && cachedEntry.data.totalUsd > 0 && now - cachedEntry.pricedAt < DEFI_STICKY_TTL_SEC * 1e3;
-      if (summary.source === "blockvision") {
-        await safeStoreSet(store, address, { data: summary, pricedAt: fetchedAt });
-        return summary;
-      }
-      if (summary.source === "partial" && summary.totalUsd > 0) {
-        await safeStoreSet(store, address, { data: summary, pricedAt: fetchedAt });
-        return summary;
-      }
-      if (cachedPositive) {
-        const stale = {
-          ...cachedEntry.data,
-          source: "partial-stale"
-        };
-        return stale;
-      }
-      return summary;
+      );
     } finally {
       defiInflight.delete(address);
     }
@@ -914,12 +1224,17 @@ async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
 }
 async function fetchOneDefiProtocol(address, protocol, apiKey) {
   const url = `${BLOCKVISION_BASE}/account/defiPortfolio?address=${encodeURIComponent(address)}&protocol=${protocol}`;
+  const signal = AbortSignal.timeout(DEFI_PORTFOLIO_TIMEOUT_MS);
   let res;
   try {
-    res = await fetch(url, {
-      headers: { "x-api-key": apiKey, accept: "application/json" },
-      signal: AbortSignal.timeout(DEFI_PORTFOLIO_TIMEOUT_MS)
-    });
+    res = await fetchBlockVisionWithRetry(
+      url,
+      {
+        headers: { "x-api-key": apiKey, accept: "application/json" },
+        signal
+      },
+      { signal }
+    );
   } catch (err) {
     console.warn(`[defi] ${protocol} fetch threw:`, err);
     return null;
@@ -1185,12 +1500,12 @@ function normalizeProtocol(protocol, result, prices) {
   if (bespoke) return bespoke(result, prices);
   return walkProtocolResponse(result, prices);
 }
-function clearPortfolioCache() {
-  portfolioCache.clear();
+async function clearPortfolioCache() {
+  await getWalletCacheStore().clear();
   portfolioInflight.clear();
 }
-function clearPortfolioCacheFor(address) {
-  portfolioCache.delete(address);
+async function clearPortfolioCacheFor(address) {
+  await getWalletCacheStore().delete(address);
   portfolioInflight.delete(address);
 }
 function clearPriceMapCache() {
@@ -3329,12 +3644,31 @@ var portfolioAnalysisTool = buildTool({
         `${apiUrl}/api/analytics/portfolio-history?days=7`,
         { headers: { "x-sui-address": address }, signal: context.signal }
       ).then((res) => res.ok ? res.json() : null).catch(() => null) : Promise.resolve(null),
-      // DeFi fetch — prefer the audric snapshot's already-computed value
-      // (when present and not 'degraded'), otherwise call the engine's
-      // direct aggregator. The 'degraded' check prevents the audric
-      // path from masking a useful direct read when the audric route's
-      // own DeFi field came back empty.
-      audricSnapshot && audricSnapshot.defiSource !== "degraded" ? Promise.resolve({
+      // DeFi fetch — prefer the audric snapshot's already-computed
+      // value, but only when we can trust it. Two trust signals:
+      //   1. `source === 'blockvision'`  — fully successful fresh read
+      //      (even if value is 0, that's a confirmed empty position).
+      //   2. `defiValueUsd > 0`           — any positive value, regardless
+      //      of source. `partial-stale` with a positive total is fine,
+      //      `partial` with a positive total is the live equivalent.
+      //
+      // [Bug — 2026-04-28 round 2] Pre-fix the trust gate was
+      // `defiSource !== 'degraded'`, which let `partial + 0` through
+      // as authoritative. During a BlockVision 429 burst the audric
+      // host's `/api/portfolio` returns `partial + 0` (some protocols
+      // failed, the rest reported $0, no sticky-positive available
+      // *in that process*) — but the engine's direct fetcher in the
+      // chat route may have a sticky-positive in *this* Vercel
+      // instance's cache. Trusting audric's $0 silently dropped the
+      // DeFi line that `balance_check` (which always calls direct)
+      // showed correctly on the same turn — same SSOT-divergence bug
+      // class, manifested in a different layer.
+      //
+      // The new condition routes around audric's $0 in exactly that
+      // case. When the direct fetch ALSO returns $0 the answer is
+      // consistent across tools (both report degraded), which is the
+      // honest UX during a real outage.
+      audricSnapshot && (audricSnapshot.defiSource === "blockvision" || audricSnapshot.defiValueUsd > 0) ? Promise.resolve({
         totalUsd: audricSnapshot.defiValueUsd,
         perProtocol: {},
         pricedAt: Date.now(),
@@ -4418,7 +4752,7 @@ function getModifiableFields(toolName) {
 }
 
 // src/prompt.ts
-var DEFAULT_SYSTEM_PROMPT = `You are Audric \u2014 a financial agent on Sui. Audric is exactly five products: Audric Passport (the trust layer \u2014 Google sign-in, non-custodial wallet, tap-to-confirm consent, sponsored gas \u2014 wraps every other product), Audric Intelligence (you \u2014 the 5-system brain: Agent Harness with 34 tools, Reasoning Engine with 9 guards and 7 skill recipes, Silent Profile, Chain Memory, AdviceLog), Audric Finance (manage money on Sui \u2014 Save via NAVI lending at 3-8% APY USDC, Credit via NAVI borrowing with health factor, Swap via Cetus aggregator across 20+ DEXs at 0.1% fee, Charts for yield/health/portfolio viz), Audric Pay (move money \u2014 send USDC, receive via payment links / invoices / QR; free, global, instant on Sui), and Audric Store (creator marketplace, ships Phase 5 \u2014 say "coming soon" if asked). Save, swap, borrow, repay, withdraw, charts \u2192 Audric Finance. Send, receive, payment-link, invoice, QR \u2192 Audric Pay. Your silent context (profile, memory, chain facts, advice log) shapes your replies but never surfaces as a notification \u2014 you act only when the user asks, and every write waits on their tap-to-confirm via Passport. You can also call 41 paid APIs (music, image, research, translation, weather, fulfilment) via MPP micropayments using the pay_api tool \u2014 this is an internal capability, not a promoted product, so only mention it when the user asks for something that needs it.
+var DEFAULT_SYSTEM_PROMPT = `You are Audric \u2014 a financial agent on Sui. Audric is exactly five products: Audric Passport (the trust layer \u2014 Google sign-in, non-custodial wallet, tap-to-confirm consent, sponsored gas \u2014 wraps every other product), Audric Intelligence (you \u2014 the 5-system brain: Agent Harness with 34 tools, Reasoning Engine with 14 guards and 6 skill recipes, Silent Profile, Chain Memory, AdviceLog), Audric Finance (manage money on Sui \u2014 Save via NAVI lending at 3-8% APY USDC, Credit via NAVI borrowing with health factor, Swap via Cetus aggregator across 20+ DEXs at 0.1% fee, Charts for yield/health/portfolio viz), Audric Pay (move money \u2014 send USDC, receive via payment links / invoices / QR; free, global, instant on Sui), and Audric Store (creator marketplace, ships Phase 5 \u2014 say "coming soon" if asked). Save, swap, borrow, repay, withdraw, charts \u2192 Audric Finance. Send, receive, payment-link, invoice, QR \u2192 Audric Pay. Your silent context (profile, memory, chain facts, advice log) shapes your replies but never surfaces as a notification \u2014 you act only when the user asks, and every write waits on their tap-to-confirm via Passport. You can also call 41 paid APIs (music, image, research, translation, weather, fulfilment) via MPP micropayments using the pay_api tool \u2014 this is an internal capability, not a promoted product, so only mention it when the user asks for something that needs it.
 
 ## Response rules
 - 1-2 sentences max. No bullet lists unless asked. No preambles.
@@ -5852,7 +6186,7 @@ var QueryEngine = class {
     };
     if (this.walletAddress) {
       this.portfolioCache?.delete(this.walletAddress);
-      clearPortfolioCacheFor(this.walletAddress);
+      await clearPortfolioCacheFor(this.walletAddress);
     }
     if (!signal.aborted) {
       await new Promise((resolve) => {
@@ -7752,6 +8086,6 @@ function sanitizeAnthropicMessages(messages) {
   return merged;
 }
 
-export { AnthropicProvider, BalanceTracker, CANVAS_TEMPLATES, ContextBudget, CostTracker, DEFAULT_GUARD_CONFIG, DEFAULT_PERMISSION_CONFIG, DEFAULT_SYSTEM_PROMPT, EarlyToolDispatcher, InMemoryDefiCacheStore, McpClientManager, McpResponseCache, MemorySessionStore, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, NaviTools, PERMISSION_PRESETS, QueryEngine, READ_TOOLS, RecipeRegistry, RetryTracker, TOOL_FLAGS, TOOL_MODIFIABLE_FIELDS, TxMutex, WRITE_TOOLS, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, applyToolFlags, balanceCheckTool, borrowTool, budgetToolResult, buildCachedSystemPrompt, buildMcpTools, buildProactivenessInstructions, buildProfileContext, buildSelfEvaluationInstruction, buildStateContext, buildTool, claimRewardsTool, classifyEffort, clearPortfolioCache, clearPortfolioCacheFor, clearPriceMapCache, compactMessages, createGuardRunnerState, engineToSSE, estimateTokens, explainTxTool, extractConversationText, extractMcpText, fetchAddressDefiPortfolio, fetchAddressPortfolio, fetchAudricHistory, fetchAudricPortfolio, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getAudricApiBase, getDefaultTools, getDefiCacheStore, getMcpManager, getModifiableFields, getToolFlags, getWalletAddress, guardArtifactPreview, guardStaleData, hasNaviMcp, healthCheckTool, loadRecipes, microcompact, mppServicesTool, parseMcpJson, parseRecipe, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, resetDefiCacheStore, resolvePermissionTier, resolveUsdValue, runGuards, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, setDefiCacheStore, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, tokenPricesTool, toolNameToOperation, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, updateGuardStateAfterToolResult, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };
+export { AnthropicProvider, BalanceTracker, CANVAS_TEMPLATES, ContextBudget, CostTracker, DEFAULT_GUARD_CONFIG, DEFAULT_LEASE_SEC, DEFAULT_PERMISSION_CONFIG, DEFAULT_POLL_BUDGET_MS, DEFAULT_POLL_INTERVAL_MS, DEFAULT_SYSTEM_PROMPT, EarlyToolDispatcher, InMemoryDefiCacheStore, InMemoryFetchLock, InMemoryWalletCacheStore, McpClientManager, McpResponseCache, MemorySessionStore, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, NaviTools, PERMISSION_PRESETS, QueryEngine, READ_TOOLS, RecipeRegistry, RetryTracker, TOOL_FLAGS, TOOL_MODIFIABLE_FIELDS, TxMutex, WRITE_TOOLS, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, applyToolFlags, awaitOrFetch, balanceCheckTool, borrowTool, budgetToolResult, buildCachedSystemPrompt, buildMcpTools, buildProactivenessInstructions, buildProfileContext, buildSelfEvaluationInstruction, buildStateContext, buildTool, claimRewardsTool, classifyEffort, clearPortfolioCache, clearPortfolioCacheFor, clearPriceMapCache, compactMessages, createGuardRunnerState, engineToSSE, estimateTokens, explainTxTool, extractConversationText, extractMcpText, fetchAddressDefiPortfolio, fetchAddressPortfolio, fetchAudricHistory, fetchAudricPortfolio, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getAudricApiBase, getDefaultTools, getDefiCacheStore, getFetchLock, getMcpManager, getModifiableFields, getToolFlags, getWalletAddress, getWalletCacheStore, guardArtifactPreview, guardStaleData, hasNaviMcp, healthCheckTool, loadRecipes, microcompact, mppServicesTool, parseMcpJson, parseRecipe, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, resetDefiCacheStore, resetFetchLock, resetWalletCacheStore, resolvePermissionTier, resolveUsdValue, runGuards, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, setDefiCacheStore, setFetchLock, setWalletCacheStore, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, tokenPricesTool, toolNameToOperation, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, updateGuardStateAfterToolResult, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map