@1delta/margin-fetcher 5.0.20 → 5.0.22

package/dist/index.d.ts

@@ -7859,6 +7859,347 @@ declare const accountDepositListKey: (account: Address) => Hex;
 /** Key of the set holding `account`'s pending GM withdrawal request keys. */
 declare const accountWithdrawalListKey: (account: Address) => Hex;
 
+/**
+ * A Pendle Principal Token, modelled as a fixed-rate earn product.
+ *
+ * ## Why this is a provider and not an ERC-4626 vault
+ *
+ * A PT is a zero-coupon bond, not a share. There is no `deposit`, no
+ * `convertToAssets`, and no share price that accrues: you BUY the PT on
+ * Pendle's AMM at a discount to face value, and at `expiry` it redeems 1:1 for
+ * the underlying. The yield is the discount, fixed the moment you buy.
+ *
+ * Consequences that shape every field below, and that a consumer must not
+ * paper over:
+ *
+ *  - **No `totalAssets` / `totalSupply` / `sharePrice`.** Nothing here is a
+ *    share/asset ratio. Size is reported in USD only, exactly like the other
+ *    two non-4626 providers (GMX, HyperCore), and this provider is likewise
+ *    excluded from `buildVaultLookup`.
+ *  - **Entry and exit are SWAPS.** Both legs route through the Pendle
+ *    aggregator (already integrated as `TradeAggregator.Pendle`), so both need
+ *    a slippage tolerance and both are priced by pool depth — which is what
+ *    `liquidityUsd` reports.
+ *  - **The row is only valid until `expiry`.** After it, the fixed rate is
+ *    meaningless (the PT redeems at par, so the forward yield is zero) and the
+ *    product is gone. Expired markets are dropped by the fetcher; see
+ *    `isLiveMarket`.
+ */
+interface PendlePtMarket extends VaultClassificationFields {
+    /** PT token address, lowercased. This is what a holder actually owns. */
+    address: string;
+    /** The Pendle AMM market contract, lowercased. Where the swap routes. */
+    marketAddress: string;
+    /**
+     * Underlying/accounting asset address, lowercased — what the PT redeems for
+     * at maturity, and the denomination of the fixed rate.
+     */
+    underlying: string;
+    /** YT address, lowercased. The complement; `PT + YT = SY`. */
+    ytAddress?: string;
+    /** SY (Standardised Yield wrapper) address, lowercased. */
+    syAddress?: string;
+    /** PT symbol, e.g. `PT-wstETH-30DEC2027`. */
+    symbol: string;
+    /** Display name for the market. */
+    name: string;
+    /**
+     * PT decimals.
+     *
+     * **NOT reliably equal to the underlying's** — 9 of 57 live Ethereum markets
+     * disagreed at integration (PT-mHyperBTC is 8 over an 18-decimal
+     * mHyperBTC). Sourced from the token list, or read on-chain; a market whose
+     * PT decimals cannot be established is DROPPED rather than defaulted, since
+     * a wrong value mis-scales every amount silently.
+     */
+    decimals: number;
+    /** Underlying asset decimals. */
+    assetDecimals: number;
+    /** Unix SECONDS. */
+    expiry: number;
+    /** ISO-8601 mirror, straight from the API. */
+    expiryIso: string;
+    /** Snapshot at fetch time — recompute from `expiry` for a live countdown. */
+    secondsToExpiry: number;
+    /** `secondsToExpiry` in days, rounded to 2dp. Convenience for display. */
+    daysToExpiry: number;
+    /**
+     * The fixed yield to maturity, as a nominal APR percent.
+     *
+     * Converted from the API's `impliedApy`, which is a compounded APY fraction.
+     * `impliedApyPercent` below carries Pendle's own figure unconverted, because
+     * that is what pendle.finance displays and a user WILL compare the two.
+     */
+    supplyRate: number;
+    /** Always 0 — PENDLE emissions accrue to LPs, never to PT holders. */
+    rewardsRate: number;
+    /** `supplyRate + rewardsRate`. The headline. */
+    depositRate: number;
+    /** Pendle's `impliedApy` as a percent, uncompounded-out. Display parity. */
+    impliedApyPercent: number;
+    /**
+     * The SY's own floating yield (percent APR) — what a PT buyer GIVES UP.
+     * Context for "is this fixed rate a good deal", never the row's own rate.
+     */
+    underlyingApyPercent?: number;
+    /** AMM swap fee as a fraction of the traded amount, e.g. `0.0005`. */
+    feeRate?: number;
+    /**
+     * Whole-market TVL in USD (`details.totalTvl`).
+     *
+     * USD-only by construction — there is no token-denominated "total assets"
+     * for a PT. Mirrors GMX/HyperCore, which also report USD and set the raw
+     * base-unit fields to null.
+     */
+    totalAssetsUsd: number;
+    /**
+     * Same number as {@link totalAssetsUsd}. Present because the cross-source
+     * sort field on `/v1/data/earn` is `formatted`, and for a USD-denominated
+     * provider the USD figure IS the comparable magnitude — the convention GMX
+     * and HyperCore already established in the recorder.
+     */
+    totalAssetsFormatted: number;
+    /**
+     * AMM pool depth in USD (`details.liquidity`) — what can actually be traded
+     * in or out right now. For a PT this is the real exit constraint: the
+     * position is always sellable in principle and rarely sellable in size.
+     */
+    liquidityUsd: number;
+    /** Permissionless — anyone can buy a PT. Always true; kept explicit. */
+    isMintable: boolean;
+    /** `market-sale`: exit is selling on Pendle's AMM at the prevailing price. */
+    withdrawalMode: 'market-sale';
+    /** Hydrated underlying metadata from the token list, if available. */
+    asset?: GenericCurrency;
+    /** USD price of one underlying unit, when a price map was supplied. */
+    priceUsd?: number;
+    /** USD price of one PT, from Pendle's own price feed when available. */
+    ptPriceUsd?: number;
+    /** Pendle's category tags, e.g. `['eth','blue-chips','lido']`. */
+    categoryIds?: string[];
+    /** The protocol behind the underlying, per Pendle, e.g. `Lido`. */
+    protocol?: string;
+}
+/** Per-chain map, keyed by lowercased PT address (parity with the other providers). */
+type PendlePtMarkets = {
+    [ptAddress: string]: PendlePtMarket;
+};
+
+interface FetchPendlePtOptions {
+    /**
+     * Include markets that have already matured.
+     *
+     * **Default `false`, and that default is the point of this provider.** An
+     * expired PT redeems at par, so its forward yield is zero — but every rate
+     * field the API and the token list carry still holds the last pre-expiry
+     * value. Serving those rows would put a stale fixed APY at the top of an
+     * APR-sorted earn list on a product that no longer exists.
+     *
+     * The escape hatch exists for the same reason yield-tracer's `/assets`
+     * route has one: a user who HOLDS a matured PT still needs the row to
+     * redeem it. Mirrors `?includeExpired=` there, including the name.
+     */
+    includeExpired?: boolean;
+    /**
+     * Clock override, unix seconds. Tests only — production always judges
+     * expiry against the real clock, never against a cached flag.
+     */
+    nowSecs?: number;
+}
+/**
+ * Fetch every LIVE Pendle PT market on a chain, modelled as fixed-rate earn
+ * products.
+ *
+ * **HTTP-only in every normal case.** Token metadata resolves in three tiers —
+ * the caller's token list, then Pendle's own global asset listing, then an
+ * on-chain `decimals()` multicall — and each tier is consulted only for what
+ * the previous one could not answer. A caller with a hydrated token list makes
+ * exactly ONE request (the shared, cached markets listing); a caller with none
+ * (the worker's `?source=live` path passes `{}`) makes two, and still never
+ * touches an RPC.
+ *
+ * The multicall is a last resort on purpose. Reading `decimals()` for ~110 PTs
+ * on Ethereum makes the entire chain's listing hostage to one multicall, and
+ * viem's `allowFailure` returns `'0x'` per call instead of throwing when the
+ * transport dies — so the failure mode is a silent, complete disappearance of
+ * Pendle on the busiest chain rather than an error anyone would notice.
+ *
+ * @param chainId         target chain
+ * @param multicallRetry  last-resort decimals gap-fill only; usually unused
+ * @param prices          price map keyed by oracle key / address
+ * @param tokenList       token list for PT + underlying metadata
+ * @param options         `includeExpired` and a test clock — see
+ *                        {@link FetchPendlePtOptions}
+ *
+ * @returns map keyed by lowercased PT address; empty on chains without a
+ *          Pendle deployment.
+ */
+declare const fetchPendlePtMarkets: (chainId: string, multicallRetry: MulticallRetryFunction, prices?: {
+    [asset: string]: number;
+}, tokenList?: GenericTokenList, options?: FetchPendlePtOptions) => Promise<PendlePtMarkets>;
+
+/**
+ * Pendle V2 public market listing.
+ *
+ * ONE un-paginated endpoint returns every Pendle market on every chain,
+ * including the per-market `details` block (implied APY, pool liquidity, TVL).
+ * That is the whole data source for this provider — no multicall, no subgraph,
+ * no API key.
+ *
+ *   https://api-v2.pendle.finance/core/v1/markets/all
+ *
+ * There is also a per-chain `/v1/{chainId}/markets/active`, which pre-filters
+ * to live markets. We deliberately do NOT use it: it costs one request per
+ * chain for the same data, and — more importantly — expiry has to be judged
+ * here anyway (see {@link isLiveMarket}), so taking the filter from the API
+ * would just move the one rule this provider must never get wrong out of our
+ * code and into someone else's.
+ *
+ * Docs: https://docs.pendle.finance/pendle-v2/introduction
+ */
+declare const PENDLE_MARKETS_URL = "https://api-v2.pendle.finance/core/v1/markets/all";
+/**
+ * Token metadata for every Pendle-known asset on every chain — decimals,
+ * symbol, name, icon. One global call, same as the markets listing.
+ *
+ * It exists here because `/markets/all` publishes addresses but NO decimals,
+ * and a PT's decimals cannot be inferred from its underlying's (they disagree
+ * on ~16 % of live markets). The alternative — reading `decimals()` on-chain
+ * for every PT — makes the whole provider depend on a ~110-call multicall on
+ * Ethereum, and when that multicall fails viem returns `'0x'` per call rather
+ * than throwing, so the entire chain's listing silently disappears. Observed,
+ * not hypothesised. An HTTP source that fails loudly is the better dependency.
+ */
+declare const PENDLE_ASSETS_URL = "https://api-v2.pendle.finance/core/v1/assets/all";
+/**
+ * Chains with Pendle deployments. The endpoint is global (it returns every
+ * chain regardless), so this set exists only to skip the round-trip on chains
+ * Pendle does not cover — the parser is chain-agnostic and a new chain appears
+ * as soon as it is added here.
+ */
+declare const PENDLE_CHAIN_IDS: Set<string>;
+declare const hasPendleMarkets: (chainId: string) => boolean;
+/**
+ * The `details` block. Every field is a FRACTION (`0.0721` = 7.21 %) except
+ * the three USD amounts.
+ *
+ * **Only `impliedApy` describes what a PT holder earns.** The others are
+ * different products' numbers sharing one object, and picking the wrong one is
+ * the same class of error as TermMax's maker-side `apr()` naming:
+ *
+ *  - `impliedApy`    — the fixed yield locked in by buying PT and holding to
+ *                      maturity. THE PT RATE.
+ *  - `underlyingApy` — the SY's own floating yield. What the YT side earns,
+ *                      and what PT holders give up.
+ *  - `pendleApy`     — PENDLE emissions paid to LPs. Not to PT holders.
+ *  - `aggregatedApy` / `maxBoostedApy` / `swapFeeApy` — LP-side returns.
+ */
+interface PendleApiMarketDetails {
+    /** AMM pool depth, USD. What can actually be traded in or out. */
+    liquidity?: number | null;
+    /** Whole-market TVL, USD (pool + SY backing). */
+    totalTvl?: number | null;
+    tradingVolume?: number | null;
+    /** Fixed yield to maturity, as a FRACTION. The PT rate. */
+    impliedApy?: number | null;
+    /** The SY's floating yield, as a FRACTION. NOT the PT rate. */
+    underlyingApy?: number | null;
+    /** PENDLE emissions to LPs, as a FRACTION. NOT the PT rate. */
+    pendleApy?: number | null;
+    /** LP total, as a FRACTION. NOT the PT rate. */
+    aggregatedApy?: number | null;
+    maxBoostedApy?: number | null;
+    swapFeeApy?: number | null;
+    /** AMM swap fee, as a FRACTION of the traded amount. */
+    feeRate?: number | null;
+    yieldRange?: {
+        min?: number | null;
+        max?: number | null;
+    } | null;
+}
+/**
+ * One `markets[]` entry.
+ *
+ * **`pt` / `yt` / `sy` / `underlyingAsset` are `"<chainId>-<address>"`**, not
+ * bare addresses — see {@link splitChainScopedAddress}. `expiry` is ISO-8601,
+ * not a unix stamp (the token list carries the unix form).
+ */
+interface PendleApiMarket {
+    /** Underlying's display name, e.g. `wstETH` — NOT the PT symbol. */
+    name?: string | null;
+    /** The AMM market contract, a bare address. */
+    address?: string | null;
+    /** ISO-8601. */
+    expiry?: string | null;
+    /** `"1-0xb253…"` */
+    pt?: string | null;
+    yt?: string | null;
+    sy?: string | null;
+    underlyingAsset?: string | null;
+    accountingAsset?: string | null;
+    protocol?: string | null;
+    icon?: string | null;
+    details?: PendleApiMarketDetails | null;
+    isNew?: boolean | null;
+    isPrime?: boolean | null;
+    categoryIds?: string[] | null;
+    chainId?: number | null;
+}
+/**
+ * Split Pendle's `"<chainId>-<address>"` composite into its parts.
+ *
+ * Returns `undefined` for anything that is not that shape — a bare address
+ * included. Pendle has never returned one, and silently accepting it would
+ * mean guessing the chain, which is how a market gets attributed to the wrong
+ * network.
+ */
+declare function splitChainScopedAddress(value: string | null | undefined): {
+    chainId: string;
+    address: string;
+} | undefined;
+/** Parse the ISO-8601 `expiry` to unix SECONDS. `undefined` when unparseable. */
+declare function parseExpirySeconds(expiry: string | null | undefined): number | undefined;
+/**
+ * Is this market still live?
+ *
+ * **Judged against the clock, every time — never off a cached flag.** The
+ * token list carries a `props.pendle.expired` boolean that is only as fresh as
+ * the last regeneration, and an expired PT that keeps showing a pre-expiry
+ * fixed APY is precisely the bug yield-tracer migration 0088 had to clean up
+ * after. A market with no parseable expiry is treated as NOT live: an
+ * unbounded fixed-rate row is never the safe default.
+ */
+declare function isLiveMarket(market: PendleApiMarket, nowSecs?: number): boolean;
+/** One `assets[]` entry from {@link PENDLE_ASSETS_URL}. */
+interface PendleApiAsset {
+    chainId?: number | null;
+    address?: string | null;
+    symbol?: string | null;
+    name?: string | null;
+    decimals?: number | null;
+    /** `['PT']`, `['YT']`, `['SY']`, … */
+    tags?: string[] | null;
+    expiry?: string | null;
+    proIcon?: string | null;
+}
+/** Drop both cached listings. Tests only. */
+declare function clearPendleMarketsCache(): void;
+/**
+ * Fetch the global Pendle market listing (all chains, live and expired).
+ *
+ * Chain filtering, expiry filtering and normalization happen in `fetchPublic`.
+ */
+declare function fetchPendleApiMarkets(): Promise<PendleApiMarket[]>;
+/** `"<chainId>-<lowercased address>"` — the key both Pendle listings use. */
+declare const assetKey: (chainId: string | number, address: string) => string;
+/**
+ * Fetch Pendle's global asset metadata, keyed by {@link assetKey}.
+ *
+ * Only called when something is missing from the caller's token list, so a
+ * fully-hydrated caller pays nothing for it.
+ */
+declare function fetchPendleApiAssets(): Promise<Map<string, PendleApiAsset>>;
+
 /**
  * Vault interface family, detected via ERC-165 `supportsInterface`.
  *
@@ -7965,7 +8306,7 @@ interface VaultLookupEntry {
 declare function buildVaultLookup(data: VaultPublicDataAll): Map<string, VaultLookupEntry>;
 
 /** Supported ERC-4626 vault providers. */
-type VaultProvider = 'fluid' | 'gearbox' | 'morpho' | 'lista' | 'silo' | 'euler-earn' | 'termmax' | 'lst' | 'savings' | 'lagoon' | 'aave-earn' | 'upshift' | 'yearn' | 'hypercore' | 'gmx';
+type VaultProvider = 'fluid' | 'gearbox' | 'morpho' | 'lista' | 'silo' | 'euler-earn' | 'termmax' | 'lst' | 'savings' | 'lagoon' | 'aave-earn' | 'upshift' | 'yearn' | 'hypercore' | 'gmx' | 'pendle';
 /**
  * Per-provider payload returned by `getVaultPublicDataAll`. Each entry is
  * present only when the matching provider was requested AND its fetch
@@ -8009,12 +8350,30 @@ interface VaultPublicDataAll {
     /** Per-chain minimum GM/GLV execution fees (wei). Populated alongside
      *  `gmx`. Gas-price-derived, so treat as fresh-at-fetch estimates. */
     gmxExecutionFees?: GmxExecutionFees;
+    /** Pendle V2 Principal Tokens as fixed-rate earn products — one row per
+     *  LIVE market, keyed by lowercased PT address. **Matured markets are
+     *  never included** (an expired PT redeems at par, so its published fixed
+     *  APY is stale by definition); pass `pendleIncludeExpired` to override,
+     *  which only a holder-facing redeem flow should ever do. Not a share
+     *  token: no `totalAssets`/`totalSupply`/share price, USD-denominated
+     *  size, and excluded from `buildVaultLookup` — the GMX/HyperCore
+     *  precedent. */
+    pendle?: PendlePtMarkets;
 }
 interface GetVaultPublicDataAllOptions {
     /** Narrow Silo to a single protocol version (`v2` or `v3`). */
     siloProtocolVersion?: 'v2' | 'v3';
     /** Page size hint for Silo's GraphQL query. */
     siloLimit?: number;
+    /**
+     * Include MATURED Pendle PT markets. Default `false`.
+     *
+     * Only a flow that services an existing holder (redeem a PT you already
+     * own) should set this. Any listing, ranking or discovery surface must
+     * leave it off: a matured PT still publishes its last pre-expiry implied
+     * APY, and that number is not an offer.
+     */
+    pendleIncludeExpired?: boolean;
 }
 /**
  * Combined output of `getVaultPublicDataAll`: the rich per-provider
@@ -10126,4 +10485,788 @@ interface TermAdapter {
 declare const TERM_ADAPTERS: TermAdapter[];
 declare function resolveAdapter(lender: string): TermAdapter | undefined;
 
-export { type AaveMetadata, type AaveV2Public, type AaveV2UserReserveResponse, type AaveV3Public, type AaveV3UserReserveResponse, type AdditionalYields, type AdminKind, ApiBookSource, type AprData, type AprPercent, type AssetQuality, type AssetRiskIndex, type AuctionWindow, type AvailabilityTerms, type BalanceData, type BaseLendingPosition, type BasicReserveResponse, type BorrowExitTerms, type BorrowTermSheet, type BuildTermSheetOptions, type ChainDiagnostic, type ChainLinkResponse, type ChainQuery, type ChainSummary, type CompoundV2Metadata, type CompoundV3Public, type CompoundV3UserReserveResponse, type ConfigEntry, type ConvertLenderUserDataOptions, type CoreValidators, type CounterpartyTerms, type CoverageInfo, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_PROFILE_ID, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, type DeepPartial, type Denomination, type DepthMap, type DssMarketRaw, type DssMarketsRaw, type DssPositionInfo, EMPTY_BALANCE, type EModeAssets, type EModeData, type EModeResult, EXACTLY_LENDER_KEY, type EndpointFailure, type EnrichmentIndex, type EulerEarnVault, type EulerEarnVaults, type EulerV2Metadata, type ExactlyFixedPool, type ExactlyFixedPosition, type ExactlyMarketAccount, type ExactlyMarketsRaw, type ExactlyUserFixedPosition, type ExposureEntry, type ExposureTerms, type ExtraValidationCall, type FeeTerm, type FeeWhen, type FeedObservation, type FeedStat, type FeedStatsMap, type FeedTimestampMap, type FetchListaVaultsFromChainOptions, type FetchMorphoVaultsFromChainOptions, type FetchOraclePricesOptions, type FetchTokenBalancesOptions, type FlattenPriorityConfig, type FluidFToken, type FluidFTokens, type FrankencoinMarketRaw, type FrankencoinMarketsRaw, type FrankencoinPositionInfo, type FullLenderRewardsMap, GMX_API_HOSTS, GMX_READ_CONTRACTS, GMX_SUPPORTED_CHAINS, type GenericCurrency, type GenericTokenList, type GetVaultPublicDataAllOptions, type GmxExecutionFees, type GmxPendingDeposit, type GmxPendingWithdrawal, type GmxReadContracts, type GmxUserBalance, type GmxUserPositions, type GmxUserPositionsOptions, type GmxVault, type GmxVaultKind, type GmxVaults, type GmxVaultsFetchOptions, type GovernancePower, type GovernanceRow, type GovernanceTerms, type GroupAccumulator, HYPERCORE_VAULT_REGISTRY, type HypercoreLockStatus, type HypercoreUserPositionsOptions, type HypercoreVault, type HypercoreVaultPosition, type HypercoreVaultRegistryEntry, type HypercoreVaults, type HypercoreVaultsFetchOptions, IDLE_MARKET_ID, INTERFACE_IDS, type IncompleteLenderRead, type IncompleteReason, type InitMetadata, type InitPublic, type InitUserReserveResponse, type InterfaceKind, type InvariantViolation, type InverseMarketRaw, type InverseMarketsRaw, type InversePositionInfo, LAGOON_API_URL, LAGOON_CHAIN_IDS, type LagoonApiVault, type LagoonSyncMode, type LagoonVault, type LagoonVaults, type LenderAssetReward, type LenderConfigData, type LenderConfigMap, type LenderCrossPoolMeta, type LenderData, type LenderDataEntry, type LenderInfo, type LenderInfoMap, type LenderPublicBase, type LenderRewardsMap, type LenderSummary, type LenderToLenderCrossPoolMeta, type LenderTotalAmounts, type LenderUserQuery, type LenderUserResponse, type LenderYieldComplete, type LenderYields$1 as LenderYields, LendingMode, type LiquidationPenaltyTerm, type LiquidationTerms, type LiquityBranchRaw, type LiquityDiscoveredTrove, type LiquityDiscovery, type LiquityMarketsRaw, type LiquitySpInfo, type LiquityTroveInfo, type ListaMarketOverrides, type LlamaLendMarketOverride, type LlamaLendMarketOverrides, type LlamaLendMarketRaw, type LlamaLendMarketsRaw, type LlamaLendPositionInfo, type LoopPostTradeMetrics, type LstDelegation, type LstDelegationKind, type LstValidator, type LstWithdrawalFetchOptions, type LstWithdrawalRegistryEntry, type LstWithdrawalRequest, type LstWithdrawalRequestsByLst, type LstWithdrawalStatus, MORPHO_LENS, MULTICALL_FAILURE, type MaturityTerms, MaxParamThresholds, type MergedUserData, type MidnightBook, type MidnightBookLevel, type MidnightBookSource, type ModeBase, type ModeVariant, type MorphoMarketOverrides, type MorphoSubgraphProxyConfig, type MorphoUserMarketBalance, type MorphoUserReserveResponse, type MorphoVault, type MorphoVaults, type MulticallEndpointOptions, type MulticallRpcBatch, type NumberMap, type Open, type OracleBand, type OracleDiagnostics, type OraclePriceEntry, type OraclePricesResult, type OracleRiskRow, type OracleTerms, type OutlierGuardConfig, type ParsedBalanceData, type ParsedResponse, type ParsedUserBalance, type PermissionKind, type PermissionParams, type PoolData, type PoolWithMeta, type PortfolioSummary, type PortfolioTotals, type PositionConstraints, type PostTradeMetrics, type PreparedCall, type PreparedMergedMulticallParams, type PreparedMergedRpcCalls, type PreparedTokenBalanceRpcCalls, type PreparedUserDataRpcCalls, type PriceDerivation, type PriceSelection, type ProtocolParams, type ProviderOptions, type RateKind, type RateMenuEntry, type RateTerms, type RawRpcBatch, type RawRpcCall, type RawRpcResponse, type ReadFailurePolicy, type RedemptionTerms, type ResupplyMarketsRaw, type ResupplyPairIdentity, type ResupplyPairRaw, type ResupplyPositionInfo, type ResupplyWrappedMarket, type RewardSourceRef, type RewardStream, type RewardTerm, type RewardTokenRef, type RiverMarketRaw, type RiverMarketsRaw, type RiverPositionInfo, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, type SelectPricesOptions, type Severity, type SeverityFinding, type SiloVault, type SiloVaults, type StCeloValidatorGroup, type StaleFeedEntry, type StampOptions, type StructuredOraclePrices, type SubAccountSummary, type SumerPositionInput, type SummaryAprData, type SummaryBalanceData, type SupplyExitMode, type SupplyExitTerms, type SupplyTermSheet, TELLER_CALLS_PER_BID, TERMMAX_CALLS_PER_ACCOUNT, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, TERM_ADAPTERS, TERM_PROFILES, TERM_SHEET_SCHEMA_VERSION, type TellerDiscoveredBid, type TellerDiscovery, type TellerMarketsRaw, type TellerPoolRaw, type TermAdapter, type TermAssetRef, type TermAuctionOrder, type TermAuctionOrders, type TermBookSource, type TermBookTop, type TermInfo, type TermListing, type TermMarketRaw, TermMaxApiSource, type TermMaxBookTop, type TermMaxCurveSegment, type TermMaxDataSource, type TermMaxDiscovery, type TermMaxFeeConfig, type TermMaxMarketConfig, type TermMaxMarketRaw, type TermMaxOrderState, type TermProfile, type TermSheet, type TermSheetDigest, type TermSheetInput, type TermSheetViolation, TermSubgraphSource, type TermTag, type TokenApprovalMeta, type TokenApprovalParams, type TokenBalanceEntry, type TokenBalanceQuery, type TokenBalanceResult, type TokenEntry, type TokenList, type TokenListInput, type TrackerDiagnostic, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, type USDPriceMap, type UpshiftApiAsset, type UpshiftApiVault, type UpshiftVault, type UpshiftVaults, type UsddMarketRaw, type UsddMarketsRaw, type DssPositionInfo as UsddPositionInfo, type UserApr, type UserConfig, type UserData, type UserDataResult, type UserLendingPosition, type UtilizationTerms, VAULT_SHARE_PRICE_PROBE, VOLATILE_VAULT_OVERRIDES, type ValidationResult, type VaultAprResult, type VaultClassification, type VaultClassificationFields, type VaultLookupEntry, type VaultMarketExposure, type VaultProvider, type VaultPublicDataAll, type VaultPublicDataResult, type VaultYieldSeries, type VaultYieldSnapshot, type YDaemonVault, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, type YearnVault, type YearnVaultKind, type YearnVaults, type YieldProfile, __resetResupplyUserCaches, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachImplications, attachPricesToFlashLiquidity, borrowDescription, borrowFindings, borrowHeadline, buildExposures, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildTermSheet, buildTermSheetsForGroup, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, collectFeedObservations, computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertDssMarketsToResponse, convertExactlyMarketsToResponse, convertFrankencoinMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertLlamaLendMarketsToResponse, convertResupplyMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, deriveBorrowTags, deriveSupplyTags, detectInterfaceKinds, dssIlkBytes32, dssKeyParts, dssLenderKey, duration, encodeBalanceFetcherCalldata, enrichTermSheet, enrichmentIndexFromRows, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feePhrase, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchDssMarkets, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchFrankencoinMarkets, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchLlamaLendMarkets, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendlePrices, fetchResupplyMarkets, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, finalizeInfo, findingsFor, frankencoinKeyParts, frankencoinLenderKey, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedLiquityTroves, getCachedTellerBids, getCachedTermMaxDiscovery, getCachedTermMaxMarket, getCachedTermMaxMarkets, getCoreValidators, getFluidFTokensConverter, getGmxApiHost, getGmxReadContracts, getGmxUserPositions, getHealthFactor, getHypercoreUserPositions, getHypercoreVaultRegistry, getLenderAssets, getLenderPublicData, getLenderPublicDataAll, getLenderPublicDataViaApi, getLenderUserDataMulti, getLenderUserDataResult, getLendersForChain, getLstDelegation, getLstValidators, getLstWithdrawalRegistry, getLstWithdrawalRequests, getMaxAmountClose, getMaxAmountCollateralSwap, getMaxAmountDebtSwap, getMaxAmountOpen, getMergedUserData, getMorphoTypeMarketConverter, getReadFailurePolicy, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getTermProfile, getVaultPublicDataAll, getVaultWithdrawalRequests, hasCritical, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, ilkToKeySegment, inverseKeyParts, inverseLenderKey, isFailedCall, isStablecoinSymbol, isYearnV3, keySegmentToIlk, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, llamaLendKeyParts, llamaLendLenderKey, mergeDeep, multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, pct, positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, rankFindings, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveAdapter, resolveDerivation, resolveStCeloDepositGroup, resupplyKeyParts, resupplyLenderKey, resupplyMarketLabel, riverKeyParts, riverLenderKey, selectAssetGroupPrices, shortDate, stampVaultClassification, supplyDescription, supplyFindings, supplyHeadline, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, termMaxApiBase, borrowNif as termMaxBorrowNif, curveApr as termMaxCurveApr, curveAprNumber as termMaxCurveAprNumber, daysToMaturity as termMaxDaysToMaturity, lendNif as termMaxLendNif, mintGtFeeRatio as termMaxMintGtFeeRatio, ratioToNumber as termMaxRatioToNumber, ratioToPercent as termMaxRatioToPercent, tickToAprNumber, tickToPrice, toDigest, toTermSheetInput, unflattenLenderData, updateFeedStats, usddIlkBytes32, usddKeyParts, usddLenderKey, validateTermSheet, validateTermSheets, validateUserData };
+/**
+ * `earnUid` — the primary key of the unified earn surface.
+ *
+ * There is NO single unified format, and deliberately so. There are two forms
+ * sharing one grammar (`<venue>:<chainId>:<ref>`):
+ *
+ * ```
+ * lending  →  <Lender>:<chainId>:<ref>              the EXISTING marketUid, verbatim
+ * vault    →  vault.<provider>:<chainId>:<address>  the only new form
+ * ```
+ *
+ * Reusing the grammar rather than inventing a format is what buys zero
+ * migration on the lending half: a lending row's `earnUid` IS its `marketUid`,
+ * so it is already valid on every existing action route.
+ *
+ * **The uid is OPAQUE.** The meaning of the third segment is venue-dependent —
+ * on the lending side it is the underlying for Aave/Morpho/Compound V3, the
+ * cToken for Compound V2, the silo for Silo, the eVault for Euler, and an
+ * INTEGER marketId for Dolomite (not an address at all). Only `parseEarnUid`
+ * may split an `earnUid`; consumers read `EarnMarket.asset.address` to learn
+ * what to deposit, never the uid.
+ *
+ * See EARN_ENDPOINT_PLAN.md §3.
+ */
+/**
+ * Namespace prefix marking the vault form. Vault providers are lowercase and
+ * `Lender` keys are uppercase, so bare provider names would already be
+ * collision-free — but only by case, which one consumer lowercasing a uid
+ * somewhere would silently break. The prefix makes the distinction structural
+ * and `isVaultVenue` a `startsWith`.
+ */
+declare const VAULT_VENUE_PREFIX = "vault.";
+/** A lending venue is a `Lender` key; a vault venue is `vault.<provider>`. */
+type EarnVenueKind = 'lending' | 'vault';
+interface ParsedLendingEarnUid {
+    kind: 'lending';
+    /** The `Lender` key, e.g. `AAVE_V3`. */
+    venue: string;
+    chainId: string;
+    /**
+     * The uid's third segment. Venue-dependent — resolve it with the worker's
+     * `parseMarketUid`, never by assuming it is a token address.
+     */
+    ref: string;
+    /** Byte-identical to the input. Pass straight to `parseMarketUid`. */
+    marketUid: string;
+}
+interface ParsedVaultEarnUid {
+    kind: 'vault';
+    /** The full venue string, e.g. `vault.savings`. */
+    venue: string;
+    /** The bare provider, e.g. `savings`. */
+    provider: VaultProvider;
+    chainId: string;
+    /** Lowercased share-token address (L1 vault address for hypercore). */
+    address: string;
+}
+type ParsedEarnUid = ParsedLendingEarnUid | ParsedVaultEarnUid;
+/**
+ * Cheap syntactic check — does this uid use the vault form? Does not validate
+ * the provider; use `parseEarnUid` when correctness matters.
+ */
+declare function isVaultVenue(uidOrVenue: string): boolean;
+/** `savings` → `vault.savings`. */
+declare function vaultVenue(provider: VaultProvider): string;
+/**
+ * Mint the vault form from its parts. The address is lowercased to match the
+ * canonical keying used across the vault pipeline (`buildVaultLookup` and the
+ * `${chainId}-${address}` DB convention both lowercase).
+ *
+ * @throws if any part is empty.
+ */
+declare function buildVaultEarnUid(provider: VaultProvider, chainId: string, address: string): string;
+/**
+ * The lending form. This is the IDENTITY FUNCTION over `marketUid` — it exists
+ * so call sites read as a deliberate mapping rather than an assignment, and so
+ * the shape is validated once at the boundary.
+ *
+ * Never RECONSTRUCT a lending uid from a row's fields. `/pools/latest` rows
+ * carry `marketUid` stamped by the public-data parsers; rebuilding it as
+ * `lender:chainId:underlying` is only correct for the default-format lenders
+ * and silently mints a wrong key for Compound V2 (needs the cToken) and
+ * Dolomite (needs the integer marketId). A wrong uid does not degrade a term
+ * sheet — it routes a deposit to the wrong market. See EARN_ENDPOINT_PLAN §3.2.
+ *
+ * @throws if `marketUid` is not three non-empty colon-separated segments, or
+ *         if it collides with the `vault.` namespace.
+ */
+declare function earnUidFromMarketUid(marketUid: string): string;
+/**
+ * Split an `earnUid` into its parts, discriminated by form.
+ *
+ * `knownProviders` defaults to undefined, which accepts any `vault.<x>` venue.
+ * Pass the live provider set when parsing untrusted input (an action route's
+ * query param) so an unknown provider fails at the edge with a clear message
+ * rather than deep inside a dispatcher.
+ *
+ * @throws on a malformed uid or an unrecognised provider.
+ */
+declare function parseEarnUid(earnUid: string, knownProviders?: readonly VaultProvider[]): ParsedEarnUid;
+/** Non-throwing `parseEarnUid`. Returns undefined instead of throwing. */
+declare function tryParseEarnUid(earnUid: string, knownProviders?: readonly VaultProvider[]): ParsedEarnUid | undefined;
+/** Which half of the surface a uid belongs to, without a full parse. */
+declare function earnVenueKind(earnUid: string): EarnVenueKind;
+
+/**
+ * `EarnMarket` — one supply-side opportunity, from either half of the stack.
+ *
+ * This is a PROJECTION, not a replacement. The borrow side, pairs, leverage
+ * and migrate stay on `/v1/data/lending/*`; a lending market appears here as
+ * one row per supplyable asset with a `refs.marketUid` pointer back.
+ *
+ * Everything here is derived from data the two origins already return — the
+ * work is unit normalization and identity, not new fetching.
+ *
+ * See EARN_ENDPOINT_PLAN.md §4.
+ */
+interface EarnMarket {
+    /**
+     * TWO FORMS, not one — see `./uid`. OPAQUE: only `parseEarnUid` may split it.
+     *   lending → the row's `marketUid`, VERBATIM
+     *   vault   → `vault.<provider>:<chainId>:<address>`
+     */
+    earnUid: string;
+    chainId: string;
+    /** `AAVE_V3` (a `Lender` key) or `vault.savings` (`vault.<provider>`). */
+    venue: string;
+    venueKind: EarnVenueKind;
+    /** Display label — 'Aave V3', 'Spark', 'Ethena'. */
+    brand?: string;
+    /** Market or vault display name. */
+    name?: string;
+    /**
+     * The uid's third segment, lifted out so consumers never parse the uid.
+     * Venue-dependent on the lending side (underlying / cToken / silo / Dolomite
+     * marketId / …); the share token on the vault side.
+     */
+    ref: string;
+    /** Branded icon URL, when one resolved. */
+    logoURI?: string;
+    /** What the user deposits. */
+    asset: EarnAsset;
+    /** Present only when depositing mints a distinct receipt token. */
+    shareToken?: EarnShareToken;
+    /** What the user earns. ALWAYS PERCENT — see `EarnRate`. */
+    rate: EarnRate;
+    /** Size and room. */
+    tvl: EarnAmount;
+    /** What can actually leave right now. Absent ⇒ not reported by the source. */
+    liquidity?: EarnAmount;
+    /**
+     * Room for new deposits, raw base units. `undefined` = uncapped,
+     * `'0'` = full. Distinct from `availability.canDeposit`, which is a
+     * permission — a vault can be permissionless AND full (3Jane USD3), or
+     * gated AND empty.
+     */
+    depositCapacity?: string;
+    /** Debt/supply ratio. Lending and lending-backed vaults only. */
+    utilization?: number;
+    /**
+     * When the deal ENDS. Present only on rows that have a maturity — Pendle
+     * PTs today, and the fixed-term lenders (TermMax, Exactly, Midnight, Term,
+     * Teller) as the term-sheet adapter reaches them.
+     *
+     * Lifted to the row root rather than left inside `termSheet` because for a
+     * fixed-rate product the maturity is not enrichment: a 9 % rate over eleven
+     * days and a 9 % rate over two years are different offers, and a client that
+     * has to opt into `?terms=full` to tell them apart will sort them into the
+     * same column. Absent ⇒ perpetual.
+     */
+    maturity?: MaturityTerms;
+    /** The deal. Digest by default, full sheet under `?terms=full`. */
+    termSheet?: TermSheet | TermSheetDigest;
+    exit: EarnExit;
+    availability: EarnAvailability;
+    risk?: EarnRisk;
+    /** How to transact. Empty ⇒ nothing can be done right now. */
+    capabilities: EarnCapability[];
+    /** Pointers, never copies. */
+    refs?: EarnRefs;
+    /** Provider-specific escape hatch. Semantics unchanged from the source. */
+    providerMeta?: Record<string, unknown>;
+}
+interface EarnAsset {
+    /** The underlying the user supplies, lowercased. */
+    address: string;
+    symbol: string;
+    decimals: number;
+    /** Price-group key ('ETH', 'USDC') — how the price store is keyed. */
+    assetGroup?: string;
+    priceUsd?: number;
+}
+interface EarnShareToken {
+    address: string;
+    symbol: string;
+    /**
+     * Share decimals. Equals `asset.decimals` for plain ERC-4626, but NOT for
+     * Lagoon (18-decimal shares over 6-decimal USDC) — never assume they match.
+     */
+    decimals: number;
+}
+/**
+ * An amount, carried in whichever scales the source actually provides.
+ *
+ * **The two origins do NOT agree on scale, and this is a 1e18 landmine.**
+ * The vault side reports `tvl.totalAssets` as a RAW base-unit integer string;
+ * the lending side reports `totalDeposits` already through `parseRawAmount`,
+ * which is `formatUnits` — i.e. TOKEN UNITS, despite the field being commented
+ * "raw amounts" at its source. Folding both into one field would sort a $1M
+ * Aave reserve below a dust vault.
+ *
+ * So: `formatted` is the cross-source field a consumer should compare on, and
+ * `raw` is present only where the source genuinely carries base units. Never
+ * infer one from the other without `asset.decimals`.
+ */
+interface EarnAmount {
+    /**
+     * Raw base-unit integer STRING — never a number; these overflow float64 well
+     * inside normal 18-decimal balances. Absent when the source is pre-formatted.
+     */
+    raw?: string;
+    /** Human/token units. The field to compare and sort on. */
+    formatted?: number;
+    usd?: number;
+}
+/**
+ * The headline yield.
+ *
+ * **Every field is a PERCENT** (`4.12` = 4.12 %). This is the single most
+ * dangerous field on the row: the lending origin reports percent, the 4626
+ * vault providers report percent, but realized APR, HyperCore `apr` and GMX
+ * `apy`/`baseApy`/`bonusApr` are FRACTIONS at the source. Normalizing them on
+ * the way in is not optional — the same column would otherwise be 100× off
+ * between two rows in one list. See `vaults/DATABASE_INTEGRATION.md` §1.
+ */
+interface EarnRate {
+    /** The headline: base + rewards + intrinsic. */
+    total: number;
+    /** Protocol interest / share-price accrual. */
+    base?: number;
+    /** Incentive programs (Merkl et al). */
+    rewards?: number;
+    /** The underlying's own yield (stETH staking under an stETH market). */
+    intrinsic?: number;
+    /**
+     * What THIS venue pays, on top of what the asset would pay in your wallet:
+     * `base + rewards`, excluding `intrinsic`.
+     *
+     * This is the number that answers "what am I being paid for taking this
+     * market's risk". `total` answers "what will my balance do", and for a
+     * yield-bearing collateral the two are very different.
+     */
+    marketOwn?: number;
+    /**
+     * True when the asset carries its own yield and the venue adds ~nothing —
+     * `intrinsic > 0` and `marketOwn < 0.01 %`.
+     *
+     * These rows are the reason an APR-sorted earn list misleads: an LST market
+     * showing 3 % out-ranks a genuine 2.5 % stablecoin market, but supplying into
+     * it earns you **the same as holding the token**, with the market's
+     * liquidation, oracle and governance risk added for free. Filtered out by
+     * default — see the `passthrough` param on `/v1/data/earn`.
+     *
+     * Distinct from `availability.gating === 'collateral-only'`, which is a
+     * market paying nothing on an asset that also pays nothing.
+     */
+    passthrough?: boolean;
+    /**
+     * HOW the rate is set — the provenance that stops a leaderboard from lying.
+     * A `variable-curve` 8 % and a `nav-accrual` 8 % are not the same promise.
+     */
+    kind: RateKind;
+    /** WHERE the number came from. */
+    source: EarnRateSource;
+    /** Unix seconds — the rate is a snapshot. */
+    asOf?: number;
+}
+type EarnRateSource = 
+/** Read from the chain (IRM, accumulator, share price). */
+'chain'
+/** Protocol or aggregator API (Morpho, DefiLlama, Strata S3). */
+ | 'api'
+/** A price/NAV feed (Re, USPC, Apyx). */
+ | 'oracle'
+/** Derived from a share-price series (`computeVaultApr`). */
+ | 'realized';
+/**
+ * How the money gets out. Flattened to the row root deliberately: on
+ * `/v1/data/vaults` this lives in `providerMeta.withdrawalMode`, which is a
+ * known integrator trap. Here it is always at the same path for every venue.
+ */
+interface EarnExit {
+    mode: SupplyExitMode;
+    settlement?: SupplyExitTerms['settlement'];
+    cooldownSecs?: number;
+    /** Instant-exit fee, where taking the fast path costs something. */
+    feeBps?: number;
+}
+interface EarnAvailability {
+    canDeposit: boolean;
+    canWithdraw: boolean;
+    /** Why not, when `canDeposit` is false. */
+    gating?: EarnGating;
+    /** Human-readable, for the disabled-CTA tooltip. */
+    reason?: string;
+}
+type EarnGating = 
+/** Contract callers must be governance-approved (Inverse, Fraxlend). */
+'allowlist-contract' | 'kyc'
+/** Permissionless but at its cap (3Jane USD3, Yield Basis). */
+ | 'cap-full' | 'paused' | 'frozen'
+/**
+ * A fixed-term product past its maturity. Entry is closed and the published
+ * rate is stale by construction; the exit leg stays open so a holder can
+ * still redeem. Should be rare — matured rows are filtered upstream — but
+ * the check is repeated here because a recorder lag is exactly how a dead
+ * market ends up at the top of a rate-sorted list.
+ */
+ | 'matured'
+/** Deposits are open but this leg earns nothing (collateral-only reserve). */
+ | 'collateral-only';
+interface EarnRisk {
+    /** Monotonic accrual vs a NAV that can fall. */
+    yieldProfile?: YieldProfile;
+    denomination?: Denomination;
+    /** The trust question, one field. */
+    counterparty?: CounterpartyTerms['solvency'];
+}
+interface EarnRefs {
+    /** Lending only — the full market (borrow side, pairs, IRM). */
+    marketUid?: string;
+    /** Can this asset also be borrowed here? */
+    borrowable?: boolean;
+    /** What actually backs a curated vault. */
+    exposures?: VaultMarketExposure[];
+}
+type EarnActionKind = 'deposit' | 'withdraw'
+/** Open an async exit (cooldown, queue, keeper ticket). */
+ | 'request-withdraw'
+/** Settle a matured request. */
+ | 'claim'
+/** Unwind an open request before it settles. */
+ | 'cancel';
+/**
+ * What can be done to this row, and what each op needs.
+ *
+ * This is what makes the flow genuinely unified: the client stops branching on
+ * provider. It renders the CTA from `capabilities`, collects whatever
+ * `requires` names, and posts one shape to `/v1/actions/earn/{action}`.
+ * Yield Basis' mandatory `debt`/`minShares`, Apyx's `tokenId`, GMX's
+ * `executionFee`, an LST's `validator` — all surface as DATA rather than as
+ * tribal knowledge in the integrator's head.
+ */
+interface EarnCapability {
+    action: EarnActionKind;
+    /**
+     * Params required BEYOND the universal set (`earnUid`, `operator`,
+     * `receiver`, `amount`). E.g. `['validator']`, `['debt','minShares']`,
+     * `['tokenId']`.
+     */
+    requires?: string[];
+    /** Deposit only — may the user pay an asset other than `asset.address`? */
+    acceptsPayAsset?: boolean;
+    /** Withdraw only — may the user receive something other than the asset? */
+    acceptsReceiveAsset?: boolean;
+    /**
+     * Settles later (keeper ticket, cooldown, queue) — the client must poll
+     * `/v1/data/earn/withdrawals` rather than treat the tx as terminal.
+     */
+    async?: boolean;
+    /** Cost hint for the CTA, before quoting. */
+    feeBps?: number;
+    /**
+     * HOW the action is executed.
+     *
+     * Absent (or `'native'`) ⇒ a protocol call — deposit/withdraw/redeem against
+     * the venue itself, which is every 4626 vault and every lending market.
+     *
+     * `'swap'` ⇒ **there is no protocol entry point at all**; the position is
+     * acquired and closed by TRADING the instrument. Pendle PTs are the case:
+     * you buy the bond on Pendle's AMM at a discount and sell it back, so both
+     * legs need a slippage tolerance, both are priced by pool depth, and neither
+     * has a "deposit the underlying" path to fall back on. A client that renders
+     * a 4626-style amount box for one of these builds an input the venue cannot
+     * serve.
+     */
+    via?: 'native' | 'swap';
+}
+/**
+ * `/v1/data/earn` response. The shape NEVER changes — a degraded source is
+ * reported in `sources[]` with the rows that did resolve still served, rather
+ * than switching to a different payload the way `/v1/data/vaults` does when
+ * its origin is down.
+ */
+interface EarnResponse {
+    ok: boolean;
+    /** Pagination offset of the first item. */
+    start: number;
+    /** Items in THIS page. */
+    count: number;
+    /** Items matching the filter across all pages. */
+    total: number;
+    /** Stamped so no consumer has to guess. Always `'percent'`. */
+    rateUnit: 'percent';
+    items: EarnMarket[];
+    sources: EarnSourceStatus[];
+    /**
+     * Rows this endpoint removed by DEFAULT, so a UI can offer them back rather
+     * than a user wondering where a market went. Only the pass-through default
+     * (see `EarnRate.passthrough`) removes anything unasked; every other filter
+     * is opt-in.
+     */
+    excluded: EarnExclusions;
+    /** What a client can filter by, derived from the data. See {@link EarnFacets}. */
+    facets: EarnFacets;
+}
+interface EarnExclusions {
+    /** Rows hidden because the venue adds ~nothing over the asset's own yield. */
+    passthrough: number;
+}
+/**
+ * The filter vocabulary, published rather than hard-coded.
+ *
+ * **A client must never ship its own list of venues or providers.** The
+ * existing frontend does — `VAULT_PROVIDERS` in `sdk/vaults-helper/types.ts`
+ * is a 13-entry copy of `VaultProvider`, already two behind the SDK's 15, so a
+ * newly-integrated protocol is invisible until the frontend redeploys. Facets
+ * invert that: the server enumerates what exists, the UI renders whatever it
+ * receives, and a new lender or vault provider appears with no client change.
+ *
+ * Counts are computed over the **full merged listing for the requested
+ * chains**, before any filter is applied — so selecting one venue does not make
+ * the other options vanish from the dropdown.
+ */
+interface EarnFacets {
+    /**
+     * Venues grouped by BRAND — the dimension a filter UI should offer.
+     *
+     * A chain can carry 20+ `MORPHO_BLUE_<id>` venues; listing each is a wall of
+     * hex nobody filters by. `brands` collapses them to one "Morpho Blue (23)"
+     * entry. `venues` stays for precise, single-market filtering.
+     */
+    brands: EarnFacetBucket[];
+    venues: EarnFacetBucket[];
+    venueKinds: EarnFacetBucket[];
+    chains: EarnFacetBucket[];
+    assetGroups: EarnFacetBucket[];
+    exitModes: EarnFacetBucket[];
+    /** Distinct actions available anywhere in the listing. */
+    actions: EarnFacetBucket[];
+}
+interface EarnFacetBucket {
+    /** The value to send back as a filter param. */
+    key: string;
+    /**
+     * Display label. **Populated for every bucket the server can name**, so a
+     * client renders `label ?? key` and ships no vocabulary of its own. An
+     * unlabelled key renders as itself rather than as a client-side guess.
+     */
+    label?: string;
+    /** One-line explanation, where the dimension has one (exit modes, kinds). */
+    description?: string;
+    /** Rows carrying this value in the unfiltered listing. */
+    count: number;
+}
+/**
+ * The display vocabulary, independent of any listing.
+ *
+ * Served by `GET /v1/data/earn/facets` so a client can build its filter UI
+ * (and label a row it already holds) **without fetching the catalogue**, and
+ * without embedding a single enum value of its own.
+ */
+interface EarnVocabulary {
+    /** dimension → key → label, e.g. `exitMode['fixed-cooldown'] = 'Cooldown'`. */
+    labels: Record<string, Record<string, string>>;
+    descriptions: Record<string, Record<string, string>>;
+}
+interface EarnSourceStatus {
+    source: 'pools' | 'vaults';
+    status: 'ok' | 'degraded' | 'failed';
+    /** Rows contributed by this source before filtering. */
+    rows: number;
+    /** Present when not `ok`. */
+    error?: string;
+}
+
+/**
+ * Display vocabulary for the earn surface — **owned by the server**.
+ *
+ * A client must not carry its own copy of any of this. That is not a style
+ * preference: every label map shipped in a frontend is a copy of server state
+ * that rots silently. When a new exit mode or vault provider is integrated, a
+ * client-side `switch` renders it as blank, as "Unknown", or worse, falls into
+ * a `default` branch that quietly misdescribes it — and nobody notices until a
+ * user acts on the wrong description.
+ *
+ * Putting the labels here means adding a mode is one change on one side, and
+ * every consumer picks it up on the next request.
+ *
+ * The rule for consumers is simply: **render `label ?? key`**. An unrecognised
+ * value then renders as itself, which is honest, rather than as a guess.
+ */
+/**
+ * Collapse a venue key to its brand.
+ *
+ * `MORPHO_BLUE_1E9D…` → `Morpho Blue`; `FLUID_1_11` → `Fluid`;
+ * `SKY_1_ETH_A` → `Sky`; `vault.savings` → `Savings`.
+ *
+ * Falls back to the longest recognised prefix, then to the family key itself —
+ * never to a guess. An unknown lender renders as its own key, which is terse
+ * but true, and adding it to the table later is a pure improvement.
+ */
+declare function venueBrand(venue: string): string;
+/** Every dimension the earn surface labels, in one lookup. */
+declare const EARN_LABELS: {
+    readonly venueKind: Record<string, string>;
+    readonly exitMode: Record<string, string>;
+    readonly action: Record<string, string>;
+    readonly gating: Record<string, string>;
+    readonly rateKind: Record<string, string>;
+    readonly rateSource: Record<string, string>;
+};
+declare const EARN_DESCRIPTIONS: {
+    readonly venueKind: Record<string, string>;
+    readonly exitMode: Record<string, string>;
+};
+type EarnLabelDimension = keyof typeof EARN_LABELS;
+/**
+ * Look up a label, falling back to the raw key.
+ *
+ * The fallback is the contract: an unlabelled value renders as itself, so a
+ * newly added mode is legible (if terse) everywhere immediately, and adding its
+ * label later is a pure improvement rather than a bug fix.
+ */
+declare function earnLabel(dimension: EarnLabelDimension, key: string): string;
+declare function earnDescription(dimension: keyof typeof EARN_DESCRIPTIONS, key: string): string | undefined;
+
+/**
+ * Multiply a formatted (human-unit) amount by a USD price.
+ *
+ * Returns `undefined` when either input is missing, rather than `0` — a vault
+ * we could not price must not sort as worthless next to one that genuinely is.
+ */
+declare function usdValue(formatted: number | undefined, priceUsd: number | undefined): number | undefined;
+/**
+ * Format a raw base-unit integer string to human units.
+ *
+ * Uses BigInt for the integer part so large balances keep full precision, then
+ * appends the fraction — `Number(raw) / 10 ** decimals` silently loses digits
+ * above 2^53, which is well inside normal 18-decimal TVLs.
+ */
+declare function formatRaw(raw: string | undefined, decimals: number): number | undefined;
+
+/**
+ * Vault half of the `/earn` normalizer: one `/vaults/latest` row → `EarnMarket`.
+ *
+ * The input is the recorder origin's item shape, which is loosely typed by
+ * design (providers add fields without a schema bump), so every read goes
+ * through a tolerant accessor and a missing field yields `undefined` rather
+ * than a throw. A row missing its two load-bearing identifiers — the vault
+ * address and the underlying — is DROPPED, not patched.
+ *
+ * See EARN_ENDPOINT_PLAN.md §4.
+ */
+/** The origin's `/vaults/latest` item. Permissive on purpose — see above. */
+interface VaultSourceRow {
+    provider?: string;
+    vaultAddress?: string;
+    underlying?: string;
+    symbol?: string;
+    name?: string;
+    displayName?: string;
+    decimals?: number;
+    assetDecimals?: number;
+    curatorName?: string;
+    sharePrice?: number | string;
+    sharePriceUsd?: number | string;
+    rates?: {
+        depositRate?: number | string;
+        rewardsRate?: number | string;
+        totalRate?: number | string;
+        supplyRate?: number | string;
+        fee?: number | string;
+    };
+    tvl?: {
+        totalAssets?: string | number;
+        totalAssetsFormatted?: number | string;
+        totalSupply?: string | number;
+        totalAssetsUsd?: number | string;
+    };
+    liquidity?: {
+        liquidity?: string | number;
+        liquidityFormatted?: number | string;
+        liquidityUsd?: number | string;
+    };
+    underlyingInfo?: {
+        asset?: {
+            symbol?: string;
+            decimals?: number;
+            logoURI?: string;
+        };
+        prices?: {
+            priceUsd?: number | string;
+        };
+    };
+    vaultInfo?: {
+        symbol?: string;
+        name?: string;
+        logoURI?: string;
+        assetGroup?: string;
+        yieldProfile?: string;
+        denomination?: string;
+    };
+    providerMeta?: Record<string, any>;
+    [key: string]: unknown;
+}
+/**
+ * Providers whose rate fields arrive as FRACTIONS (`0.0412`) rather than
+ * percent (`4.12`), and therefore need scaling.
+ *
+ * **EMPTY for the origin path, and that is the verified answer, not a
+ * default.** The underlying hazard is real — `vaults/DATABASE_INTEGRATION.md`
+ * §1 documents HyperCore's `apr` and GMX's `apy`/`baseApy`/`bonusApr` as
+ * fractions where every 4626 provider reports percent — but the recorder
+ * already resolves it before the row reaches us. `mapGmxToListing` /
+ * `mapHypercoreToListing` in the origin's `routes/vaults.ts` run every rate
+ * through `pct()` (`× 100`) and park the raw fraction under
+ * `providerMeta.apr`, explicitly "for sort/filter parity".
+ *
+ * So scaling here would DOUBLE-convert and inflate every GMX and HyperCore row
+ * 100× — the exact bug this constant was written to prevent, in the opposite
+ * direction.
+ *
+ * The set survives as a parameter rather than being deleted because the
+ * SDK-fed path has the opposite convention: `getVaultPublicDataAll` emits the
+ * raw provider fractions with no `pct()` in between. Anything reading the SDK
+ * directly (a recorder, a `?source=live` fallback) must pass
+ * {@link SDK_FRACTION_RATE_PROVIDERS}.
+ */
+declare const FRACTION_RATE_PROVIDERS: ReadonlySet<string>;
+/**
+ * The fraction-reporting providers **as the SDK emits them**, before the
+ * recorder's `pct()` pass. Pass this to {@link earnMarketFromVault} when the
+ * rows come from `getVaultPublicDataAll` rather than from `/vaults/latest`.
+ */
+declare const SDK_FRACTION_RATE_PROVIDERS: ReadonlySet<string>;
+/** Per-call overrides for sources that disagree with the origin's conventions. */
+interface EarnVaultNormalizeOptions {
+    /**
+     * Providers whose rates need `× 100`. Defaults to
+     * {@link FRACTION_RATE_PROVIDERS} (empty — the origin already normalized).
+     */
+    fractionRateProviders?: ReadonlySet<string>;
+}
+/**
+ * Normalize one origin vault row. Returns `undefined` when the row lacks the
+ * identifiers needed to key or transact it — a dropped row is recoverable, a
+ * row with a fabricated key is not.
+ */
+declare function earnMarketFromVault(row: VaultSourceRow, chainId: string, opts?: EarnVaultNormalizeOptions): EarnMarket | undefined;
+/**
+ * Convert a source rate to PERCENT.
+ *
+ * `undefined` in ⇒ `undefined` out. Zero is preserved (a real 0 % is
+ * meaningful — a collateral-only leg genuinely earns nothing) rather than
+ * being folded into `undefined`.
+ */
+declare function ratePercent(value: unknown, provider: string, fractionProviders?: ReadonlySet<string>): number | undefined;
+/**
+ * Cheap plausibility guard for the fraction/percent question.
+ *
+ * Not a correctness proof — a genuine 300 % vault exists and a genuine 0.02 %
+ * one does too. It catches the systematic case: a whole provider's rows
+ * landing three orders of magnitude off because the origin already normalized
+ * and we normalized again. Call it from a test or a recorder, not per request.
+ */
+declare function implausibleRatePercent(percent: number): boolean;
+
+/**
+ * Lending half of the `/earn` normalizer: one `/pools/latest` row →
+ * `EarnMarket`, projecting the SUPPLY side only.
+ *
+ * The borrow side is not dropped, it is *pointed at*: `refs.marketUid` +
+ * `refs.borrowable` let a consumer jump to `/v1/data/lending/*` for the full
+ * market. Duplicating the borrow economics here would double the payload to
+ * serve a question this endpoint does not ask.
+ *
+ * The origin reshapes the SDK's flat `PoolData` into a partly-nested form
+ * (`caps`, `flags`, `underlyingInfo`), and the origin lives in another repo —
+ * so every field is read tolerantly in BOTH shapes. That is deliberate
+ * defensiveness, not indecision: a field that moves nests silently, and a
+ * silently-missing `isFrozen` would advertise a dead market as depositable.
+ *
+ * See EARN_ENDPOINT_PLAN.md §4.
+ */
+/** The origin's `/pools/latest` item (`PoolWithMeta`). Permissive by design. */
+interface PoolSourceRow {
+    /** Stamped by the public-data parsers. REQUIRED — see `earnMarketFromPool`. */
+    marketUid?: string;
+    lender?: string;
+    lenderKey?: string;
+    chainId?: string;
+    poolId?: string;
+    underlying?: string;
+    name?: string;
+    asset?: {
+        address?: string;
+        symbol?: string;
+        decimals?: number;
+        logoURI?: string;
+        assetGroup?: string;
+    };
+    underlyingInfo?: {
+        asset?: {
+            address?: string;
+            symbol?: string;
+            decimals?: number;
+            logoURI?: string;
+        };
+        assetGroup?: string;
+        prices?: {
+            priceUsd?: number | string;
+        };
+    };
+    decimals?: number;
+    /** Origin-computed `depositRate + intrinsicYield`. */
+    apr?: number | string;
+    price?: number | string;
+    depositRate?: number | string;
+    intrinsicYield?: number | string;
+    variableBorrowRate?: number | string;
+    rewards?: Array<{
+        asset?: string;
+        depositRate?: number | string;
+    }>;
+    totalDeposits?: string | number;
+    totalDepositsUSD?: number | string;
+    totalDepositsUsd?: number | string;
+    totalLiquidity?: number | string;
+    totalLiquidityUSD?: number | string;
+    totalLiquidityUsd?: number | string;
+    utilization?: number | string;
+    supplyCap?: number | string;
+    caps?: {
+        supplyCap?: number | string;
+        borrowCap?: number | string;
+    };
+    collateralActive?: boolean;
+    borrowingEnabled?: boolean;
+    depositsEnabled?: boolean;
+    isActive?: boolean;
+    isFrozen?: boolean;
+    flags?: {
+        collateralActive?: boolean;
+        borrowingEnabled?: boolean;
+        depositsEnabled?: boolean;
+        isActive?: boolean;
+        isFrozen?: boolean;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Normalize one origin pool row.
+ *
+ * Returns `undefined` when the row carries no `marketUid`. **The uid is never
+ * reconstructed** — rebuilding it as `lender:chainId:underlying` is only
+ * correct for the default-format lenders and silently mints a wrong key for
+ * Compound V2 (needs the cToken) and Dolomite (needs the integer marketId).
+ * A wrong term sheet is a display bug; a wrong uid routes a deposit to the
+ * wrong market. Drop the row and let the caller log it.
+ *
+ * See EARN_ENDPOINT_PLAN.md §3.2.
+ */
+declare function earnMarketFromPool(row: PoolSourceRow, fallbackChainId?: string): EarnMarket | undefined;
+
+/**
+ * Stamp `capabilities[]` onto a normalized row.
+ *
+ * Mutates and returns the row — it is called once per row inside the
+ * normalizer's own loop, and cloning several thousand rows to avoid a local
+ * mutation is a real cost for no benefit.
+ */
+declare function stampCapabilities(row: EarnMarket): EarnMarket;
+
+export { type AaveMetadata, type AaveV2Public, type AaveV2UserReserveResponse, type AaveV3Public, type AaveV3UserReserveResponse, type AdditionalYields, type AdminKind, ApiBookSource, type AprData, type AprPercent, type AssetQuality, type AssetRiskIndex, type AuctionWindow, type AvailabilityTerms, type BalanceData, type BaseLendingPosition, type BasicReserveResponse, type BorrowExitTerms, type BorrowTermSheet, type BuildTermSheetOptions, type ChainDiagnostic, type ChainLinkResponse, type ChainQuery, type ChainSummary, type CompoundV2Metadata, type CompoundV3Public, type CompoundV3UserReserveResponse, type ConfigEntry, type ConvertLenderUserDataOptions, type CoreValidators, type CounterpartyTerms, type CoverageInfo, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_PROFILE_ID, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, type DeepPartial, type Denomination, type DepthMap, type DssMarketRaw, type DssMarketsRaw, type DssPositionInfo, EARN_DESCRIPTIONS, EARN_LABELS, EMPTY_BALANCE, type EModeAssets, type EModeData, type EModeResult, EXACTLY_LENDER_KEY, type EarnActionKind, type EarnAmount, type EarnAsset, type EarnAvailability, type EarnCapability, type EarnExclusions, type EarnExit, type EarnFacetBucket, type EarnFacets, type EarnGating, type EarnLabelDimension, type EarnMarket, type EarnRate, type EarnRateSource, type EarnRefs, type EarnResponse, type EarnRisk, type EarnShareToken, type EarnSourceStatus, type EarnVaultNormalizeOptions, type EarnVenueKind, type EarnVocabulary, type EndpointFailure, type EnrichmentIndex, type EulerEarnVault, type EulerEarnVaults, type EulerV2Metadata, type ExactlyFixedPool, type ExactlyFixedPosition, type ExactlyMarketAccount, type ExactlyMarketsRaw, type ExactlyUserFixedPosition, type ExposureEntry, type ExposureTerms, type ExtraValidationCall, FRACTION_RATE_PROVIDERS, type FeeTerm, type FeeWhen, type FeedObservation, type FeedStat, type FeedStatsMap, type FeedTimestampMap, type FetchListaVaultsFromChainOptions, type FetchMorphoVaultsFromChainOptions, type FetchOraclePricesOptions, type FetchPendlePtOptions, type FetchTokenBalancesOptions, type FlattenPriorityConfig, type FluidFToken, type FluidFTokens, type FrankencoinMarketRaw, type FrankencoinMarketsRaw, type FrankencoinPositionInfo, type FullLenderRewardsMap, GMX_API_HOSTS, GMX_READ_CONTRACTS, GMX_SUPPORTED_CHAINS, type GenericCurrency, type GenericTokenList, type GetVaultPublicDataAllOptions, type GmxExecutionFees, type GmxPendingDeposit, type GmxPendingWithdrawal, type GmxReadContracts, type GmxUserBalance, type GmxUserPositions, type GmxUserPositionsOptions, type GmxVault, type GmxVaultKind, type GmxVaults, type GmxVaultsFetchOptions, type GovernancePower, type GovernanceRow, type GovernanceTerms, type GroupAccumulator, HYPERCORE_VAULT_REGISTRY, type HypercoreLockStatus, type HypercoreUserPositionsOptions, type HypercoreVault, type HypercoreVaultPosition, type HypercoreVaultRegistryEntry, type HypercoreVaults, type HypercoreVaultsFetchOptions, IDLE_MARKET_ID, INTERFACE_IDS, type IncompleteLenderRead, type IncompleteReason, type InitMetadata, type InitPublic, type InitUserReserveResponse, type InterfaceKind, type InvariantViolation, type InverseMarketRaw, type InverseMarketsRaw, type InversePositionInfo, LAGOON_API_URL, LAGOON_CHAIN_IDS, type LagoonApiVault, type LagoonSyncMode, type LagoonVault, type LagoonVaults, type LenderAssetReward, type LenderConfigData, type LenderConfigMap, type LenderCrossPoolMeta, type LenderData, type LenderDataEntry, type LenderInfo, type LenderInfoMap, type LenderPublicBase, type LenderRewardsMap, type LenderSummary, type LenderToLenderCrossPoolMeta, type LenderTotalAmounts, type LenderUserQuery, type LenderUserResponse, type LenderYieldComplete, type LenderYields$1 as LenderYields, LendingMode, type LiquidationPenaltyTerm, type LiquidationTerms, type LiquityBranchRaw, type LiquityDiscoveredTrove, type LiquityDiscovery, type LiquityMarketsRaw, type LiquitySpInfo, type LiquityTroveInfo, type ListaMarketOverrides, type LlamaLendMarketOverride, type LlamaLendMarketOverrides, type LlamaLendMarketRaw, type LlamaLendMarketsRaw, type LlamaLendPositionInfo, type LoopPostTradeMetrics, type LstDelegation, type LstDelegationKind, type LstValidator, type LstWithdrawalFetchOptions, type LstWithdrawalRegistryEntry, type LstWithdrawalRequest, type LstWithdrawalRequestsByLst, type LstWithdrawalStatus, MORPHO_LENS, MULTICALL_FAILURE, type MaturityTerms, MaxParamThresholds, type MergedUserData, type MidnightBook, type MidnightBookLevel, type MidnightBookSource, type ModeBase, type ModeVariant, type MorphoMarketOverrides, type MorphoSubgraphProxyConfig, type MorphoUserMarketBalance, type MorphoUserReserveResponse, type MorphoVault, type MorphoVaults, type MulticallEndpointOptions, type MulticallRpcBatch, type NumberMap, type Open, type OracleBand, type OracleDiagnostics, type OraclePriceEntry, type OraclePricesResult, type OracleRiskRow, type OracleTerms, type OutlierGuardConfig, PENDLE_ASSETS_URL, PENDLE_CHAIN_IDS, PENDLE_MARKETS_URL, type ParsedBalanceData, type ParsedEarnUid, type ParsedLendingEarnUid, type ParsedResponse, type ParsedUserBalance, type ParsedVaultEarnUid, type PendleApiAsset, type PendleApiMarket, type PendleApiMarketDetails, type PendlePtMarket, type PendlePtMarkets, type PermissionKind, type PermissionParams, type PoolData, type PoolSourceRow, type PoolWithMeta, type PortfolioSummary, type PortfolioTotals, type PositionConstraints, type PostTradeMetrics, type PreparedCall, type PreparedMergedMulticallParams, type PreparedMergedRpcCalls, type PreparedTokenBalanceRpcCalls, type PreparedUserDataRpcCalls, type PriceDerivation, type PriceSelection, type ProtocolParams, type ProviderOptions, type RateKind, type RateMenuEntry, type RateTerms, type RawRpcBatch, type RawRpcCall, type RawRpcResponse, type ReadFailurePolicy, type RedemptionTerms, type ResupplyMarketsRaw, type ResupplyPairIdentity, type ResupplyPairRaw, type ResupplyPositionInfo, type ResupplyWrappedMarket, type RewardSourceRef, type RewardStream, type RewardTerm, type RewardTokenRef, type RiverMarketRaw, type RiverMarketsRaw, type RiverPositionInfo, SDK_FRACTION_RATE_PROVIDERS, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, type SelectPricesOptions, type Severity, type SeverityFinding, type SiloVault, type SiloVaults, type StCeloValidatorGroup, type StaleFeedEntry, type StampOptions, type StructuredOraclePrices, type SubAccountSummary, type SumerPositionInput, type SummaryAprData, type SummaryBalanceData, type SupplyExitMode, type SupplyExitTerms, type SupplyTermSheet, TELLER_CALLS_PER_BID, TERMMAX_CALLS_PER_ACCOUNT, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, TERM_ADAPTERS, TERM_PROFILES, TERM_SHEET_SCHEMA_VERSION, type TellerDiscoveredBid, type TellerDiscovery, type TellerMarketsRaw, type TellerPoolRaw, type TermAdapter, type TermAssetRef, type TermAuctionOrder, type TermAuctionOrders, type TermBookSource, type TermBookTop, type TermInfo, type TermListing, type TermMarketRaw, TermMaxApiSource, type TermMaxBookTop, type TermMaxCurveSegment, type TermMaxDataSource, type TermMaxDiscovery, type TermMaxFeeConfig, type TermMaxMarketConfig, type TermMaxMarketRaw, type TermMaxOrderState, type TermProfile, type TermSheet, type TermSheetDigest, type TermSheetInput, type TermSheetViolation, TermSubgraphSource, type TermTag, type TokenApprovalMeta, type TokenApprovalParams, type TokenBalanceEntry, type TokenBalanceQuery, type TokenBalanceResult, type TokenEntry, type TokenList, type TokenListInput, type TrackerDiagnostic, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, type USDPriceMap, type UpshiftApiAsset, type UpshiftApiVault, type UpshiftVault, type UpshiftVaults, type UsddMarketRaw, type UsddMarketsRaw, type DssPositionInfo as UsddPositionInfo, type UserApr, type UserConfig, type UserData, type UserDataResult, type UserLendingPosition, type UtilizationTerms, VAULT_SHARE_PRICE_PROBE, VAULT_VENUE_PREFIX, VOLATILE_VAULT_OVERRIDES, type ValidationResult, type VaultAprResult, type VaultClassification, type VaultClassificationFields, type VaultLookupEntry, type VaultMarketExposure, type VaultProvider, type VaultPublicDataAll, type VaultPublicDataResult, type VaultSourceRow, type VaultYieldSeries, type VaultYieldSnapshot, type YDaemonVault, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, type YearnVault, type YearnVaultKind, type YearnVaults, type YieldProfile, __resetResupplyUserCaches, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachImplications, attachPricesToFlashLiquidity, borrowDescription, borrowFindings, borrowHeadline, buildExposures, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildTermSheet, buildTermSheetsForGroup, buildVaultEarnUid, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, clearPendleMarketsCache, collectFeedObservations, computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertDssMarketsToResponse, convertExactlyMarketsToResponse, convertFrankencoinMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertLlamaLendMarketsToResponse, convertResupplyMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, deriveBorrowTags, deriveSupplyTags, detectInterfaceKinds, dssIlkBytes32, dssKeyParts, dssLenderKey, duration, earnDescription, earnLabel, earnMarketFromPool, earnMarketFromVault, earnUidFromMarketUid, earnVenueKind, encodeBalanceFetcherCalldata, enrichTermSheet, enrichmentIndexFromRows, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feePhrase, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchDssMarkets, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchFrankencoinMarkets, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchLlamaLendMarkets, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendleApiAssets, fetchPendleApiMarkets, fetchPendlePrices, fetchPendlePtMarkets, fetchResupplyMarkets, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, finalizeInfo, findingsFor, formatRaw, frankencoinKeyParts, frankencoinLenderKey, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedLiquityTroves, getCachedTellerBids, getCachedTermMaxDiscovery, getCachedTermMaxMarket, getCachedTermMaxMarkets, getCoreValidators, getFluidFTokensConverter, getGmxApiHost, getGmxReadContracts, getGmxUserPositions, getHealthFactor, getHypercoreUserPositions, getHypercoreVaultRegistry, getLenderAssets, getLenderPublicData, getLenderPublicDataAll, getLenderPublicDataViaApi, getLenderUserDataMulti, getLenderUserDataResult, getLendersForChain, getLstDelegation, getLstValidators, getLstWithdrawalRegistry, getLstWithdrawalRequests, getMaxAmountClose, getMaxAmountCollateralSwap, getMaxAmountDebtSwap, getMaxAmountOpen, getMergedUserData, getMorphoTypeMarketConverter, getReadFailurePolicy, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getTermProfile, getVaultPublicDataAll, getVaultWithdrawalRequests, hasCritical, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasPendleMarkets, hasUpshiftVaults, hasYearnVaults, ilkToKeySegment, implausibleRatePercent, inverseKeyParts, inverseLenderKey, isFailedCall, isLiveMarket as isLivePendleMarket, isStablecoinSymbol, isVaultVenue, isYearnV3, keySegmentToIlk, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, llamaLendKeyParts, llamaLendLenderKey, mergeDeep, multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseEarnUid, parseMergedResult, parseMulticallRpcResponses, parseExpirySeconds as parsePendleExpirySeconds, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, pct, assetKey as pendleAssetKey, positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, rankFindings, ratePercent, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveAdapter, resolveDerivation, resolveStCeloDepositGroup, resupplyKeyParts, resupplyLenderKey, resupplyMarketLabel, riverKeyParts, riverLenderKey, selectAssetGroupPrices, shortDate, splitChainScopedAddress as splitPendleChainScopedAddress, stampCapabilities, stampVaultClassification, supplyDescription, supplyFindings, supplyHeadline, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, termMaxApiBase, borrowNif as termMaxBorrowNif, curveApr as termMaxCurveApr, curveAprNumber as termMaxCurveAprNumber, daysToMaturity as termMaxDaysToMaturity, lendNif as termMaxLendNif, mintGtFeeRatio as termMaxMintGtFeeRatio, ratioToNumber as termMaxRatioToNumber, ratioToPercent as termMaxRatioToPercent, tickToAprNumber, tickToPrice, toDigest, toTermSheetInput, tryParseEarnUid, unflattenLenderData, updateFeedStats, usdValue, usddIlkBytes32, usddKeyParts, usddLenderKey, validateTermSheet, validateTermSheets, validateUserData, vaultVenue, venueBrand };