@1delta/margin-fetcher 5.0.46 → 5.0.48

package/dist/index.js

@@ -14976,8 +14976,46 @@ var ComptrollerAbi = [
     outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
     stateMutability: "view",
     type: "function"
+  },
+  // Per-market pause guardians. Classic Compound V2 keeps them as public
+  // mappings on the Comptroller — the cToken lenses do NOT expose them, so a
+  // fork on the standard lens path can only learn its pause state from here.
+  // `mintAllowed` / `borrowAllowed` hard-revert ("mint is paused" /
+  // "borrow is paused") when set, which is why they gate `depositsEnabled` /
+  // `borrowingEnabled` rather than merely capping an amount.
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "mintGuardianPaused",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "borrowGuardianPaused",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
   }
 ];
+var COMPTROLLER_PAUSE_READ_LENDERS = [
+  Lender.COMPOUND_V2,
+  Lender.CREAM_FINANCE,
+  Lender.FLUX_FINANCE,
+  Lender.WE_PIGGY,
+  Lender.GAMMA,
+  Lender.CAPY_FI,
+  Lender.LODESTAR,
+  Lender.TENDER
+];
+var usesComptrollerPauseReads = (lender) => COMPTROLLER_PAUSE_READ_LENDERS.includes(lender);
+var parsePausedFlag = (raw) => typeof raw === "boolean" ? raw : void 0;
+var resolveMarketPause = (token, live) => {
+  const mintPaused = live?.mintPaused ?? token?.mintPaused;
+  const borrowPaused = live?.borrowPaused ?? token?.borrowPaused;
+  if (mintPaused === void 0 && borrowPaused === void 0) return void 0;
+  return { mintPaused, borrowPaused };
+};
 
 // src/lending/public-data/compound-v2/publicCallBuild.ts
 var buildCompoundV2StyleLenderReserveCall = (chainId, lender) => {
@@ -15058,6 +15096,18 @@ var buildCompoundV2StyleLenderReserveCall = (chainId, lender) => {
       name: "liquidationIncentiveMantissa",
       params: []
     });
+    if (usesComptrollerPauseReads(lender)) {
+      for (const name of ["mintGuardianPaused", "borrowGuardianPaused"]) {
+        for (const tk of tokens) {
+          calls.push({
+            abi: ComptrollerAbi,
+            address: stdComptroller,
+            name,
+            params: [tk.cToken]
+          });
+        }
+      }
+    }
   }
   return calls;
 };
@@ -15513,7 +15563,10 @@ function convertSingleEntry(opts) {
   if (perMarketIncentive !== void 0 && Number(perMarketIncentive) > 0) {
     liquidationPenalty = Math.max(
       Number(
-        parseRawAmount(perMarketIncentive.toString(), RESERVE_MANTISSA_DECIMALS)
+        parseRawAmount(
+          perMarketIncentive.toString(),
+          RESERVE_MANTISSA_DECIMALS
+        )
       ) - 1,
       0
     );
@@ -15534,7 +15587,11 @@ function convertSingleEntry(opts) {
   );
   const liquidity = totalSupplyUnderlying - totalDebt;
   const price2 = prices[asset.assetGroup] ?? 0;
-  const pausedActions = currentEntry.pausedActions;
+  const pausedActions = { ...currentEntry.pausedActions };
+  if (opts.pause?.mintPaused !== void 0)
+    pausedActions[0 /* MINT */] = opts.pause.mintPaused;
+  if (opts.pause?.borrowPaused !== void 0)
+    pausedActions[2 /* BORROW */] = opts.pause.borrowPaused;
   const allPaused = pausedActions[0 /* MINT */] && pausedActions[2 /* BORROW */] && pausedActions[1 /* REDEEM */] && pausedActions[3 /* REPAY */];
   const poolId = asset.address;
   const collateralActive = Boolean(currentEntry?.isListed);
@@ -16366,7 +16423,9 @@ var getCompoundV2DataConverter = (lender, chainId, prices, additionalYields, tok
   const isSumer = isSumerType(lender);
   const stdComptroller = isSumer ? void 0 : getCompoundV2Comptroller(chainId, lender);
   const stdComptrollerCalls = stdComptroller ? 2 : 0;
-  const expectedNumberOfCalls = isSumer ? tokenCount + SUMER_GROUP_COUNT : tokenCount + stdComptrollerCalls;
+  const pauseReads = Boolean(stdComptroller) && usesComptrollerPauseReads(lender);
+  const pauseCalls = pauseReads ? tokenCount * 2 : 0;
+  const expectedNumberOfCalls = isSumer ? tokenCount + SUMER_GROUP_COUNT : tokenCount + stdComptrollerCalls + pauseCalls;
   const reader = getReader(lender, chainId);
   return [
     (data) => {
@@ -16403,6 +16462,8 @@ var getCompoundV2DataConverter = (lender, chainId, prices, additionalYields, tok
         globalCloseFactor = closeFactorMantissa;
         globalLiquidationPenalty = incentiveMantissa !== void 0 ? Math.max(incentiveMantissa - 1, 0) : void 0;
       }
+      const mintPausedBase = tokenCount + stdComptrollerCalls;
+      const borrowPausedBase = mintPausedBase + tokenCount;
       for (let i = 0; i < tokenCount; i++) {
         const { underlying, cToken } = compoundV2Tokens2[i];
         if (!cToken || !underlying) continue;
@@ -16419,7 +16480,13 @@ var getCompoundV2DataConverter = (lender, chainId, prices, additionalYields, tok
           additionalYields,
           cToken,
           closeFactor: globalCloseFactor,
-          liquidationPenalty: globalLiquidationPenalty
+          liquidationPenalty: globalLiquidationPenalty,
+          // live guardian read first, then the static fallback published on
+          // the token entry for forks that expose no getter at all
+          pause: pauseReads ? resolveMarketPause(compoundV2Tokens2[i], {
+            mintPaused: parsePausedFlag(data[mintPausedBase + i]),
+            borrowPaused: parsePausedFlag(data[borrowPausedBase + i])
+          }) : void 0
         });
         out.data[entry.marketUid] = entry;
       }
@@ -19386,6 +19453,19 @@ function parseVault(vault, chainId, prices, additionalYields, tokenList, liquidi
     const meta = tokenList[token];
     return toOracleKey(meta?.assetGroup) ?? toGenericPriceKey(token, chainId);
   };
+  const basketRate = (legs) => {
+    let value = 0;
+    let weighted = 0;
+    for (const leg of legs) {
+      const v = leg.amount * (prices[priceKeyFor(leg.token)] ?? 0);
+      if (v <= 0) continue;
+      value += v;
+      weighted += v * leg.rate;
+    }
+    return value > 0 ? weighted / value : legs[0]?.rate ?? 0;
+  };
+  const basketSupplyRate = isSmartCol ? basketRate(colLegs) : void 0;
+  const basketBorrowRate = isSmartDebt ? basketRate(debtLegs) : void 0;
   const irmTotals = (state, decimals) => state ? {
     irmTotalDeposits: Number(parseRawAmount(state.totalSupply, decimals)),
     irmTotalDebt: Number(parseRawAmount(state.totalBorrow, decimals))
@@ -19451,8 +19531,49 @@ function parseVault(vault, chainId, prices, additionalYields, tokenList, liquidi
        * it a smart market is described as an ordinary pool — the generic
        * builder cannot tell them apart.
        */
+      /**
+       * THIS ROW'S ASSET IS NOT INDEPENDENTLY HOLDABLE.
+       *
+       * LENDER-AGNOSTIC ON PURPOSE — it sits on the ROW, not inside `fluid`,
+       * because the shape is not Fluid's alone: Lista SmartLP's collateral
+       * receipt, GMX's GM/GLV baskets and Fluid's smart sides are all market
+       * sides whose position unit is a multi-token basket (the same set
+       * LP_ACTIONS_PLAN.md enumerates). Any of them can set this, and a
+       * consumer branches on it once instead of learning each protocol.
+       *
+       * True means: depositing any leg mints a share of a basket over ALL of
+       * them, and the POOL — not the user — sets and continuously re-sets the
+       * ratio. There is no way to "hold the ETH leg" of a USDC+ETH side; the
+       * split drifts with every trade and with the range shifting around its
+       * centre price.
+       *
+       * Three consequences a consumer must handle: "you deposited X" is false
+       * from the first block; a single leg's rate is right per DOLLAR but is
+       * NOT the position's rate (use the basket rate); and an exit has to be
+       * sized in shares rather than in this token.
+       */
+      ...isSmartVault ? { autoBalanced: true } : {},
       fluid: isSmartVault ? {
         vaultType,
+        /**
+         * The rate of the POSITION, not of this leg.
+         *
+         * A per-leg rate is individually correct — every dollar in the LP
+         * earns the DEX trading yield regardless of which token it sits in,
+         * so `legRate = liquidityRate + tradingRate` is right per dollar.
+         * What it is NOT is the vault's APR: ranking or headlining a single
+         * leg overstates the position whenever the legs differ. On the live
+         * USDC+ETH/USDC+ETH vault the legs read 11.81 % and 8.19 % while
+         * the position earns 10.33 % — and a "best APR" taken as the max
+         * over legs shows 11.81 %.
+         *
+         * Value-weighted by each leg's own share of the side, which is the
+         * pool's composition as this vault holds it. Fluid's own UI
+         * publishes exactly this figure (10.33 % supply / −1.72 % borrow),
+         * and these match it to the basis point.
+         */
+        basketSupplyRate,
+        basketBorrowRate,
         isSmartCol,
         isSmartDebt,
         /** Both legs of the collateral LP, in token0/token1 order. */
@@ -27655,7 +27776,31 @@ var maxRetries = 3;
 var MULTICALL_FAILURE = "0x";
 var isFailedCall = (value) => value === void 0 || value === null || value === MULTICALL_FAILURE;
 var MULTICALL_REPAIR_ROUNDS = 3;
-var MAX_CALLS_PER_SHARD = 400;
+var MAX_CALLS_PER_SHARD = 300;
+var ONE_REQUEST_BATCH_BYTES = 1e6;
+var MAX_INFLIGHT_REQUESTS = 6;
+var HEDGE_DELAY_MS = 1200;
+var SHARD_TIMEOUT_MS = 4e3;
+var MIN_ADAPTIVE_SHARD = 25;
+var ADAPTIVE_CAP_TTL_MS = 6e4;
+var endpointCallCap = /* @__PURE__ */ new Map();
+var capFor = (url, requested) => {
+  const hit = endpointCallCap.get(url);
+  if (!hit) return requested;
+  if (Date.now() - hit.at > ADAPTIVE_CAP_TTL_MS) {
+    endpointCallCap.delete(url);
+    return requested;
+  }
+  return Math.min(requested, hit.calls);
+};
+var noteEndpointRefusal = (url, calls) => {
+  if (calls <= MIN_ADAPTIVE_SHARD) return;
+  const next = Math.max(MIN_ADAPTIVE_SHARD, Math.floor(calls / 2));
+  const current = endpointCallCap.get(url);
+  if (current && Date.now() - current.at <= ADAPTIVE_CAP_TTL_MS && current.calls <= next)
+    return;
+  endpointCallCap.set(url, { calls: next, at: Date.now() });
+};
 var DETERMINISTIC_ERROR_NAMES = /* @__PURE__ */ new Set([
   "ContractFunctionRevertedError",
   "RawContractError",
@@ -27679,13 +27824,13 @@ var REPAIR_BACKOFF_JITTER_MS = 60;
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 var backoffForRound = (round) => REPAIR_BACKOFF_BASE_MS * 2 ** round + Math.random() * REPAIR_BACKOFF_JITTER_MS;
 var endpointUrl = (client, rpcId) => client?.transport?.url ?? `rpc#${rpcId}`;
-var resolveEndpoint = (chainId, getEvmClient17, startRpcId, tried, maxProbe = 12) => {
+var resolveEndpoint = (chainId, getEvmClient17, startRpcId, tried, maxProbe = 12, timeoutMs) => {
   let fallback = null;
   for (let probe = 0; probe < maxProbe; probe++) {
     const rpcId = startRpcId + probe;
     let client;
     try {
-      client = getEvmClient17(chainId, rpcId);
+      client = getEvmClient17(chainId, rpcId, { timeoutMs });
     } catch {
       break;
     }
@@ -27894,39 +28039,30 @@ var multicallShardedAbiArray = async (chainId, abi, calls, getEvmClient17, poolS
     functionName: name,
     args: params
   }));
+  const requestBytes = batchSize < MULTICALL_DEFAULT_BATCH_SIZE ? batchSize : ONE_REQUEST_BATCH_BYTES;
+  const workerBudget = Math.max(1, Math.floor(MAX_INFLIGHT_REQUESTS / 2));
+  const workers = Math.max(1, Math.min(poolSize, workerBudget));
   const shardSize = Math.max(
     1,
-    Math.min(MAX_CALLS_PER_SHARD, Math.ceil(contracts.length / poolSize))
+    Math.min(MAX_CALLS_PER_SHARD, Math.ceil(contracts.length / workers))
   );
   const batches = [];
   for (let i = 0; i < contracts.length; i += shardSize) {
     batches.push({ start: i, items: contracts.slice(i, i + shardSize) });
   }
   const results = new Array(contracts.length);
-  const runBatch = async (batch, rpcId, attemptsLeft, size, tried) => {
-    const endpoint = resolveEndpoint(chainId, getEvmClient17, rpcId, tried);
-    if (!endpoint) {
-      if (logs)
-        console.log(
-          `sharded multicall: no untried endpoint left for chain ${chainId}`
-        );
-      return;
-    }
-    const shardOptions = {
-      tried,
-      onEndpointFailure: options?.onEndpointFailure
-    };
+  const request = async (endpoint, items) => {
     try {
       const returnData = await endpoint.client.multicall({
         allowFailure,
-        batchSize: size,
-        contracts: batch.items
+        batchSize: requestBytes,
+        contracts: items
       });
-      let slots = toSlots(returnData, allowFailure);
-      if (allowFailure && attemptsLeft > 0 && slots.length > 0 && slots.every((s) => isFailedCall(s.value) && !s.permanent)) {
+      const slots = toSlots(returnData, allowFailure);
+      if (allowFailure && slots.length > 0 && slots.every((s) => isFailedCall(s.value) && !s.permanent)) {
         if (logs)
           console.log(
-            `sharded multicall shard fully failed on rpc ${endpoint.rpcId}, failing over`
+            `sharded multicall: rpc ${endpoint.rpcId} answered ${items.length} calls with nothing`
           );
         options?.onEndpointFailure?.({
           chainId,
@@ -27934,61 +28070,165 @@ var multicallShardedAbiArray = async (chainId, abi, calls, getEvmClient17, poolS
           rpcId: endpoint.rpcId,
           kind: "slots"
         });
-        await sleep(backoffForRound(0));
-        return runBatch(
-          batch,
-          endpoint.rpcId + 1,
-          attemptsLeft - 1,
-          size,
-          tried
-        );
-      }
-      if (allowFailure && retryFailed) {
-        slots = await repairFailedSlots(
-          chainId,
-          batch.items,
-          slots,
-          getEvmClient17,
-          endpoint.rpcId + 1,
-          size,
-          logs,
-          MULTICALL_REPAIR_ROUNDS,
-          shardOptions
-        );
-      }
-      recordPermanentFailures(slots, batch.start, permanentFailures);
-      for (let j = 0; j < slots.length; j++) {
-        results[batch.start + j] = slots[j].value;
+        noteEndpointRefusal(endpoint.url, items.length);
+        return null;
       }
+      return slots;
     } catch (error) {
-      if (logs) console.log("error in sharded multicall batch", error);
+      if (logs) console.log("error in sharded multicall request", error);
       options?.onEndpointFailure?.({
         chainId,
         url: endpoint.url,
         rpcId: endpoint.rpcId,
         kind: "transport"
       });
-      if (attemptsLeft <= 0) throw error;
-      await sleep(backoffForRound(0));
-      return runBatch(
-        batch,
-        endpoint.rpcId + 1,
-        attemptsLeft - 1,
-        Math.max(1, Math.floor(size / 2)),
-        tried
+      noteEndpointRefusal(endpoint.url, items.length);
+      return null;
+    }
+  };
+  const firstUsable = (attempts) => new Promise((resolve) => {
+    let pending = attempts.length;
+    let settled = false;
+    const lose = () => {
+      if (!settled && --pending === 0) resolve(null);
+    };
+    for (const attempt of attempts) {
+      attempt.then((won) => {
+        if (settled) return;
+        if (won) {
+          settled = true;
+          resolve(won);
+        } else lose();
+      }, lose);
+    }
+  });
+  const attemptHedged = async (items, startRpcId, tried) => {
+    const primary = resolveEndpoint(
+      chainId,
+      getEvmClient17,
+      startRpcId,
+      tried,
+      12,
+      SHARD_TIMEOUT_MS
+    );
+    if (!primary) {
+      if (logs)
+        console.log(
+          `sharded multicall: no untried endpoint left for chain ${chainId}`
+        );
+      return null;
+    }
+    let timer;
+    let hedgeStarted = false;
+    let beginHedge = () => {
+    };
+    const hedged = new Promise((resolve) => {
+      beginHedge = () => {
+        if (hedgeStarted) return;
+        hedgeStarted = true;
+        clearTimeout(timer);
+        const alt = resolveEndpoint(
+          chainId,
+          getEvmClient17,
+          primary.rpcId + 1,
+          tried,
+          12,
+          SHARD_TIMEOUT_MS
+        );
+        if (!alt) return resolve(null);
+        const altItems = items.slice(0, capFor(alt.url, items.length));
+        if (altItems.length < items.length) return resolve(null);
+        request(alt, items).then(
+          (slots) => resolve(slots ? { slots, rpcId: alt.rpcId } : null)
+        );
+      };
+    });
+    timer = setTimeout(() => beginHedge(), HEDGE_DELAY_MS);
+    const direct = request(primary, items).then((slots) => {
+      if (slots) return { slots, rpcId: primary.rpcId };
+      beginHedge();
+      return null;
+    });
+    const won = await firstUsable([direct, hedged]);
+    clearTimeout(timer);
+    return won;
+  };
+  const runBatch = async (batch, rpcId, attemptsLeft, tried) => {
+    if (!batch.items.length) return;
+    const won = await attemptHedged(batch.items, rpcId, tried);
+    if (!won) {
+      if (attemptsLeft > 0 && batch.items.length > 1) {
+        const half = Math.ceil(batch.items.length / 2);
+        await sleep(backoffForRound(0));
+        await runBatch(
+          { start: batch.start, items: batch.items.slice(0, half) },
+          rpcId,
+          attemptsLeft - 1,
+          tried
+        );
+        await runBatch(
+          { start: batch.start + half, items: batch.items.slice(half) },
+          rpcId + 1,
+          attemptsLeft - 1,
+          tried
+        );
+      }
+      return;
+    }
+    let slots = won.slots;
+    if (allowFailure && retryFailed) {
+      slots = await repairFailedSlots(
+        chainId,
+        batch.items,
+        slots,
+        getEvmClient17,
+        won.rpcId + 1,
+        requestBytes,
+        logs,
+        MULTICALL_REPAIR_ROUNDS,
+        { tried, onEndpointFailure: options?.onEndpointFailure }
       );
     }
+    recordPermanentFailures(slots, batch.start, permanentFailures);
+    for (let j = 0; j < slots.length; j++) {
+      results[batch.start + j] = slots[j].value;
+    }
   };
-  const workers = Math.max(1, Math.min(poolSize, batches.length));
   let cursor = 0;
   const worker = async (workerId) => {
     while (true) {
       const idx = cursor++;
       if (idx >= batches.length) break;
-      await runBatch(batches[idx], workerId, retries, batchSize, /* @__PURE__ */ new Set());
+      const batch = batches[idx];
+      const tried = /* @__PURE__ */ new Set();
+      const start = resolveEndpoint(
+        chainId,
+        getEvmClient17,
+        workerId,
+        void 0,
+        12,
+        SHARD_TIMEOUT_MS
+      );
+      const cap = start ? capFor(start.url, batch.items.length) : batch.items.length;
+      for (let off = 0; off < batch.items.length; off += cap) {
+        await runBatch(
+          {
+            start: batch.start + off,
+            items: batch.items.slice(off, off + cap)
+          },
+          workerId,
+          retries,
+          tried
+        );
+      }
     }
   };
-  await Promise.all(Array.from({ length: workers }, (_3, w) => worker(w)));
+  await Promise.all(
+    Array.from(
+      { length: Math.min(workers, batches.length) },
+      (_3, w) => worker(w)
+    )
+  );
   return results;
 };
 function prepareMulticallInputs(abi, calls) {
@@ -53819,6 +54059,19 @@ var FlashAbi = [
     name: "FLASHLOAN_PREMIUM_TOTAL",
     inputs: []
   },
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -53841,6 +54094,14 @@ var FlashAbi = [
 ];
 var DEFAULT_BATCH_SIZE = 4096;
 var isValidResult = (v) => typeof v === "bigint";
+var NATIVE_DECIMALS = 18;
+function parseDecimalsResult(v) {
+  const n = typeof v === "bigint" ? Number(v) : v;
+  if (typeof n !== "number" || !Number.isInteger(n) || n < 0 || n > 36) {
+    return void 0;
+  }
+  return n;
+}
 var FLASHLOAN_ENABLED_MASK = BigInt(
   "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFFFFFF"
 );
@@ -53906,6 +54167,20 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
   const balancerV3Calls = buildBalanceCalls(balancerV3s);
   const uniswapV4s = RELEVANT_UNISWAP_V4_FORKS[chain] ?? [];
   const uniswapV4Calls = buildBalanceCalls(uniswapV4s);
+  const decimalsByAsset = {
+    [zeroAddress]: NATIVE_DECIMALS
+  };
+  for (const asset of unifiedAssets) {
+    const fromList = list[asset]?.decimals;
+    if (typeof fromList === "number") decimalsByAsset[asset] = fromList;
+  }
+  const assetsMissingDecimals = unifiedAssets.filter(
+    (asset) => decimalsByAsset[asset] === void 0
+  );
+  const decimalsCalls = assetsMissingDecimals.map((address) => ({
+    name: "decimals",
+    address
+  }));
   const calls = [
     ...aaveCalls,
     ...balancerV2Calls,
@@ -53913,6 +54188,8 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
     ...balancerV3Calls,
     ...uniswapV4Calls
   ];
+  const decimalsOffset = calls.length;
+  calls.push(...decimalsCalls);
   const rawResults = await multicallRetry({
     chain,
     calls,
@@ -53922,6 +54199,10 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
     providerId: 0,
     allowFailure: true
   });
+  assetsMissingDecimals.forEach((asset, i) => {
+    const parsed = parseDecimalsResult(rawResults[decimalsOffset + i]);
+    if (parsed !== void 0) decimalsByAsset[asset] = parsed;
+  });
   let liquidity = {};
   let currentOffset = 0;
   aaveProtocols.forEach((aave) => {
@@ -53934,7 +54215,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
       const rawAmount = data[2 * i];
       const config = data[2 * i + 1];
       if (typeof rawAmount !== "bigint" || typeof config !== "bigint") return;
-      const decimals = list[asset]?.decimals;
+      const decimals = decimalsByAsset[asset];
       const enabled = !AAVE_V3_LENDERS.includes(aave) || getFlashLoanEnabled(config);
       if (enabled && rawAmount > 0n && FLASH_LOAN_IDS[aave] !== void 0) {
         if (!liquidity[asset]) liquidity[asset] = [];
@@ -53945,7 +54226,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
           source: getAaveTypePoolAddress(chain, aave),
           fee: fee.toString(),
           availableRaw: rawAmount.toString(),
-          available: Number(formatUnits(rawAmount, decimals ?? 18)),
+          available: decimals === void 0 ? void 0 : Number(formatUnits(rawAmount, decimals)),
           decimals
         });
       }
@@ -53956,7 +54237,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
     const data = rawResults.slice(currentOffset, callLen + currentOffset);
     currentOffset += callLen;
     unifiedAssets.forEach((asset, i) => {
-      const decimals = list[asset]?.decimals;
+      const decimals = decimalsByAsset[asset];
       const rawAmount = data[i];
       if (isValidResult(rawAmount) && rawAmount > 0n) {
         if (!liquidity[asset]) liquidity[asset] = [];
@@ -53967,7 +54248,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
           source: balancer.address,
           fee: "0",
           availableRaw: rawAmount.toString(),
-          available: Number(formatUnits(rawAmount, decimals ?? 18)),
+          available: decimals === void 0 ? void 0 : Number(formatUnits(rawAmount, decimals)),
           decimals
         });
       }
@@ -53981,7 +54262,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
       const rawAmount = data[i];
       if (isValidResult(rawAmount) && rawAmount > 0n) {
         if (!liquidity[asset]) liquidity[asset] = [];
-        const decimals = list[asset]?.decimals;
+        const decimals = decimalsByAsset[asset];
         liquidity[asset].push({
           id: FLASH_LOAN_IDS[morpho.pool],
           name: morpho.pool,
@@ -53989,7 +54270,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
           source: morpho.address,
           fee: "0",
           availableRaw: rawAmount.toString(),
-          available: Number(formatUnits(rawAmount, decimals ?? 18)),
+          available: decimals === void 0 ? void 0 : Number(formatUnits(rawAmount, decimals)),
           decimals
         });
       }
@@ -54000,7 +54281,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
     const data = rawResults.slice(currentOffset, callLen + currentOffset);
     currentOffset += callLen;
     unifiedAssets.forEach((asset, i) => {
-      const decimals = list[asset]?.decimals;
+      const decimals = decimalsByAsset[asset];
       const rawAmount = data[i];
       if (isValidResult(rawAmount) && rawAmount > 0n) {
         if (!liquidity[asset]) liquidity[asset] = [];
@@ -54011,7 +54292,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
           source: balancerV3.address,
           fee: "0",
           availableRaw: rawAmount.toString(),
-          available: Number(formatUnits(rawAmount, decimals ?? 18)),
+          available: decimals === void 0 ? void 0 : Number(formatUnits(rawAmount, decimals)),
           decimals
         });
       }
@@ -54022,7 +54303,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
     const data = rawResults.slice(currentOffset, callLen + currentOffset);
     currentOffset += callLen;
     unifiedAssets.forEach((asset, i) => {
-      const decimals = list[asset]?.decimals;
+      const decimals = decimalsByAsset[asset];
       const rawAmount = data[i];
       if (isValidResult(rawAmount) && rawAmount > 0n) {
         if (!liquidity[asset]) liquidity[asset] = [];
@@ -54033,7 +54314,7 @@ async function fetchFlashLiquidityForChain(chain, multicallRetry, list = {}) {
           source: uniV4.address,
           fee: "0",
           availableRaw: rawAmount.toString(),
-          available: Number(formatUnits(rawAmount, decimals ?? 18)),
+          available: decimals === void 0 ? void 0 : Number(formatUnits(rawAmount, decimals)),
           decimals
         });
       }
@@ -54050,7 +54331,9 @@ function attachPricesToFlashLiquidity(chainId, liq, prices, list = {}) {
     const price2 = prices[priceKey] ?? 0;
     liqCopy[asset] = entry.map((e) => ({
       ...e,
-      availableUSD: e.available * price2
+      // absent when the token amount itself is unknown — never 0, which reads
+      // as "no liquidity" rather than "not priced"
+      availableUSD: e.available === void 0 ? void 0 : e.available * price2
     }));
   });
   return liqCopy;
@@ -65653,9 +65936,8 @@ function borrowDescription(b) {
       b.rate.minApr != null && b.rate.maxApr != null ? `You choose your own rate between ${pct(b.rate.minApr)} and ${pct(b.rate.maxApr)}; a lower rate is cheaper but makes you redeemed first.` : "You choose your own interest rate; a lower rate is cheaper but makes you redeemed first."
     );
   } else {
-    parts.push(
-      `You pay ${pct(b.rate.apr)}${b.rate.isLocked ? ", locked for the term" : ", floating with utilization"}.`
-    );
+    const how = b.rate.isLocked ? ", locked for the term" : b.rate.kind === "variable-curve" ? ", floating with utilization" : b.rate.kind === "variable-managed" ? ", set by the protocol rather than floating with utilization" : "";
+    parts.push(`You pay ${pct(b.rate.apr)}${how}.`);
   }
   parts.push(
     b.debtShape === "static-face" ? "The amount owed is fixed at trade time and does not accrue." : b.debtShape === "prepaid" ? "The debt principal is static; the cost is the prepaid interest token burning down." : "The amount owed grows continuously as interest accrues."
@@ -65674,11 +65956,27 @@ function borrowDescription(b) {
       `It matures on ${shortDate(b.maturity.maturity)}${what ? `; if nothing is done then, ${what}` : ""}.`
     );
   }
+  const withheld = (b.fees ?? []).filter(
+    (f) => f.when === "entry" && f.basis === "principal" && f.unit === "percent" && f.value > 0
+  );
+  if (withheld.length > 0) {
+    const total = withheld.reduce((a, f) => a + f.value, 0);
+    const named = withheld.map((f) => `${f.label.toLowerCase()} ${pct(f.value)}`).join(" + ");
+    parts.push(
+      `${pct(total)} of anything you borrow is withheld at open` + (withheld.length > 1 ? ` (${named})` : "") + `, so you receive ${pct(100 - total)} of what you owe.`
+    );
+  }
   if (b.liquidation.trigger === "time") {
     parts.push(
       "Liquidation here is triggered by TIME, not price \u2014 being late is the trigger, and being over-collateralised does not protect you."
     );
-  } else if (b.liquidation.liquidationLtv != null) {
+  } else if (b.liquidation.model === "auction" && !(b.liquidation.liquidationLtv > 0)) {
+    const pen = b.liquidation.penalty;
+    const win = b.liquidation.windowSecs;
+    parts.push(
+      "Liquidation is a public auction rather than a loan-to-value threshold" + (win ? `, open for ${duration(win)} once started` : "") + (pen != null ? `, and the liquidator is paid ${pct(pen * 100)}` : "") + "."
+    );
+  } else if (b.liquidation.liquidationLtv != null && b.liquidation.liquidationLtv > 0) {
     const pen = b.liquidation.penalty;
     parts.push(
       `Liquidation starts at ${pct(b.liquidation.liquidationLtv * 100)} LTV` + (pen != null ? `, with a ${pct(pen * 100)} penalty` : "") + "."