@1delta/margin-fetcher 0.0.265 → 0.0.267

package/dist/vaults/lst/readers/renzo.d.ts

@@ -0,0 +1,19 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Renzo ezETH reader.
+ *
+ * Two calls: `ezETH.totalSupply()` + `RestakeManager.calculateTVLs()`.
+ * `calculateTVLs()` returns a 3-tuple; the third element is total
+ * ETH-denominated TVL across all operator delegators. Exchange rate
+ * is TVL / totalSupply (1e18-scaled).
+ *
+ * `calculateTVLs()` is a relatively heavy call — fine for a single
+ * per-chain snapshot but don't loop it.
+ *
+ * Fallback: when `readerExtras.restakeManager` is absent (e.g. on a
+ * chain without a registered manager), surface a 1:1 placeholder
+ * exchange rate so the entry still produces non-zero state.
+ */
+export declare const readerRenzoEzEth: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=renzo.d.ts.map

package/dist/vaults/lst/readers/renzo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renzo.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/renzo.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,gBAAgB,KAAG,SAoC1D,CAAA"}

package/dist/vaults/lst/readers/rocketpool.d.ts

@@ -0,0 +1,17 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Rocket Pool rETH reader.
+ *
+ * Two required calls: `rETH.totalSupply()` + `rETH.getExchangeRate()`.
+ * Optional third call: `RocketDepositPool.getBalance()` — instant-burn
+ * buffer. Added when the registry's `readerExtras.rocketDepositPool`
+ * is populated (which it is for chainId 1).
+ *
+ * Note: the deposit-pool address upgrades via `RocketStorage` over
+ * time; the registry holds the current snapshot, but production code
+ * paths that mint should resolve via `RocketStorage` rather than
+ * hard-coding. Reading the balance for display is more forgiving.
+ */
+export declare const readerRocketReth: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=rocketpool.d.ts.map

package/dist/vaults/lst/readers/rocketpool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rocketpool.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/rocketpool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAmC,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE1E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,gBAAgB,KAAG,SA6B1D,CAAA"}

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

@@ -0,0 +1,65 @@
+/**
+ * Shared types and helpers used by every per-protocol LST reader.
+ *
+ * Each reader contributes a slice of the orchestrator's multicall
+ * payload (`calls` + matching `abis`) and a `parse` function that
+ * consumes exactly `calls.length` results back. The shape is uniform
+ * regardless of protocol so the orchestrator can flatten the work
+ * into a single multicall.
+ */
+/** 10**18 — used to call rate-by-amount getters (e.g. `mETHToETH(1e18)`,
+ *  `convertToAssets(1e18)`) and to scale exchange rates. Every LST in
+ *  the registry today has 18 decimals; if that ever changes, swap to
+ *  `10n ** BigInt(entry.decimals)` per call site. */
+export declare const ONE_E18: bigint;
+/** One multicall item — matches the shape the existing vault providers
+ *  pass to `multicallRetry` (`{ address, name, params }` with a
+ *  parallel ABI array). */
+export interface LstCall {
+    address: string;
+    name: string;
+    params: readonly unknown[];
+    /** Optional override — when set, the orchestrator dispatches this
+     *  call to a multicall on the named chain instead of the request's
+     *  chain. Used for cross-chain entries whose user-facing token
+     *  lives on one chain (e.g. MaticX on Polygon) but whose rate
+     *  getter lives on another (Ethereum home contract). */
+    chainId?: string;
+}
+/** What a reader produces after consuming its multicall slice. */
+export interface LstOnChainState {
+    /** Total underlying held, raw. */
+    totalAssets: bigint;
+    /** Total shares minted, raw. */
+    totalSupply: bigint;
+    /** 1e18-scaled exchange rate: 1 share → X underlying. */
+    exchangeRate: bigint;
+    /** Instant-exit liquidity buffer estimate, raw. Undefined when the
+     *  protocol exposes none. */
+    liquidity?: bigint;
+}
+/**
+ * Produced by per-protocol readers — a self-contained slice of the
+ * multicall payload plus a parser that consumes exactly `calls.length`
+ * results.
+ */
+export interface LstReader {
+    /** Multicall items contributed by this LST. */
+    calls: LstCall[];
+    /** Matching ABI per call slot. `any[]` to accept the `as const`
+     *  fragments from `../abis` without per-call casting — the
+     *  downstream multicall API is itself `any`-typed. */
+    abis: any[];
+    /** Parses the slice of multicall results corresponding to this
+     *  reader's calls. Returns `undefined` on parse failure so the
+     *  orchestrator can skip the entry without poisoning the rest. */
+    parse: (slice: unknown[]) => LstOnChainState | undefined;
+}
+/**
+ * Safely coerce a multicall return cell to `bigint`. Multicall
+ * failures surface as `undefined` (or wrapped objects when
+ * `allowFailure` is on) — returning `undefined` lets the parser 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/lst/readers/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;qDAGqD;AACrD,eAAO,MAAM,OAAO,QAAa,CAAA;AAEjC;;2BAE2B;AAC3B,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,SAAS,OAAO,EAAE,CAAA;IAC1B;;;;4DAIwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,kEAAkE;AAClE,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAA;IACnB,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAA;IACpB;iCAC6B;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,+CAA+C;IAC/C,KAAK,EAAE,OAAO,EAAE,CAAA;IAChB;;0DAEsD;IAEtD,IAAI,EAAE,GAAG,EAAE,CAAA;IACX;;sEAEkE;IAClE,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,eAAe,GAAG,SAAS,CAAA;CACzD;AAED;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,MAAM,GAAG,SAgB9C,CAAA"}

package/dist/vaults/lst/readers/stader.d.ts

@@ -0,0 +1,34 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Stader ETHx reader.
+ *
+ * Two calls: `ETHx.totalSupply()` + `StakePoolsManager
+ * .getExchangeRate()` (returns 1e18-scaled ETH-per-ETHx rate).
+ *
+ * Fallback: when `readerExtras.staderStakePoolsManager` is absent,
+ * fall back to `ETHx.totalSupply()` with a 1:1 placeholder rate.
+ */
+export declare const readerStaderEthx: (entry: LstRegistryEntry) => LstReader;
+/**
+ * Stader MaticX reader.
+ *
+ * Two calls:
+ *  1. `MaticX.totalSupply()` — on the entry's chain (Ethereum
+ *     L1 entry or Polygon bridge-token entry)
+ *  2. `convertMaticXToMatic(1e18)` — on the **home** contract; the
+ *     Polygon bridge child has no rate getter, so the call always
+ *     goes to the Ethereum home contract. When
+ *     `readerExtras.staderMaticXHomeContract` is set, the call is
+ *     dispatched cross-chain to the home contract on
+ *     `readerExtras.staderMaticXHomeChainId`. Otherwise it's a
+ *     local call on `entry.address`.
+ *
+ * The 3-tuple return is `(amountInMatic, totalShares,
+ * totalPooledMatic)`; element 0 is the 1e18-scaled rate, element 2
+ * is total MATIC pooled (a stronger `totalAssets` than the derived
+ * `totalSupply * rate / 1e18`, but only from the home chain — on
+ * Polygon we still surface the Polygon-side `totalSupply`).
+ */
+export declare const readerStaderMaticX: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=stader.d.ts.map

package/dist/vaults/lst/readers/stader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stader.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/stader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,gBAAgB,KAAG,SAoC1D,CAAA;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,gBAAgB,KAAG,SAsC5D,CAAA"}

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

@@ -0,0 +1,14 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * StakeWise V3 osETH reader.
+ *
+ * Two calls: `osETH.totalSupply()` + `OsTokenVaultController
+ * .convertToAssets(1e18)`. The controller does the share→assets
+ * conversion at the protocol's current exchange rate.
+ *
+ * Fallback: when `readerExtras.osTokenController` is absent, surface
+ * a 1:1 placeholder rate.
+ */
+export declare const readerStakeWiseOsEth: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=stakewise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stakewise.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/stakewise.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,gBAAgB,KAAG,SAoC9D,CAAA"}

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

@@ -0,0 +1,15 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * StakedCelo (stCELO) reader.
+ *
+ * Two calls: `stCELO.totalSupply()` + `Manager.toCelo(1e18)` (returns
+ * the 1e18-scaled CELO-per-stCELO rate). stCELO is value-accruing
+ * (non-rebasing); the Manager holds the rate, not the token.
+ *
+ * The Manager address is pinned in
+ * `entry.readerExtras.stceloManager`. Falls back to a 1:1 placeholder
+ * if absent.
+ */
+export declare const readerStCelo: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=stcelo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stcelo.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/stcelo.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,gBAAgB,KAAG,SAoCtD,CAAA"}

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

@@ -0,0 +1,18 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * StellaSwap stDOT reader (Moonbeam chain 1284).
+ *
+ * Three calls:
+ *   1. `stDOT.totalSupply()` — total shares minted (non-rebasing).
+ *   2. `stDOT.getPooledTokenByShares(1e18)` — 1e18-scaled DOT-per-share
+ *      rate. The getter is linear in shares, so passing 1e18 returns the
+ *      rate directly regardless of the token's 10 decimals.
+ *   3. `stDOT.getTotalPooledToken()` — total pooled DOT (incl. rewards),
+ *      used as `totalAssets`.
+ *
+ * Value-accruing share-price model (same shape as the Lair stKAIA reader);
+ * built on the lido-dot-ksm contract StellaSwap operates.
+ */
+export declare const readerStellaStDot: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=stella.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stella.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/stella.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,gBAAgB,KAAG,SAyB1D,CAAA"}

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

@@ -0,0 +1,13 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Swell rswETH reader — `getRate()`.
+ *
+ * Two calls: `rswETH.totalSupply()` + `rswETH.getRate()`. Both 1e18.
+ *
+ * swETH (the older LST at `0xf951…d78`) uses a different exchange-rate
+ * getter and is intentionally not in the registry yet — re-add once
+ * its selector is verified against the deployed contract.
+ */
+export declare const readerSwellGetRate: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=swell.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swell.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/swell.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,gBAAgB,KAAG,SAkB3D,CAAA"}

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

@@ -0,0 +1,15 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Valantis wstHYPE reader.
+ *
+ * Two calls: `wstHYPE.totalSupply()` + `stHYPE.balancePerShare()`
+ * (1e18-scaled HYPE-per-share). wstHYPE wraps the same underlying
+ * state as stHYPE, so the rate getter on the stHYPE contract works
+ * for both.
+ *
+ * `entry.readerExtras.valantisStHype` pins the stHYPE address. Fall
+ * back to `offChain`-style placeholder if absent.
+ */
+export declare const readerValantisWstHype: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=valantis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valantis.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/valantis.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,gBAAgB,KAAG,SAoC/D,CAAA"}

package/dist/vaults/lst/readers/veda.d.ts

@@ -0,0 +1,19 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Veda Labs BoringVault reader — used for ether.fi's eBTC.
+ *
+ * The vault share token has no ERC-4626 surface; its exchange rate
+ * lives on the Accountant's `getRate()`, denominated in the base
+ * asset's decimals (8 for the BTC vaults). Two calls:
+ *   1. `vault.totalSupply()`
+ *   2. `Accountant.getRate()` — assets-per-share, base-asset decimals.
+ *
+ * The rate is normalised to the 1e18 scale the rest of the pipeline
+ * expects via `10 ** (18 - entry.decimals)` (rate decimals == the
+ * token's decimals for these single-base-asset BTC vaults). Requires
+ * `readerExtras.vedaAccountant`; without it the reader degrades to a
+ * bare `totalSupply()` at a 1:1 rate so the entry still surfaces.
+ */
+export declare const readerVedaAccountant: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=veda.d.ts.map

package/dist/vaults/lst/readers/veda.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"veda.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/veda.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,gBAAgB,KAAG,SAgC9D,CAAA"}

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

@@ -0,0 +1,135 @@
+import type { YieldFetcher } from '../../yields/types';
+import type { LstWithdrawalMode } from './types';
+/** Reader kind — picks which on-chain call set the orchestrator emits
+ *  for a given LST. See `readers.ts` for the per-kind implementations. */
+export type LstReaderKind = 'erc4626' | 'erc4626PreviewRedeem' | 'lidoWstEth' | 'rocketReth' | 'etherfiWeEth' | 'renzoEzEth' | 'kelpRsEth' | 'swellGetRate' | 'stakewiseOsEth' | 'staderEthx' | 'staderMaticX' | 'mantleMEth' | 'beetsStS' | 'benqiSavax' | 'kinetiqKHype' | 'valantisWstHype' | 'hyperbeatBeHype' | 'stceloManager' | 'lairStKaia' | 'listaSlisBnb' | 'dineroBeraEth' | 'bgtWrapper1to1' | 'ankrRatio' | 'coreEarnRate' | 'coreStakedRatio' | 'stellaStDot' | 'vedaAccountant' | 'offChain';
+/**
+ * Static registry entry for an LST share-token.
+ *
+ * Per-chain LSTs live in {@link LST_REGISTRY}. Each entry pins the
+ * on-chain identity (address, decimals, brand), the reader strategy
+ * (which contracts to multicall and how to compute the rate), the
+ * mint/withdrawal metadata used by downstream calldata routing, and a
+ * pointer to the existing intrinsic-yield fetcher whose APR is
+ * surfaced as `supplyRate`.
+ */
+export interface LstRegistryEntry {
+    /** Share-token contract address, lowercased. */
+    address: string;
+    /** Underlying asset address, lowercased — `zeroAddress` for native
+     *  ETH, an ERC-20 address otherwise (e.g. wstETH for pufETH). */
+    underlying: string;
+    /** Share-token symbol. */
+    symbol: string;
+    /** Display name — `${brand} ${symbol}` is composed in the parser if
+     *  this is omitted. */
+    brand: string;
+    /** Share decimals. */
+    decimals: number;
+    /** Reader strategy — drives the multicall payload. */
+    reader: LstReaderKind;
+    /** Whether this is a real ERC-4626 (informational; the reader still
+     *  decides the call shape). */
+    isErc4626: boolean;
+    /** Whether the share token rebases. */
+    isRebasing: boolean;
+    /** Whether the LST can be minted permissionlessly on-chain. */
+    isMintable: boolean;
+    /** Whether the mint entry accepts native ETH. */
+    isNativeUnderlying: boolean;
+    /** Mint entry contract — used by calldata-sdk when wiring deposits. */
+    mintContract?: string;
+    /** Mint input asset. */
+    mintInputAsset?: 'native' | string;
+    /** Withdrawal mechanism. */
+    withdrawalMode: LstWithdrawalMode;
+    /** Fixed cooldown in seconds (only for `fixed-cooldown` mode). */
+    withdrawalCooldownSeconds?: number;
+    /** Existing intrinsic-yield fetcher whose APR is surfaced as
+     *  `supplyRate`. Undefined when no yield source exists yet (e.g.
+     *  ynLSDe). */
+    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;
+    /** Extra contracts the reader needs (oracle, deposit pool, …).
+     *  Shape is reader-specific. */
+    readerExtras?: {
+        /** Renzo `RestakeManager` (chainId 1: 0x74a09653a083691711cf8215a6ab074bb4e99ef5). */
+        restakeManager?: string;
+        /** Kelp `LRTOracle` (chainId 1: 0x349a73444b1a310bae67ef67973022020d70020d). */
+        lrtOracle?: string;
+        /** StakeWise `OsTokenVaultController` (chainId 1:
+         *  0x2a261e60fb14586b474c208b1b7ac6d0f5000306). */
+        osTokenController?: string;
+        /** Stader `StaderStakePoolsManager` (chainId 1:
+         *  0xcf5ea1b38380f6af39068375516daf40ed70d299). */
+        staderStakePoolsManager?: string;
+        /** Mantle `Staking` (chainId 1: 0xe3cbd06d7dadb3f4e6557bab7edd924cd1489e8f). */
+        mantleStaking?: string;
+        /** Rocket Pool `RocketDepositPool` (current address — resolve via
+         *  `RocketStorage` at deploy time; this is a snapshot). */
+        rocketDepositPool?: string;
+        /** EtherFi `LiquidityPool` — exposes the pooled-ETH buffer. */
+        etherFiLiquidityPool?: string;
+        /** Kinetiq `StakingAccountant` (chainId 999:
+         *  0x9209648Ec9D448EF57116B73A2f081835643dc7A) — exposes
+         *  `kHYPEToHYPE(uint256)`. */
+        kinetiqAccountant?: string;
+        /** Valantis `stHYPE` (chainId 999:
+         *  0xffaa4a3d97fe9107cef8a3f48c069f577ff76cc1) — exposes
+         *  `balancePerShare()` (1e18-scaled HYPE-per-share). */
+        valantisStHype?: string;
+        /** Hyperbeat `StakingCore` (chainId 999:
+         *  0xcEAD893b162D38e714D82d06a7fe0b0dc3c38E0b) — exposes
+         *  `BeHYPEToHYPE(uint256)`. */
+        hyperbeatStakingCore?: string;
+        /** StakedCelo `Manager` (Celo mainnet 42220:
+         *  0x0239b96D10a434a56CC9E09383077A0490cF9398) — exposes
+         *  `toCelo(uint256)` (1e18-scaled CELO-per-stCELO). */
+        stceloManager?: string;
+        /** Stader MaticX **home** contract address, used by the
+         *  cross-chain Polygon entry. The Polygon bridge child has no
+         *  rate getter — the rate is read from the Ethereum home
+         *  contract (`0xf03a…b645`) via cross-chain dispatch. */
+        staderMaticXHomeContract?: string;
+        /** Chain to dispatch the rate-getter call to. Pairs with
+         *  `staderMaticXHomeContract`. */
+        staderMaticXHomeChainId?: string;
+        /** Lista `ListaStakeManager` (BNB chain 56:
+         *  0x1adb950d8bb3da4be104211d5ab038628e477fe6) — exposes
+         *  `convertSnBnbToBnb(uint256)` (1e18-scaled BNB-per-slisBNB) and
+         *  `getTotalPooledBnb()`. The slisBNB token itself carries no rate. */
+        listaStakeManager?: string;
+        /** Veda BoringVault `AccountantWithRateProviders` (eBTC on chain 1:
+         *  0x1b293DC39F94157fA0D1D36d7e0090C8B8B8c13F) — exposes
+         *  `getRate()` (assets-per-share, base-asset decimals). The eBTC
+         *  vault token carries no ERC-4626 rate surface. */
+        vedaAccountant?: string;
+        /** stCORE `Earn` contract (Core chain 1116:
+         *  0xf5fA1728bABc3f8D2a617397faC2696c958C3409 = `stCORE.earn()`) —
+         *  exposes `getCurrentExchangeRate()` (1e6-scaled CORE-per-stCORE).
+         *  The stCORE token itself carries no rate getter. */
+        coreEarn?: string;
+        /** Core staking contract holding `totalStaked()` when it is not the
+         *  share token itself — dualCORE's b14g `coreVault`
+         *  (0xee21ab613d30330823D35Cf91A84cE964808B83F = `dualCORE.coreVault()`).
+         *  SCORE omits this (it is its own staking contract). */
+        coreStakeContract?: string;
+    };
+}
+/**
+ * Per-chain LST allowlist. Keyed by chainId (string to match the rest
+ * of the codebase). Add new chains by appending an entry; the LST
+ * vault provider returns `{}` for chains with no entry.
+ *
+ * Coverage: Ethereum mainnet only in this drop — see VAULT_CANDIDATES.md
+ * for the broader roadmap (HyperEVM LSTs, ezETH on L2s, etc.).
+ */
+export declare const LST_REGISTRY: {
+    [chainId: string]: LstRegistryEntry[];
+};
+/** Returns the registry entries for a chain, or `[]` when unsupported. */
+export declare const getLstRegistry: (chainId: string) => LstRegistryEntry[];
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/vaults/lst/registry.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,133 @@
+import type { LstAcceptedInput } from '@1delta/calldata-sdk';
+import { GenericCurrency } from '../../types/general';
+import type { VaultClassificationFields } from '../classification';
+/**
+ * Withdrawal exit mode for an LST. Drives downstream UX: queued LSTs
+ * need a withdrawal-request flow, instant ones can burn-to-asset right
+ * away, off-chain ones must be routed through the issuer or a DEX.
+ *
+ * See LST_WITHDRAWAL_QUEUES.md for the per-LST mechanism details.
+ */
+export type LstWithdrawalMode = 'queued' | 'fixed-cooldown' | 'instant-or-queued' | 'fee-or-queued' | 'off-chain' | 'dex-only';
+/**
+ * Parsed LST share-token entry.
+ *
+ * LSTs are protocol-issued staking-share tokens (Lido stETH, Rocket
+ * Pool rETH, EtherFi weETH, …). Some are real ERC-4626 vaults
+ * (pufETH), most use a custom share/exchange-rate interface.
+ *
+ * Modeled to mirror the existing vault provider shapes (`MorphoVault`,
+ * `FluidFToken`, `EulerEarnVault`) so the cross-provider lookup picks
+ * them up without branching. The required cross-provider fields
+ * (`address`, `underlying`, `symbol`, `name`, `decimals`, `totalAssets`,
+ * `totalSupply`) match `buildVaultLookup`'s structural constraint —
+ * extending this type while dropping one of them will break the
+ * compile.
+ */
+export interface LstShareToken extends VaultClassificationFields {
+    /** Share-token contract address, lowercased. */
+    address: string;
+    /** Underlying asset address, lowercased. `zeroAddress` for LSTs whose
+     *  underlying is native ETH (most ETH LSTs). For pufETH the
+     *  underlying is wstETH. */
+    underlying: string;
+    /** Share-token symbol, e.g. `wstETH`, `weETH`, `rETH`. */
+    symbol: string;
+    /** Share-token name as returned by `name()`, or a falsy-safe fallback
+     *  composed from the brand + symbol. */
+    name: string;
+    /** Cross-provider UI label — `${brand} ${symbol}` (e.g. `Lido wstETH`,
+     *  `EtherFi weETH`). Always non-empty. */
+    displayName: string;
+    /** Brand label — `Lido`, `EtherFi`, `Rocket Pool`, … */
+    brand: string;
+    /** Alias for `brand` to match `curatorName` on the other providers'
+     *  vault types — keeps cross-provider UI code uniform. */
+    curatorName: string;
+    /** Share decimals (always 18 in practice for the LSTs covered here). */
+    decimals: number;
+    /** Total underlying held, raw integer (wei-like) as string.
+     *  Computed as `totalSupply * exchangeRate / 10**decimals` when the
+     *  share token does not expose a direct `totalAssets()`. */
+    totalAssets: string;
+    /** Total shares minted, raw integer as string. */
+    totalSupply: string;
+    /** Raw `convertToShares(10**decimals)` — 1 underlying → X shares. */
+    convertToShares: string;
+    /** Raw `convertToAssets(10**decimals)` — 1 share → X underlying. */
+    convertToAssets: string;
+    /** 1e18-scaled exchange rate: 1 share → X underlying. The canonical
+     *  pricing primitive — `convertToAssets` is derived from this when
+     *  `decimals != 18`. */
+    exchangeRate: string;
+    /** Supply APR in percent (e.g. `3.12` = 3.12 %). Sourced from the
+     *  matching intrinsic-yield fetcher. */
+    supplyRate: number;
+    /** Extra rewards APR in percent — usually 0 for LSTs; populated only
+     *  when the protocol layers a separate reward stream on top. */
+    rewardsRate: number;
+    /** Sum of `supplyRate + rewardsRate` — what a depositor actually
+     *  earns. */
+    depositRate: number;
+    /** True if the share token is a real ERC-4626. Drives whether the
+     *  calldata builder uses `deposit(uint256,address)` or a
+     *  protocol-specific entry. */
+    isErc4626: boolean;
+    /** True if the share token rebases (e.g. stETH, eETH). Most LSTs
+     *  covered here are non-rebasing wrappers (wstETH, weETH). */
+    isRebasing: boolean;
+    /** False when the share token cannot be minted permissionlessly
+     *  on-chain — e.g. cbETH (Coinbase off-chain mint). */
+    isMintable: boolean;
+    /** True if the mint entry accepts native ETH (`payable`). */
+    isNativeUnderlying: boolean;
+    /** Mint entry contract address, lowercased. Undefined when
+     *  `isMintable === false`. */
+    mintContract?: string;
+    /** Input asset for the mint call. `native` for `payable` entries,
+     *  otherwise a lowercased ERC-20 address. Undefined when not
+     *  mintable. The primary input; see `acceptedInputs` for the full set. */
+    mintInputAsset?: 'native' | string;
+    /**
+     * Full set of pay assets the mint accepts, with each path's shape and any
+     * required options — the machine-readable answer to "what can I pay with".
+     * Sourced from calldata-sdk's `LST_INPUT_CAPABILITIES`; falls back to a
+     * single entry derived from `mintInputAsset` for kinds with no alternatives.
+     * Empty when `isMintable === false`. Use this to drive the deposit-action
+     * request (`payAsset` + the per-path `needs` options). */
+    acceptedInputs: LstAcceptedInput[];
+    /** Withdrawal mechanism — see `LstWithdrawalMode`. */
+    withdrawalMode: LstWithdrawalMode;
+    /** Fixed cooldown in seconds for `fixed-cooldown` mode. Undefined
+     *  otherwise. Queue-finalization protocols (Lido, EtherFi, …) have
+     *  no fixed delay — their wait depends on the validator-exit queue. */
+    withdrawalCooldownSeconds?: number;
+    /** Hydrated asset metadata from the provided token list, if any. */
+    asset?: GenericCurrency;
+    /** USD price of one underlying unit, if prices were supplied. */
+    priceUsd?: number;
+    /** Human-formatted total assets (`totalAssets / 10**decimals`). */
+    totalAssetsFormatted: number;
+    /** Human-formatted total assets in USD. */
+    totalAssetsUsd: number;
+    /** Instant-exit liquidity estimate, raw integer as string. Populated
+     *  only when a protocol exposes a queryable buffer (e.g. Rocket Pool
+     *  `RocketDepositPool.getBalance()`, EtherFi `LiquidityPool` buffer). */
+    liquidity?: string;
+    /** Human-formatted instant-exit liquidity. */
+    liquidityFormatted?: number;
+    /** Human-formatted instant-exit liquidity in USD. */
+    liquidityUsd?: number;
+}
+/**
+ * Full parsed payload: per-share-token-address map.
+ *
+ * Keyed by lowercased share-token address (parity with Morpho / Silo /
+ * Euler-Earn). LSTs do not naturally key by underlying — many LSTs
+ * share `zeroAddress` (native ETH) as their underlying, so the
+ * underlying-keyed shape used by Fluid/Gearbox would collide.
+ */
+export type LstShareTokens = {
+    [shareAddress: string]: LstShareToken;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/vaults/lst/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAElE;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,gBAAgB,GAChB,mBAAmB,GACnB,eAAe,GACf,WAAW,GACX,UAAU,CAAA;AAEd;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,aAAc,SAAQ,yBAAyB;IAC9D,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAA;IACf;;gCAE4B;IAC5B,UAAU,EAAE,MAAM,CAAA;IAClB,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAA;IACd;4CACwC;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ;8CAC0C;IAC1C,WAAW,EAAE,MAAM,CAAA;IACnB,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAA;IACb;8DAC0D;IAC1D,WAAW,EAAE,MAAM,CAAA;IACnB,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAA;IAEhB;;gEAE4D;IAC5D,WAAW,EAAE,MAAM,CAAA;IACnB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAA;IACnB,qEAAqE;IACrE,eAAe,EAAE,MAAM,CAAA;IACvB,oEAAoE;IACpE,eAAe,EAAE,MAAM,CAAA;IACvB;;4BAEwB;IACxB,YAAY,EAAE,MAAM,CAAA;IAEpB;4CACwC;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB;oEACgE;IAChE,WAAW,EAAE,MAAM,CAAA;IACnB;iBACa;IACb,WAAW,EAAE,MAAM,CAAA;IAEnB;;mCAE+B;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB;kEAC8D;IAC9D,UAAU,EAAE,OAAO,CAAA;IACnB;2DACuD;IACvD,UAAU,EAAE,OAAO,CAAA;IACnB,6DAA6D;IAC7D,kBAAkB,EAAE,OAAO,CAAA;IAE3B;kCAC8B;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;8EAE0E;IAC1E,cAAc,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAA;IAClC;;;;;;8DAM0D;IAC1D,cAAc,EAAE,gBAAgB,EAAE,CAAA;IAElC,sDAAsD;IACtD,cAAc,EAAE,iBAAiB,CAAA;IACjC;;2EAEuE;IACvE,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAElC,oEAAoE;IACpE,KAAK,CAAC,EAAE,eAAe,CAAA;IACvB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mEAAmE;IACnE,oBAAoB,EAAE,MAAM,CAAA;IAC5B,2CAA2C;IAC3C,cAAc,EAAE,MAAM,CAAA;IAEtB;;6EAEyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8CAA8C;IAC9C,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAAA;CACtC,CAAA"}

package/dist/vaults/lst/withdrawals/abis/beets.d.ts

@@ -0,0 +1,51 @@
+/** Beets stS — paginated user-withdraw enumeration + delay constant.
+ *  Address on chain 146: `0xe5da20f15420ad15de0fa650600afc998bbe3955`. */
+export declare const BeetsStSWithdrawalAbi: readonly [{
+    readonly name: "getUserWithdraws";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+    }, {
+        readonly type: "uint256";
+        readonly name: "skip";
+    }, {
+        readonly type: "uint256";
+        readonly name: "maxSize";
+    }, {
+        readonly type: "bool";
+        readonly name: "reverseOrder";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "uint8";
+            readonly name: "kind";
+        }, {
+            readonly type: "uint256";
+            readonly name: "validatorId";
+        }, {
+            readonly type: "uint256";
+            readonly name: "assetAmount";
+        }, {
+            readonly type: "bool";
+            readonly name: "isWithdrawn";
+        }, {
+            readonly type: "uint256";
+            readonly name: "requestTimestamp";
+        }, {
+            readonly type: "address";
+            readonly name: "user";
+        }];
+    }];
+}, {
+    readonly name: "withdrawDelay";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=beets.d.ts.map

package/dist/vaults/lst/withdrawals/abis/beets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beets.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/beets.ts"],"names":[],"mappings":"AAAA;0EAC0E;AAC1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCxB,CAAA"}