@1delta/margin-fetcher 0.0.265 → 0.0.267

package/dist/vaults/lst/withdrawals/readers/staderMaticx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staderMaticx.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/staderMaticx.ts"],"names":[],"mappings":"AAKA,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAE7D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,EAAE,mBAoDhC,CAAA"}

package/dist/vaults/lst/withdrawals/readers/stakewise.d.ts

@@ -0,0 +1,26 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * StakeWise V3 osETH — multi-vault async exit queue, indexed only via
+ * StakeWise's self-hosted subgraph.
+ *
+ * Sequence:
+ *  1. GraphQL POST to the StakeWise subgraph for all non-claimed exit
+ *     requests owned by `user`. Returns the list with per-vault
+ *     positionTicket + (lagging) `isClaimable`.
+ *  2. For each request that has an `exitQueueIndex` assigned, multicall
+ *     `calculateExitedAssets(receiver, positionTicket, timestamp,
+ *     exitQueueIndex)` on the vault to re-confirm finalization (the
+ *     subgraph lags a few blocks; on-chain is the source of truth).
+ *  3. Normalise to `LstWithdrawalRequest[]`.
+ *
+ * Subgraph downtime: returns `[]` and lets the orchestrator surface
+ * "we don't know your requests" rather than fail-loud. The reader's
+ * caller already tolerates per-reader empty results.
+ *
+ * Per-vault address surfaced in `lst` field overrides the registry's
+ * osETH share-token address — StakeWise exits are per-vault, not
+ * per-osETH (osETH is the protocol-wide minted share). Each request
+ * carries its source vault so UIs can group / route claims correctly.
+ */
+export declare const readerStakeWise: LstWithdrawalReader;
+//# sourceMappingURL=stakewise.d.ts.map

package/dist/vaults/lst/withdrawals/readers/stakewise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stakewise.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/stakewise.ts"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AA2C7D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,EAAE,mBAkF7B,CAAA"}

package/dist/vaults/lst/withdrawals/readers/stcelo.d.ts

@@ -0,0 +1,16 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * StakedCelo (stCELO) — pending-withdrawal enumeration.
+ *
+ * Single stage: `Account.getPendingWithdrawals(beneficiary)` returns
+ * parallel `(values[], timestamps[])` arrays. Each entry is a
+ * LockedGold unlock created by `Account.withdraw`; `timestamp` is the
+ * unix-second moment it becomes claimable via
+ * `Account.finishPendingWithdrawal`.
+ *
+ * Entries only appear here **after** the per-group `Account.withdraw`
+ * step has run (the post-`Manager.withdraw` scheduled withdrawals are
+ * not yet LockedGold pending withdrawals and so are not enumerated).
+ */
+export declare const readerStCelo: LstWithdrawalReader;
+//# sourceMappingURL=stcelo.d.ts.map

package/dist/vaults/lst/withdrawals/readers/stcelo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stcelo.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/stcelo.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,UAAU,CAAA;AAEjB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,EAAE,mBA6C1B,CAAA"}

package/dist/vaults/lst/withdrawals/readers/stella.d.ts

@@ -0,0 +1,17 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * StellaSwap stDOT unbonding reader (Moonbeam 1284).
+ *
+ * One call: `getUnbonded(user) → (waiting, unbonded)`. The lido-dot-ksm
+ * stToken tracks only the per-user **aggregate** in two buckets — no
+ * per-request IDs — so this surfaces up to two synthetic requests:
+ *   - `waiting`  > 0 → a `pending` request (still in the ~28-day unbond;
+ *     the exact ready time is not exposed per-bucket, so `readyAt` is
+ *     left unset).
+ *   - `unbonded` > 0 → a `claimable` request (matured, redeemable via
+ *     `claimUnbonded()`).
+ *
+ * No enumeration, same single-call shape as the Ethena cooldown reader.
+ */
+export declare const readerStellaUnbond: LstWithdrawalReader;
+//# sourceMappingURL=stella.d.ts.map

package/dist/vaults/lst/withdrawals/readers/stella.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stella.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/stella.ts"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAE7D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,EAAE,mBAgDhC,CAAA"}

package/dist/vaults/lst/withdrawals/readers/swell.d.ts

@@ -0,0 +1,18 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Swell rswETH — ERC-721 enumerable rswEXIT NFT. Same enumeration
+ * pattern as EtherFi:
+ *  1. `balanceOf(user)` → count.
+ *  2. `tokenOfOwnerByIndex(user, i)` for i in [0, count) — enumerate
+ *     token IDs.
+ *  3. `getWithdrawalRequest(id)` per id + a single
+ *     `getLastTokenIdProcessed()` for the finalization frontier.
+ *
+ * A request is claimable iff `tokenId <= lastTokenIdProcessed`.
+ *
+ * Log-free per `INDEXING_STRATEGIES.md`: ERC721EnumerableUpgradeable
+ * is in rswEXIT's inheritance chain (verified via
+ * `supportsInterface(0x780e9d63)`).
+ */
+export declare const readerSwell: LstWithdrawalReader;
+//# sourceMappingURL=swell.d.ts.map

package/dist/vaults/lst/withdrawals/readers/swell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swell.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/swell.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAEvE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,EAAE,mBAmEzB,CAAA"}

package/dist/vaults/lst/withdrawals/readers/trufin.d.ts

@@ -0,0 +1,19 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * TruFin TruMATIC — log-free via caller-supplied
+ * `{ validator, nonce }` pairs.
+ *
+ * Unlike Mantle/Puffer (single-bigint id), TruFin's natural request
+ * unit is `(validator, unbondNonce)` — both arguments to the claim
+ * function `withdrawClaim(unbondNonce, validator)`. The reader
+ * filters `knownIds` to objects with `validator` + `nonce`.
+ *
+ * Per pair: multicall `withdrawals(validator, nonce)` +
+ * `isClaimable(nonce, validator)`. `withdrawals` also returns the
+ * recipient — used as a defensive filter against stale persisted
+ * IDs from other accounts.
+ *
+ * Returns `[]` when no pairs are supplied.
+ */
+export declare const readerTruFin: LstWithdrawalReader;
+//# sourceMappingURL=trufin.d.ts.map

package/dist/vaults/lst/withdrawals/readers/trufin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trufin.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/trufin.ts"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAE7D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,EAAE,mBA8D1B,CAAA"}

package/dist/vaults/lst/withdrawals/readers/valantis.d.ts

@@ -0,0 +1,11 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Valantis stHYPE / wstHYPE — burn-request enumeration on the Overseer.
+ *
+ * Single call: `getBurns(user, 0, MAX_BURNS)` returns parallel `(Burn[],
+ * ids[], redeemable[])`. `completed` burns have already been redeemed
+ * and are skipped. The Overseer exposes no per-burn ready timestamp, so
+ * `status` comes from the `redeemable` flag.
+ */
+export declare const readerValantis: LstWithdrawalReader;
+//# sourceMappingURL=valantis.d.ts.map

package/dist/vaults/lst/withdrawals/readers/valantis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valantis.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/valantis.ts"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAM7D;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,mBAkD5B,CAAA"}

package/dist/vaults/lst/withdrawals/readers/yieldnest.d.ts

@@ -0,0 +1,11 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * YieldNest ynETH — ERC-721 enumerable withdrawal queue with
+ * deterministic `secondsToFinalization` (a global value, applied to
+ * every request's `creationTimestamp`).
+ *
+ * Three stages: `balanceOf` → per-index id → per-id detail. Plus a
+ * one-time `secondsToFinalization()` for `readyAt` computation.
+ */
+export declare const readerYieldNest: LstWithdrawalReader;
+//# sourceMappingURL=yieldnest.d.ts.map

package/dist/vaults/lst/withdrawals/readers/yieldnest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yieldnest.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/yieldnest.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,UAAU,CAAA;AAEjB;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,mBA2E7B,CAAA"}

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

@@ -0,0 +1,46 @@
+import type { LstWithdrawalReaderKind } from './types';
+/**
+ * Static registry entry for an LST's withdrawal-request enumeration
+ * surface.
+ *
+ * Each entry pins: the LST share-token address, the brand/symbol
+ * (for output labelling), the reader kind, and any auxiliary contract
+ * addresses the reader needs (the withdrawal-manager NFT/queue
+ * contract, Polygon stake manager for MaticX, …).
+ *
+ * Mirrors [LST_WITHDRAWAL_QUEUES.md](../LST_WITHDRAWAL_QUEUES.md);
+ * read that for per-protocol semantics.
+ */
+export interface LstWithdrawalRegistryEntry {
+    /** LST share-token address (matches `address` in
+     *  `../registry.ts → LST_REGISTRY`). Lowercased. */
+    lst: string;
+    /** Brand label. */
+    brand: string;
+    /** Symbol — used to label the per-asset request list in UI. */
+    symbol: string;
+    /** Reader kind. */
+    reader: LstWithdrawalReaderKind;
+    /** Optional withdrawal contract — separate from the LST share token
+     *  for most protocols. Lowercased.
+     *  - Lido: WithdrawalQueueERC721
+     *  - EtherFi: WithdrawRequestNFT
+     *  - YieldNest: WithdrawalQueueManager
+     *  - Stader ETHx: UserWithdrawalManager
+     *  - Stader MaticX: the home contract itself
+     *  - Renzo: WithdrawQueue
+     *  - BENQI sAVAX: the sAVAX contract itself
+     *  - Beets stS: the SonicStaking proxy itself
+     *  - Hyperbeat hbHYPE: the share token itself (ERC-7540 surface) */
+    withdrawalContract?: string;
+    /** Polygon IStakeManager — only for `staderMaticXQueue`. The
+     *  finalization check requires `epoch()` + `withdrawalDelay()`. */
+    polygonStakeManager?: string;
+}
+/** Per-chain LST withdrawal-reader allowlist. */
+export declare const LST_WITHDRAWAL_REGISTRY: {
+    [chainId: string]: LstWithdrawalRegistryEntry[];
+};
+/** Returns the withdrawal-registry entries for a chain, or `[]`. */
+export declare const getLstWithdrawalRegistry: (chainId: string, extraEntries?: LstWithdrawalRegistryEntry[]) => LstWithdrawalRegistryEntry[];
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/withdrawals/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,0BAA0B;IACzC;wDACoD;IACpD,GAAG,EAAE,MAAM,CAAA;IACX,mBAAmB;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAA;IACd,mBAAmB;IACnB,MAAM,EAAE,uBAAuB,CAAA;IAC/B;;;;;;;;;;wEAUoE;IACpE,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B;uEACmE;IACnE,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED,iDAAiD;AACjD,eAAO,MAAM,uBAAuB,EAAE;IACpC,CAAC,OAAO,EAAE,MAAM,GAAG,0BAA0B,EAAE,CAAA;CAoYhD,CAAA;AAED,oEAAoE;AACpE,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,EACf,eAAe,0BAA0B,EAAE,KAC1C,0BAA0B,EAQ5B,CAAA"}

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

@@ -0,0 +1,74 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1 @@
+{"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/types.d.ts

@@ -1,4 +1,5 @@
 import { GenericCurrency } from '../../types/general';
+import type { VaultClassificationFields } from '../classification';
 /** Curator metadata as surfaced by the Morpho API. */
 export interface VaultCuratorMeta {
     /** Curator slug, e.g. `gauntlet`, `kpk`, `steakhouse`. */
@@ -25,7 +26,7 @@ export interface VaultCuratorMeta {
  * than underlying — differs from Fluid/Gearbox where one vault per
  * underlying is the norm.
  */
-export interface MorphoVault {
+export interface MorphoVault extends VaultClassificationFields {
     /** MetaMorpho vault (share token) contract address, lowercased. */
     address: string;
     /** Lowercased underlying ERC20 address. */

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/vaults/morpho/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAErD,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,WAAW;IAC1B,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;IAEnB,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;CACrB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,yCAAyC;IACzC,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,CAAA;CACpC,CAAA"}
+{"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;AAElE,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;IAEnB,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;CACrB;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

@@ -0,0 +1,12 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,33 @@
+/** 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1 @@
+{"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,CAyGvB,CAAA"}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1 @@
+{"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"}

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

@@ -0,0 +1,44 @@
+/**
+ * Shared types and helpers for savings-vault readers.
+ *
+ * Mirrors [../../lst/readers/shared.ts](../../lst/readers/shared.ts)
+ * so cross-provider tooling (orchestrator slicing, parser shape) stays
+ * uniform.
+ */
+/** 10**18 — scaling factor for normalised exchange rates. */
+export declare const ONE_E18: bigint;
+/** One multicall item — `{ address, name, params }` matched against
+ *  a parallel ABI array, identical to every other vault provider. */
+export interface SavingsCall {
+    address: string;
+    name: string;
+    params: readonly unknown[];
+}
+/** What a reader produces after consuming its multicall slice. */
+export interface SavingsOnChainState {
+    /** Total underlying held, raw. */
+    totalAssets: bigint;
+    /** Total shares minted, raw. */
+    totalSupply: bigint;
+    /** 1e18-scaled exchange rate: 1 share → X underlying.
+     *  Normalised regardless of share decimals. */
+    exchangeRate: bigint;
+}
+/** A self-contained slice of the multicall payload plus a parser
+ *  that consumes exactly `calls.length` results. */
+export interface SavingsReader {
+    calls: SavingsCall[];
+    /** ABI per call slot. `any[]` to accept `as const` fragments without
+     *  per-call casting — the downstream multicall API is `any`-typed. */
+    abis: any[];
+    /** Returns `undefined` on parse failure so the orchestrator can
+     *  skip the entry without poisoning the batch. */
+    parse: (slice: unknown[]) => SavingsOnChainState | undefined;
+}
+/**
+ * Safely coerce a multicall return cell to `bigint`. Failures surface
+ * as `undefined` so the parser can bail on the whole entry without
+ * poisoning the batch.
+ */
+export declare const toBigInt: (v: unknown) => bigint | undefined;
+//# sourceMappingURL=shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/vaults/savings/readers/shared.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,6DAA6D;AAC7D,eAAO,MAAM,OAAO,QAAa,CAAA;AAEjC;qEACqE;AACrE,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,SAAS,OAAO,EAAE,CAAA;CAC3B;AAED,kEAAkE;AAClE,MAAM,WAAW,mBAAmB;IAClC,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAA;IACnB;mDAC+C;IAC/C,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;oDACoD;AACpD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,EAAE,CAAA;IACpB;0EACsE;IAEtE,IAAI,EAAE,GAAG,EAAE,CAAA;IACX;sDACkD;IAClD,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,mBAAmB,GAAG,SAAS,CAAA;CAC7D;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,MAAM,GAAG,SAgB9C,CAAA"}

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

@@ -0,0 +1,69 @@
+import type { YieldFetcher } from '../../yields/types';
+import type { SavingsWithdrawalMode } from './types';
+/**
+ * Static registry entry for a savings vault.
+ *
+ * Per-chain entries live in {@link SAVINGS_REGISTRY}. Each pins the
+ * on-chain identity (address, decimals), brand metadata, the
+ * withdrawal mechanism (drives UX), and a pointer to the existing
+ * intrinsic-yield fetcher whose APR is surfaced as `supplyRate`.
+ *
+ * No `reader` discriminant — every savings entry uses the same
+ * generic ERC-4626 reader. If a future entry diverges (e.g.
+ * rebasing-via-wrapper for srUSD), add a kind here and extend
+ * [`readers/`](./readers/).
+ */
+export interface SavingsRegistryEntry {
+    /** Share-token contract address, lowercased. */
+    address: string;
+    /** Underlying ERC-20 address, lowercased. */
+    underlying: string;
+    /** Share-token symbol — usually the on-chain `symbol()`. */
+    symbol: string;
+    /** Brand label (`Ethena`, `Sky`, `Maker`, …). */
+    brand: string;
+    /** Share decimals. Most are 18; Maple syrup* are 6. */
+    decimals: number;
+    /** Underlying ERC-20 decimals. Defaults to `decimals` when absent
+     *  — every ERC-4626 vault except a handful keep share/underlying
+     *  decimals aligned. yUSD breaks this (18-decimal shares over
+     *  6-decimal USDC) so it must set this explicitly. */
+    underlyingDecimals?: number;
+    /** True if the share token rebases. False for nearly every
+     *  savings vault — the rebase lives on the underlying. */
+    isRebasing: boolean;
+    /** Whether deposits are permissionless. */
+    isMintable: boolean;
+    /** Mint entry — undefined ⇒ share token itself (ERC-4626
+     *  `deposit/mint`). */
+    mintContract?: string;
+    /** Withdrawal mechanism. */
+    withdrawalMode: SavingsWithdrawalMode;
+    /** Fixed cooldown in seconds for `fixed-cooldown` mode. Pinned
+     *  here; read on-chain if the precise governance-current value is
+     *  needed. */
+    withdrawalCooldownSeconds?: number;
+    /** Existing intrinsic-yield fetcher whose APR is surfaced as
+     *  `supplyRate`. Optional — `sDAI` for example has no dedicated
+     *  fetcher today; entry still works, `supplyRate` defaults to 0. */
+    yieldFetcher?: YieldFetcher;
+    /** Key inside the yield fetcher's `YieldResult` to read. Yield
+     *  fetchers return maps keyed by symbol or by a free-text label;
+     *  this is the exact key. */
+    yieldKey?: string;
+}
+/**
+ * Per-chain savings-vault allowlist. Assembled at module load from
+ * single-chain entries plus the expanded `MULTI_CHAIN_GROUPS`.
+ *
+ * See [TIMELOCKS_AND_CHAINS.md](./TIMELOCKS_AND_CHAINS.md) for the
+ * verification notes and
+ * [../lst/EXPANSION_PLAN.md](../lst/EXPANSION_PLAN.md) for the
+ * rollout order.
+ */
+export declare const SAVINGS_REGISTRY: {
+    [chainId: string]: SavingsRegistryEntry[];
+};
+/** Returns the registry entries for a chain, or `[]` when unsupported. */
+export declare const getSavingsRegistry: (chainId: string) => SavingsRegistryEntry[];
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/vaults/savings/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAgBtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,oBAAoB;IACnC,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAA;IACd,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAA;IACb,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAA;IAChB;;;0DAGsD;IACtD,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B;8DAC0D;IAC1D,UAAU,EAAE,OAAO,CAAA;IACnB,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAA;IACnB;2BACuB;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,4BAA4B;IAC5B,cAAc,EAAE,qBAAqB,CAAA;IACrC;;kBAEc;IACd,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC;;wEAEoE;IACpE,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;iCAE6B;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AA2UD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAAA;CAapE,CAAA;AAEN,0EAA0E;AAC1E,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,KAAG,oBAAoB,EACxC,CAAA"}