@1delta/margin-fetcher 0.0.2889 → 5.0.0

package/dist/vaults/lst/withdrawals/types.d.ts

@@ -1,74 +0,0 @@
-/**
- * Normalised shape for a single pending withdrawal request, uniform
- * across all LST protocols regardless of underlying mechanism
- * (fixed-cooldown vs queue-finalization vs ERC-7540).
- *
- * Consumers (UI, worker-api) treat the list as a single bucket;
- * protocol-specific fields like `queuePosition` are populated when
- * available and ignored otherwise.
- *
- * See [../LST_WITHDRAWAL_QUEUES.md](../LST_WITHDRAWAL_QUEUES.md) for
- * the per-protocol enumeration ABI and the
- * [GAPS.md](../../GAPS.md) section A for the design intent.
- */
-export interface LstWithdrawalRequest {
-    /** LST share-token address the request was made against. */
-    lst: string;
-    /** Brand label — `Lido`, `EtherFi`, `Renzo`, … */
-    brand: string;
-    /** Symbol — `wstETH`, `weETH`, `ezETH`, … */
-    symbol: string;
-    /** Protocol-native request identifier (NFT tokenId, queue index,
-     *  ERC-7540 requestId, …). Encoded as a string for cross-protocol
-     *  uniformity. */
-    requestId: string;
-    /** Raw underlying amount the request will return on claim. Wei-like
-     *  integer string. Some protocols only know this at claim time
-     *  (queue-finalization with floating finalization rate) — those
-     *  surface the **expected** amount at request time. */
-    amountUnderlying: string;
-    /** Status discriminator. */
-    status: LstWithdrawalStatus;
-    /** Unix seconds when the request becomes claimable. Set for
-     *  fixed-cooldown protocols where the deadline is deterministic.
-     *  Unset for queue-finalization protocols (use `queuePosition` +
-     *  `etaSeconds` instead) and ERC-7540 (use `status` directly). */
-    readyAt?: number;
-    /** Unix seconds when the claim window closes. Currently only used
-     *  by sAVAX (15-day cooldown + 2-day claim window). After this
-     *  timestamp the request transitions to `expired` and the unlock
-     *  is forfeited unless admin recovery is triggered. */
-    expiresAt?: number;
-    /** Position in the protocol's queue, relative to the finalization
-     *  frontier. Set for queue-finalization protocols. Positive values
-     *  mean "still pending"; zero or negative means "finalized". */
-    queuePosition?: number;
-    /** Off-chain estimate of seconds-to-claim. Only set when the
-     *  orchestrator received a finalization-rate sample (TODO: not
-     *  yet wired). Frontier-based protocols can show this when
-     *  available. */
-    etaSeconds?: number;
-}
-/** Status discriminator for a withdrawal request. */
-export type LstWithdrawalStatus = 
-/** Submitted; not yet claimable. */
-'pending'
-/** Ready to claim now. */
- | 'claimable'
-/** Already claimed (typically pruned from the list — kept for
- *  protocols that surface historical entries via the same getter). */
- | 'claimed'
-/** Window expired without being claimed. Only meaningful for
- *  sAVAX-style protocols with a finite claim window. */
- | 'expired';
-/** Withdrawal-reader implementation kind — drives which enumeration
- *  function the user is queried against. */
-export type LstWithdrawalReaderKind = 'lidoQueue' | 'etherfiNft' | 'yieldNestNft' | 'staderEthxQueue' | 'staderMaticXQueue' | 'renzoQueue' | 'kelpQueue' | 'benqiSavaxQueue' | 'beetsStSQueue' | 'hyperbeatBeHype7540' | 'erc7540' | 'ethenaCooldown' | 'swellNft' | 'stakeWiseSubgraph' | 'mantleCallerSuppliedIds' | 'pufferCallerSuppliedIds' | 'trufinCallerSuppliedIds' | 'lairCallerSuppliedIds' | 'stceloAccountQueue' | 'kinetiqQueue' | 'beHypeQueue' | 'valantisBurnQueue' | 'listaQueue' | 'iberaQueue' | 'primeStakingQueue' | 'berapawRedeemQueue' | 'stellaUnbondQueue' | 'eventsOnly' | 'noQueue' | 'unverified';
-/** Map keyed by lowercased LST share-token address. The orchestrator
- *  fetches all LSTs on a chain in parallel and returns this map
- *  (possibly with empty arrays for LSTs the user has no requests
- *  against). */
-export type LstWithdrawalRequestsByLst = {
-    [lstAddress: string]: LstWithdrawalRequest[];
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/vaults/lst/withdrawals/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/withdrawals/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,oBAAoB;IACnC,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAA;IACX,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAA;IACb,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAA;IACd;;sBAEkB;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB;;;2DAGuD;IACvD,gBAAgB,EAAE,MAAM,CAAA;IACxB,4BAA4B;IAC5B,MAAM,EAAE,mBAAmB,CAAA;IAC3B;;;sEAGkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;2DAGuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;oEAEgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;qBAGiB;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,qDAAqD;AACrD,MAAM,MAAM,mBAAmB;AAC7B,oCAAoC;AAClC,SAAS;AACX,0BAA0B;GACxB,WAAW;AACb;sEACsE;GACpE,SAAS;AACX;wDACwD;GACtD,SAAS,CAAA;AAEb;4CAC4C;AAC5C,MAAM,MAAM,uBAAuB,GAC/B,WAAW,GACX,YAAY,GACZ,cAAc,GACd,iBAAiB,GACjB,mBAAmB,GACnB,YAAY,GACZ,WAAW,GACX,iBAAiB,GACjB,eAAe,GACf,qBAAqB,GACrB,SAAS,GACT,gBAAgB,GAChB,UAAU,GACV,mBAAmB,GACnB,yBAAyB,GACzB,yBAAyB,GACzB,yBAAyB,GACzB,uBAAuB,GACvB,oBAAoB,GACpB,cAAc,GACd,aAAa,GACb,mBAAmB,GACnB,YAAY,GACZ,YAAY,GACZ,mBAAmB,GACnB,oBAAoB,GACpB,mBAAmB,GACnB,YAAY,GACZ,SAAS,GACT,YAAY,CAAA;AAEhB;;;gBAGgB;AAChB,MAAM,MAAM,0BAA0B,GAAG;IACvC,CAAC,UAAU,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAAA;CAC7C,CAAA"}

package/dist/vaults/lst/yieldBinding.d.ts

@@ -1,26 +0,0 @@
-import type { LstRegistryEntry } from './registry';
-/**
- * Runs every yield source referenced by an LST registry slice and
- * returns a flat `address → apr%` map.
- *
- * Two pieces of complexity wrapped here:
- *
- *  1. **Dedup** — many registry entries can point at the same
- *     `YieldFetcher` instance (today only one does, but the wstETH /
- *     weETH composition pattern lights this up). We collect unique
- *     fetcher refs, run each `safeFetch` once, and reuse the result
- *     when reading per-entry keys.
- *
- *  2. **weETH special case** — `createWeethFetcher` needs a wstETH
- *     promise as input because EtherFi's APR is `wstETH APR + LRT2
- *     bonus`. We compute it here using the same wstETH result we
- *     already fetched (or a fresh one) — the registry can't pre-bind
- *     it cleanly because `wstethFetcher` is a `YieldFetcher` not a
- *     `Promise`.
- *
- * Returns `{ [shareAddressLowercase]: aprPercent }`. Missing keys
- * become `0` downstream — never `undefined` — so the parser doesn't
- * have to branch.
- */
-export declare const resolveYieldApr: (entries: LstRegistryEntry[]) => Promise<Record<string, number>>;
-//# sourceMappingURL=yieldBinding.d.ts.map

package/dist/vaults/lst/yieldBinding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"yieldBinding.d.ts","sourceRoot":"","sources":["../../../src/vaults/lst/yieldBinding.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,gBAAgB,EAAE,KAC1B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoDhC,CAAA"}

package/dist/vaults/morpho/allocationWalk.d.ts

@@ -1,78 +0,0 @@
-import type { MorphoTypeVaultEntry } from '@1delta/data-sdk';
-import { GenericTokenList, MulticallRetryFunction } from '../../types';
-import type { VaultMarketExposure } from './types';
-/**
- * Context for deriving an exposure's `marketUid` — the join key shared with
- * the lending/markets API. The uid mirrors that path:
- * `createMarketUid(chainId, `${protocol}_${MARKETID}`, underlying)`, where
- * `underlying` is the vault's loan asset (its supply side).
- */
-export interface MarketUidContext {
-    chainId: string;
-    underlying: string;
-    /** Market lender prefix, e.g. `MORPHO_BLUE` or `LISTA_DAO`. */
-    protocol: string;
-}
-/**
- * Per-market supply rate + share/asset totals, keyed by lower-cased market id.
- * Supply APR is net of the market-level protocol fee (not the vault
- * performance fee). Shared by the Lista (Moolah) and standard MetaMorpho
- * on-chain fetchers — only the rate *source* differs, the allocation math is
- * identical.
- */
-export interface MarketRate {
-    supplyApr: number;
-    totalSupplyAssets: bigint;
-    totalSupplyShares: bigint;
-    /** Lowercased collateral token backing the market, '' if unknown. */
-    collateralAddress: string;
-    /** Currently-withdrawable assets in the market — `totalSupplyAssets −
-     *  totalBorrowAssets`, raw integer. Drives the vault's real withdrawable
-     *  liquidity; omit/0 when the borrow side is unknown (degrades to
-     *  treating the allocation as fully liquid). */
-    liquidity?: bigint;
-}
-/**
- * Read `<core>.position(marketId, vault).supplyShares` for every
- * (vault, market) pair the vaults actually queue. Keyed by
- * `${vaultLower}:${marketIdLower}`. Empty when the core is unknown.
- *
- * The Morpho Blue and Moolah (Lista) cores share the `position` ABI, so this
- * is protocol-agnostic.
- */
-export declare function fetchVaultSupplyShares(chainId: string, core: string | undefined, entries: MorphoTypeVaultEntry[], marketIdsByVault: string[][], multicallRetry: MulticallRetryFunction): Promise<Map<string, bigint>>;
-/**
- * Allocation walk: for each market the vault lends into, convert its supply
- * shares to assets and record the exposure. Returns:
- *  - `depositRate`: allocation-weighted market supply APR over *total*
- *    assets (idle balances dilute it), net of the vault performance fee —
- *    matching how MetaMorpho-style `netApy` is derived.
- *  - `exposures`: per-market breakdown, ordered by weight descending.
- *  - `liquidityFormatted`: real withdrawable underlying — idle deposits plus,
- *    from each allocation, at most the market's liquid cash
- *    (`min(allocation, market.liquidity)`), clamped to `totalAssets`. When no
- *    market exposes a `liquidity`, this equals `totalAssets` (the previous
- *    optimistic ceiling).
- */
-export declare function computeVaultAllocation(vaultAddress: string, decimals: number, totalAssetsFormatted: number, feePercent: number, priceUsd: number, marketIds: string[], rateMap: Map<string, MarketRate>, positionMap: Map<string, bigint>, tokenList: GenericTokenList, uidCtx?: MarketUidContext): {
-    depositRate: number;
-    exposures: VaultMarketExposure[];
-    liquidityFormatted: number;
-};
-/**
- * Allocation walk for **Morpho Vaults V2** (adapter-based). Unlike V1, the
- * per-market assets come **directly** from the adapter's
- * `expectedSupplyAssets(marketId)` (no share→asset conversion), so this takes a
- * pre-resolved `marketAssetsRaw` map (marketId → raw underlying) instead of
- * `positionMap` + a share/asset ratio. Everything else mirrors
- * {@link computeVaultAllocation}: market supply APR + liquidity come from the
- * same lens-sourced `rateMap`, the result is allocation-weighted over total
- * assets and net of the vault's performance fee, and `liquidity` is
- * `idle + Σ min(allocation, market liquid)` clamped to total assets.
- */
-export declare function computeV2Allocation(decimals: number, totalAssetsFormatted: number, feePercent: number, priceUsd: number, marketAssetsRaw: Map<string, bigint>, rateMap: Map<string, MarketRate>, tokenList: GenericTokenList, uidCtx?: MarketUidContext): {
-    depositRate: number;
-    exposures: VaultMarketExposure[];
-    liquidityFormatted: number;
-};
-//# sourceMappingURL=allocationWalk.d.ts.map

package/dist/vaults/morpho/allocationWalk.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"allocationWalk.d.ts","sourceRoot":"","sources":["../../../src/vaults/morpho/allocationWalk.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAItE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAA;CACjB;AAkBD;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,iBAAiB,EAAE,MAAM,CAAA;IACzB,iBAAiB,EAAE,MAAM,CAAA;IACzB,qEAAqE;IACrE,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;oDAGgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,EAAE,oBAAoB,EAAE,EAC/B,gBAAgB,EAAE,MAAM,EAAE,EAAE,EAC5B,cAAc,EAAE,sBAAsB,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgC9B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,oBAAoB,EAAE,MAAM,EAC5B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAChC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,SAAS,EAAE,gBAAgB,EAC3B,MAAM,CAAC,EAAE,gBAAgB,GACxB;IACD,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,mBAAmB,EAAE,CAAA;IAChC,kBAAkB,EAAE,MAAM,CAAA;CAC3B,CA+DA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,oBAAoB,EAAE,MAAM,EAC5B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAChC,SAAS,EAAE,gBAAgB,EAC3B,MAAM,CAAC,EAAE,gBAAgB,GACxB;IACD,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,mBAAmB,EAAE,CAAA;IAChC,kBAAkB,EAAE,MAAM,CAAA;CAC3B,CAsDA"}

package/dist/vaults/morpho/fetchFromApi.d.ts

@@ -1,14 +0,0 @@
-import { GenericTokenList } from '../../types';
-import { MorphoVaults } from './types';
-/**
- * Fetches MetaMorpho vaults from the public Morpho API for a single chain.
- *
- * Covers all chains indexed by `blue-api.morpho.org` (Ethereum mainnet,
- * Base, Arbitrum, Polygon, Unichain, etc.). Pages through at most
- * `maxItems` entries — vault counts per chain are well under 200 in
- * practice but we loop defensively for mainnet where count is highest.
- */
-export declare function fetchMorphoVaultsFromApi(chainId: string, prices?: {
-    [asset: string]: number;
-}, tokenList?: GenericTokenList, maxItems?: number): Promise<MorphoVaults>;
-//# sourceMappingURL=fetchFromApi.d.ts.map

package/dist/vaults/morpho/fetchFromApi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetchFromApi.d.ts","sourceRoot":"","sources":["../../../src/vaults/morpho/fetchFromApi.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAI9C,OAAO,EAAe,YAAY,EAAoB,MAAM,SAAS,CAAA;AA+PrE;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,MAAM,GAAE;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,EACxC,SAAS,GAAE,gBAAqB,EAChC,QAAQ,SAAM,GACb,OAAO,CAAC,YAAY,CAAC,CAkBvB"}

package/dist/vaults/morpho/fetchFromChain.d.ts

@@ -1,31 +0,0 @@
-import { type MorphoTypeVaultEntry } from '@1delta/data-sdk';
-import { GenericTokenList, MulticallRetryFunction } from '../../types';
-import { MorphoVaults } from './types';
-export interface FetchMorphoVaultsFromChainOptions {
-    /** Restrict to a subset of curator-protocol keys (e.g. `['LISTA_DAO']`). */
-    protocols?: string[];
-    /**
-     * Override the registry — `[{ vault, underlying, name? }]`. Lets fork tests
-     * point at a specific vault list without populating the global registry.
-     */
-    vaultsOverride?: MorphoTypeVaultEntry[];
-}
-/**
- * On-chain MetaMorpho vault fetcher — multicalls every vault listed in
- * `morphoTypeVaults()` for the chain (or in `opts.vaultsOverride`) and
- * normalizes the results to the same `MorphoVaults` shape produced by the
- * Morpho API and Goldsky paths.
- *
- * Intended as a fallback for forks / chains where the Morpho public API and
- * Goldsky subgraph are unreachable. The supply rate isn't computable from
- * vault state alone (it requires walking the underlying market allocations),
- * so `supplyRate` and `rewardsRate` are surfaced as `0` — same convention
- * used by the Goldsky path when rewards aren't indexed. `liquidity` is the
- * real withdrawable amount from the allocation walk (idle + Σ min(allocation,
- * market liquidity)); it falls back to `totalAssets` only when no lens/core is
- * available for the chain.
- */
-export declare const fetchMorphoVaultsFromChain: (chainId: string, multicallRetry: MulticallRetryFunction, prices?: {
-    [asset: string]: number;
-}, tokenList?: GenericTokenList, opts?: FetchMorphoVaultsFromChainOptions) => Promise<MorphoVaults>;
-//# sourceMappingURL=fetchFromChain.d.ts.map

package/dist/vaults/morpho/fetchFromChain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetchFromChain.d.ts","sourceRoot":"","sources":["../../../src/vaults/morpho/fetchFromChain.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGtE,OAAO,EAAe,YAAY,EAAE,MAAM,SAAS,CAAA;AAgKnD,MAAM,WAAW,iCAAiC;IAChD,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB;;;OAGG;IACH,cAAc,CAAC,EAAE,oBAAoB,EAAE,CAAA;CACxC;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,GACrC,SAAS,MAAM,EACf,gBAAgB,sBAAsB,EACtC,SAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,EACxC,YAAW,gBAAqB,EAChC,OAAM,iCAAsC,KAC3C,OAAO,CAAC,YAAY,CAmKtB,CAAA"}

package/dist/vaults/morpho/fetchListaFromChain.d.ts

@@ -1,40 +0,0 @@
-import { type MorphoTypeVaultEntry } from '@1delta/data-sdk';
-import { GenericTokenList, MulticallRetryFunction } from '../../types';
-import { MorphoVaults } from './types';
-export interface FetchListaVaultsFromChainOptions {
-    /**
-     * Override the registry — `[{ vault, underlying, name? }]`. Lets fork
-     * tests point at a specific vault list without populating the global
-     * registry.
-     */
-    vaultsOverride?: MorphoTypeVaultEntry[];
-}
-/**
- * On-chain Lista DAO (Moolah-fork) vault fetcher. Same output shape as
- * `fetchMorphoVaultsFromChain`, different read path:
- *
- *  - Phase 1 multicall: `name / symbol / decimals / totalAssets /
- *    totalSupply / fee / feeRecipient / CURATOR` per vault. The role hash
- *    returned by `CURATOR()` is contract-defined, not derivable, so it
- *    must be read on-chain.
- *  - Phase 2 multicall: `getRoleMember(CURATOR_ROLE, 0)` per vault →
- *    surfaces the curator address (Moolah uses
- *    `AccessControlEnumerable`, no direct `curator()` getter).
- *
- * `owner` / `guardian` are surfaced as `undefined` (Moolah uses
- * `DEFAULT_ADMIN_ROLE` for admin and has no guardian role; left out to
- * avoid extra round-trips). `timelock` is `0` — no timelock pattern in
- * Moolah.
- *
- * APR is computed via an allocation walk: each vault's `withdrawQueue`
- * enumerates the markets it lends to; `MOOLAH.position(id, vault)` gives
- * the vault's supply shares per market; the Lista lens supplies each
- * market's supply APY + share/asset totals. The vault `depositRate` is the
- * allocation-weighted market supply APR over `totalAssets` (idle assets
- * earn nothing), net of the vault performance `fee`. If the Moolah core
- * address or lens is missing for the chain, APR falls back to `0`.
- */
-export declare const fetchListaVaultsFromChain: (chainId: string, multicallRetry: MulticallRetryFunction, prices?: {
-    [asset: string]: number;
-}, tokenList?: GenericTokenList, opts?: FetchListaVaultsFromChainOptions) => Promise<MorphoVaults>;
-//# sourceMappingURL=fetchListaFromChain.d.ts.map

package/dist/vaults/morpho/fetchListaFromChain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetchListaFromChain.d.ts","sourceRoot":"","sources":["../../../src/vaults/morpho/fetchListaFromChain.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAA;AAUzB,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAItE,OAAO,EAAe,YAAY,EAAuB,MAAM,SAAS,CAAA;AAwFxE,MAAM,WAAW,gCAAgC;IAC/C;;;;OAIG;IACH,cAAc,CAAC,EAAE,oBAAoB,EAAE,CAAA;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,gBAAgB,sBAAsB,EACtC,SAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,EACxC,YAAW,gBAAqB,EAChC,OAAM,gCAAqC,KAC1C,OAAO,CAAC,YAAY,CAmHtB,CAAA"}

package/dist/vaults/morpho/fetchPublic.d.ts

@@ -1,28 +0,0 @@
-import { GenericTokenList, MulticallRetryFunction } from '../../types';
-import { MorphoVaults } from './types';
-/**
- * One-shot fetcher for all MetaMorpho vaults on a chain.
- *
- * Routes between two data sources, normalized to the same `MorphoVault`
- * shape: the curated **on-chain** path (via the `morphoTypeVaults` registry)
- * for chains the hosted API doesn't cover, and the public **Morpho API**
- * for chains it indexes. The on-chain branch needs a `multicallRetry`
- * executor; the API branch ignores it (HTTP GraphQL).
- *
- * (A Goldsky-subgraph branch used to serve SEI / Celo / Lisk / Soneium / TAC
- * / Hemi, but all of those now have on-chain registry entries — and the
- * upstream subgraph endpoints were retired — so the on-chain path covers them
- * with real `liquidity`/APR and the subgraph path was removed.)
- *
- * @param chainId        target chain
- * @param multicallRetry provider-level multicall executor (on-chain branch)
- * @param prices         optional price map keyed by oracle key / underlying
- * @param tokenList      optional token list for hydrating `asset` metadata
- *
- * @returns `MorphoVaults` — map keyed by lowercased vault address, or
- *          an empty object when the chain has no Morpho deployment.
- */
-export declare const fetchMorphoVaults: (chainId: string, multicallRetry: MulticallRetryFunction, prices?: {
-    [asset: string]: number;
-}, tokenList?: GenericTokenList) => Promise<MorphoVaults>;
-//# sourceMappingURL=fetchPublic.d.ts.map

package/dist/vaults/morpho/fetchPublic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetchPublic.d.ts","sourceRoot":"","sources":["../../../src/vaults/morpho/fetchPublic.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGtE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAatC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,EACf,gBAAgB,sBAAsB,EACtC,SAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,EACxC,YAAW,gBAAqB,KAC/B,OAAO,CAAC,YAAY,CAUtB,CAAA"}

package/dist/vaults/morpho/index.d.ts

@@ -1,6 +0,0 @@
-export { fetchMorphoVaults } from './fetchPublic';
-export { fetchMorphoVaultsFromApi } from './fetchFromApi';
-export { fetchMorphoVaultsFromChain, type FetchMorphoVaultsFromChainOptions, } from './fetchFromChain';
-export { fetchListaVaultsFromChain, type FetchListaVaultsFromChainOptions, } from './fetchListaFromChain';
-export type { MorphoVault, MorphoVaults, VaultCuratorMeta } from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/vaults/morpho/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vaults/morpho/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAA;AACzD,OAAO,EACL,0BAA0B,EAC1B,KAAK,iCAAiC,GACvC,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,yBAAyB,EACzB,KAAK,gCAAgC,GACtC,MAAM,uBAAuB,CAAA;AAC9B,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA"}

package/dist/vaults/morpho/types.d.ts

@@ -1,120 +0,0 @@
-import { GenericCurrency } from '../../types/general';
-import type { VaultClassificationFields } from '../classification';
-import type { VaultMarketExposure } from '../exposure';
-export type { VaultMarketExposure } from '../exposure';
-/** Curator metadata as surfaced by the Morpho API. */
-export interface VaultCuratorMeta {
-    /** Curator slug, e.g. `gauntlet`, `kpk`, `steakhouse`. */
-    id: string;
-    /** Display name, e.g. `Gauntlet`, `KPK`, `Steakhouse Financial`. */
-    name: string;
-    /** Logo URL (typically a CDN-hosted SVG). */
-    image?: string;
-    /** Whether Morpho has verified this curator. */
-    verified?: boolean;
-}
-/**
- * Parsed MetaMorpho vault entry.
- *
- * MetaMorpho vaults are standalone ERC-4626 yield vaults that allocate
- * their deposits across one or more Morpho Blue markets (per-vault
- * strategy configured by a curator). They are NOT a lending market — no
- * collateral, no borrow, no liquidation — just a deposit → earn shape,
- * modeled separately from the per-market borrow side in
- * `src/lending/public-data/morpho/`.
- *
- * Multiple vaults typically exist per underlying (different curators /
- * risk profiles), so the top-level map is keyed by vault address rather
- * than underlying — differs from Fluid/Gearbox where one vault per
- * underlying is the norm.
- */
-export interface MorphoVault extends VaultClassificationFields {
-    /** MetaMorpho vault (share token) contract address, lowercased. */
-    address: string;
-    /** Lowercased underlying ERC20 address. */
-    underlying: string;
-    /** Vault share-token symbol, e.g. `bbUSDC`, `steakUSDC`. */
-    symbol: string;
-    /** Vault share-token name as returned by `name()`, e.g.
-     *  `Morpho USDC Steakhouse`. Raw — may be inconsistently formatted
-     *  across vaults; use `displayName` for UI. */
-    name: string;
-    /** Cross-provider UI label — `${curatorName ?? 'Morpho'} ${asset.symbol}`
-     *  (e.g. `Steakhouse USDC`, `Gauntlet WETH`). Always non-empty. */
-    displayName: string;
-    /** Share and underlying decimals (ERC-4626 keeps them aligned). */
-    decimals: number;
-    /** Total underlying assets held by the vault, raw integer as string. */
-    totalAssets: string;
-    /** Total shares minted, raw integer as string. */
-    totalSupply: string;
-    /** Raw `convertToAssets(10**shareDecimals)` — 1 share → X underlying,
-     *  asset-scaled. Derived from `totalAssets / totalSupply`. */
-    convertToAssets: string;
-    /** Supply APR in percent, net of vault fee (e.g. `4.12` = 4.12 %). */
-    supplyRate: number;
-    /** Extra rewards APR in percent, on top of `supplyRate`. */
-    rewardsRate: number;
-    /** Sum of `supplyRate + rewardsRate` — what a depositor actually earns. */
-    depositRate: number;
-    /** Performance fee in percent (e.g. `5.0` = 5 %). */
-    fee: number;
-    /** Timelock for vault config changes, in seconds. */
-    timelock: number;
-    /** Whether the vault is listed by the Morpho frontend. Goldsky-sourced
-     *  chains default to `true` (listing is Morpho-API-only). */
-    whitelisted: boolean;
-    /** Owner address, lowercased — may be absent if not set. */
-    owner?: string;
-    /** Curator address, lowercased — may be absent if not set. */
-    curator?: string;
-    /** Guardian address, lowercased — may be absent if not set. */
-    guardian?: string;
-    /** Human-readable curator label for UI (e.g. `Steakhouse`, `Gauntlet`).
-     *  Populated from the Morpho API's `state.curators[].name`; undefined on
-     *  Goldsky-sourced chains where the subgraph carries only the address. */
-    curatorName?: string;
-    /** Curator logo URL from the Morpho API (CDN-hosted SVG). Undefined on
-     *  Goldsky-sourced chains. */
-    curatorImage?: string;
-    /** Full curator list — set when a vault has co-curators. First entry
-     *  matches `curatorName` / `curatorImage`. Undefined on Goldsky-sourced
-     *  chains. */
-    curators?: VaultCuratorMeta[];
-    /** Hydrated asset metadata from the provided token list, if any. */
-    asset?: GenericCurrency;
-    /** USD price of one underlying unit, if prices were supplied / returned. */
-    priceUsd?: number;
-    /** Human-formatted total assets (`totalAssets / 10^decimals`). */
-    totalAssetsFormatted: number;
-    /** Human-formatted total assets in USD. */
-    totalAssetsUsd: number;
-    /** Underlying currently withdrawable *right now*, raw integer as string.
-     *  Caps immediate withdrawals — the rest of `totalAssets` is locked in
-     *  markets up to their utilisation. A vault's `publicAllocatorConfig`
-     *  (when present) can expand this at tx time by reallocating between
-     *  markets before the exit. Not a withdrawal timelock — MetaMorpho has
-     *  no per-deposit timelock; the `timelock` field is governance-only. */
-    liquidity: string;
-    /** Human-formatted immediate withdrawable liquidity. */
-    liquidityFormatted: number;
-    /** Human-formatted immediate withdrawable liquidity in USD. */
-    liquidityUsd: number;
-    /** Per-market allocation breakdown — which Morpho/Moolah markets the
-     *  vault lends into and how much, ordered by weight descending. Populated
-     *  by the on-chain Lista (Moolah) path; undefined on paths that don't
-     *  surface allocations (API/subgraph/standard on-chain). */
-    exposures?: VaultMarketExposure[];
-}
-/**
- * Full parsed payload: per-vault-address map.
- *
- * Morpho has many vaults per underlying (one per curator strategy), so
- * keying by vault address keeps every entry distinct. Callers that want a
- * per-underlying view can group by `underlying` downstream.
- */
-export type MorphoVaults = {
-    /** Keyed by lowercased vault address. */
-    [vaultAddress: string]: MorphoVault;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/vaults/morpho/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/vaults/morpho/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,sDAAsD;AACtD,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,EAAE,EAAE,MAAM,CAAA;IACV,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,gDAAgD;IAChD,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAY,SAAQ,yBAAyB;IAC5D,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAA;IACf,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAA;IACd;;mDAE+C;IAC/C,IAAI,EAAE,MAAM,CAAA;IACZ;uEACmE;IACnE,WAAW,EAAE,MAAM,CAAA;IACnB,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAA;IAEhB,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAA;IACnB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAA;IACnB;kEAC8D;IAC9D,eAAe,EAAE,MAAM,CAAA;IAEvB,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAA;IACnB,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAA;IAEnB,qDAAqD;IACrD,GAAG,EAAE,MAAM,CAAA;IACX,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAA;IAChB;iEAC6D;IAC7D,WAAW,EAAE,OAAO,CAAA;IAEpB,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB;;8EAE0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;kCAC8B;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;kBAEc;IACd,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAA;IAE7B,oEAAoE;IACpE,KAAK,CAAC,EAAE,eAAe,CAAA;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,kEAAkE;IAClE,oBAAoB,EAAE,MAAM,CAAA;IAC5B,2CAA2C;IAC3C,cAAc,EAAE,MAAM,CAAA;IAEtB;;;;;4EAKwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,wDAAwD;IACxD,kBAAkB,EAAE,MAAM,CAAA;IAC1B,+DAA+D;IAC/D,YAAY,EAAE,MAAM,CAAA;IAEpB;;;gEAG4D;IAC5D,SAAS,CAAC,EAAE,mBAAmB,EAAE,CAAA;CAClC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,yCAAyC;IACzC,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,CAAA;CACpC,CAAA"}

package/dist/vaults/savings/abis/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * Minimal ABI fragments for ERC-4626 savings vaults. Only the read
- * surface we actually call is included.
- *
- * Every savings entry today uses the same generic ERC-4626 reader so
- * a single `shared.ts` is sufficient. When a future entry needs a
- * custom getter (e.g. a `floorPrice()` for a bond-shaped vault),
- * add a per-protocol file (`abis/<protocol>.ts`) following the LST
- * provider's pattern in [../../lst/abis/](../../lst/abis/).
- */
-export * from './shared';
-//# sourceMappingURL=index.d.ts.map

package/dist/vaults/savings/abis/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vaults/savings/abis/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,UAAU,CAAA"}

package/dist/vaults/savings/abis/shared.d.ts

@@ -1,33 +0,0 @@
-/** Standard ERC-20 `totalSupply()`. */
-export declare const TotalSupplyAbi: readonly [{
-    readonly name: "totalSupply";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-}];
-/** ERC-4626 read surface — `totalAssets()` + `convertToAssets(uint256)`. */
-export declare const Erc4626ReadAbi: readonly [{
-    readonly name: "totalAssets";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-}, {
-    readonly name: "convertToAssets";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "shares";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-        readonly name: "assets";
-    }];
-}];
-//# sourceMappingURL=shared.d.ts.map

package/dist/vaults/savings/abis/shared.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/vaults/savings/abis/shared.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,eAAO,MAAM,cAAc;;;;;;;;EAQjB,CAAA;AAEV,4EAA4E;AAC5E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;EAejB,CAAA"}

package/dist/vaults/savings/fetchPublic.d.ts

@@ -1,22 +0,0 @@
-import { MulticallRetryFunction, GenericTokenList } from '../../types';
-import type { SavingsVaults } from './types';
-/**
- * One-shot fetcher for all savings vaults on a chain.
- *
- * Two parallel I/O legs that both feed the same output map:
- *
- *  1. **On-chain leg** — every reader's calls (3 per entry:
- *     `totalAssets`, `totalSupply`, `convertToAssets(10**decimals)`)
- *     are concatenated into a single `multicallRetry` payload. The
- *     response is sliced back into per-entry chunks and parsed;
- *     per-entry failures are silently dropped.
- *
- *  2. **APR leg** — `resolveYieldApr` dedups the registry's
- *     `YieldFetcher` refs and runs each once.
- *
- * Returns `{}` when the chain has no registry entries.
- */
-export declare const fetchSavingsVaults: (chainId: string, multicallRetry: MulticallRetryFunction, prices?: {
-    [asset: string]: number;
-}, tokenList?: GenericTokenList) => Promise<SavingsVaults>;
-//# sourceMappingURL=fetchPublic.d.ts.map

package/dist/vaults/savings/fetchPublic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetchPublic.d.ts","sourceRoot":"","sources":["../../../src/vaults/savings/fetchPublic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAKtE,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,SAAS,CAAA;AAI1D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,MAAM,EACf,gBAAgB,sBAAsB,EACtC,SAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,EACxC,YAAW,gBAAqB,KAC/B,OAAO,CAAC,aAAa,CAuHvB,CAAA"}

package/dist/vaults/savings/index.d.ts

@@ -1,4 +0,0 @@
-export { fetchSavingsVaults } from './fetchPublic';
-export type { SavingsVault, SavingsVaults, SavingsWithdrawalMode, } from './types';
-export { SAVINGS_REGISTRY, getSavingsRegistry, type SavingsRegistryEntry, } from './registry';
-//# sourceMappingURL=index.d.ts.map

package/dist/vaults/savings/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vaults/savings/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAClD,YAAY,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,GACtB,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,oBAAoB,GAC1B,MAAM,YAAY,CAAA"}

package/dist/vaults/savings/readers/erc4626.d.ts

@@ -1,25 +0,0 @@
-import type { SavingsRegistryEntry } from '../registry';
-import { type SavingsReader } from './shared';
-/**
- * Generic ERC-4626 reader — three calls per entry:
- *   1. `totalAssets()`
- *   2. `totalSupply()`
- *   3. `convertToAssets(10**shareDecimals)`
- *
- * The third gives `assets per 1 share` in **raw underlying units**.
- * To normalise to a 1e18-scaled "underlying per share" rate, we
- * divide by `10**underlyingDecimals`.
- *
- * For vaults where share and underlying decimals match (the
- * ERC-4626 convention) this collapses to `convertToAssets(1e18) *
- * 1e18 / 1e18`. For yUSD (18-d shares over 6-d USDC) it correctly
- * scales 1e6 → 1e18.
- *
- * Every savings entry today uses this reader. When a future entry
- * diverges (rebasing-via-wrapper for srUSD, bond floor for USD0++,
- * oracle-priced for RWA), add a sibling reader file under `readers/`
- * mirroring [../../lst/readers/](../../lst/readers/) and extend the
- * dispatch in [./index.ts](./index.ts).
- */
-export declare const readerErc4626: (entry: SavingsRegistryEntry) => SavingsReader;
-//# sourceMappingURL=erc4626.d.ts.map

package/dist/vaults/savings/readers/erc4626.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"erc4626.d.ts","sourceRoot":"","sources":["../../../../src/vaults/savings/readers/erc4626.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AACvD,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,oBAAoB,KAAG,aAiC3D,CAAA"}

package/dist/vaults/savings/readers/index.d.ts

@@ -1,16 +0,0 @@
-import type { SavingsRegistryEntry } from '../registry';
-import type { SavingsReader } from './shared';
-export type { SavingsCall, SavingsOnChainState, SavingsReader } from './shared';
-export { ONE_E18, toBigInt } from './shared';
-/**
- * Dispatch a registry entry to its reader.
- *
- * Today every savings entry uses the generic ERC-4626 reader. When a
- * future entry needs a custom shape (e.g. wrapped-rebasing for srUSD,
- * `floorPrice()` for USD0++, oracle-priced for RWA), add a
- * `reader` discriminant to {@link SavingsRegistryEntry} and a case
- * here — same pattern as
- * [../../lst/readers/index.ts](../../lst/readers/index.ts).
- */
-export declare const buildReader: (entry: SavingsRegistryEntry) => SavingsReader;
-//# sourceMappingURL=index.d.ts.map

package/dist/vaults/savings/readers/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vaults/savings/readers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,YAAY,EAAE,WAAW,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC/E,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,oBAAoB,KAAG,aACpC,CAAA"}