@1delta/margin-fetcher 0.0.265 → 0.0.267

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

@@ -0,0 +1,34 @@
+/** Stader StakePoolsManager — `getExchangeRate()` returns the
+ *  1e18-scaled ETH-per-ETHx rate. (The 3-tuple variant
+ *  `(totalEthBalance, totalEthxSupply, reportingBlock)` lives on
+ *  StaderOracle, not StakePoolsManager — don't confuse the two.) */
+export declare const StaderEthxAbi: readonly [{
+    readonly name: "getExchangeRate";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+/** Stader MaticX (Ethereum home contract) — `convertMaticXToMatic`
+ *  returns a 3-tuple `(amountInMatic, totalShares, totalPooledMatic)`.
+ *  Pass `1e18` to get the 1e18-scaled MATIC-per-MaticX rate in the
+ *  first element. */
+export declare const StaderMaticXAbi: readonly [{
+    readonly name: "convertMaticXToMatic";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "balance";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }, {
+        readonly type: "uint256";
+    }, {
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=stader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stader.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/abis/stader.ts"],"names":[],"mappings":"AAAA;;;oEAGoE;AACpE,eAAO,MAAM,aAAa;;;;;;;;EAQhB,CAAA;AAEV;;;qBAGqB;AACrB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAQlB,CAAA"}

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/stella.d.ts

@@ -0,0 +1,30 @@
+/** StellaSwap stDOT (Moonbeam chain 1284) — liquid-staked DOT built on the
+ *  lido-dot-ksm architecture. Non-rebasing, value-accruing: `totalSupply()`
+ *  is shares, and the share→DOT rate is read via `getPooledTokenByShares`.
+ *  Because that getter is linear in shares, calling it with `1e18` yields a
+ *  1e18-scaled rate directly (decimals-independent — stDOT/xcDOT are 10-dec).
+ *  `getTotalPooledToken()` returns total pooled DOT (incl. rewards).
+ *
+ *  stDOT: `0xbc7e02c4178a7df7d3e564323a5c359dc96c4db4`
+ *  xcDOT: `0xffffffff1fcacbd218edc0eba20fc2308c778080` (underlying) */
+export declare const StellaStDotAbi: readonly [{
+    readonly name: "getPooledTokenByShares";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "_sharesAmount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "getTotalPooledToken";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=stella.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stella.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/abis/stella.ts"],"names":[],"mappings":"AAAA;;;;;;;;uEAQuE;AACvE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;EAejB,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/coreValidators.d.ts

@@ -0,0 +1,16 @@
+import type { Address } from 'viem';
+export interface CoreValidators {
+    /** Currently-elected validators — the set earning rewards this round.
+     *  Prefer these for `options.validator` on stCORE / SCORE mints. */
+    validators: Address[];
+    /** All registered candidates (delegatable superset of `validators`). */
+    candidates: Address[];
+}
+/**
+ * Fetch the live Core validator + candidate operator addresses on-chain.
+ *
+ * Rotates through the configured Core RPCs (`maxRpcTries`) so a single
+ * flaky endpoint doesn't fail the read. Throws only if every RPC fails.
+ */
+export declare const getCoreValidators: (maxRpcTries?: number) => Promise<CoreValidators>;
+//# sourceMappingURL=coreValidators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coreValidators.d.ts","sourceRoot":"","sources":["../../../src/vaults/lst/coreValidators.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AA4CnC,MAAM,WAAW,cAAc;IAC7B;wEACoE;IACpE,UAAU,EAAE,OAAO,EAAE,CAAA;IACrB,wEAAwE;IACxE,UAAU,EAAE,OAAO,EAAE,CAAA;CACtB;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,oBAAe,KACd,OAAO,CAAC,cAAc,CA4BxB,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":"AAKA,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAKtE,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,SAAS,CAAA;AA8B5D;;;;;;;;;;;;;;;;;;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,CAyJxB,CAAA"}

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

@@ -0,0 +1,6 @@
+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';
+export { getCoreValidators, type CoreValidators } from './coreValidators';
+//# 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;AACtB,OAAO,EAAE,iBAAiB,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,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/core.d.ts

@@ -0,0 +1,22 @@
+import type { LstRegistryEntry } from '../registry';
+import { type LstReader } from './shared';
+/**
+ * stCORE reader (Core chain 1116).
+ *
+ * The rate lives on the `Earn` contract (address in
+ * `readerExtras.coreEarn`), not the token. `getCurrentExchangeRate()`
+ * returns a **1e6-scaled** CORE-per-stCORE rate, so it is rescaled to
+ * the 1e18 convention. `totalAssets = totalSupply * rate / 1e6`.
+ */
+export declare const readerCoreEarnRate: (entry: LstRegistryEntry) => LstReader;
+/**
+ * SCORE / dualCORE reader (Core chain 1116).
+ *
+ * Value-accruing share tokens: `exchangeRate = totalStaked / totalSupply`
+ * (1e18-scaled). `totalStaked` is read from `readerExtras.coreStakeContract`
+ * when set (dualCORE → its b14g `coreVault`), otherwise from the token
+ * itself (SCORE is its own staking contract). `totalSupply` is always the
+ * share token's.
+ */
+export declare const readerCoreStakedRatio: (entry: LstRegistryEntry) => LstReader;
+//# sourceMappingURL=core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/readers/core.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAK5D;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,gBAAgB,KAAG,SAqB5D,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,gBAAgB,KAAG,SAyB/D,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;AA0BnD,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,SA2DrD,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"}