@1delta/data-sdk 0.0.41 → 0.0.43

package/dist/lending/silo.d.ts

@@ -0,0 +1,129 @@
+export type SiloHalfStatic = {
+    /** silo (vault) address */
+    silo: string;
+    /** underlying borrowable asset for this side */
+    token: string;
+    /** ERC-20 decimals for `token`, cached to avoid an extra RPC */
+    decimals: number;
+    /** Optional symbol cache for UI; not consumed by the fetcher */
+    symbol?: string;
+    /** Share-token addresses (for user-data fetchers / liquidations) */
+    protectedShareToken: string;
+    collateralShareToken: string;
+    debtShareToken: string;
+    /** Per-side oracles (1e18-scaled price quoting) */
+    solvencyOracle: string;
+    maxLtvOracle: string;
+    /** Interest rate model contract */
+    interestRateModel: string;
+    /** LTV at 1e18 scale */
+    maxLtv: string;
+    /** Liquidation threshold (LLTV) at 1e18 scale */
+    lt: string;
+    /** Target LTV after liquidation (1e18) */
+    liquidationTargetLtv: string;
+    /** Fee parameters (1e18) */
+    liquidationFee: string;
+    flashloanFee: string;
+    daoFee: string;
+    deployerFee: string;
+    /** Optional hook receiver / quote-before flag */
+    hookReceiver?: string;
+    callBeforeQuote?: boolean;
+};
+export type SiloMarketEntry = {
+    /** Shared SiloConfig address (one per pair) */
+    siloConfig: string;
+    /** Optional human-readable name from the factory event / curated list */
+    name?: string;
+    silo0: SiloHalfStatic;
+    silo1: SiloHalfStatic;
+};
+/**
+ * chainId → list of (silo0, silo1) pairs.
+ *
+ * Stored as an array to match the on-disk `silo-v2-markets.json` shape.
+ * Per-chain pair counts are small (~100 max), so the linear lookup in
+ * `getSiloV2MarketEntry` is fine. If that ever changes, build an index
+ * lazily here.
+ */
+export type SiloMarketsType = {
+    [chainId: string]: SiloMarketEntry[];
+};
+/**
+ * Per-chain Silo v2 peripheral / singleton addresses.
+ *
+ * Both `lens` and `factory` are deployed once per chain and shared by every
+ * Silo v2 market on that chain, so they live together in one map instead of
+ * being split across `siloLens` / `siloFactory`. Add new chain-wide
+ * singletons (e.g. `siloRouter`, `siloIncentivesController`) here.
+ */
+export type SiloPeripheralsEntry = {
+    /** SiloLens (v2) — exposes getDepositAPR / getBorrowAPR / getUtilization */
+    lens: string;
+    /** SiloFactory — used by the initializer to discover deployed silo pairs */
+    factory: string;
+    /** Optional: router / wrapped-native gateway, populated when needed */
+    router?: string;
+    /** Optional: incentives controller for reward APR */
+    incentivesController?: string;
+};
+/** chainId → Silo v2 peripheral addresses */
+export type SiloPeripheralsType = {
+    [chainId: string]: SiloPeripheralsEntry;
+};
+export declare const siloMarkets: () => SiloMarketsType;
+export declare const siloPeripherals: () => SiloPeripheralsType;
+export declare const siloMarketsV3: () => SiloMarketsType;
+export declare const siloPeripheralsV3: () => SiloPeripheralsType;
+/**
+ * Synthesize the per-pair lender key for a Silo v2 market.
+ *
+ * Mirrors `aaveV4SpokeLenderKey` and the Morpho `MORPHO_BLUE_<HEX>`
+ * convention so each Silo pair shows up as its own isolated lender —
+ * exactly like an Aave V4 spoke or a Morpho Blue market — without any
+ * Silo-specific routing logic in the rest of the codebase.
+ *
+ * Format: `SILO_V2_${siloConfigAddr.slice(2).toUpperCase()}`
+ *
+ * Keyed by `SiloConfig` rather than either silo because the config is the
+ * stable, shared identity of the pair (silo0/silo1 are derived from it).
+ *
+ * `isSiloV2Type()` works on this because it matches `startsWith('SILO_V2')`.
+ */
+export declare function siloV2LenderKey(siloConfig: string): string;
+/**
+ * Inverse of `siloV2LenderKey`: given a per-pair lender key, return
+ * `{ siloConfigAddrLower }`. Returns `undefined` if the key isn't a per-pair
+ * Silo v2 key (e.g. someone passed the bare prefix `SILO_V2`).
+ */
+export declare function parseSiloV2LenderKey(lenderKey: string): {
+    siloConfigAddrLower: string;
+} | undefined;
+/**
+ * Look up a Silo v2 market entry by per-pair lender key.
+ * Returns `undefined` if no entry exists for that chain/config.
+ */
+export declare function getSiloV2MarketEntry(chainId: string, lenderKey: string): SiloMarketEntry | undefined;
+/**
+ * Silo v3 per-pair lender key helpers.
+ *
+ * Silo v3 uses the exact same on-chain data model and metadata shape as v2
+ * (`SiloMarketEntry`/`SiloHalfStatic`) — only the deployment set, factory
+ * and indexer protocol tag differ — so v3 pairs get their own isolated
+ * lender token namespace (`SILO_V3_<HEX>`) and live in a separate
+ * `siloMarketsV3` registry slot. Keeping the two separate means a v2 and
+ * v3 pair with the same `SiloConfig` address could in principle coexist
+ * without clashing, and downstream consumers can filter by prefix.
+ *
+ * Format: `SILO_V3_${siloConfigAddr.slice(2).toUpperCase()}`
+ */
+export declare function siloV3LenderKey(siloConfig: string): string;
+export declare function parseSiloV3LenderKey(lenderKey: string): {
+    siloConfigAddrLower: string;
+} | undefined;
+/**
+ * Look up a Silo v3 market entry by per-pair lender key.
+ * Returns `undefined` if no entry exists for that chain/config.
+ */
+export declare function getSiloV3MarketEntry(chainId: string, lenderKey: string): SiloMarketEntry | undefined;

package/dist/lending/teller.d.ts

@@ -0,0 +1,68 @@
+/** Per-chain, protocol-level (evergreen) Teller addresses. */
+export type TellerConfigChain = {
+    /** TellerV2 — loan lifecycle: bid reads, repayLoanFull, approveMarketForwarder. */
+    tellerV2: string;
+    /** MarketRegistry — market owners / default windows / attestation rules. */
+    marketRegistry: string;
+    /** CollateralManager — per-bid collateral escrow (approve target on open). */
+    collateralManager: string;
+    /** LenderManager — tokenizes the lender side of an accepted loan (ERC-721). */
+    lenderManager?: string | null;
+    /** LenderCommitmentForwarder — legacy commitment forwarder (optional). */
+    lenderCommitmentForwarder?: string | null;
+    /** SmartCommitmentForwarder — borrower entrypoint for pool-backed loans. */
+    smartCommitmentForwarder: string;
+    /** LenderCommitmentGroup pool factory V1 (Smart pools) — for pool discovery. */
+    lenderCommitmentGroupFactory?: string | null;
+    /** LenderCommitmentGroup pool factory V2 (ERC-4626 pools; bulk of liquidity). */
+    lenderCommitmentGroupFactoryV2?: string | null;
+    /** LenderCommitmentGroup pool factory V3 (ERC-4626 pools). */
+    lenderCommitmentGroupFactoryV3?: string | null;
+};
+export type TellerConfigType = {
+    [chainId: string]: TellerConfigChain;
+};
+/** A Teller LenderCommitmentGroup pool: one fixed principal↔collateral pair. */
+export type TellerPoolConfig = {
+    /** Pool (LenderCommitmentGroup) address — also the per-market lender-key body. */
+    pool: string;
+    /** MarketRegistry market id this pool lends into. Immutable; OPTIONAL —
+     *  read on-chain via `getMarketId()` when absent (the curated list from the
+     *  Teller API doesn't carry it). */
+    marketId?: string;
+    /** Principal (loan / debt) token address. */
+    principal: string;
+    /** Principal token symbol, e.g. "USDC". */
+    principalSymbol: string;
+    /** Principal token decimals. */
+    principalDecimals: number;
+    /** Collateral token address. */
+    collateral: string;
+    /** Collateral token symbol, e.g. "WETH". */
+    collateralSymbol: string;
+    /** Collateral token decimals. */
+    collateralDecimals: number;
+    /** Max loan duration (seconds) the pool allows (borrower picks ≤ this).
+     *  Immutable; OPTIONAL — read on-chain via `getMaxLoanDuration()` when absent. */
+    maxLoanDuration?: number;
+    /** Pool generation hint (2 = ERC-4626 `_Pool_V2/V3`, 1 = `_Smart`), from the
+     *  Teller API `isV2` flag. Borrow path is identical; only supply-side differs. */
+    isV2?: boolean;
+    /** WAD/bps interest-rate lower bound (informational; enforced on-chain). */
+    interestRateLowerBound?: string | number | null;
+    /** WAD/bps interest-rate upper bound (informational; enforced on-chain). */
+    interestRateUpperBound?: string | number | null;
+    /** Optional display label, e.g. "Teller USDC / WETH". */
+    name?: string;
+};
+export type TellerPoolsType = {
+    [chainId: string]: TellerPoolConfig[];
+};
+export declare const tellerConfig: () => TellerConfigType;
+export declare const tellerPools: () => TellerPoolsType;
+/** Per-chain evergreen Teller addresses (undefined if none/unloaded). */
+export declare const tellerConfigByChain: (chainId: string | number) => TellerConfigChain | undefined;
+/** All Teller pool configs on a chain (empty array if none/unloaded). */
+export declare const tellerPoolsByChain: (chainId: string | number) => TellerPoolConfig[];
+/** Look up one Teller pool config by its LenderCommitmentGroup address (case-insensitive). */
+export declare const tellerPoolByAddress: (chainId: string | number, pool: string) => TellerPoolConfig | undefined;

package/dist/lending/term.d.ts

@@ -0,0 +1,82 @@
+/** Per-chain, protocol-level (evergreen) Term Finance addresses + data endpoint. */
+export type TermConfigChain = {
+    /** TermController — validates deployed repos (`isTermDeployed`). */
+    termController: string;
+    /** RepoTokenLinkedList — the shared secondary-market repo-token order book. */
+    repoTokenLinkedList?: string | null;
+    /** RepoTokenLinkedListEventEmitter — the listing event source the subgraph indexes. */
+    repoTokenListEventEmitter?: string | null;
+    /** DiscountRateAdapter — helper used to price secondary listings. */
+    discountRateAdapter?: string | null;
+    /** TermPriceConsumerV3 — Term's own on-chain price oracle (singleton per
+     *  chain). `usdValueOfTokens(token, 10^dec)` → per-token USD price (1e18).
+     *  The same oracle Term liquidates against, so it drives liquidation risk. */
+    priceOracle?: string | null;
+    /** Term data endpoint base (subgraph/HTTP) for listings + auction state. */
+    apiBaseUrl?: string | null;
+};
+export type TermConfigType = {
+    [chainId: string]: TermConfigChain;
+};
+/** One collateral leg of a Term repo (mirrors TermRepoCollateralManager state). */
+export type TermCollateralParam = {
+    token: string;
+    /** WAD-scaled maintenance collateral ratio (as string). */
+    maintenanceRatio: string;
+    /** WAD-scaled initial collateral ratio (as string). */
+    initialRatio?: string;
+    /** WAD-scaled liquidated-damages factor (liquidation penalty, as string). */
+    liquidatedDamages?: string;
+    decimals: number;
+};
+/** A Term Finance repo/market: the serial contract addresses + fixed terms. */
+export type TermMarketConfig = {
+    /** bytes32/string term repo id (`termRepoId`). */
+    termRepoId: string;
+    /** TermRepoServicer — timing + repurchase ledger + redeem/repay. */
+    servicer: string;
+    /** TermRepoToken — ERC-20 lender claim (balanceOf → lent principal). */
+    repoToken: string;
+    /** TermRepoCollateralManager — collateral lock/unlock + balances. */
+    collateralManager: string;
+    /** TermAuction — clears the current/latest auction for this repo (optional). */
+    auction?: string;
+    /** TermAuctionOfferLocker — lend-side offer submission for the active auction. */
+    offerLocker?: string;
+    /** TermAuctionBidLocker — borrow-side bid submission for the active auction. */
+    bidLocker?: string;
+    /** The loan/lend token borrowers receive and lenders supply (== `purchaseToken`). */
+    purchaseToken: string;
+    loanDecimals: number;
+    /** Ordered collateral legs; index = the on-chain collateral index. */
+    collateralParams: TermCollateralParam[];
+    /** Maturity, unix seconds (as string). */
+    maturity: string;
+    /** Redemption timestamp, unix seconds (as string). */
+    redemptionTimestamp?: string;
+    /** End of the repurchase window, unix seconds (as string). */
+    endOfRepurchaseWindow?: string;
+    /** Fixed redemption value per repo token at maturity (WAD, as string). */
+    redemptionValue?: string;
+    /** WAD-scaled servicing fee (as string). */
+    servicingFee?: string;
+    /** Optional display label, e.g. "USDC / WETH — 2026-09-18". */
+    name?: string;
+};
+export type TermMarketsType = {
+    [chainId: string]: TermMarketConfig[];
+};
+export declare const termConfig: () => TermConfigType;
+export declare const setTermApiBase: (url: string | undefined | null) => void;
+export declare const termApiBaseOverride: () => string | undefined;
+/**
+ * Resolve the Term data endpoint base for a chain: override → config → ''.
+ * Term has no public hosted endpoint, so an empty string means "no live data
+ * source configured" and callers fall back to static config / on-chain reads.
+ */
+export declare const resolveTermApiBase: (chainId: string) => string;
+export declare const termMarkets: () => TermMarketsType;
+/** All Term Finance market configs on a chain (empty array if none/unloaded). */
+export declare const termMarketsByChain: (chainId: string | number) => TermMarketConfig[];
+/** Look up one Term repo config by its term repo id (case-insensitive). */
+export declare const termMarketById: (chainId: string | number, termRepoId: string) => TermMarketConfig | undefined;

package/dist/lending/termMax.d.ts

@@ -0,0 +1,65 @@
+/** Per-chain, protocol-level (evergreen) TermMax addresses. */
+export type TermMaxConfigChain = {
+    /** TermMaxRouterV2 — the native atomic write surface (borrow, repay, …). */
+    routerV2: string;
+    /** OracleAggregatorV2 — `getPrice(asset) → (price, decimals)`; the feed LTV
+     *  and liquidation are computed against. */
+    oracleAggregatorV2: string;
+    /** TermMaxViewer — batch position/order reads (the user-data multicall target). */
+    viewer: string;
+    /** WhitelistManager — gates which markets/adapters the ROUTER will touch.
+     *  Does NOT gate the market/order/GT primitives (those are permissionless). */
+    whitelistManager?: string | null;
+    /** TermMaxSwapAdapter — the router swap adapter that executes ORDER swaps
+     *  inside a `SwapPath`. Required to build `borrowTokenFromCollateral`; the
+     *  order swaps themselves can be called directly without it. */
+    termMaxSwapAdapter?: string | null;
+    /** Market factories, newest last. Used for event-based discovery when the
+     *  API is unavailable; not needed on the happy path. */
+    marketFactories?: string[] | null;
+    /** Legacy V1 router — retired, kept only so a stale key can be recognised
+     *  and rejected rather than silently encoded against. */
+    routerV1?: string | null;
+    /** TermMax data API base, e.g. `https://api.termmax.ts.finance`. Overridable
+     *  per chain so a self-hosted indexer can be swapped in. */
+    apiBaseUrl?: string | null;
+};
+export type TermMaxConfigType = {
+    [chainId: string]: TermMaxConfigChain;
+};
+/** TermMax per-chain config map (undefined if unloaded). */
+export declare const termMaxConfig: () => TermMaxConfigType;
+/** TermMax deployment addresses for one chain (undefined if unloaded). */
+export declare const termMaxConfigByChain: (chainId: string | number) => TermMaxConfigChain | undefined;
+/** Chains with a TermMax deployment loaded. */
+export declare const termMaxChainIds: () => string[];
+/**
+ * TermMax data API base for a chain. Read through the getter (not a module
+ * constant) for the same reason as Midnight/Term: the per-request metadata
+ * re-init rewrites `termMaxConfig`, so a captured value goes stale.
+ */
+export declare const termMaxApiBaseUrl: (chainId: string | number) => string;
+/**
+ * Synthesize the per-market lender key for a TermMax market.
+ *
+ * Mirrors `EXACTLY_<MARKET_ADDRESS_HEX>` / `TELLER_<POOL_ADDRESS_HEX>`. One key
+ * per TermMax market, i.e. per (debtToken, collateral, maturity) tuple — the
+ * maturity is baked into the market contract, so unlike Exactly there is NO
+ * `terms[]` menu underneath a key.
+ *
+ * Format: `TERMMAX_${marketAddr.slice(2).toUpperCase()}`
+ *
+ * chainId is intentionally NOT in the token (chain scoping happens at the
+ * marketUid level), matching every other per-market key in this package.
+ *
+ * `isTermMax()` works on this because it matches `startsWith('TERMMAX')`.
+ */
+export declare function termMaxLenderKey(market: string): string;
+/**
+ * Inverse of `termMaxLenderKey`: given a per-market lender key, return
+ * `{ marketAddrLower }`. Returns `undefined` if the key isn't a per-market
+ * TermMax key (e.g. someone passed the bare prefix `TERMMAX`).
+ */
+export declare function parseTermMaxLenderKey(lenderKey: string): {
+    marketAddrLower: string;
+} | undefined;

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "Hold and initialize lending protocol data across a stack",
   "files": [
     "dist"