@1delta/margin-fetcher 0.0.263 → 0.0.266

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

@@ -0,0 +1,16 @@
+/** StakeWise V3 OsTokenVaultController — `convertToAssets(uint256)`
+ *  returns ETH backing for a given osToken share amount. */
+export declare const StakeWiseOsTokenAbi: readonly [{
+    readonly name: "convertToAssets";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "osTokenShares";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "assets";
+    }];
+}];
+//# sourceMappingURL=stakewise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stakewise.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/abis/stakewise.ts"],"names":[],"mappings":"AAAA;4DAC4D;AAC5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAQtB,CAAA"}

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

@@ -0,0 +1,17 @@
+/** StakedCelo Manager — `toCelo(uint256)` returns the CELO owed for a
+ *  given stCELO amount. Pass `1e18` to get the 1e18-scaled
+ *  CELO-per-stCELO rate. Manager (Celo mainnet 42220):
+ *  `0x0239b96D10a434a56CC9E09383077A0490cF9398`. */
+export declare const StCeloManagerAbi: readonly [{
+    readonly name: "toCelo";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "stCeloAmount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=stcelo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stcelo.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/abis/stcelo.ts"],"names":[],"mappings":"AAAA;;;oDAGoD;AACpD,eAAO,MAAM,gBAAgB;;;;;;;;;;;EAQnB,CAAA"}

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

@@ -0,0 +1,13 @@
+/** Swell rswETH — `getRate()` returns ETH-per-share at 1e18.
+ *  Same shape as EtherFi's `getRate()` but kept as its own fragment so
+ *  this file is self-contained. */
+export declare const SwellGetRateAbi: readonly [{
+    readonly name: "getRate";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=swell.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swell.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/abis/swell.ts"],"names":[],"mappings":"AAAA;;mCAEmC;AACnC,eAAO,MAAM,eAAe;;;;;;;;EAQlB,CAAA"}

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

@@ -0,0 +1,13 @@
+/** Valantis stHYPE — `balancePerShare()` returns the 1e18-scaled
+ *  HYPE-per-share rate. wstHYPE wraps the same underlying state, so
+ *  this is the rate for both stHYPE and wstHYPE. */
+export declare const ValantisStHypeAbi: readonly [{
+    readonly name: "balancePerShare";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=valantis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valantis.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/abis/valantis.ts"],"names":[],"mappings":"AAAA;;oDAEoD;AACpD,eAAO,MAAM,iBAAiB;;;;;;;;EAQpB,CAAA"}

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

@@ -0,0 +1,14 @@
+/** Veda Labs BoringVault Accountant `getRate()` — assets-per-share in
+ *  the base asset's decimals (the BTC vaults are BTC-denominated at 8
+ *  decimals). The vault share token itself exposes no ERC-4626 surface,
+ *  so the rate is read from its Accountant. */
+export declare const VedaAccountantGetRateAbi: readonly [{
+    readonly name: "getRate";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=veda.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"veda.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/abis/veda.ts"],"names":[],"mappings":"AAAA;;;+CAG+C;AAC/C,eAAO,MAAM,wBAAwB;;;;;;;;EAQ3B,CAAA"}

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

@@ -0,0 +1,25 @@
+import { MulticallRetryFunction, GenericTokenList } from '../../types';
+import type { LstShareTokens } from './types';
+/**
+ * One-shot fetcher for all LST share tokens on a chain.
+ *
+ * Two parallel I/O legs that both feed the same output map:
+ *
+ *  1. **On-chain leg** — every reader's calls are concatenated into a
+ *     single `multicallRetry` payload; the response is sliced back
+ *     into per-entry chunks and parsed. Failures in one entry's
+ *     parser produce `undefined` and are silently dropped — they
+ *     don't sink the whole batch.
+ *
+ *  2. **APR leg** — `resolveYieldApr` dedups the registry's
+ *     `YieldFetcher` refs, runs each once, and resolves the weETH
+ *     composition (wstETH base + EtherFi LRT2 bonus).
+ *
+ * Returns `{}` when the chain has no registry entries. Per-entry
+ * failures (multicall slice missing, parser returned `undefined`,
+ * APR missing) result in that entry being omitted, never throwing.
+ */
+export declare const fetchLstShareTokens: (chainId: string, multicallRetry: MulticallRetryFunction, prices?: {
+    [asset: string]: number;
+}, tokenList?: GenericTokenList) => Promise<LstShareTokens>;
+//# sourceMappingURL=fetchPublic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetchPublic.d.ts","sourceRoot":"","sources":["../../../src/vaults/lst/fetchPublic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAKtE,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,SAAS,CAAA;AAK5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,EACf,gBAAgB,sBAAsB,EACtC,SAAQ;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,EACxC,YAAW,gBAAqB,KAC/B,OAAO,CAAC,cAAc,CAwJxB,CAAA"}

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

@@ -0,0 +1,5 @@
+export { fetchLstShareTokens } from './fetchPublic';
+export type { LstShareToken, LstShareTokens, LstWithdrawalMode } from './types';
+export { getLstRegistry, LST_REGISTRY, type LstRegistryEntry, type LstReaderKind, } from './registry';
+export { getLstWithdrawalRequests, getVaultWithdrawalRequests, getLstWithdrawalRegistry, LST_WITHDRAWAL_REGISTRY, type LstWithdrawalFetchOptions, type LstWithdrawalRegistryEntry, type LstWithdrawalRequest, type LstWithdrawalRequestsByLst, type LstWithdrawalStatus, type LstWithdrawalReaderKind, } from './withdrawals';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vaults/lst/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC/E,OAAO,EACL,cAAc,EACd,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,wBAAwB,EACxB,0BAA0B,EAC1B,wBAAwB,EACxB,uBAAuB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,GAC7B,MAAM,eAAe,CAAA"}

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

@@ -0,0 +1,16 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Ankr reader — ankrETH, ankrBNB, ankrAVAX, ankrMATIC.
+ *
+ * Two calls: `totalSupply()` + `ratio()`. Ankr's `ratio()` is the
+ * 1e18-scaled *shares-per-underlying* rate (the inverse of the usual
+ * convention) and decreases as staking rewards accrue, so:
+ *
+ *   exchangeRate (underlying-per-share, 1e18) = 1e18 * 1e18 / ratio
+ *   totalAssets                               = totalSupply * 1e18 / ratio
+ *
+ * Verified on-chain: e.g. ankrETH ratio ≈ 0.812e18 → 1 ankrETH ≈ 1.231 ETH.
+ */
+export declare const readerAnkrRatio: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=ankr.d.ts.map

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

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

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

@@ -0,0 +1,16 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Beets stS (Sonic Staked Sonic) reader.
+ *
+ * Three calls:
+ *   1. `stS.totalSupply()`
+ *   2. `stS.getRate()` — 1e18-scaled S-per-stS rate
+ *   3. `stS.totalPool()` — undelegated S buffer (instant-exit liquidity)
+ *
+ * Verified against `beethovenxfi/sonic-staking` source — `getRate()`
+ * is the canonical share-price getter, `totalPool()` reflects how
+ * much S can exit without going through the validator-unbond queue.
+ */
+export declare const readerBeetsStS: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=beets.d.ts.map

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

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

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

@@ -0,0 +1,16 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * BENQI sAVAX reader.
+ *
+ * Three calls:
+ *   1. `sAVAX.totalSupply()`
+ *   2. `sAVAX.getPooledAvaxByShares(1e18)` — 1e18-scaled AVAX-per-sAVAX
+ *   3. `sAVAX.totalPooledAvax()` — total AVAX held
+ *
+ * Lido-clone pattern. Function names per BENQI docs — the live
+ * read on chainId 43114 confirms them (entries silently drop on
+ * mismatch thanks to the `'0x'`-safe `toBigInt`).
+ */
+export declare const readerBenqiSavax: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=benqi.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Generic 1:1 BGT-wrapper reader (Infrared iBGT, BeraPaw LBGT, Bearn
+ * yBGT, Stride stBGT).
+ *
+ * Berachain's BGT is non-transferable and earned via Proof-of-Liquidity;
+ * these tokens are liquid wrappers backed 1:1 by BGT and do NOT accrue —
+ * the value of 1 wrapper does not rise relative to 1 BGT. So there is no
+ * exchange-rate getter to read: `exchangeRate` is fixed at 1e18 and
+ * `totalAssets == totalSupply`. Only `totalSupply()` is fetched.
+ */
+export declare const readerBgtWrapper1to1: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=bgtWrapper.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Dinero beraETH reader.
+ *
+ * beraETH is a wrapper over the rberaETH base LST and is not ERC-4626
+ * (`asset()`/`convertToAssets()` revert). Two calls:
+ * `beraETH.totalSupply()` + `beraETH.LSTPerToken()` (the 1e18-scaled
+ * underlying-per-share rate, ≈1.0535 at time of writing). The ETH rate is
+ * synced cross-chain from Dinero's mainnet apxETH engine, so reading it on
+ * the token is sufficient — no extra contract needed.
+ */
+export declare const readerDineroBeraEth: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=dinero.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dinero.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/dinero.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,mBAAmB,GAAI,OAAO,gBAAgB,KAAG,SAkB5D,CAAA"}

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

@@ -0,0 +1,23 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Generic ERC-4626 reader. Three calls:
+ *   1. `totalAssets()`
+ *   2. `totalSupply()`
+ *   3. `convertToAssets(1e18)`
+ *
+ * The third gives a 1e18-scaled exchange rate without needing a
+ * separate decimals branch. Used for real 4626 shares (pufETH, ynETH).
+ */
+export declare const readerErc4626: (entry: LstRegistryEntry) => LstReader;
+/**
+ * ERC-4626 reader variant that derives the rate from `previewRedeem`
+ * rather than `convertToAssets`. Identical call shape otherwise.
+ *
+ * Used for multi-asset vaults that revert on `convertToAssets` but
+ * implement `previewRedeem` (YieldNest ynLSDe). The unit-of-account is
+ * still 18-decimal (ETH-denominated), so the result is interchangeable
+ * with the generic reader's `exchangeRate`.
+ */
+export declare const readerErc4626PreviewRedeem: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=erc4626.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"erc4626.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/erc4626.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,gBAAgB,KAAG,SAoBtD,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GACrC,OAAO,gBAAgB,KACtB,SAoBD,CAAA"}

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

@@ -0,0 +1,15 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * EtherFi weETH reader.
+ *
+ * Two required calls: `weETH.totalSupply()` + `weETH.getRate()` (eETH
+ * per weETH). Optional third call:
+ * `LiquidityPool.getTotalPooledEther()` — buffer indicator.
+ *
+ * `getRate()` returns eETH-per-weETH (rebasing underlying); we treat
+ * eETH ≈ ETH for the exchange-rate surface — close enough for vault
+ * display, the eETH/ETH peg is invariant by construction.
+ */
+export declare const readerEtherFiWeEth: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=etherfi.d.ts.map

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

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

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

@@ -0,0 +1,17 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Hyperbeat beHYPE reader.
+ *
+ * Two calls: `beHYPE.totalSupply()` + `StakingCore.BeHYPEToHYPE(1e18)`
+ * (1e18-scaled HYPE-per-beHYPE).
+ *
+ * Despite the "Hyperbeat × ether.fi" branding, this is **not** an
+ * `AccountantWithRateProviders` — the rate getter follows the same
+ * `XToY` pattern as Kinetiq. `entry.readerExtras.hyperbeatStakingCore`
+ * pins the address.
+ *
+ * Fall back to `offChain`-style placeholder if absent.
+ */
+export declare const readerHyperbeatBeHype: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=hyperbeat.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+import type { LstRegistryEntry } from '../registry';
+import type { LstReader } from './shared';
+export type { LstCall, LstOnChainState, LstReader } from './shared';
+export { ONE_E18, toBigInt } from './shared';
+/**
+ * Dispatch a registry entry to its per-protocol reader.
+ *
+ * Single source of truth for the reader-kind → implementation
+ * mapping. Adding a new LST means:
+ *   1. Add an ABI fragment under `../abis/<protocol>.ts`.
+ *   2. Add a reader under `./readers/<protocol>.ts`.
+ *   3. Extend `LstReaderKind` in `../registry.ts` and add a case
+ *      below.
+ *   4. Register the LST in `LST_REGISTRY` with the new reader kind.
+ *
+ * Each reader contributes 1–3 multicall items + a parser that consumes
+ * exactly `calls.length` results. The orchestrator
+ * (`../fetchPublic.ts`) flattens every entry's contribution into a
+ * single multicall and slices the result back per-entry.
+ */
+export declare const buildReader: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAwBnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,YAAY,EAAE,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACnE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE5C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,gBAAgB,KAAG,SAqDrD,CAAA"}

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

@@ -0,0 +1,13 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Kelp rsETH reader.
+ *
+ * Two calls: `rsETH.totalSupply()` + `LRTOracle.rsETHPrice()`.
+ * Oracle returns the 1e18-scaled ETH-per-rsETH price.
+ *
+ * Fallback: when `readerExtras.lrtOracle` is absent, surface a 1:1
+ * placeholder rate.
+ */
+export declare const readerKelpRsEth: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=kelp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kelp.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/kelp.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,eAAe,GAAI,OAAO,gBAAgB,KAAG,SAoCzD,CAAA"}

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

@@ -0,0 +1,17 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Kinetiq kHYPE reader.
+ *
+ * Two calls: `kHYPE.totalSupply()` + `StakingAccountant
+ * .kHYPEToHYPE(1e18)` (returns the 1e18-scaled HYPE-per-kHYPE rate).
+ *
+ * The kHYPE token contract is a plain ERC-20; the rate-bearing
+ * accountant is a separate contract — its address is pinned in
+ * `entry.readerExtras.kinetiqAccountant`.
+ *
+ * Fallback to `offChain`-style placeholder if the accountant is
+ * absent (e.g. on a chain without a Kinetiq deployment).
+ */
+export declare const readerKinetiqKHype: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=kinetiq.d.ts.map

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

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

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

@@ -0,0 +1,16 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Lair Finance stKAIA reader (Kaia chain 8217).
+ *
+ * Three calls:
+ *   1. `stKAIA.totalSupply()`
+ *   2. `stKAIA.getRatio()` — 1e18-scaled KAIA-per-stKAIA rate
+ *   3. `stKAIA.totalStaking()` — total KAIA managed (incl. rewards)
+ *
+ * Share-price model (non-rebasing), same shape as the BENQI sAVAX
+ * reader. `getRatio()` equals `totalStaking()/totalSupply()`, so the
+ * derived fallback matches the protocol's own `totalStaking()`.
+ */
+export declare const readerLairStKaia: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=lair.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Lido wstETH reader.
+ *
+ * Two calls: `wstETH.totalSupply()` + `wstETH.stEthPerToken()`.
+ * `totalAssets` is the stETH held by the wrapper, computed as
+ * `totalSupply * stEthPerToken / 1e18` — wstETH has no direct
+ * `totalAssets()` getter, this is the closest invariant.
+ */
+export declare const readerLidoWstEth: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=lido.d.ts.map

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

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

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

@@ -0,0 +1,17 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Lista slisBNB reader.
+ *
+ * Three calls: `slisBNB.totalSupply()` + `ListaStakeManager
+ * .convertSnBnbToBnb(1e18)` (1e18-scaled BNB-per-slisBNB rate) +
+ * `ListaStakeManager.getTotalPooledBnb()` (total BNB backing the
+ * supply, used directly as `totalAssets`).
+ *
+ * The slisBNB token is a plain ERC-20; the rate-bearing StakeManager is
+ * a separate contract — its address is pinned in
+ * `entry.readerExtras.listaStakeManager`. Falls back to a 1.0
+ * placeholder rate if the manager is absent.
+ */
+export declare const readerListaSlisBnb: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=lista.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Mantle mETH reader.
+ *
+ * Two calls: `mETH.totalSupply()` + `Staking.mETHToETH(1e18)`. The
+ * staking contract quotes mETH→ETH at the current rate; calling with
+ * `1e18` returns the 1e18-scaled rate directly.
+ *
+ * Fallback: when `readerExtras.mantleStaking` is absent, surface
+ * totalSupply with a 1:1 placeholder rate.
+ */
+export declare const readerMantleMEth: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=mantle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mantle.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/mantle.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,gBAAgB,GAAI,OAAO,gBAAgB,KAAG,SAoC1D,CAAA"}

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

@@ -0,0 +1,11 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * Off-chain reader — single `totalSupply()` so the entry carries
+ * non-zero state even when no rate getter is available on-chain.
+ *
+ * Used when an LST publishes its exchange rate exclusively off-chain
+ * and the rest of the on-chain surface is the bare ERC-20.
+ */
+export declare const readerOffChain: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=offChain.d.ts.map

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

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

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"}