@1delta/margin-fetcher 5.0.0 → 5.0.1

package/dist/index.d.ts

@@ -8767,7 +8767,16 @@ interface AvailabilityTerms {
     gating: Open<'permissionless' | 'whitelist' | 'attestation' | 'kyc' | 'allowlist-contract'>;
     /** Absent ⇒ no window applies. NOT the same as `closed`. */
     window?: AuctionWindow;
-    /** Raw base units. */
+    /**
+     * Minimum position size to OPEN, in RAW base units of THIS side's asset.
+     *
+     * On the borrow side this is a minimum DEBT (Comet `baseBorrowMin`, Liquity
+     * `minDebt`, Maker-fork `dust`). On the supply/collateral side it is a
+     * minimum COLLATERAL — a genuinely different gate, and the only one some
+     * lenders have: Frankencoin caps nothing on the debt but refuses a position
+     * below `minimumCollateral`, and dropping under it closes the position
+     * permanently.
+     */
     minSize?: string;
     cap?: string;
     /** 0..1 — how full the cap is. */

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, LIQUITY_FAMILY_LENDERS, isAaveType, isCompoundV3, isMultiMarket, isSiloV2Type, isSiloV3Type, isDolomite, isResupply, isFrankencoin, 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, 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, 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, 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';
@@ -61581,6 +61581,32 @@ var TERM_PROFILES = [
       ]
     }
   }),
+  P({
+    id: "frankencoin.challenge@v1",
+    name: "Frankencoin position",
+    family: "frankencoin",
+    borrow: {
+      description: "A per-position CDP minting ZCHF. There is no price oracle: you DECLARE the liquidation price yourself, and anyone may challenge it with a Dutch auction.",
+      implications: [
+        "Liquidation is NOT driven by your health factor. A challenge succeeds when the market price falls below the price YOU declared, regardless of how much you have borrowed \u2014 repaying does not reduce that risk, only re-declaring the price does.",
+        "You owe more than you received: a 10\u201340 % reserve contribution is withheld at mint, plus an upfront fee. The debt is not the amount you got.",
+        "The position EXPIRES on a fixed date; past it the position can be liquidated."
+      ]
+    }
+  }),
+  P({
+    id: "resupply.cdp@v1",
+    name: "Resupply pair",
+    family: "resupply",
+    borrow: {
+      description: "A CDP minting reUSD against a supply position in ANOTHER lending market, held as a staked ERC-4626 share.",
+      implications: [
+        "Redemptions are COMMUNAL: collateral is skimmed pro-rata from every borrower in the pair, so being well-collateralised does not exempt you and there is no rate to raise in defence.",
+        "Your collateral is a lending position elsewhere \u2014 bad debt in that market is bad debt here.",
+        "There is a hard minimum position size: a smaller borrow, or a repay that would leave less than it, reverts."
+      ]
+    }
+  }),
   // ── Vaults ───────────────────────────────────────────────────────────────
   P({
     id: "vault.lending@v1",
@@ -61851,7 +61877,9 @@ function resolveMinDebt(input) {
     // USDD / Maker-fork: `dust` IS the per-vault debt floor.
     m.usdd?.dust,
     // Gearbox credit facade.
-    m.gearbox?.minDebt
+    m.gearbox?.minDebt,
+    // Resupply — a hard per-position floor that also bounds partial repayment.
+    m.resupply?.minimumBorrowAmount
   ];
   for (const c of candidates) {
     if (c == null) continue;
@@ -61862,6 +61890,14 @@ function resolveMinDebt(input) {
   }
   return void 0;
 }
+function resolveMinCollateral(input) {
+  const m = input.market ?? {};
+  const raw = m.frankencoin?.minimumCollateral;
+  if (raw == null) return void 0;
+  const str3 = String(raw);
+  if (str3 === "0" || str3 === "" || !/^\d+$/.test(str3)) return void 0;
+  return str3;
+}
 function capUtil(total, cap) {
   if (!isNum(cap) || cap <= 0 || !isNum(total)) return void 0;
   return clamp01(total / cap);
@@ -61893,7 +61929,7 @@ function buildAvailability(input, side) {
     gating: "permissionless",
     // A borrow below the protocol's floor REVERTS, so gate the CTA on it
     // rather than letting the transaction fail.
-    minSize: side === "borrow" ? resolveMinDebt(input) : void 0,
+    minSize: side === "borrow" ? resolveMinDebt(input) : resolveMinCollateral(input),
     cap: isNum(cap) && cap > 0 ? String(cap) : void 0,
     capUtilization,
     requires: side === "supply" ? ["token-approval"] : void 0
@@ -63060,6 +63096,158 @@ var llamaLendAdapter = {
     };
   }
 };
+var ppmToPercent = (v) => {
+  if (v == null) return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n / 1e4 : void 0;
+};
+var frankencoinAdapter = {
+  id: "frankencoin",
+  matches: isFrankencoin,
+  profileId: () => "frankencoin.challenge@v1",
+  build: (input) => {
+    const fc = input.market?.frankencoin ?? {};
+    const reservePct = ppmToPercent(fc.reserveContributionPPM);
+    const upfrontPct = ppmToPercent(fc.upfrontFeePPM);
+    const challengerPct = ppmToPercent(fc.challengerRewardPPM);
+    const expiration = Number(fc.expiration ?? 0);
+    const challengePeriod = Number(fc.challengePeriod ?? 0);
+    const fees = [
+      reservePct != null && reservePct > 0 ? {
+        id: "reserve-contribution",
+        label: "Equity-reserve contribution",
+        when: "entry",
+        unit: "percent",
+        basis: "principal",
+        value: reservePct,
+        payee: "protocol",
+        description: "Withheld at mint into the FPS equity reserve. You owe the full amount but receive this much less, so the debt is NOT what you got."
+      } : null,
+      upfrontPct != null && upfrontPct > 0 ? {
+        id: "origination",
+        label: "Upfront interest",
+        when: "entry",
+        unit: "percent",
+        basis: "principal",
+        value: upfrontPct,
+        payee: "protocol",
+        description: "Charged once at mint, pro-rated over the time to expiry."
+      } : null
+    ].filter(Boolean);
+    return {
+      // Not a coverage hole: the protocol has no price feed by design.
+      oracle: { kind: "none" },
+      borrow: {
+        debtShape: "accruing",
+        maturity: expiration > 0 ? {
+          kind: "fixed-date",
+          maturity: expiration,
+          maturityIso: new Date(expiration * 1e3).toISOString(),
+          atMaturity: "liquidatable"
+        } : void 0,
+        exit: {
+          // Repaying is not free here: the reserve haircut means the net cost
+          // is `faceDelta − assignedReserve`, and it is resolved at repay time.
+          earlyRepay: "discount",
+          atMaturityCost: "accrued",
+          lateBehaviour: "liquidatable",
+          partialAllowed: true
+        },
+        liquidation: {
+          // A Dutch-auction challenge, not a repay-and-seize.
+          model: "auction",
+          absorber: "liquidator",
+          // Price-triggered, but against the OWNER-DECLARED price — and with
+          // no health gate whatsoever.
+          trigger: "price",
+          seizure: "proportional",
+          permissioned: false,
+          windowSecs: challengePeriod > 0 ? challengePeriod : void 0,
+          penalty: challengerPct != null ? challengerPct / 100 : 0,
+          penalties: challengerPct != null ? [
+            {
+              id: "challenger-reward",
+              label: "Challenger reward",
+              value: challengerPct / 100,
+              description: "Paid to whoever successfully challenges the declared price."
+            }
+          ] : void 0,
+          badDebt: "socialized"
+        },
+        fees,
+        counterparty: { kind: "cdp", solvency: "overcollateralized" }
+      },
+      constraints: {
+        crossMargin: false,
+        // Each position is its own CONTRACT, cloned from an "original".
+        positionModel: "account",
+        positionIdMeaning: "Each position is its own contract, cloned from the market\u2019s original position; you own the clone."
+      }
+    };
+  }
+};
+var e5ToFraction = (v) => {
+  if (v == null) return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n / 1e5 : void 0;
+};
+var resupplyAdapter = {
+  id: "resupply",
+  matches: isResupply,
+  profileId: () => "resupply.cdp@v1",
+  build: (input) => {
+    const rs = input.market?.resupply ?? {};
+    const liquidationFee = e5ToFraction(rs.liquidationFee);
+    const mintFee = e5ToFraction(rs.mintFee);
+    const minBorrow = rs.minimumBorrowAmount != null && String(rs.minimumBorrowAmount) !== "0" ? String(rs.minimumBorrowAmount) : void 0;
+    return {
+      borrow: {
+        debtShape: "accruing",
+        exit: {
+          earlyRepay: "free",
+          atMaturityCost: "accrued",
+          lateBehaviour: "none",
+          partialAllowed: true,
+          // The floor bounds repayment too: a partial repay may not leave the
+          // position under it.
+          minDebt: minBorrow
+        },
+        liquidation: {
+          model: "repay-seize",
+          absorber: "liquidator",
+          trigger: "price",
+          seizure: "proportional",
+          penalty: liquidationFee ?? 0,
+          // Every borrower in the pair is exposed, not just the marginal one.
+          redeemable: true,
+          badDebt: "socialized"
+        },
+        fees: mintFee != null && mintFee > 0 ? [
+          {
+            id: "origination",
+            label: "Mint fee",
+            when: "entry",
+            unit: "percent",
+            basis: "principal",
+            value: mintFee * 100,
+            payee: "protocol"
+          }
+        ] : void 0,
+        availability: minBorrow ? { minSize: minBorrow } : void 0,
+        counterparty: { kind: "cdp", solvency: "overcollateralized" }
+      },
+      supply: {
+        // The collateral is itself a lending position elsewhere.
+        principal: { protected: false, risks: ["bad-debt"] }
+      },
+      constraints: {
+        crossMargin: false,
+        positionModel: "account",
+        positionIdMeaning: "One position per address per pair \u2014 address-keyed, no discovery."
+      }
+    };
+  }
+};
 
 // src/terms/adapters/index.ts
 var TERM_ADAPTERS = [
@@ -63076,7 +63264,9 @@ var TERM_ADAPTERS = [
   compoundV3Adapter,
   fluidAdapter,
   gearboxAdapter,
-  llamaLendAdapter
+  llamaLendAdapter,
+  frankencoinAdapter,
+  resupplyAdapter
 ];
 function resolveAdapter(lender) {
   return TERM_ADAPTERS.find((a) => a.matches(lender));
@@ -63470,11 +63660,15 @@ function validateTermSheet(sheet) {
   if (o) {
     if (o.kind === "none" && o.address)
       fail("oracle-none-address", "oracle.kind none must not carry an address");
-    if (o.kind === "none" && sheet.borrow && sheet.borrow.liquidation.trigger !== "time")
-      fail(
-        "no-oracle-non-time",
-        `oracle.kind none but liquidation.trigger is ${sheet.borrow.liquidation.trigger}`
-      );
+    if (o.kind === "none" && sheet.borrow) {
+      const t = sheet.borrow.liquidation.trigger;
+      const m = sheet.borrow.liquidation.model;
+      if (t !== "time" && t !== "none" && m !== "auction")
+        fail(
+          "no-oracle-non-time",
+          `oracle.kind none but liquidation.trigger is ${t} with model ${m ?? "unset"}`
+        );
+    }
     if (o.address && o.address !== o.address.toLowerCase())
       fail("oracle-lowercase", "oracle.address must be lowercased");
   }