@1delta/margin-fetcher 5.0.4 → 5.0.5

package/README.md

@@ -331,4 +331,4 @@ User positions (`{credit, debt, collateral[128], collateralBitmap}`) are read vi
 
 > **Scope:** the fetcher and direct spot actions (supply collateral / borrow-via-`take` / repay /
 > withdraw) are wired. Composer-routed leverage and native ETH are deferred — see
-> [`calldata-sdk/src/evm/generic/midnight/COMPOSER_PLAN.md`](../calldata-sdk/src/evm/generic/midnight/COMPOSER_PLAN.md).
+> [`calldata-sdk/src/evm/generic/midnight/COMPOSER.md`](../calldata-sdk/src/evm/generic/midnight/COMPOSER.md).

package/dist/index.d.ts

@@ -3332,7 +3332,7 @@ declare function resupplyKeyParts(key: string): {
  * Map one Resupply deployment's on-chain batch into the shared
  * `MorphoGeneralPublicResponse` shape, keyed `RESUPPLY_<chainId>_<PAIR>`.
  *
- * Four modelling decisions worth knowing (all from RESUPPLY_PLAN.md):
+ * Four modelling decisions worth knowing (all from RESUPPLY.md):
  *
  *  - **The collateral we publish is the UNDERLYING (crvUSD / frxUSD), not the
  *    ERC-4626 share.** The share is an internal accounting unit that no token
@@ -3620,7 +3620,7 @@ declare const usddIlkBytes32: (ilk: string) => `0x${string}`;
  * ink total).
  *
  * The roster is EMPTY on both EVM chains today (`cdpi() = 0`, no ilk filed —
- * see USDD_PLAN.md), so this returns zero markets without issuing a
+ * see USDD.md), so this returns zero markets without issuing a
  * multicall. The code path stays live so the day metadata fills, data flows
  * with no code change.
  */
@@ -3744,7 +3744,7 @@ declare function frankencoinKeyParts(key: string): {
  * Map one Frankencoin deployment's on-chain batch into the shared
  * `MorphoGeneralPublicResponse` shape, keyed `FRANKENCOIN_<chainId>_<ORIGINAL>`.
  *
- * Three modelling decisions worth knowing (all from FRANKENCOIN_PLAN.md):
+ * Three modelling decisions worth knowing (all from FRANKENCOIN.md):
  *
  *  - **The liquidation price is owner-DECLARED, not an oracle.** `price` is
  *    36-dec scaled against the collateral's decimals and is policed by a
@@ -8646,6 +8646,22 @@ interface BorrowExitTerms {
     minDebt?: string;
     /** Over-repay REVERTS (Midnight `uint128` underflow) — a real footgun. */
     overRepayReverts?: boolean;
+    /**
+     * Seconds after OPENING (or topping up) during which the debt cannot be
+     * repaid at all.
+     *
+     * The mirror of `SupplyExitTerms.cooldownSecs`, and deliberately a separate
+     * field because it is a categorically worse term: a supply cooldown delays
+     * your money, a REPAY cooldown means a position cannot be closed,
+     * deleveraged or migrated out — and, on the one lender that has it, means an
+     * incoming liquidation cannot be averted by repaying either.
+     *
+     * Only Curvance (`MIN_HOLD_PERIOD`, 1200 s) has one today, which is exactly
+     * why it needs to be stated rather than assumed away: every other lender we
+     * carry lets you exit at any block, and the generic builder's
+     * `availability.canClose: true` encodes that assumption.
+     */
+    cooldownSecs?: number;
     fees: FeeTerm[];
 }
 /** One named penalty, for models where a single number is not enough. */

package/dist/index.js

@@ -1,7 +1,7 @@
 import { parseAbi, keccak256, encodeAbiParameters, formatEther, BaseError, erc20Abi, stringToHex, pad, encodeFunctionData, formatUnits, isAddress, getAddress, decodeFunctionResult, decodeAbiParameters, concat, AbiEncodingLengthMismatchError, concatHex, toBytes, slice, hexToString, InvalidAddressError, boolToHex, integerRegex, numberToHex, bytesRegex, BytesSizeMismatchError, arrayRegex, UnsupportedPackedAbiType } from './chunk-YILYOOYB.js';
 import './chunk-BYTNVMX7.js';
 import './chunk-PR4QN5HX.js';
-import { Lender, isExactly, isMidnight, isTerm, isTermMax, isTeller, isListaDao, isLiquityFamily, isRiver, isInverse, isUsdd, isCompoundV3Type, isFluid, isGearboxV3, isLlamaLend, isFrankencoin, isResupply, LIQUITY_FAMILY_LENDERS, isAaveType, isCompoundV3, isMultiMarket, isSiloV2Type, isSiloV3Type, isDolomite, isCurvance, hasCrossMarginRisk, isEulerType, isAaveV4Type, isInit, isMorphoType, isCompoundV2Type, isVenusType, isSumerType, AAVE_V3_LENDERS, AAVE_V2_LENDERS, isAaveV2Type, isAaveV32Type, isAaveV3Type, isYLDR, isLista, hasSubAccounts, isTectonicType, isKineticType, isBenqiType } from '@1delta/lender-registry';
+import { Lender, isExactly, isMidnight, isTerm, isTermMax, isTeller, isListaDao, isLiquityFamily, isRiver, isInverse, isUsdd, isCompoundV3Type, isFluid, isGearboxV3, isLlamaLend, isFrankencoin, isResupply, isCurvance, LIQUITY_FAMILY_LENDERS, isAaveType, isCompoundV3, isMultiMarket, isSiloV2Type, isSiloV3Type, isDolomite, hasCrossMarginRisk, isEulerType, isAaveV4Type, isInit, isMorphoType, isCompoundV2Type, isVenusType, isSumerType, AAVE_V3_LENDERS, AAVE_V2_LENDERS, isAaveV2Type, isAaveV32Type, isAaveV3Type, isYLDR, isLista, hasSubAccounts, isTectonicType, isKineticType, isBenqiType } from '@1delta/lender-registry';
 export { hasCrossMarginRisk, isAaveType, isAaveV2Type, isAaveV32Type, isAaveV3Type, isCompoundV3, isCompoundV3Type, isInit, isMorphoType, isMultiMarket, isYLDR } from '@1delta/lender-registry';
 import { fetchTokenLists, fetchTokenList, aavePools, compoundV3Pools, initConfig, morphoPools, compoundV2Pools, eulerVaults, siloMarkets, siloV2LenderKey, siloMarketsV3, siloV3LenderKey, aaveV4Spokes, aaveV4SpokeLenderKey, fluidResolvers, gearboxResolvers, dolomiteConfigs, midnightConfig, termConfig, termMarketsByChain, exactlyConfig, liquityLendersByChain, riverLendersByChain, inverseLendersByChain, llamaLendLendersByChain, usddLendersByChain, frankencoinLendersByChain, resupplyLendersByChain, curvanceLendersByChain, tellerConfigByChain, tellerPoolsByChain, termMaxConfigByChain, aaveReserves, compoundV3Reserves, liquityConfigFor, liquityBranchesByChain, riverConfigFor, riverChainData, termMaxApiBaseUrl, termMaxLenderKey, inverseConfigFor, inverseChainData, llamaLendConfigFor, llamaLendChainData, llamaLendApiBaseUrl, resupplyConfigFor, usddConfigFor, usddChainData, frankencoinConfigFor, frankencoinChainData, aaveOracles, morphoTypeMarkets, resolveMidnightApiBase, resolveTermApiBase, llamaLendMarketByVault, getSiloV2MarketEntry, getSiloV3MarketEntry, dolomiteEmode, curvanceConfigFor, aaveTokens, morphoTypeVaults, eulerConfigs, gearboxMarketCompressor, gearboxMarketConfigurators, gearboxV3LenderKey, midnightMarketsByChain, parseAaveV4SpokeLenderKey, gearboxAccountCompressor, compoundV2Tokens, exactlyMarketsByChain, aaveOraclesConfig, compoundV2Oracles, compoundV2TokenArray, compoundV2OraclesConfig, compoundV3OraclesData, compoundV3BaseData, compoundV2Reserves, aaveV4Oracles } from '@1delta/data-sdk';
 import lodash from 'lodash';
@@ -23450,6 +23450,30 @@ async function fetchCurvanceMarkets(lender, chainId) {
   );
   return result;
 }
+async function fetchMinLoanSizes(chainId, marketManagers) {
+  const out = /* @__PURE__ */ new Map();
+  if (marketManagers.length === 0) return out;
+  try {
+    const res = await multicallRetryUniversal({
+      chain: chainId,
+      calls: marketManagers.map((mm) => ({
+        address: mm,
+        name: "MIN_LOAN_SIZE",
+        params: []
+      })),
+      abi: marketManagers.map(() => CurvanceMarketManagerAbi),
+      allowFailure: true
+    });
+    marketManagers.forEach((mm, i) => {
+      const v = res?.[i];
+      if (typeof v === "bigint") out.set(mm.toLowerCase(), v);
+      else if (typeof v === "string" && /^\d+$/.test(v))
+        out.set(mm.toLowerCase(), BigInt(v));
+    });
+  } catch {
+  }
+  return out;
+}
 async function fetchViaReader(lender, chainId, config) {
   const reader = config.protocolReader;
   let staticData = [];
@@ -23540,9 +23564,18 @@ async function fetchViaReader(lender, chainId, config) {
     markets.push({
       marketManager,
       cooldownLength: big2(m?.cooldownLength),
+      // Filled in below — one batched round for every market at once.
+      minLoanSizeUsdWad: 0n,
       tokens
     });
   }
+  const minLoans = await fetchMinLoanSizes(
+    chainId,
+    markets.map((mk) => mk.marketManager)
+  );
+  for (const mk of markets) {
+    mk.minLoanSizeUsdWad = minLoans.get(mk.marketManager.toLowerCase()) ?? 0n;
+  }
   return { lender, config, markets };
 }
 async function fetchViaMulticall(lender, chainId, config) {
@@ -23729,10 +23762,19 @@ async function fetchViaMulticall(lender, chainId, config) {
         // `MIN_HOLD_PERIOD` is a constant on every deployment; hardcoding the
         // known value here beats an extra round-trip in the fallback path.
         cooldownLength: 1200n,
+        minLoanSizeUsdWad: 0n,
         tokens: [token]
       });
   });
-  return { lender, config, markets: [...byManager.values()] };
+  const out = [...byManager.values()];
+  const minLoans = await fetchMinLoanSizes(
+    chainId,
+    out.map((mk) => mk.marketManager)
+  );
+  for (const mk of out) {
+    mk.minLoanSizeUsdWad = minLoans.get(mk.marketManager.toLowerCase()) ?? 0n;
+  }
+  return { lender, config, markets: out };
 }
 function allowlist(config) {
   if (!config.marketAllowlist || config.marketAllowlist.length === 0) {
@@ -24608,6 +24650,13 @@ function convertCurvanceMarketsToResponse(raw, chainId, prices = {}, _additional
            * opened or topped up — gate every exit flow on it.
            */
           holdPeriodSeconds: Number(market.cooldownLength || 1200n),
+          /**
+           * `MIN_LOAN_SIZE` in WAD **USD** — not base units, unlike every
+           * other lender's floor. Gates BOTH ends: opening below it reverts,
+           * and so does a partial repay leaving less (a full repay always
+           * works). `0` means the read failed, NOT that there is no floor.
+           */
+          minLoanSizeUsdWad: market.minLoanSizeUsdWad.toString(),
           /**
            * Native-leverage entry points for this market, or `undefined` when
            * none is registered — which is a REAL state, not a gap: 5 of the 25
@@ -62083,6 +62132,16 @@ var ROW_DESCRIPTOR_KEYS = [
   "exactly",
   "usdd",
   "termmax",
+  // These five were missing, and the failure is SILENT: the adapter still
+  // runs, reads an empty descriptor and returns a sheet that looks complete
+  // while omitting the lender's whole reason for having an adapter. Any lender
+  // with an entry in `TERM_ADAPTERS` that reads `input.market.<key>` belongs
+  // here — the adapter list and this list must not drift apart.
+  "llamalend",
+  "frankencoin",
+  "resupply",
+  "gearbox",
+  "curvance",
   "broker",
   "collateralProvider",
   "loanProvider"
@@ -62705,6 +62764,26 @@ var TERM_PROFILES = [
       ]
     }
   }),
+  P({
+    id: "curvance.dual@v1",
+    name: "Curvance isolated market",
+    family: "curvance",
+    supply: {
+      description: "An isolated two-token market on Monad. Each leg is a cToken; a leg with no debt cap is collateral-only and pays no supply interest \u2014 its return is the underlying asset\u2019s own yield.",
+      implications: [
+        "Posting collateral starts a 20-minute hold during which you cannot redeem or transfer your shares.",
+        "A collateral-only leg pays 0 % \u2014 the yield you earn is whatever the deposited asset earns on its own."
+      ]
+    },
+    borrow: {
+      description: "Borrow the market\u2019s other leg against your collateral, with liquidation running from a soft threshold (partial) to a hard one (full).",
+      implications: [
+        "You cannot repay for 20 MINUTES after opening or topping up \u2014 the position cannot be closed, deleveraged or migrated out in that window, and an incoming liquidation cannot be averted by repaying (adding collateral still works).",
+        "There is a $10 minimum debt, and it gates the exit as well: a partial repay that would leave less than $10 of debt reverts. Closing in full is always allowed.",
+        "Liquidation has TWO thresholds \u2014 the headline penalty is the one at the soft threshold, and it scales up continuously to the hard one."
+      ]
+    }
+  }),
   // ── Vaults ───────────────────────────────────────────────────────────────
   P({
     id: "vault.lending@v1",
@@ -64386,6 +64465,107 @@ var resupplyAdapter = {
     };
   }
 };
+function minLoanInAssetUnits(minLoanUsdWad, priceUsdWad, decimals) {
+  const floor = toBig6(minLoanUsdWad);
+  const price2 = toBig6(priceUsdWad);
+  if (floor == null || price2 == null || floor === 0n || price2 === 0n) {
+    return void 0;
+  }
+  const dec = typeof decimals === "number" ? decimals : Number(decimals);
+  if (!Number.isFinite(dec) || dec < 0 || dec > 36) return void 0;
+  const scaled = floor * 10n ** BigInt(dec);
+  const units = (scaled + price2 - 1n) / price2;
+  return units > 0n ? units.toString() : void 0;
+}
+function toBig6(v) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number" && Number.isFinite(v)) return BigInt(Math.trunc(v));
+  if (typeof v === "string" && /^\d+$/.test(v)) return BigInt(v);
+  return void 0;
+}
+var curvanceAdapter = {
+  id: "curvance",
+  matches: isCurvance,
+  profileId: () => "curvance.dual@v1",
+  build: (input) => {
+    const cv = input.market?.curvance ?? {};
+    const holdSecs = typeof cv.holdPeriodSeconds === "number" && cv.holdPeriodSeconds > 0 ? cv.holdPeriodSeconds : void 0;
+    const tokens = Array.isArray(cv.tokens) ? cv.tokens : [];
+    const debtLeg = tokens.find(
+      (t) => String(t?.underlying ?? "").toLowerCase() === String(input.underlying ?? "").toLowerCase()
+    ) ?? void 0;
+    const minDebt = minLoanInAssetUnits(
+      cv.minLoanSizeUsdWad,
+      debtLeg?.assetPrice,
+      debtLeg?.assetDecimals ?? debtLeg?.decimals
+    );
+    const softPen = numOrUndef(debtLeg?.liquidationPenaltySoft);
+    const hardPen = numOrUndef(debtLeg?.liquidationPenaltyHard);
+    return {
+      constraints: {
+        // One position per address per market; both legs share one health.
+        positionModel: "account",
+        positionIdMeaning: "the borrower address itself \u2014 Curvance keys a position to the account, there is no loan id or NFT",
+        crossMargin: false
+      },
+      borrow: {
+        debtShape: "accruing",
+        availability: {
+          // A borrow below the floor REVERTS, so the CTA must be gated on it.
+          minSize: minDebt
+          // The hold period blocks CLOSING, which the generic builder assumes
+          // is always possible. Stated on the exit side below; `canClose`
+          // stays true because it is per-ACCOUNT and time-bound, not a market
+          // property — a market-level `false` here would read as "nobody can
+          // ever exit", which is wrong and worse.
+        },
+        exit: {
+          partialAllowed: true,
+          minDebt,
+          cooldownSecs: holdSecs
+        },
+        ...softPen != null || hardPen != null ? {
+          liquidation: {
+            // Two thresholds with a continuously scaling penalty and close
+            // factor between them, plus a Fastlane/Atlas auction path that
+            // can set both at runtime.
+            model: "dual-threshold",
+            trigger: "price",
+            penalty: softPen ?? hardPen,
+            penalties: [
+              ...softPen != null ? [
+                {
+                  id: "soft",
+                  label: "Soft threshold (partial)",
+                  value: softPen,
+                  description: "First touch: a PARTIAL liquidation at the close factor, at the lower penalty."
+                }
+              ] : [],
+              ...hardPen != null ? [
+                {
+                  id: "hard",
+                  label: "Hard threshold (full)",
+                  value: hardPen,
+                  description: "Full liquidation at the higher penalty. The penalty scales continuously between the two."
+                }
+              ] : []
+            ]
+          }
+        } : {}
+      },
+      supply: {
+        exit: {
+          // The same 20 minutes blocks redemption and share transfers, not
+          // just repayment.
+          cooldownSecs: holdSecs
+        }
+      }
+    };
+  }
+};
+function numOrUndef(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
 
 // src/terms/adapters/index.ts
 var TERM_ADAPTERS = [
@@ -64404,7 +64584,8 @@ var TERM_ADAPTERS = [
   gearboxAdapter,
   llamaLendAdapter,
   frankencoinAdapter,
-  resupplyAdapter
+  resupplyAdapter,
+  curvanceAdapter
 ];
 function resolveAdapter(lender) {
   return TERM_ADAPTERS.find((a) => a.matches(lender));