@1delta/margin-fetcher 0.0.2889 → 5.0.0

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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,3 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,7 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,21 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,23 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,3 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,17 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,56 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,15 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,26 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/stella.d.ts

@@ -1,17 +0,0 @@
-import { type LstWithdrawalReader } from './shared';
-/**
- * StellaSwap stDOT unbonding reader (Moonbeam 1284).
- *
- * One call: `getUnbonded(user) → (waiting, unbonded)`. The lido-dot-ksm
- * stToken tracks only the per-user **aggregate** in two buckets — no
- * per-request IDs — so this surfaces up to two synthetic requests:
- *   - `waiting`  > 0 → a `pending` request (still in the ~28-day unbond;
- *     the exact ready time is not exposed per-bucket, so `readyAt` is
- *     left unset).
- *   - `unbonded` > 0 → a `claimable` request (matured, redeemable via
- *     `claimUnbonded()`).
- *
- * No enumeration, same single-call shape as the Ethena cooldown reader.
- */
-export declare const readerStellaUnbond: LstWithdrawalReader;
-//# sourceMappingURL=stella.d.ts.map

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

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

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

@@ -1,18 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,19 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,46 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;CAufhD,CAAA;AAED,oEAAoE;AACpE,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,EACf,eAAe,0BAA0B,EAAE,KAC1C,0BAA0B,EAQ5B,CAAA"}