@1delta/margin-fetcher 0.0.263 → 0.0.266

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

@@ -0,0 +1,22 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Generic ERC-7540 async-redeem reader.
+ *
+ * Uses the single-pending-request shortcut (`requestId = 0`) common
+ * to most 7540 vaults. For vaults that emit distinct requestIds per
+ * call, this misses requests beyond the first — caller would need
+ * event indexing to enumerate all IDs.
+ *
+ * Two calls in one multicall:
+ *  - `pendingRedeemRequest(0, user)` → shares still pending
+ *  - `claimableRedeemRequest(0, user)` → shares ready to claim
+ *
+ * If both are zero, no pending request; we return [].
+ *
+ * `amountUnderlying` is approximated by `convertToAssets(shares)` —
+ * the orchestrator could enrich with the vault's live exchange rate
+ * but for now we surface raw shares with a `symbol` of the share
+ * token.
+ */
+export declare const readerErc7540: LstWithdrawalReader;
+//# sourceMappingURL=erc7540.d.ts.map

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

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

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

@@ -0,0 +1,13 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Ethena-style cooldown reader (sUSDe, and any savings vault exposing
+ * the same `cooldowns(address)` getter).
+ *
+ * One call: `cooldowns(user) → (cooldownEnd, underlyingAmount)`. A
+ * non-zero `underlyingAmount` means the user has assets escrowed in the
+ * cooldown; `cooldownEnd` is the unlock time. `status` is derived from
+ * `cooldownEnd` vs now (`pending` before, `claimable` after). No
+ * enumeration — Ethena keeps a single cooldown slot per user.
+ */
+export declare const readerEthenaCooldown: LstWithdrawalReader;
+//# sourceMappingURL=ethenaCooldown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ethenaCooldown.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/ethenaCooldown.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2B,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAE5E;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAyClC,CAAA"}

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

@@ -0,0 +1,13 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * EtherFi WithdrawRequestNFT — ERC-721 enumerable.
+ *
+ * Three stages:
+ *  1. `balanceOf(user)` → count.
+ *  2. `tokenOfOwnerByIndex(user, i)` for i in [0, count) — enumerate
+ *     token IDs.
+ *  3. `getRequest(id) + isFinalized(id) + isValid(id)` per id — get
+ *     per-request status.
+ */
+export declare const readerEtherFi: LstWithdrawalReader;
+//# sourceMappingURL=etherfi.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+import { type LstWithdrawalReader } from './shared';
+export declare const readerIbera: LstWithdrawalReader;
+//# sourceMappingURL=ibera.d.ts.map

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

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

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

@@ -0,0 +1,7 @@
+import type { LstWithdrawalRegistryEntry } from '../registry';
+import type { LstWithdrawalReader } from './shared';
+export type { LstWithdrawalReader, LstWithdrawalKnownId, LstWithdrawalKnownIds, } from './shared';
+export { computeStatus, toBigInt, toNumber } from './shared';
+/** Dispatch a registry entry to its withdrawal reader. */
+export declare const buildWithdrawalReader: (entry: LstWithdrawalRegistryEntry) => LstWithdrawalReader;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAA;AA2B7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAEnD,YAAY,EACV,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE5D,0DAA0D;AAC1D,eAAO,MAAM,qBAAqB,GAChC,OAAO,0BAA0B,KAChC,mBA0DF,CAAA"}

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

@@ -0,0 +1,21 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Kelp rsETH — per-asset FIFO deque keyed by `(asset, user)`.
+ *
+ * Log-free enumeration sequence:
+ *  1. For each whitelisted asset, derive the deque value slot via
+ *     `keccak256` and read it with `eth_getStorageAt`. The 32-byte
+ *     word holds `_begin` (low 128 bits) and `_end` (high 128 bits);
+ *     `length = _end - _begin`.
+ *  2. Multicall `getUserWithdrawalRequest(asset, user, i)` for
+ *     `i in [0, length)`. The contract handles the `_begin` offset
+ *     internally — pass plain index, not `i + _begin`.
+ *  3. Pull `withdrawalDelayBlocks()` once for the per-request
+ *     finalization check (`currentBlock >= withdrawalStartBlock + delay`).
+ *
+ * Storage slot is brittle to upgrades. Re-verify the slot derivation
+ * if the proxy's implementation changes — see
+ * `INDEXING_STRATEGIES.md` for the derivation walkthrough.
+ */
+export declare const readerKelp: LstWithdrawalReader;
+//# sourceMappingURL=kelp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kelp.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/kelp.ts"],"names":[],"mappings":"AAIA,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AA+C7D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,EAAE,mBA6GxB,CAAA"}

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

@@ -0,0 +1,13 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Kinetiq kHYPE — per-user withdrawal-request enumeration on the
+ * StakingManager Diamond.
+ *
+ * Stage 1: `nextWithdrawalId(user)` (request count) + `withdrawalDelay()`.
+ * Stage 2: `withdrawalRequests(user, id)` for `id in [0, count)`.
+ *
+ * A confirmed/cleared request reads back `hypeAmount == 0` and is
+ * skipped. `readyAt = timestamp + withdrawalDelay`.
+ */
+export declare const readerKinetiq: LstWithdrawalReader;
+//# sourceMappingURL=kinetiq.d.ts.map

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

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

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

@@ -0,0 +1,23 @@
+import type { LstWithdrawalReader } from './shared';
+/**
+ * Lair Finance stKAIA — log-free via caller-supplied IDs.
+ *
+ * Unstaking is a two-step 7-day queue on the stKAIA contract:
+ * `unstake(node, amount)` burns stKAIA and emits a request, then
+ * `claim(requestId)` pays out after the unbonding period. The contract
+ * exposes no confirmed public getter to enumerate a user's pending
+ * requests (only `claim(uint256)`), so — per the no-logs constraint —
+ * the reader expects the caller (frontend / worker-api) to have
+ * captured each `requestId` from the unstake tx receipt and to pass the
+ * accumulated list as `knownIds`.
+ *
+ * Without a detail getter we cannot resolve the settled amount or the
+ * exact `readyAt`, so each known id is surfaced as a bare `pending`
+ * request. If a public request-detail getter is later confirmed on the
+ * stKAIA contract, enrich here: resolve `amountUnderlying` and
+ * `readyAt = requestTs + 7d`, then derive `status` via `computeStatus`.
+ *
+ * Returns `[]` when no IDs are supplied — no enumeration is attempted.
+ */
+export declare const readerLair: LstWithdrawalReader;
+//# sourceMappingURL=lair.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lair.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/lair.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,UAAU,EAAE,mBAmBxB,CAAA"}

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

@@ -0,0 +1,16 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Lido stETH/wstETH — FIFO withdrawal queue, NFT-enumerable.
+ *
+ * Two stages:
+ *  1. `WithdrawalQueueERC721.getWithdrawalRequests(owner) → uint256[]`
+ *     — enumerate request IDs owned by the user.
+ *  2. `WithdrawalQueueERC721.getWithdrawalStatus(ids[]) → struct[]` +
+ *     `getLastFinalizedRequestId()` — get per-request status + the
+ *     frontier for queue-position computation.
+ *
+ * `amountUnderlying` = `amountOfStETH` (raw wei stETH at request time;
+ * exact ETH payout is determined at finalization).
+ */
+export declare const readerLido: LstWithdrawalReader;
+//# sourceMappingURL=lido.d.ts.map

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

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

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

@@ -0,0 +1,18 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Lista slisBNB — per-user withdrawal-request enumeration on the
+ * ListaStakeManager.
+ *
+ * Stage 1: `getUserWithdrawalRequests(user)` → open requests
+ *          (`uuid`, `amountInSnBnb`, `startTime`).
+ * Stage 2: per index, `getUserRequestStatus(user, idx)` →
+ *          `(isClaimable, amount)` where `amount` is the BNB owed.
+ *
+ * `getUserRequestStatus` is indexed by position in the array returned
+ * by stage 1 (not by `uuid`). The StakeManager exposes no per-request
+ * ready timestamp — claimability follows the BNB validator unbond
+ * (~7–15 days) — so `status` is derived from `isClaimable` and
+ * `readyAt` is left unset (mirrors the beHYPE / Kelp readers).
+ */
+export declare const readerLista: LstWithdrawalReader;
+//# sourceMappingURL=lista.d.ts.map

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

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

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

@@ -0,0 +1,18 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Mantle mETH — log-free via caller-supplied IDs.
+ *
+ * No user-keyed on-chain storage exists; the only on-chain
+ * enumeration path is the `UnstakeRequestCreated` event. Per the
+ * no-logs constraint, the reader expects the caller (frontend /
+ * worker-api) to have captured `unstakeRequestId` from the withdraw
+ * tx receipt at request time and to pass the accumulated list as
+ * `knownIds`.
+ *
+ * Returns `[]` when no IDs are supplied — no enumeration is attempted.
+ *
+ * Per id: multicall `requestByID(id)` + `requestInfo(id)`. The latter
+ * already returns the claimable flag and the settled amount.
+ */
+export declare const readerMantle: LstWithdrawalReader;
+//# sourceMappingURL=mantle.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+import { type LstWithdrawalReader } from './shared';
+export declare const readerPrimeStaking: LstWithdrawalReader;
+//# sourceMappingURL=primestaking.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"primestaking.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/primestaking.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AA0BvE,eAAO,MAAM,kBAAkB,EAAE,mBA4EhC,CAAA"}

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

@@ -0,0 +1,17 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Puffer pufETH — log-free via caller-supplied IDs.
+ *
+ * The reader expects `knownIds` to be the list of `withdrawalIdx`
+ * values captured from the `WithdrawalRequested` event in the
+ * withdraw tx receipt at request time.
+ *
+ * Per request: multicall `getWithdrawal(idx)` per id plus a single
+ * `getFinalizedWithdrawalBatch()` + `BATCH_SIZE()` for the
+ * finalization frontier. A request is claimable iff
+ * `floor(idx / BATCH_SIZE) <= finalizedBatch`.
+ *
+ * Returns `[]` when no IDs are supplied.
+ */
+export declare const readerPuffer: LstWithdrawalReader;
+//# sourceMappingURL=puffer.d.ts.map

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

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

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

@@ -0,0 +1,16 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Renzo ezETH — per-user indexed enumeration. Deterministic readyAt
+ * via `createdAt + coolDownPeriod()`.
+ *
+ * Three stages:
+ *  1. `getOutstandingWithdrawRequests(user)` → count + cooldown
+ *     constant in one multicall.
+ *  2. `withdrawRequests(user, i)` per index.
+ *
+ * Note: Renzo deletes entries on claim, compacting the array — the
+ * index returned here is the **client-side index at fetch time**.
+ * Re-enumerate after each claim.
+ */
+export declare const readerRenzo: LstWithdrawalReader;
+//# sourceMappingURL=renzo.d.ts.map

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

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

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

@@ -0,0 +1,56 @@
+import type { MulticallRetryFunction } from '../../../../types';
+import type { LstWithdrawalRegistryEntry } from '../registry';
+import type { LstWithdrawalRequest } from '../types';
+/** Composite withdrawal id for protocols where the natural unit is a
+ *  `(validator, nonce)` pair (e.g. TruFin TruMATIC), in addition to
+ *  the standard `bigint` id used by everything else. */
+export type LstWithdrawalKnownId = bigint | {
+    validator: string;
+    nonce: bigint;
+};
+/** Per-LST list of caller-known withdrawal IDs, keyed by lowercased
+ *  LST share-token address. Caller (frontend / worker-api) captures
+ *  these from the withdraw tx receipt at request time and passes the
+ *  accumulated list back on subsequent reads.
+ *
+ *  See `INDEXING_STRATEGIES.md` — "Caller-supplied IDs" section — for
+ *  why this is the universal log-free fallback. */
+export type LstWithdrawalKnownIds = {
+    [lstAddress: string]: LstWithdrawalKnownId[];
+};
+/**
+ * Reader interface for per-user withdrawal-request enumeration.
+ *
+ * Each reader is responsible for its protocol's enumeration sequence
+ * (typically two stages: a `count` / `balanceOf` call to discover how
+ * many pending requests exist, then a per-id detail call). Returns a
+ * normalised `LstWithdrawalRequest[]` regardless of mechanism.
+ *
+ * Why a callable function instead of the data-driven `LstReader`
+ * shape used elsewhere: withdrawal enumeration is **per-user** and
+ * usually **multi-stage** (count depends on user; detail calls depend
+ * on count). Inlining the sequencing in each reader is simpler than
+ * stage-based pipelining at the orchestrator level.
+ *
+ * Tolerances: per-reader failures (RPC errors, malformed responses)
+ * should NOT throw — return an empty array and log via the
+ * orchestrator's debug channel. The vaults-endpoint user model
+ * tolerates "we don't know your requests" but not "the entire
+ * endpoint failed".
+ *
+ * `knownIds` is only used by `callerSupplied`-style readers (Mantle,
+ * Puffer, TruFin). Readers with on-chain enumeration ignore it.
+ */
+export interface LstWithdrawalReader {
+    fetch: (user: string, multicallRetry: MulticallRetryFunction, chainId: string, entry: LstWithdrawalRegistryEntry, knownIds?: LstWithdrawalKnownId[]) => Promise<LstWithdrawalRequest[]>;
+}
+/** Safely coerce a multicall return cell to bigint. Mirrors the
+ *  pattern used in `vaults/lst/readers/shared.ts`. */
+export declare const toBigInt: (v: unknown) => bigint | undefined;
+/** Safely coerce to number. Used for counts / indices (uint sizes
+ *  that fit in Number range). */
+export declare const toNumber: (v: unknown) => number | undefined;
+/** Builds the `status` field given `readyAt`/`expiresAt` and the
+ *  current time. */
+export declare const computeStatus: (readyAt: number, expiresAt?: number, nowSeconds?: number) => "pending" | "claimable" | "expired";
+//# sourceMappingURL=shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/readers/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC/D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAEpD;;wDAEwD;AACxD,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhF;;;;;;mDAMmD;AACnD,MAAM,MAAM,qBAAqB,GAAG;IAClC,CAAC,UAAU,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAAA;CAC7C,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,CACL,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,sBAAsB,EACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,0BAA0B,EACjC,QAAQ,CAAC,EAAE,oBAAoB,EAAE,KAC9B,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAAA;CACrC;AAED;sDACsD;AACtD,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,MAAM,GAAG,SAa9C,CAAA;AAED;iCACiC;AACjC,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,MAAM,GAAG,SAK9C,CAAA;AAED;oBACoB;AACpB,eAAO,MAAM,aAAa,GACxB,SAAS,MAAM,EACf,YAAY,MAAM,EAClB,aAAY,MAAsC,KACjD,SAAS,GAAG,WAAW,GAAG,SAI5B,CAAA"}

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

@@ -0,0 +1,15 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Stader ETHx — per-user request ID list + per-id detail.
+ *
+ * Two stages:
+ *  1. `getRequestIdsByUser(owner)` → uint256[] of request IDs.
+ *  2. `userWithdrawRequests(id)` per id → request struct. Status is
+ *     finalized iff `id < nextRequestIdToFinalize` AND
+ *     `ethFinalized > 0`.
+ *
+ * `amountUnderlying` uses `ethFinalized` when finalized (the actual
+ * payable amount) and `ethExpected` while pending.
+ */
+export declare const readerStaderEthx: LstWithdrawalReader;
+//# sourceMappingURL=staderEthx.d.ts.map

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

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

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

@@ -0,0 +1,18 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Stader MaticX — per-user array enumeration on the Ethereum home
+ * contract. Finalized when `IStakeManager(stakeManager).epoch() >=
+ * requestEpoch + stakeManager.withdrawalDelay()`.
+ *
+ * Single stage: `getUserWithdrawalRequests(user)` returns the array
+ * + `IStakeManager.epoch()` and `IStakeManager.withdrawalDelay()` for
+ * finalization checks. Stake manager address is pinned in
+ * `readerExtras.polygonStakeManager`.
+ *
+ * Per-request `readyAt` is a Polygon-checkpoint-based ETA, not a wall
+ * clock. We surface it as the boolean `claimable` via
+ * `requestEpoch + withdrawalDelay <= currentEpoch`; consumers wanting
+ * an estimated time should map "checkpoints" → "seconds" off-chain.
+ */
+export declare const readerStaderMaticX: LstWithdrawalReader;
+//# sourceMappingURL=staderMaticx.d.ts.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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