@1delta/margin-fetcher 0.0.265 → 0.0.267

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

@@ -0,0 +1,65 @@
+/** YieldNest WithdrawalQueueManager — ERC-721 enumerable + per-id
+ *  getter. Address on chain 1:
+ *  `0x0bc9bc81ad379810b36ad5cc95387112990aa67b`. */
+export declare const YieldNestWithdrawalQueueAbi: readonly [{
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "tokenOfOwnerByIndex";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }, {
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "withdrawalRequest";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "tokenId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint256";
+            readonly name: "amount";
+        }, {
+            readonly type: "uint256";
+            readonly name: "feeAtRequestTime";
+        }, {
+            readonly type: "uint256";
+            readonly name: "redemptionRateAtRequestTime";
+        }, {
+            readonly type: "uint256";
+            readonly name: "creationTimestamp";
+        }, {
+            readonly type: "bool";
+            readonly name: "processed";
+        }, {
+            readonly type: "bytes";
+            readonly name: "data";
+        }];
+    }];
+}, {
+    readonly name: "secondsToFinalization";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=yieldnest.d.ts.map

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

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

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

@@ -0,0 +1,53 @@
+import type { MulticallRetryFunction } from '../../../types';
+import type { LstWithdrawalKnownIds } from './readers';
+import type { LstWithdrawalRegistryEntry } from './registry';
+import type { LstWithdrawalRequestsByLst } from './types';
+/** Optional knobs for the orchestrator. */
+export interface LstWithdrawalFetchOptions {
+    /** Per-LST caller-supplied IDs. Required for protocols whose
+     *  readers are `callerSupplied`-shaped (Mantle, Puffer, TruFin) —
+     *  those readers return `[]` when no IDs are supplied. Ignored by
+     *  protocols with on-chain enumeration. Keyed by lowercased LST
+     *  share-token address. */
+    knownIds?: LstWithdrawalKnownIds;
+    /** Caller-supplied registry entries appended to the static registry.
+     *  Lets the orchestrator read withdrawal requests for vaults not in
+     *  the hardcoded LST allowlist — e.g. an arbitrary ERC-7540 vault
+     *  surfaced by the public-data lookup. Each entry needs at least
+     *  `{ lst, brand, symbol, reader }`; the `erc7540` reader needs only
+     *  the address. De-duped against the static registry (static wins). */
+    extraEntries?: LstWithdrawalRegistryEntry[];
+}
+/**
+ * Fetch a user's pending LST withdrawal requests across all LSTs on
+ * a chain.
+ *
+ * One reader-`fetch` invocation per registered LST, all running in
+ * parallel via `Promise.all`. Per-reader failures (RPC error,
+ * malformed response, unsupported protocol) are logged and produce
+ * an empty array — they don't sink the whole call.
+ *
+ * Returns a map keyed by lowercased LST share-token address.
+ * Empty-array entries are kept so callers can render "no pending
+ * requests" UX uniformly.
+ *
+ * For protocols with no user-keyed on-chain storage and no public
+ * subgraph (Mantle mETH, Puffer pufETH, TruFin TruMATIC), pass
+ * `options.knownIds[lstAddress]` — the list of withdrawal IDs the
+ * caller captured at request time. See `INDEXING_STRATEGIES.md`
+ * "Caller-supplied IDs" section.
+ *
+ * Note: the orchestrator runs N parallel multicalls (one per LST,
+ * possibly with internal sub-stages). Per-chain consolidation is not
+ * yet implemented — see GAPS.md section F for the optimization
+ * trade-off.
+ */
+export declare const getLstWithdrawalRequests: (user: string, chainId: string, multicallRetry: MulticallRetryFunction, options?: LstWithdrawalFetchOptions) => Promise<LstWithdrawalRequestsByLst>;
+/**
+ * Alias for {@link getLstWithdrawalRequests}. The orchestrator is no
+ * longer LST-specific — with `options.extraEntries` it reads withdrawal
+ * requests for any vault (e.g. arbitrary ERC-7540) — so this name reads
+ * better at non-LST call sites. Same signature, same behaviour.
+ */
+export declare const getVaultWithdrawalRequests: (user: string, chainId: string, multicallRetry: MulticallRetryFunction, options?: LstWithdrawalFetchOptions) => Promise<LstWithdrawalRequestsByLst>;
+//# sourceMappingURL=fetchPublic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetchPublic.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/withdrawals/fetchPublic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAE5D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA;AAEtD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAC5D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAA;AAQzD,2CAA2C;AAC3C,MAAM,WAAW,yBAAyB;IACxC;;;;+BAI2B;IAC3B,QAAQ,CAAC,EAAE,qBAAqB,CAAA;IAChC;;;;;2EAKuE;IACvE,YAAY,CAAC,EAAE,0BAA0B,EAAE,CAAA;CAC5C;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,MAAM,EACZ,SAAS,MAAM,EACf,gBAAgB,sBAAsB,EACtC,UAAU,yBAAyB,KAClC,OAAO,CAAC,0BAA0B,CA4BpC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,SAxC/B,MAAM,WACH,MAAM,kBACC,sBAAsB,YAC5B,yBAAyB,KAClC,OAAO,CAAC,0BAA0B,CAoC6B,CAAA"}

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

@@ -0,0 +1,5 @@
+export { getLstWithdrawalRequests, getVaultWithdrawalRequests, type LstWithdrawalFetchOptions, } from './fetchPublic';
+export { LST_WITHDRAWAL_REGISTRY, getLstWithdrawalRegistry, type LstWithdrawalRegistryEntry, } from './registry';
+export type { LstWithdrawalRequest, LstWithdrawalRequestsByLst, LstWithdrawalStatus, LstWithdrawalReaderKind, } from './types';
+export type { LstWithdrawalKnownId, LstWithdrawalKnownIds } from './readers';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vaults/lst/withdrawals/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,0BAA0B,EAC1B,KAAK,yBAAyB,GAC/B,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,KAAK,0BAA0B,GAChC,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,oBAAoB,EACpB,0BAA0B,EAC1B,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,SAAS,CAAA;AAChB,YAAY,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA"}

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

@@ -0,0 +1,13 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Beets stS — paginated user-withdraw enumeration on the SonicStaking
+ * proxy. 14-day Sonic validator unbond is the cooldown.
+ *
+ * Single stage: fetch up to N requests + `withdrawDelay()` constant
+ * in one multicall. `WithdrawRequest.isWithdrawn` flips to true on
+ * claim.
+ *
+ * Hardcoded page size of 200 — should cover any realistic user.
+ */
+export declare const readerBeets: LstWithdrawalReader;
+//# sourceMappingURL=beets.d.ts.map

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

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

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

@@ -0,0 +1,15 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * Hyperbeat beHYPE — per-user withdrawal-request enumeration on the
+ * WithdrawManager.
+ *
+ * Stage 1: `getUserUnclaimedWithdrawals(user)` → open request ids.
+ * Stage 2: per id, `withdrawalQueue(id)` (amounts) +
+ *          `canClaimWithdrawal(id)` (finalization flag).
+ *
+ * The WithdrawManager exposes no per-request ready timestamp, so
+ * `status` is derived from `canClaimWithdrawal` and `readyAt` is left
+ * unset (mirrors the Kelp reader).
+ */
+export declare const readerBeHype: LstWithdrawalReader;
+//# sourceMappingURL=behype.d.ts.map

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

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

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

@@ -0,0 +1,15 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * BENQI sAVAX — paginated unlock-requests. 15-day cooldown + 2-day
+ * claim window.
+ *
+ * Two stages:
+ *  1. `getUnlockRequestCount(user) + cooldownPeriod() + redeemPeriod()`
+ *  2. `getPaginatedUnlockRequests(user, 0, count)`
+ *
+ * Surfaces both `readyAt` (cooldown end) and `expiresAt` (claim
+ * window close). After `expiresAt` the request becomes `expired` and
+ * the unlock is forfeited.
+ */
+export declare const readerBenqi: LstWithdrawalReader;
+//# sourceMappingURL=benqi.d.ts.map

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

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

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

@@ -0,0 +1,13 @@
+import { type LstWithdrawalReader } from './shared';
+/**
+ * BeraPaw LBGT — redemption position on the BeraPawForge.
+ *
+ * LBGT → BERA exits are tracked per-user by `redeemPosition(account)`
+ * returning `(queued, available)` LBGT amounts (1:1 with BERA). There is
+ * no per-request id, so this emits at most two normalised entries: the
+ * `available` portion as `claimable` and the `queued` portion as
+ * `pending`. No deterministic `readyAt` (depends on `queueDelay()` from
+ * the request block), so it's left unset.
+ */
+export declare const readerBeraPaw: LstWithdrawalReader;
+//# sourceMappingURL=berapaw.d.ts.map

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

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

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

@@ -0,0 +1,21 @@
+import type { LstWithdrawalReader } from './shared';
+/**
+ * Placeholder reader for protocols that can't be enumerated
+ * on-chain. Used for:
+ *  - **eventsOnly** — mETH, pufETH, osETH require off-chain event
+ *    indexing to discover request IDs. The orchestrator could be
+ *    extended to accept an event-derived list of (user, requestId)
+ *    pairs as input; until then these return [].
+ *  - **noQueue** — rETH (instant burn against deposit-pool buffer)
+ *    and cbETH (off-chain Coinbase redemption). No queue to
+ *    enumerate.
+ *  - **unverified** — kHYPE, beHYPE, wstHYPE, swETH. Function
+ *    selectors not yet pinned against the deployed contracts.
+ *
+ * Returning [] is correct behavior: the user simply has no
+ * fetched-via-this-API pending withdrawals for this LST, even if
+ * they have one in reality. UI should surface the limitation
+ * separately (e.g. link to the protocol's official UI).
+ */
+export declare const readerEmpty: LstWithdrawalReader;
+//# sourceMappingURL=empty.d.ts.map

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

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

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;AA4B7D,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,mBA4DF,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