@1delta/data-sdk 0.0.41 → 0.0.43

package/dist/lending/llamalend.d.ts

@@ -0,0 +1,208 @@
+/** Per-chain LlamaLend deployment seed (hand-maintained). */
+export type LlamaLendConfigChain = {
+    /** v1 `OneWayLendingFactory` — parallel index getters. Absent on chains
+     *  that only ever got v2. */
+    oneWayFactory?: string;
+    /** v2 `LendFactory` — struct-returning `markets(i)`; `version()` = `2.0.0`. */
+    lendFactory?: string;
+    /** v2 LendConfigurator (admin surface; carried for completeness). */
+    configurator?: string;
+    /**
+     * Curve's deployed v1 LeverageZap for this chain, and the aggregator router
+     * it is hard-wired to. THIS is how leverage works here — we do not deploy a
+     * callbacker.
+     *
+     * The zap's router is an IMMUTABLE with no allowlist, and `callback_bytes`
+     * is forwarded to it verbatim, so arbitrary aggregator calldata is already
+     * permitted. Two are deployed per chain (Odos and 1inch); pick whichever
+     * aggregator is quoting, and ALWAYS check the quote's target against
+     * `*Router` before encoding — the zap forwards mismatched calldata to the
+     * wrong contract rather than rejecting it.
+     */
+    leverageZapOdos?: string;
+    leverageZapOdosRouter?: string;
+    leverageZap1inch?: string;
+    leverageZap1inchRouter?: string;
+    /**
+     * Lowest `factoryIndex` the zaps accept — markets below it were deployed
+     * from a blueprint the zap does not recognise. 9 on Ethereum and Arbitrum,
+     * 0 on Optimism. This is a WIDER gate than delegation: 84.9% of borrows
+     * qualify, including markets that are not delegation-capable, because
+     * leverage is EOA-direct and needs no grant.
+     */
+    leverageStartId?: number;
+    /**
+     * The crvUSD mint (CDP) factory, when the chain's zap indexes it as
+     * `factoryId = 1`. Present on Ethereum only. Recorded because the SAME zap
+     * serves those markets — see LLAMALEND.md.
+     */
+    crvUsdFactory?: string;
+    /** Curve data API base. Overridable so a self-hosted indexer can be
+     *  swapped in; the default serves every chain and both generations from
+     *  one call. */
+    apiBaseUrl?: string | null;
+    /** The chain's slug in the Curve API's `blockchainId` field
+     *  (`ethereum` / `optimism` / `arbitrum` / `fraxtal` / `sonic`). */
+    apiChainSlug?: string;
+};
+export type LlamaLendConfigType = {
+    [lender: string]: {
+        [chainId: string]: LlamaLendConfigChain;
+    };
+};
+/** One LlamaLend market (= one Controller). */
+export type LlamaLendMarketConfig = {
+    /** Controller contract — also the per-market key suffix
+     *  (`LLAMALEND_<CONTROLLER_ADDR>`). */
+    controller: string;
+    /** ERC-4626 vault — the lender side. TRAP: shares run ~1000x the asset
+     *  scale (`DEAD_SHARES`), so never assume 1:1. */
+    vault: string;
+    /** LLAMMA. MUST be excluded from any leverage swap route — the Controller
+     *  asserts the AMM's band state is unchanged across a callback. */
+    amm: string;
+    collateralToken: string;
+    collateralDecimals: number;
+    collateralSymbol?: string;
+    borrowedToken: string;
+    borrowedDecimals: number;
+    borrowedSymbol?: string;
+    monetaryPolicy: string;
+    priceOracle?: string;
+    /** 1 = `oneway` (v1, `*_extended` leverage), 2 = `oneway-v2` (v2, callbacker
+     *  folded into the base functions). Branch every encoder on this. */
+    version: 1 | 2;
+    /**
+     * Whether this Controller carries the boolean delegation grant
+     * (`approve(spender, allow)` + `_for` on the writes).
+     *
+     * PER-MARKET, not per-protocol: only newer-blueprint controllers have it
+     * (48 of 98 markets at 2026-08, and 0 of 22 on Arbitrum). Derived by the
+     * metadata generator from a runtime-bytecode selector scan, because an
+     * `eth_call` probe cannot distinguish "no such method" from a node hiccup
+     * on most public RPCs. FAIL CLOSED — treat `undefined` as `false`.
+     */
+    supportsDelegation: boolean;
+    /** Band-geometry parameter `A` from the AMM. With `loanDiscount` and the
+     *  chosen `N` this fixes the effective collateral factor. */
+    ammA: string;
+    /** WAD haircut used when sizing a loan. */
+    loanDiscount: string;
+    /** WAD hard-liquidation bonus (applies only BELOW the whole band range —
+     *  inside it the position soft-liquidates with no penalty). */
+    liquidationDiscount: string;
+    /**
+     * The market's index in its factory — `controllers(i)`. Doubles as the
+     * `controller_id` the leverage zap's `callback_args` requires, so it is
+     * mandatory for any leveraged encode. The Curve API exposes it as the
+     * numeric suffix of `id` (`oneway-41`).
+     */
+    factoryIndex: number;
+    /**
+     * Whether Curve's v1 leverage zap accepts this market
+     * (`factoryIndex >= leverageStartId`, and v1 only — v2 markets live in a
+     * factory the zap does not index). Independent of `supportsDelegation`.
+     */
+    supportsLeverage: boolean;
+    /** Band count offered by default in the UI (Curve's own default is 10).
+     *  There is no single LTV — the collateral factor is a function of N — so
+     *  public data reports `collateralFactor` at this N and exposes the rest
+     *  of the curve alongside. */
+    defaultBands?: number;
+    /** Monetary-policy family: `semilog` (v1) or `hyperbolic` (v2). The
+     *  `hyperbolic-dynamic` variant pulls its target rate from an external
+     *  rate calculator tracking a yield-bearing asset, so its curve moves
+     *  under a cache — never serve it from stale params. */
+    rateModel?: 'semilog' | 'hyperbolic' | 'hyperbolic-dynamic';
+    /** Gauge (CRV emissions on the vault side), v1 only. */
+    gauge?: string | null;
+    /** v2 only: 0 DISABLES borrowing. A fresh v2 market looks live but is not. */
+    borrowCap?: string;
+    name?: string;
+};
+/** Generated per-chain data: the curated market roster. */
+export type LlamaLendChainData = {
+    markets: LlamaLendMarketConfig[];
+};
+export type LlamaLendMarketsType = {
+    [lender: string]: {
+        [chainId: string]: LlamaLendChainData;
+    };
+};
+export declare const llamaLendConfig: () => LlamaLendConfigType;
+/** Deployment seed for one LlamaLend lender on a chain (undefined if unloaded). */
+export declare const llamaLendConfigFor: (lender: string, chainId: string | number) => LlamaLendConfigChain | undefined;
+export declare const llamaLendMarkets: () => LlamaLendMarketsType;
+/** Generated chain data (curated market roster; undefined if unloaded). */
+export declare const llamaLendChainData: (lender: string, chainId: string | number) => LlamaLendChainData | undefined;
+/** Find one LlamaLend market by its Controller address. */
+export declare const llamaLendMarketByController: (lender: string, chainId: string | number, controller: string) => LlamaLendMarketConfig | undefined;
+/**
+ * Find one LlamaLend market by its ERC-4626 VAULT address (the lender side).
+ *
+ * The roster is keyed on the Controller because that is the borrow surface,
+ * but other protocols reference LlamaLend by its vault — Resupply, for
+ * instance, custodies the vault SHARE as collateral, so the vault is the only
+ * handle it exposes. This is the join for "which LlamaLend market does that
+ * wrapper actually sit on top of".
+ */
+export declare const llamaLendMarketByVault: (lender: string, chainId: string | number, vault: string) => LlamaLendMarketConfig | undefined;
+/**
+ * All LlamaLend lender keys with config on a chain (drives getLendersForChain).
+ * Gated on a factory being present — a chain entry with neither factory is a
+ * placeholder, not a live deployment.
+ */
+export declare const llamaLendLendersByChain: (chainId: string | number) => string[];
+/**
+ * Whether a LlamaLend market accepts on-behalf calls (`_for` + the boolean
+ * `approve` grant). FAILS CLOSED: an unknown market, an unloaded roster or an
+ * explicit `false` all return `false`, because calling `approve` on an older
+ * controller reverts with no usable reason string.
+ */
+export declare const llamaLendSupportsDelegation: (lender: string, chainId: string | number, controller: string) => boolean;
+/**
+ * Resolve the leverage zap + its hard-wired router for a chain and aggregator.
+ * `undefined` means leverage is unavailable there for that aggregator, which
+ * callers must report rather than silently falling back — there is no Composer
+ * route that can be funded.
+ */
+export declare const llamaLendLeverageZap: (lender: string, chainId: string | number, aggregator: "odos" | "1inch") => {
+    zap: string;
+    router: string;
+} | undefined;
+/**
+ * Whether a market can be leveraged at all: it must be v1, at or above the
+ * chain's `leverageStartId`, and the chain must have a zap deployed. Fails
+ * closed on an unknown market.
+ */
+export declare const llamaLendSupportsLeverage: (lender: string, chainId: string | number, controller: string) => boolean;
+/**
+ * Curve data API base. Read through the getter (not a module constant) for the
+ * same reason as TermMax/Midnight: the per-request metadata re-init rewrites
+ * `llamaLendConfig`, so a captured value goes stale.
+ */
+export declare const llamaLendApiBaseUrl: (lender: string, chainId: string | number) => string;
+/**
+ * Per-market lender key for one LlamaLend market, keyed by its CONTROLLER (the
+ * borrow-side contract), not the vault — the Controller is what every write
+ * and every user read targets.
+ *
+ * Format: `LLAMALEND_${controllerAddr.slice(2).toUpperCase()}`
+ *
+ * Both generations share this key space deliberately: they are one brand to the
+ * user, and the Curve API returns them in one list. The `version` field on the
+ * market row is what encoders branch on. chainId is intentionally NOT in the
+ * token (chain scoping happens at the marketUid level), matching every other
+ * per-market key in this package.
+ *
+ * `isLlamaLend()` works on this because it matches `startsWith('LLAMALEND')`.
+ */
+export declare function llamaLendLenderKey(controller: string): string;
+/**
+ * Inverse of `llamaLendLenderKey`: given a per-market lender key, return
+ * `{ controllerAddrLower }`. Returns `undefined` if the key isn't a per-market
+ * LlamaLend key (e.g. someone passed the bare prefix `LLAMALEND`).
+ */
+export declare function parseLlamaLendLenderKey(lenderKey: string): {
+    controllerAddrLower: string;
+} | undefined;

package/dist/lending/midnight.d.ts

@@ -0,0 +1,72 @@
+/** Per-chain Midnight deployment addresses + HTTP API endpoint. */
+export type MidnightConfigChain = {
+    /** Core Midnight contract. */
+    midnight: string;
+    /** MidnightBundlesV1 periphery (spot supply/borrow/repay bundles). */
+    midnightBundles: string;
+    /** On-chain mempool log contract where signed offers are published. */
+    midnightMempool: string;
+    ecrecoverRatifier?: string | null;
+    ecrecoverAuthorizer?: string | null;
+    setterRatifier?: string | null;
+    /** Midnight HTTP API base for book/quote/offer data (defaults to Morpho hosted). */
+    apiBaseUrl?: string | null;
+};
+export type MidnightConfigType = {
+    [chainId: string]: MidnightConfigChain;
+};
+/** One collateral leg of a Midnight market (mirrors on-chain CollateralParams). */
+export type MidnightCollateralParam = {
+    token: string;
+    /** WAD-scaled liquidation LTV (as string). */
+    lltv: string;
+    /** WAD-scaled liquidation cursor (as string). */
+    liquidationCursor: string;
+    oracle: string;
+    decimals: number;
+};
+/** A Midnight market: full struct params needed to build calls + read state. */
+export type MidnightMarketConfig = {
+    /** bytes32 market id (IdLib hash of the Market struct). */
+    marketId: string;
+    loanToken: string;
+    loanDecimals: number;
+    /** Ordered collateral legs; index = the on-chain `collateralIndex`. */
+    collateralParams: MidnightCollateralParam[];
+    /** Maturity, unix seconds (as string). */
+    maturity: string;
+    /** Recovery-close-factor threshold (WAD, as string). */
+    rcfThreshold: string;
+    enterGate: string;
+    liquidatorGate: string;
+    /**
+     * Mutable per-market settlement fees, one per TTM breakpoint index
+     * [0d,1d,7d,30d,90d,180d,360d], in cbp (centi-basis-points; fraction =
+     * cbp·1e-6). Governance-settable (`feeSetter`), so it is NOT part of the
+     * immutable market id and is snapshotted on-chain each metadata refresh.
+     * Absent when the on-chain read was unavailable.
+     */
+    settlementFeeCbp?: number[];
+    /**
+     * Mutable per-market continuous fee (uint32), a per-second WAD rate borne by
+     * lenders (annual fraction = continuousFee·secondsPerYear/1e18, capped 1%/yr).
+     * Governance-settable; snapshotted on-chain like `settlementFeeCbp`. Stored
+     * as a decimal string. Absent when the on-chain read was unavailable.
+     */
+    continuousFee?: string;
+    /** Optional display label, e.g. "USDC / WETH — 2026-09-18". */
+    name?: string;
+};
+export type MidnightMarketsType = {
+    [chainId: string]: MidnightMarketConfig[];
+};
+export declare const midnightConfig: () => MidnightConfigType;
+export declare const setMidnightApiBase: (url: string | undefined | null) => void;
+export declare const midnightApiBaseOverride: () => string | undefined;
+/** Resolve the Midnight API base for a chain: override → config → hosted default. */
+export declare const resolveMidnightApiBase: (chainId: string) => string;
+export declare const midnightMarkets: () => MidnightMarketsType;
+/** All Midnight market configs on a chain (empty array if none/unloaded). */
+export declare const midnightMarketsByChain: (chainId: string | number) => MidnightMarketConfig[];
+/** Look up one Midnight market config by its bytes32 id (case-insensitive). */
+export declare const midnightMarketById: (chainId: string | number, marketId: string) => MidnightMarketConfig | undefined;

package/dist/lending/morpho.d.ts

@@ -0,0 +1,72 @@
+export type MorphoPoolsType = {
+    [fork: string]: {
+        [chainId: string]: string;
+    };
+};
+export type MorphoBundler3ChainConfig = {
+    bundler3: string;
+    generalAdapter1: string;
+    paraswapAdapter?: string | null;
+    erc20WrapperAdapter?: string | null;
+    compoundV2MigrationAdapter?: string | null;
+    compoundV3MigrationAdapter?: string | null;
+    aaveV2MigrationAdapter?: string | null;
+    aaveV3CoreMigrationAdapter?: string | null;
+    aaveV3PrimeMigrationAdapter?: string | null;
+    aaveV3EtherFiMigrationAdapter?: string | null;
+    aaveV3OptimizerMigrationAdapter?: string | null;
+};
+export type MorphoBundler3Type = {
+    [chainId: string]: MorphoBundler3ChainConfig;
+};
+/** NB: the `Mropho` spelling is a long-standing typo kept for compatibility. */
+export interface MrophoOracleInfo {
+    oracle: string;
+    loanAsset: string;
+    collateralAsset: string;
+    loanAssetDecimals: number;
+    collateralAssetDecimals: number;
+}
+export type MorphoOracles = {
+    [c: string]: MrophoOracleInfo[];
+};
+export type MorphoTypeOracles = {
+    [chainId: string]: {
+        [protocol: string]: MrophoOracleInfo[];
+    };
+};
+export type MorphoTypeMarkets = {
+    [protocol: string]: {
+        [chainId: string]: string[];
+    };
+};
+/**
+ * Static MetaMorpho-shaped vault registry, keyed by curator-protocol then chain.
+ * Sourced from `data/morpho-type-vaults.json` in `lender-metadata`. Used by the
+ * on-chain `fetchMorphoVaultsFromChain` path for forks / chains where the
+ * Morpho public API or Goldsky subgraph isn't available.
+ */
+export type MorphoTypeVaultEntry = {
+    /** Lowercased vault (share-token) contract address. */
+    vault: string;
+    /** Lowercased underlying ERC20 address. */
+    underlying: string;
+    /** Curated display name (e.g. `Lista USD1 Vault`). Optional. */
+    name?: string;
+    /** Vault interface version. `v1` = MetaMorpho (withdraw-queue → markets);
+     *  `v2` = Vaults V2 (adapter-based). Drives the on-chain fetcher's
+     *  allocation walk. Absent ⇒ the fetcher auto-detects on-chain
+     *  (`adaptersLength()` present ⇒ v2). */
+    version?: 'v1' | 'v2';
+};
+export type MorphoTypeVaultsType = {
+    [protocol: string]: {
+        [chainId: string]: MorphoTypeVaultEntry[];
+    };
+};
+export declare const morphoPools: () => MorphoPoolsType;
+export declare const morphoOracles: () => MorphoOracles;
+export declare const morphoTypeOracles: () => MorphoTypeOracles;
+export declare const morphoTypeMarkets: () => MorphoTypeMarkets;
+export declare const morphoTypeVaults: () => MorphoTypeVaultsType;
+export declare const morphoBundler3: () => MorphoBundler3Type;

package/dist/lending/registry.d.ts

@@ -0,0 +1,140 @@
+/**
+ * The global lender-data registry — the one piece of mutable state in this
+ * package.
+ *
+ * Every getter in `src/lending/*` reads through `getGlobalData()`, and
+ * `initializeLenderData` is the only writer. State lives on `globalThis` (not a
+ * module-level `let`) so that several copies of the package — a worker bundling
+ * its own instance, a transitive dependency pulling a second one — still share
+ * one registry.
+ *
+ * IMPORTANT: this module must have **no runtime imports**. Every per-lender
+ * module imports `getGlobalData` from here, so a value import in the other
+ * direction would create a cycle. The type imports below are `import type` and
+ * are erased at compile time.
+ *
+ * ADDING A LENDER: create `src/lending/<lender>.ts` (types + getters), then
+ * touch this file twice — one line in `GlobalLenderDataRegistry` and one line
+ * in `LENDER_DATA_DEFAULTS`. Nothing else: the `initializeLenderData` parameter
+ * type and its assignment loop are both derived from those two.
+ */
+import type { AaveOraclesConfigType, AavePoolsType, AaveTokensType, AaveWethGatewayType } from './aave';
+import type { AaveV4OraclesType, AaveV4PeripheralsType, AaveV4SpokesType } from './aaveV4';
+import type { GeneralReservesMap, OracleMap } from './common';
+import type { CompoundV2OraclesConfigType, CompoundV2PoolsType, CompoundV2TokenArrayType, CompoundV2TokensType } from './compoundV2';
+import type { CompoundV3BaseDataType, CompoundV3BulkerType, CompoundV3OracleDataMap, CompoundV3PoolsType } from './compoundV3';
+import type { CurvanceConfigType } from './curvance';
+import type { DolomiteConfigsType, DolomiteEmodeType } from './dolomite';
+import type { UsddConfigType, UsddMarketsType } from './dss';
+import type { EulerConfigsType, EulerVaultsType } from './euler';
+import type { ExactlyConfigType, ExactlyMarketsType } from './exactly';
+import type { FluidResolversType, FluidVaultsType } from './fluid';
+import type { FrankencoinConfigType, FrankencoinMarketsType } from './frankencoin';
+import type { GearboxResolversType } from './gearbox';
+import type { InitConfigType } from './initProtocol';
+import type { InverseConfigType, InverseMarketsType } from './inverse';
+import type { ListaNativeProviderType } from './lista';
+import type { LiquityConfigType, LiquityMarketsType } from './liquity';
+import type { LlamaLendConfigType, LlamaLendMarketsType } from './llamalend';
+import type { MidnightConfigType, MidnightMarketsType } from './midnight';
+import type { MorphoBundler3Type, MorphoOracles, MorphoPoolsType, MorphoTypeMarkets, MorphoTypeOracles, MorphoTypeVaultsType } from './morpho';
+import type { FraxlendConfigType } from './fraxlend';
+import type { ResupplyConfigType } from './resupply';
+import type { RiverConfigType, RiverMarketsType } from './river';
+import type { SiloMarketsType, SiloPeripheralsType } from './silo';
+import type { TellerConfigType, TellerPoolsType } from './teller';
+import type { TermConfigType, TermMarketsType } from './term';
+import type { TermMaxConfigType } from './termMax';
+/**
+ * Every data slot the registry holds, one group per lender family. A slot name
+ * is the getter name (`aaveTokens()` reads `aaveTokens`) and, suffixed with
+ * `Override`, the `initializeLenderData` argument that writes it.
+ */
+export interface GlobalLenderDataRegistry {
+    aaveTokens: AaveTokensType;
+    aavePools: AavePoolsType;
+    aaveReserves: GeneralReservesMap;
+    aaveOracles: OracleMap;
+    aaveOraclesConfig: AaveOraclesConfigType;
+    aaveWethGateway: AaveWethGatewayType;
+    aaveV4Spokes: AaveV4SpokesType;
+    aaveV4Oracles: AaveV4OraclesType;
+    aaveV4Peripherals: AaveV4PeripheralsType;
+    compoundV2Pools: CompoundV2PoolsType;
+    compoundV2Tokens: CompoundV2TokensType;
+    compoundV2TokenArray: CompoundV2TokenArrayType;
+    compoundV2Reserves: GeneralReservesMap;
+    compoundV2Oracles: OracleMap;
+    compoundV2OraclesConfig: CompoundV2OraclesConfigType;
+    compoundV3Pools: CompoundV3PoolsType;
+    compoundV3BaseData: CompoundV3BaseDataType;
+    compoundV3Reserves: GeneralReservesMap;
+    compoundV3OraclesData: CompoundV3OracleDataMap;
+    compoundV3Bulker: CompoundV3BulkerType;
+    morphoPools: MorphoPoolsType;
+    morphoOracles: MorphoOracles;
+    morphoTypeOracles: MorphoTypeOracles;
+    morphoTypeMarkets: MorphoTypeMarkets;
+    morphoTypeVaults: MorphoTypeVaultsType;
+    morphoBundler3: MorphoBundler3Type;
+    initConfig: InitConfigType;
+    listaNativeProvider: ListaNativeProviderType;
+    midnightConfig: MidnightConfigType;
+    midnightMarkets: MidnightMarketsType;
+    termConfig: TermConfigType;
+    termMarkets: TermMarketsType;
+    termMaxConfig: TermMaxConfigType;
+    exactlyConfig: ExactlyConfigType;
+    exactlyMarkets: ExactlyMarketsType;
+    tellerConfig: TellerConfigType;
+    tellerPools: TellerPoolsType;
+    liquityConfig: LiquityConfigType;
+    liquityMarkets: LiquityMarketsType;
+    riverConfig: RiverConfigType;
+    riverMarkets: RiverMarketsType;
+    inverseConfig: InverseConfigType;
+    inverseMarkets: InverseMarketsType;
+    usddConfig: UsddConfigType;
+    usddMarkets: UsddMarketsType;
+    skyConfig: UsddConfigType;
+    skyMarkets: UsddMarketsType;
+    frankencoinConfig: FrankencoinConfigType;
+    frankencoinMarkets: FrankencoinMarketsType;
+    llamaLendConfig: LlamaLendConfigType;
+    llamaLendMarkets: LlamaLendMarketsType;
+    resupplyConfig: ResupplyConfigType;
+    curvanceConfig: CurvanceConfigType;
+    fraxlendConfig: FraxlendConfigType;
+    eulerConfigs: EulerConfigsType;
+    eulerVaults: EulerVaultsType;
+    dolomiteConfigs: DolomiteConfigsType;
+    dolomiteEmode: DolomiteEmodeType;
+    siloMarkets: SiloMarketsType;
+    siloPeripherals: SiloPeripheralsType;
+    siloMarketsV3: SiloMarketsType;
+    siloPeripheralsV3: SiloPeripheralsType;
+    fluidResolvers: FluidResolversType;
+    fluidVaults: FluidVaultsType;
+    gearboxResolvers: GearboxResolversType;
+}
+/**
+ * Read the registry. Internal to `src/lending` — consumers use the per-lender
+ * getters, which is where the shape is documented.
+ */
+export declare function getGlobalData(): GlobalLenderDataRegistry;
+/**
+ * Arguments of {@link initializeLenderData}: one optional `<slot>Override` per
+ * registry slot, derived from `GlobalLenderDataRegistry` so a new slot cannot
+ * be forgotten here.
+ */
+export type LenderDataOverrides = {
+    [K in keyof GlobalLenderDataRegistry as `${K}Override`]?: GlobalLenderDataRegistry[K];
+};
+/**
+ * Override datas used in the SDK - works across all module instances.
+ *
+ * Each override REPLACES its slot wholesale (no merging); falsy/omitted
+ * overrides leave the current value untouched, so partial re-initialization is
+ * safe. `@1delta/initializer-sdk` is the usual caller.
+ */
+export declare function initializeLenderData(overrides: LenderDataOverrides): void;

package/dist/lending/resupply.d.ts

@@ -0,0 +1,77 @@
+/** Per-chain, protocol-level (evergreen) Resupply addresses. */
+export type ResupplyConfigChain = {
+    /** ResupplyRegistry — `getAllPairAddresses()` IS the market discovery, and
+     *  `getAddress(key)` resolves every other singleton. */
+    registry: string;
+    /** reUSD — the only debt asset. */
+    reusd: string;
+    /** Utilities lens — `getPairInterestRate`, `getUnderlyingSupplyRate`,
+     *  `getSwapRouteAmountOut`, `isSolventAfterLeverage`. Optional, but every
+     *  rate and every leverage pre-flight is far cheaper with it. */
+    utilities?: string | null;
+    /** The built-in Curve `Swapper` — every leg for every pair is already
+     *  registered on it, so a leverage route needs no aggregator at all. This
+     *  is THE DEFAULT leverage swapper. */
+    curveSwapper?: string | null;
+    /** `RouterSwapper` wrapping the Enso router. Whitelisted on every pair, and
+     *  it executes ARBITRARY router calldata packed into the `address[] path` —
+     *  which is what makes aggregator-quoted looping possible at all. */
+    ensoSwapper?: string | null;
+    /** Same, wrapping the LI.FI Diamond. No LI.FI fetcher on our side yet. */
+    lifiSwapper?: string | null;
+    /** RedemptionHandler — the (communal) peg mechanism. Read-only for us. */
+    redemptionHandler?: string | null;
+    /** LiquidationHandler — liquidations are insurance-pool-funded, whole-position. */
+    liquidationHandler?: string | null;
+    /** InsurancePool — reUSD staked as first-loss capital. */
+    insurancePool?: string | null;
+    /** sreUSD — the savings leg (belongs to SAVINGS_REGISTRY; carried here for
+     *  completeness so one config row describes the whole protocol). */
+    sreusd?: string | null;
+    /** PriceWatcher — supplies the off-peg weight the borrow rate is scaled by. */
+    priceWatcher?: string | null;
+    /** reUSD USD price feed (`PriceWatcher.oracle()`); its `price()` is 18-dec USD. */
+    reusdOracle?: string | null;
+    /** reUSD decimals (18). */
+    debtDecimals?: number;
+    /** Optional allowlist of pair addresses. When set, on-chain discovery is
+     *  INTERSECTED with it; when absent (the default) every registered pair
+     *  with a non-zero `borrowLimit` is published. */
+    pairAllowlist?: string[] | null;
+};
+export type ResupplyConfigType = {
+    [lender: string]: {
+        [chainId: string]: ResupplyConfigChain;
+    };
+};
+/**
+ * Built-in Ethereum deployment seed for Resupply.
+ *
+ * Every other lender's config comes exclusively from `lender-metadata`, and a
+ * published `config/resupply.json` still WINS over this (see
+ * `resupplyConfigFor`). The fallback exists because these are immutable
+ * protocol singletons — `RouterSwapper` even hardcodes the registry address in
+ * its own bytecode — and because the whole market roster is discovered from
+ * `registry` at runtime. So the integration is live with nothing to publish,
+ * and publishing later is a pure override.
+ *
+ * Verified on-chain 2026-08-04 (block ~25,683,400). Deliberately NOT taken
+ * from the docs' `faq/contract-addresses` page or the repo's
+ * `deployment/contracts.json`: both are stale and list a REVOKED Odos swapper.
+ * Resolved via `Registry.getAddress(key)` over `getAllKeys()`.
+ */
+export declare const RESUPPLY_ETHEREUM_CONFIG: ResupplyConfigChain;
+export declare const resupplyConfig: () => ResupplyConfigType;
+/**
+ * Deployment seed for one Resupply lender on a chain. Published metadata wins;
+ * the built-in Ethereum row is the fallback so the provider works before
+ * `config/resupply.json` exists.
+ */
+export declare const resupplyConfigFor: (lender: string, chainId: string | number) => ResupplyConfigChain | undefined;
+/**
+ * All Resupply lender keys with config on a chain (drives getLendersForChain).
+ * Gated on the REGISTRY — the one address the whole provider is bootstrapped
+ * from. Union of published metadata and the built-in row, so the fan-out
+ * happens with or without a publish.
+ */
+export declare const resupplyLendersByChain: (chainId: string | number) => string[];

package/dist/lending/river.d.ts

@@ -0,0 +1,61 @@
+/** Per-chain River deployment seed (hand-maintained). */
+export type RiverConfigChain = {
+    /** SatoshiXApp — the EIP-2535 diamond ALL ops are called on. */
+    xapp: string;
+    /** The debt token (satUSD — a LayerZero OFT; address differs per chain). */
+    debtToken: string;
+    /** Debt token decimals (18 on every known deployment). */
+    debtDecimals?: number;
+    /** SatoshiPeriphery proxy (native wrap + OFT-send legs; optional, skippable). */
+    periphery?: string | null;
+};
+export type RiverConfigType = {
+    [lender: string]: {
+        [chainId: string]: RiverConfigChain;
+    };
+};
+/** One River market (= one TroveManager beacon proxy, one collateral). */
+export type RiverMarketConfig = {
+    /** Factory index — also the per-market lender-key suffix (`RIVER_<index>`). */
+    index: number;
+    troveManager: string;
+    sortedTroves?: string;
+    collToken: string;
+    collDecimals: number;
+    /** WAD strings, snapshotted on-chain each refresh (owner-mutable params). */
+    mcr: string;
+    /** Protocol-set interest rate (raw; currently 0 everywhere). */
+    interestRate?: string;
+    /** Decaying-baseRate mint-fee bounds, WAD (floor 0.5%, cap 5% typical). */
+    borrowingFeeFloor?: string;
+    maxBorrowingFee?: string;
+    /** Per-market debt ceiling in debt-token units (owner-settable). */
+    maxSystemDebt?: string;
+    /** Debt-side gas compensation (2 satUSD typical) — minted on open, burned on close. */
+    debtGasCompensation?: string;
+    paused?: boolean;
+    sunsetting?: boolean;
+    /** Optional display label, e.g. "satUSD / WETH". */
+    name?: string;
+};
+/** Generated per-chain data: diamond-level params + the TroveManager list. */
+export type RiverChainData = {
+    /** Diamond-level minimum net debt (owner-settable — refreshed each run). */
+    minNetDebt: string;
+    markets: RiverMarketConfig[];
+};
+export type RiverMarketsType = {
+    [lender: string]: {
+        [chainId: string]: RiverChainData;
+    };
+};
+export declare const riverConfig: () => RiverConfigType;
+/** Deployment seed for one River lender on a chain (undefined if unloaded). */
+export declare const riverConfigFor: (lender: string, chainId: string | number) => RiverConfigChain | undefined;
+export declare const riverMarkets: () => RiverMarketsType;
+/** Generated chain data (minNetDebt + TroveManager list; undefined if unloaded). */
+export declare const riverChainData: (lender: string, chainId: string | number) => RiverChainData | undefined;
+/** Look up one River market by its factory index (the per-market key suffix). */
+export declare const riverMarketByIndex: (lender: string, chainId: string | number, index: number | string) => RiverMarketConfig | undefined;
+/** All River lender keys with config on a chain (drives getLendersForChain). */
+export declare const riverLendersByChain: (chainId: string | number) => string[];