@1delta/data-sdk 0.0.41 → 0.0.43

package/dist/lending/exactly.d.ts

@@ -0,0 +1,53 @@
+/** Per-chain, protocol-level (evergreen) Exactly addresses. */
+export type ExactlyConfigChain = {
+    /** Auditor — cross-margin risk controller (enterMarket / accountLiquidity). */
+    auditor: string;
+    /** Previewer — read-only aggregate view (markets + fixed pools + account). */
+    previewer: string;
+    /** RatePreviewer — read-only rate projection helper (optional). */
+    ratePreviewer?: string | null;
+    /** MarketETHRouter — native-ETH wrapper around the WETH market (optional). */
+    marketETHRouter?: string | null;
+    /** The WETH Market the ETH router wraps (optional convenience). */
+    wethMarket?: string | null;
+    /** Debt-rollover periphery — Optimism `DebtManager` (all three roll
+     *  directions + leverage), Base `DebtRoller` (`rollFixed` ONLY). Same
+     *  field, different deployment name per chain; consumed by the Exactly
+     *  rollover builder. */
+    debtManager?: string | null;
+    /** RewardsController — EXA/OP rewards (optional, not used yet). */
+    rewardsController?: string | null;
+};
+export type ExactlyConfigType = {
+    [chainId: string]: ExactlyConfigChain;
+};
+/** An Exactly Market: one per underlying asset (maturities live inside it). */
+export type ExactlyMarketConfig = {
+    /** Market (ERC4626 vault) address — also the per-market lender-key body. */
+    market: string;
+    /** Underlying asset address. */
+    asset: string;
+    /** Market share-token symbol, e.g. "exaUSDC". */
+    symbol: string;
+    /** Underlying asset symbol, e.g. "USDC". */
+    assetSymbol: string;
+    /** Market share decimals (== asset decimals for Exactly markets). */
+    decimals: number;
+    /** Underlying asset decimals. */
+    assetDecimals: number;
+    /** Number of future fixed pools the market maintains (informational). */
+    maxFuturePools?: number;
+    /** Optional display label, e.g. "Exactly USDC". */
+    name?: string;
+};
+export type ExactlyMarketsType = {
+    [chainId: string]: ExactlyMarketConfig[];
+};
+export declare const exactlyConfig: () => ExactlyConfigType;
+export declare const exactlyMarkets: () => ExactlyMarketsType;
+/** All Exactly market configs on a chain (empty array if none/unloaded). */
+export declare const exactlyMarketsByChain: (chainId: string | number) => ExactlyMarketConfig[];
+/** Look up one Exactly market config by its Market address (case-insensitive). */
+export declare const exactlyMarketByAddress: (chainId: string | number, market: string) => ExactlyMarketConfig | undefined;
+/** Look up one Exactly market config by its underlying asset (case-insensitive). */
+export declare const exactlyMarketByAsset: (chainId: string | number, asset: string) => ExactlyMarketConfig | undefined;

package/dist/lending/fluid.d.ts

@@ -0,0 +1,53 @@
+export type FluidResolvers = {
+    lendingResolver: string;
+    vaultResolver: string;
+    liquidityResolver: string;
+};
+export type FluidResolversType = {
+    [chainId: string]: FluidResolvers;
+};
+/** One asset on a vault side — underlying token and its fToken wrapper (if any). */
+export type FluidVaultAsset = {
+    /** Lowercased underlying ERC20 address. Native ETH is represented by
+     *  `zeroAddress` (`0x0000…0000`) — the Fluid on-chain EEE sentinel is
+     *  normalized away at the parser boundary to match the rest of the
+     *  lending stack's convention. Use `isNativeAddress` in calldata-sdk
+     *  if you need to accept either form. */
+    underlying: string;
+    /** Lowercased fToken address wrapping this underlying, or `null` if none.
+     *  `null` does NOT imply "not borrowable" — borrowability is a separate
+     *  Liquidity/vault-config property. */
+    fToken: string | null;
+};
+/** One side of a Fluid vault — supply or borrow. Uniform shape across all vault
+ *  types: `assets.length === 1` means simple, `> 1` means smart (DEX LP).
+ *  `dex !== null` is equivalent. */
+export type FluidVaultSide = {
+    /** 1 entry for simple sides, 2 entries for smart (DEX LP) sides. Order matches
+     *  the vault's `constantsView().{supply|borrow}Token.{token0,token1}`. */
+    assets: FluidVaultAsset[];
+    /** Fluid DEX pool contract. `null` for simple sides. */
+    dex: string | null;
+    /** Optional SmartLending wrapper over the DEX LP (ERC4626-like). `null` when unused. */
+    smartLending: string | null;
+};
+export type FluidVaultMeta = {
+    vaultId: number;
+    /** Raw `IFluidVault.TYPE()` — Fluid uses scaled constants 10000/20000/30000/40000
+     *  for T1/T2/T3/T4. Prefer `side.dex !== null` for smart-side detection. */
+    type: 10000 | 20000 | 30000 | 40000;
+    supply: FluidVaultSide;
+    borrow: FluidVaultSide;
+};
+/** Keyed by vault contract address (lowercased) for O(1) lookup. */
+export type FluidVaultsType = {
+    [chainId: string]: {
+        [vaultAddress: string]: FluidVaultMeta;
+    };
+};
+export declare const fluidResolvers: () => FluidResolversType;
+export declare const fluidVaults: () => FluidVaultsType;
+/** List of chains where Fluid resolvers are registered. */
+export declare const fluidChains: () => string[];
+/** Vault entries for a chain as `[address, meta]` tuples. */
+export declare const fluidVaultEntries: (chainId: string) => [string, FluidVaultMeta][];

package/dist/lending/frankencoin.d.ts

@@ -0,0 +1,76 @@
+/** Per-chain Frankencoin deployment seed (hand-maintained). */
+export type FrankencoinConfigChain = {
+    /** ZCHF — the only debt asset. */
+    zchf: string;
+    /** MintingHub V2 — clone/challenge entry point. */
+    mintingHub: string;
+    /** Equity (FPS) — first-loss tranche holding the withheld reserve. */
+    equity: string;
+    /** PositionRoller (carries a protocol-native ZCHF flash loan). */
+    roller?: string;
+    /** Leadrate module — the protocol-wide base rate. */
+    leadrate?: string;
+    /** Savings module (the savings vault leg lives in SAVINGS_REGISTRY;
+     *  carried here for completeness). */
+    savings?: string;
+    /** Chainlink-shaped CHF/USD feed — required for USD normalisation. */
+    chfUsdFeed?: string;
+    /** Debt decimals (18). */
+    debtDecimals?: number;
+    /** Legacy MintingHub V1 — dead but deployed; positions carrying this hub
+     *  must never reach the V2 builders. */
+    mintingHubV1?: string;
+};
+export type FrankencoinConfigType = {
+    [lender: string]: {
+        [chainId: string]: FrankencoinConfigChain;
+    };
+};
+/** One Frankencoin market (= one ORIGINAL position). */
+export type FrankencoinMarketConfig = {
+    /** The original position contract — also the per-market key suffix
+     *  (`FRANKENCOIN_<chainId>_<ADDR>`). */
+    position: string;
+    collToken: string;
+    collDecimals: number;
+    collSymbol?: string;
+    /** Owner-declared liquidation price, 36-dec scaled against the
+     *  collateral's decimals. NOT an oracle quote. */
+    price: string;
+    /** ppm — risk premium on top of the hub lead rate. */
+    riskPremiumPPM: string;
+    /** ppm — withheld into the equity reserve at mint (10-40% observed). */
+    reserveContribution: string;
+    /** Minimum collateral for a clone (raw collateral units). */
+    minimumCollateral: string;
+    /** Total ZCHF this original + its clones may mint. */
+    limitForClones?: string;
+    /** Unix seconds — positions EXPIRE (forced sale after). */
+    expiration: string;
+    start?: string;
+    challengePeriod?: string;
+    /** Position version — only 2 is supported; V1 is dead. */
+    version?: number;
+    name?: string;
+};
+/** Generated per-chain data: the curated original-position roster. */
+export type FrankencoinChainData = {
+    markets: FrankencoinMarketConfig[];
+};
+export type FrankencoinMarketsType = {
+    [lender: string]: {
+        [chainId: string]: FrankencoinChainData;
+    };
+};
+export declare const frankencoinConfig: () => FrankencoinConfigType;
+/** Deployment seed for one Frankencoin lender on a chain. */
+export declare const frankencoinConfigFor: (lender: string, chainId: string | number) => FrankencoinConfigChain | undefined;
+export declare const frankencoinMarkets: () => FrankencoinMarketsType;
+/** Generated chain data (curated original-position roster). */
+export declare const frankencoinChainData: (lender: string, chainId: string | number) => FrankencoinChainData | undefined;
+/** Look up one market by its ORIGINAL position address (the key suffix). */
+export declare const frankencoinMarketByPosition: (lender: string, chainId: string | number, position: string) => FrankencoinMarketConfig | undefined;
+/** All Frankencoin lender keys with config on a chain (drives
+ *  getLendersForChain). Gated on the MintingHub, the one address every
+ *  flow needs. */
+export declare const frankencoinLendersByChain: (chainId: string | number) => string[];

package/dist/lending/fraxlend.d.ts

@@ -0,0 +1,85 @@
+/** One curated Fraxlend pair. Everything not listed here (asset, collateral,
+ *  LTV, rates, caps, pause flags) is read from the pair itself — these fields
+ *  exist only to curate and to label. */
+export type FraxlendPairEntry = {
+    /** The `FraxlendPair` contract. Doubles as the market id: the lender key is
+     *  `FRAXLEND_<chainId>_<address>`. */
+    address: string;
+    /** The pair's own `symbol()`, e.g. `ffrxUSD(sfrxETH)-58`. Carried for
+     *  labelling and to make a stale allowlist obvious in a diff — NOT used for
+     *  dispatch. */
+    symbol?: string;
+    /** Human label for the UI, e.g. `frxUSD / sfrxETH`. */
+    label?: string;
+    /** Set false to keep a pair in the roster for READS (existing positions
+     *  stay serviceable, repay/withdraw keep working) while refusing new
+     *  borrows. The Lista lesson: a market in run-off must not vanish, or users
+     *  with open debt lose the UI that closes it. */
+    borrowEnabled?: boolean;
+};
+/** Per-chain, protocol-level Fraxlend addresses. */
+export type FraxlendConfigChain = {
+    /** `FraxlendPairDeployer` — the on-chain pair registry. Carried for
+     *  AUDITING the allowlist against the chain (a generator can diff the two
+     *  and flag new listed pairs). NEVER use it for runtime discovery. */
+    deployer?: string | null;
+    /**
+     * The swapper Frax has whitelisted for native leverage, as of the last
+     * audit. This is a HINT for the generator and for diagnostics — the runtime
+     * MUST still probe `pair.swappers(addr)` per pair, because the mapping is
+     * owner-mutable in both directions and is set per pair, not globally.
+     * Treating this address as "leverage is available" without the probe would
+     * advertise a loop that reverts `BadSwapper()`.
+     */
+    leverageSwapper?: string | null;
+    /** The curated pair roster. Absent or empty ⇒ the provider publishes
+     *  nothing on this chain (fail closed — never fall back to the deployer). */
+    pairs: FraxlendPairEntry[];
+};
+export type FraxlendConfigType = {
+    [lender: string]: {
+        [chainId: string]: FraxlendConfigChain;
+    };
+};
+/**
+ * Built-in Ethereum seed.
+ *
+ * Published `config/fraxlend.json` metadata WINS over this (see
+ * `fraxlendConfigFor`); the seed exists so the provider is live before the
+ * metadata PR lands, which is the Resupply/Curvance precedent.
+ *
+ * Curated 2026-08-11 by profiling all 71 deployer pairs on-chain: every pair
+ * below held more than ~1,000 units of supply, which reproduces exactly the
+ * 13-pair set that frax.com/lend lists. Everything excluded is either a
+ * FraxlendV1 contract, a frozen market, or dust (the next-largest omitted pair
+ * holds ~900 units and the long tail bottoms out at 2).
+ *
+ * Totals at curation: ~$8.4M supplied / ~$5.1M borrowed, and ONE pair
+ * (`0xaB3cb84c…`, frxUSD/sfrxETH) is 62 % of supply and 69 % of borrows.
+ */
+export declare const FRAXLEND_ETHEREUM_CONFIG: FraxlendConfigChain;
+export declare const fraxlendConfig: () => FraxlendConfigType;
+/**
+ * Deployment seed for one Fraxlend lender on a chain. Published metadata wins;
+ * the built-in Ethereum row is the fallback so the provider works before
+ * `config/fraxlend.json` exists.
+ *
+ * Gated on a NON-EMPTY `pairs` array, not merely on the key existing: an
+ * allowlist-driven provider with an empty roster must publish nothing rather
+ * than fall through to on-chain discovery.
+ */
+export declare const fraxlendConfigFor: (lender: string, chainId: string | number) => FraxlendConfigChain | undefined;
+/** All Fraxlend lender keys with a non-empty roster on a chain (drives
+ *  getLendersForChain). Union of published metadata and the built-in row. */
+export declare const fraxlendLendersByChain: (chainId: string | number) => string[];
+/** The curated pair roster for a lender/chain, or `[]`. */
+export declare const fraxlendPairsFor: (lender: string, chainId: string | number) => FraxlendPairEntry[];
+/** Build the per-pair lender key. Lower-cased address so the key is stable
+ *  regardless of how the allowlist was checksummed. */
+export declare const fraxlendPairKey: (chainId: string | number, pair: string) => string;
+/** Inverse of {@link fraxlendPairKey}. Returns undefined for the bare
+ *  `FRAXLEND` dispatch key. */
+export declare const parseFraxlendPairKey: (lender: string) => {
+    chainId: string;
+    pair: string;
+} | undefined;

package/dist/lending/gearbox.d.ts

@@ -0,0 +1,74 @@
+export type GearboxChainResolvers = {
+    /** curator address (lowercased) → curator display name */
+    marketConfigurators: {
+        [addr: string]: string;
+    };
+    /**
+     * BotListV3 contract address for this chain. Used by the lender-permission
+     * fetch to read `botPermissions(bot, creditManager, borrower)`. Sourced
+     * upstream via `AddressProviderV310.getAddressOrRevert("BOT_LIST", 3_10)`.
+     */
+    botList?: string;
+};
+export type GearboxResolversType = {
+    addressProviderV310: string;
+    marketCompressorV310: string;
+    chains: {
+        [chainId: string]: GearboxChainResolvers;
+    };
+};
+export declare const gearboxResolvers: () => GearboxResolversType;
+/** List of chains where Gearbox V3.1 configurators are registered. */
+export declare const gearboxChains: () => string[];
+/** V3.1 deterministic MarketCompressor address (same on every chain). */
+export declare const gearboxMarketCompressor: () => string | undefined;
+/** V3.1 deterministic AddressProvider address (same on every chain). */
+export declare const gearboxAddressProviderV310: () => string | undefined;
+/**
+ * BotListV3 contract address for a chain — used by the lender-permission
+ * fetch to read `botPermissions(bot, creditManager, borrower)`. Read from
+ * the per-chain `gearbox-resolvers.json` entry (`chains[chainId].botList`).
+ * Returns `undefined` when the metadata layer hasn't provided one yet.
+ */
+export declare const gearboxBotListV3: (chainId: string) => string | undefined;
+/**
+ * V3.1 deterministic CreditAccountCompressor address.
+ *
+ * Same CREATE2-derived address on every Gearbox V3.1 chain. Not in the
+ * resolvers JSON yet — hardcoded here until we decide whether to surface
+ * it in `lender-metadata` (the config gains no flexibility; the address
+ * is fixed across chains).
+ */
+export declare const GEARBOX_ACCOUNT_COMPRESSOR_V310 = "0x4115708Fc8fe6bB392De2e0C21c2C81dA2222394";
+export declare const gearboxAccountCompressor: () => string;
+/**
+ * MarketConfigurator address → curator name for a given chain, or
+ * `undefined` if no curator is registered on that chain.
+ *
+ * Configurators are the entry point into `MarketCompressor.getMarkets`
+ * — each one is operated by a known curator (cp0x, Re7, Chaos Labs, …).
+ */
+export declare const gearboxMarketConfigurators: (chainId: string) => {
+    [addr: string]: string;
+} | undefined;
+/**
+ * Synthesize the per-CreditManager lender key for a Gearbox V3 market.
+ *
+ * Mirrors `siloV2LenderKey` / `aaveV4SpokeLenderKey` — each CreditManager
+ * is its own isolated lending venue (positions in CM-A are invisible to
+ * CM-B even when both draw from the same pool), so it gets its own lender
+ * key rather than a config bucket under a shared parent.
+ *
+ * Format: `GEARBOX_V3_${creditManagerAddr.slice(2).toUpperCase()}`
+ *
+ * `isGearboxV3()` works on this because it matches `startsWith('GEARBOX_V3')`.
+ */
+export declare function gearboxV3LenderKey(creditManager: string): string;
+/**
+ * Inverse of `gearboxV3LenderKey`: given a per-CM lender key, return
+ * `{ creditManagerAddrLower }`. Returns `undefined` if the key isn't a
+ * per-CM Gearbox V3 key (e.g. someone passed the bare prefix `GEARBOX_V3`).
+ */
+export declare function parseGearboxV3LenderKey(lenderKey: string): {
+    creditManagerAddrLower: string;
+} | undefined;

package/dist/lending/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Lending data layer — one module per lender family, all re-exported here.
+ *
+ * `registry.ts` owns the global state and the single writer
+ * (`initializeLenderData`); everything else is types + getters for one
+ * protocol family. See the package README for the layout and for how to add a
+ * lender.
+ *
+ * `getGlobalData` is deliberately NOT re-exported: it is the internal handle
+ * the per-lender getters read through, and consumers should use those instead.
+ */
+export { initializeLenderData } from './registry';
+export type { GlobalLenderDataRegistry, LenderDataOverrides } from './registry';
+export * from './common';
+export * from './aave';
+export * from './aaveV4';
+export * from './compoundV2';
+export * from './compoundV3';
+export * from './morpho';
+export * from './euler';
+export * from './silo';
+export * from './fluid';
+export * from './gearbox';
+export * from './dolomite';
+export * from './initProtocol';
+export * from './lista';
+export * from './midnight';
+export * from './term';
+export * from './termMax';
+export * from './exactly';
+export * from './teller';
+export * from './liquity';
+export * from './river';
+export * from './inverse';
+export * from './frankencoin';
+export * from './dss';
+export * from './llamalend';
+export * from './resupply';
+export * from './curvance';
+export * from './fraxlend';

package/dist/lending/initProtocol.d.ts

@@ -0,0 +1,11 @@
+export type InitConfigEntry = {
+    pool: string;
+    underlying: string;
+    modes: number[];
+};
+export type InitConfigType = {
+    [lender: string]: {
+        [chainId: string]: InitConfigEntry[];
+    };
+};
+export declare const initConfig: () => InitConfigType;

package/dist/lending/inverse.d.ts

@@ -0,0 +1,63 @@
+/** Per-chain FiRM deployment seed (hand-maintained). */
+export type InverseConfigChain = {
+    /** DOLA — the only debt asset. */
+    dola: string;
+    /** DBR — the prepaid-interest token (deficit gates borrows AND withdrawals). */
+    dbr: string;
+    /** Pessimistic oracle (2-day-low `viewPrice`). */
+    oracle: string;
+    /** BorrowController v4 (contract-caller allowlist; EOAs bypass). */
+    borrowController: string;
+    /** Debt decimals (18). */
+    debtDecimals?: number;
+    /** Metadata snapshot of the DBR price in DOLA (= fixed borrow APR as a
+     *  decimal) — FALLBACK ONLY when the live API/AMM read fails. */
+    dbrPriceDolaSnapshot?: string;
+};
+export type InverseConfigType = {
+    [lender: string]: {
+        [chainId: string]: InverseConfigChain;
+    };
+};
+/** One FiRM market (= one Market contract, one collateral). */
+export type InverseMarketConfig = {
+    /** Market contract — also the per-market lender-key suffix (`INVERSE_<ADDR>`). */
+    address: string;
+    collToken: string;
+    collDecimals: number;
+    /** Escrow implementation the Market clones per user (CREATE2 predict). */
+    escrowImplementation: string;
+    /** Owner-mutable params, snapshotted each metadata refresh. */
+    collateralFactorBps: string;
+    liquidationIncentiveBps: string;
+    liquidationFactorBps: string;
+    /** Replenisher's cut of a force-replenish (1000 = 10%). Optional: older
+     *  metadata snapshots predate it, and it is bot-side economics — the
+     *  borrower always pays the full `DBR.replenishmentPriceBps`. */
+    replenishmentIncentiveBps?: string;
+    /** Smaller borrows revert (DOLA units, human number as string). */
+    minDebt: string;
+    /** Per-market daily borrow cap (DOLA, human number as string). */
+    dailyLimit: string;
+    borrowPaused?: boolean;
+    name?: string;
+};
+/** Generated per-chain data: the curated Market list. */
+export type InverseChainData = {
+    markets: InverseMarketConfig[];
+};
+export type InverseMarketsType = {
+    [lender: string]: {
+        [chainId: string]: InverseChainData;
+    };
+};
+export declare const inverseConfig: () => InverseConfigType;
+/** Deployment seed for one Inverse lender on a chain (undefined if unloaded). */
+export declare const inverseConfigFor: (lender: string, chainId: string | number) => InverseConfigChain | undefined;
+export declare const inverseMarkets: () => InverseMarketsType;
+/** Generated chain data (curated Market list; undefined if unloaded). */
+export declare const inverseChainData: (lender: string, chainId: string | number) => InverseChainData | undefined;
+/** Find one FiRM market by its Market contract address. */
+export declare const inverseMarketByAddress: (lender: string, chainId: string | number, address: string) => InverseMarketConfig | undefined;
+/** All Inverse lender keys with config on a chain (drives getLendersForChain). */
+export declare const inverseLendersByChain: (chainId: string | number) => string[];

package/dist/lending/liquity.d.ts

@@ -0,0 +1,120 @@
+/** Per-deployment, per-chain shared Liquity-family addresses + deviation params. */
+export type LiquityConfigChain = {
+    /** CollateralRegistry — branch enumeration + redemptions. */
+    collateralRegistry: string;
+    /** The deployment's stable token (BOLD / feUSD / USDaf / USND / USDQ …). */
+    boldToken: string;
+    /** Stable token decimals (18 for every known deployment). */
+    boldDecimals?: number;
+    /** HintHelpers — insert-position hints + upfront-fee predictions. */
+    hintHelpers: string;
+    /** MultiTroveGetter — paginated rate-ordered trove reads. */
+    multiTroveGetter: string;
+    /** WETH-equivalent used for the gas compensation pull on openTrove. */
+    wethToken: string;
+    /** Gas compensation pulled on open, wei (vanilla 0.0375e18; Felix 0; Nerite 1e15). */
+    gasCompensation: string;
+    /** Minimum trove debt in stable units, WAD (vanilla 2000e18; Nerite/Quill 500e18). */
+    minDebt: string;
+    /** Interest-rate bounds, WAD annual (vanilla 0.5%–250%; Quill 6%–350%). */
+    minAnnualInterestRate: string;
+    maxAnnualInterestRate: string;
+    /** Upfront-fee averaging period, seconds (vanilla 7 days). */
+    upfrontInterestPeriodSeconds?: string;
+    /** Premature rate-adjustment cooldown, seconds (vanilla 7 days). */
+    interestRateAdjCooldownSeconds?: string;
+    /** Share of borrow interest routed to SP depositors, WAD (vanilla 0.75e18). */
+    spYieldSplit?: string;
+    /** Fork exposes per-branch debt caps (Nerite getDebtLimit / Felix MaxCapDebt). */
+    hasDebtCaps?: boolean;
+    /** Fork exposes deploy-parameterized constants as TroveManager getters (Quill). */
+    hasForkParamGetters?: boolean;
+    /** Proxied deployment (Felix/Ebisu): constants are admin-mutable → refresh required. */
+    mutableParams?: boolean;
+    /**
+     * Known trove-opening periphery contracts (WETH / GasComp / Leverage
+     * zappers). Troves opened through a zapper have NFT ids salted by the
+     * zapper address AND a transformed owner index — user-data discovery must
+     * probe these in addition to direct opens (the official frontends open
+     * through zappers, so most real troves are zapper-salted).
+     */
+    zappers?: string[];
+    /**
+     * Fork wrapper tokens: collIndex → the user-facing asset the branch
+     * collateral wraps. The generator copies these onto branch records
+     * (`LiquityBranchConfig.collWrapper`).
+     */
+    collWrappers?: {
+        [collIndex: string]: string;
+    };
+    /** Subgraph endpoint for trove discovery enrichment (optional, may be down). */
+    subgraphUrl?: string | null;
+    /** api.liquity.org-style stats endpoint for APY smoothing (optional, may be down). */
+    apiBaseUrl?: string | null;
+};
+export type LiquityConfigType = {
+    [lender: string]: {
+        [chainId: string]: LiquityConfigChain;
+    };
+};
+/** One collateral branch of a Liquity-family deployment (= one market). */
+export type LiquityBranchConfig = {
+    /** CollateralRegistry index — also the per-branch lender-key suffix. */
+    collIndex: number;
+    collToken: string;
+    collDecimals: number;
+    /**
+     * The user-facing asset the branch collateral wraps, when the fork inserts a
+     * wrapper (Felix feUBTC←UBTC, USDaf WBTC18←WBTC / ysyBOLD←yBOLD). Deposit /
+     * withdraw builders add a wrap/unwrap leg when set. Null/absent = no wrapper.
+     */
+    collWrapper?: string | null;
+    addressesRegistry: string;
+    borrowerOperations: string;
+    troveManager: string;
+    troveNFT: string;
+    stabilityPool: string;
+    activePool: string;
+    defaultPool?: string;
+    sortedTroves: string;
+    priceFeed: string;
+    /**
+     * Decimals of `PriceFeed.lastGoodPrice()`. 18 on canonical (18-dec) collateral
+     * and omitted there; forks that list NON-18-dec collateral split into two camps
+     * and only metadata tells them apart — see `liquityCollateralPrice` in
+     * margin-fetcher. Ebisu bakes the scaling into the feed (`36 - collDecimals`);
+     * Enosys keeps the feed at 18 and normalizes collateral inside its CR math.
+     */
+    priceDecimals?: number;
+    gasPool?: string;
+    collSurplusPool?: string;
+    /** Branch risk ratios, WAD (snapshotted; proxied forks can change them). */
+    ccr: string;
+    mcr: string;
+    scr: string;
+    bcr?: string;
+    /** Liquidation penalties, WAD (SP offset / redistribution). */
+    liquidationPenaltySP?: string;
+    liquidationPenaltyRedistribution?: string;
+    /** Branch debt cap in stable units, WAD (only forks with `hasDebtCaps`). */
+    debtCap?: string | null;
+    /** Optional display label, e.g. "Liquity V2 wstETH". */
+    name?: string;
+};
+export type LiquityMarketsType = {
+    [lender: string]: {
+        [chainId: string]: LiquityBranchConfig[];
+    };
+};
+export declare const liquityConfig: () => LiquityConfigType;
+/** Shared config for one Liquity-family deployment on a chain (undefined if unloaded). */
+export declare const liquityConfigFor: (lender: string, chainId: string | number) => LiquityConfigChain | undefined;
+export declare const liquityMarkets: () => LiquityMarketsType;
+/** All branches of one Liquity-family deployment on a chain (empty if none/unloaded). */
+export declare const liquityBranchesByChain: (lender: string, chainId: string | number) => LiquityBranchConfig[];
+/** Look up one branch by its CollateralRegistry index (the per-branch key suffix). */
+export declare const liquityBranchByIndex: (lender: string, chainId: string | number, collIndex: number | string) => LiquityBranchConfig | undefined;
+/** Look up one branch by its TroveManager address (the marketUid address). */
+export declare const liquityBranchByTroveManager: (lender: string, chainId: string | number, troveManager: string) => LiquityBranchConfig | undefined;
+/** All Liquity-family lender keys with config on a chain (drives getLendersForChain). */
+export declare const liquityLendersByChain: (chainId: string | number) => string[];

package/dist/lending/lista.d.ts

@@ -0,0 +1,6 @@
+export type ListaNativeProviderType = {
+    [chainId: string]: {
+        nativeProvider: string;
+    };
+};
+export declare const listaNativeProvider: () => ListaNativeProviderType;