@1delta/margin-fetcher 0.0.265 → 0.0.267

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

@@ -0,0 +1,54 @@
+/** Mantle UnstakeRequestsManager — per-id detail getter.
+ *  Address on chain 1: `0x38fdf7B489316E03eD8754aD339cb5c4483FDcf9`.
+ *
+ *  No user-keyed on-chain storage; enumeration only via the
+ *  `UnstakeRequestCreated` event. We instead accept caller-supplied
+ *  IDs (captured from the withdraw-tx receipt at request time) and
+ *  read the detail per-id. */
+export declare const MantleUnstakeRequestsManagerAbi: readonly [{
+    readonly name: "requestByID";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "unstakeRequestID";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint64";
+            readonly name: "id";
+        }, {
+            readonly type: "address";
+            readonly name: "requester";
+        }, {
+            readonly type: "uint128";
+            readonly name: "mETHLocked";
+        }, {
+            readonly type: "uint128";
+            readonly name: "ethRequested";
+        }, {
+            readonly type: "uint128";
+            readonly name: "cumulativeETHRequested";
+        }, {
+            readonly type: "uint64";
+            readonly name: "blockNumber";
+        }];
+    }];
+}, {
+    readonly name: "requestInfo";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "unstakeRequestID";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+        readonly name: "isFinalized";
+    }, {
+        readonly type: "uint256";
+        readonly name: "claimableAmount";
+    }];
+}];
+//# sourceMappingURL=mantle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mantle.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/mantle.ts"],"names":[],"mappings":"AAAA;;;;;;8BAM8B;AAC9B,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BlC,CAAA"}

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

@@ -0,0 +1,57 @@
+/**
+ * PrimeStaking psXDC V3 vault — withdrawal global-queue read surface
+ * (XDC mainnet, chainId 50). Vault
+ * `0x98D916F5773Ac0482b49856f2659d6c32114C4Ba`.
+ *
+ * `redeemWithQueue` mints a GLOBAL `requestId` (there is no
+ * `getUserWithdrawals(address)` getter), so enumeration scans
+ * `withdrawalRequests(requestId)` and filters by the `receiver` field —
+ * the same shape as Infrared's iBERA WithdraworLite queue. Each request
+ * carries a `processed` flag (true once the masternode payout has
+ * settled it and the assets are claimable via `claimQueuedAssets`);
+ * `nextWithdrawalRequestId` is the exclusive upper bound of assigned ids
+ * and `nextUnprocessedWithdrawalRequestId` is the FIFO finalisation
+ * frontier (ids below it are processed).
+ */
+export declare const PrimeStakingQueueAbi: readonly [{
+    readonly name: "withdrawalRequests";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "requestId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "receiver";
+        readonly type: "address";
+    }, {
+        readonly name: "shares";
+        readonly type: "uint256";
+    }, {
+        readonly name: "assets";
+        readonly type: "uint256";
+    }, {
+        readonly name: "processed";
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "nextWithdrawalRequestId";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "nextUnprocessedWithdrawalRequestId";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=primestaking.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"primestaking.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/primestaking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BvB,CAAA"}

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

@@ -0,0 +1,48 @@
+/** Puffer PufferWithdrawalManager — per-id detail getter.
+ *  Address on chain 1: `0xDdA0483184E75a5579ef9635ED14BacCf9d50283`.
+ *
+ *  No user-keyed on-chain storage; enumeration only via the
+ *  `WithdrawalRequested` event. Reader accepts caller-supplied
+ *  withdrawal indices (captured from the tx receipt) and reads detail
+ *  per-id. `getFinalizedWithdrawalBatch()` returns the highest batch
+ *  that has settled — a request is claimable iff
+ *  `request.batchIdx <= finalizedBatch`. */
+export declare const PufferWithdrawalManagerAbi: readonly [{
+    readonly name: "getWithdrawal";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "withdrawalIdx";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint128";
+            readonly name: "pufETHAmount";
+        }, {
+            readonly type: "uint128";
+            readonly name: "pufETHToETHExchangeRate";
+        }, {
+            readonly type: "address";
+            readonly name: "recipient";
+        }];
+    }];
+}, {
+    readonly name: "getFinalizedWithdrawalBatch";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "BATCH_SIZE";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=puffer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"puffer.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/puffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;4CAQ4C;AAC5C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B7B,CAAA"}

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

@@ -0,0 +1,50 @@
+/** Renzo WithdrawQueue — per-user enumeration + cooldown.
+ *  Address on chain 1: `0x5efc9d10e42fb517456f4ac41eb5e2ebe42c8918`. */
+export declare const RenzoWithdrawQueueAbi: readonly [{
+    readonly name: "getOutstandingWithdrawRequests";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "withdrawRequests";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+    }, {
+        readonly type: "uint256";
+        readonly name: "index";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "collateralToken";
+    }, {
+        readonly type: "uint256";
+        readonly name: "withdrawRequestNonce";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amountToRedeem";
+    }, {
+        readonly type: "uint256";
+        readonly name: "ezETHLocked";
+    }, {
+        readonly type: "uint256";
+        readonly name: "createdAt";
+    }];
+}, {
+    readonly name: "coolDownPeriod";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=renzo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renzo.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/renzo.ts"],"names":[],"mappings":"AAAA;wEACwE;AACxE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BxB,CAAA"}

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

@@ -0,0 +1,48 @@
+/** Stader ETHx UserWithdrawalManager — per-user enumeration +
+ *  per-request detail. Address on chain 1:
+ *  `0x9f0491b32dbce587c50c4c43ab303b06478193a7`. */
+export declare const StaderEthxWithdrawalAbi: readonly [{
+    readonly name: "getRequestIdsByUser";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "_owner";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256[]";
+    }];
+}, {
+    readonly name: "userWithdrawRequests";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "requestId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "uint256";
+        readonly name: "ethXAmount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "ethExpected";
+    }, {
+        readonly type: "uint256";
+        readonly name: "ethFinalized";
+    }, {
+        readonly type: "uint256";
+        readonly name: "requestBlock";
+    }];
+}, {
+    readonly name: "nextRequestIdToFinalize";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=staderEthx.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+/** Stader MaticX (Ethereum home contract) — per-user enumeration.
+ *  Address on chain 1:
+ *  `0xf03a7eb46d01d9ecaa104558c732cf82f6b6b645`. Polygon
+ *  delegation goes through the IStakeManager `withdrawalDelay()`. */
+export declare const StaderMaticxWithdrawalAbi: readonly [{
+    readonly name: "getUserWithdrawalRequests";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "_user";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "uint256";
+            readonly name: "amount";
+        }, {
+            readonly type: "uint256";
+            readonly name: "validatorNonce";
+        }, {
+            readonly type: "uint256";
+            readonly name: "requestEpoch";
+        }, {
+            readonly type: "address";
+            readonly name: "validatorAddress";
+        }];
+    }];
+}];
+/** Polygon IStakeManager — used to compute `readyAt` for MaticX
+ *  withdrawals. `epoch()` returns the current Polygon checkpoint,
+ *  `withdrawalDelay()` is the unbond duration. */
+export declare const PolygonStakeManagerAbi: readonly [{
+    readonly name: "epoch";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "withdrawalDelay";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=staderMaticx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"staderMaticx.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/staderMaticx.ts"],"names":[],"mappings":"AAAA;;;qEAGqE;AACrE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;EAkB5B,CAAA;AAEV;;kDAEkD;AAClD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;EAezB,CAAA"}

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

@@ -0,0 +1,47 @@
+/** StakeWise V3 vault — minimal ABI for `calculateExitedAssets`
+ *  finalization re-check after subgraph query.
+ *
+ *  The subgraph returns `isClaimable` based on its last-indexed block,
+ *  which can lag a few blocks. For correctness we re-confirm against
+ *  the vault contract; for `claimable`-status reporting we use the
+ *  on-chain answer. */
+export declare const StakeWiseV3VaultAbi: readonly [{
+    readonly name: "calculateExitedAssets";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "receiver";
+    }, {
+        readonly type: "uint256";
+        readonly name: "positionTicket";
+    }, {
+        readonly type: "uint256";
+        readonly name: "timestamp";
+    }, {
+        readonly type: "uint256";
+        readonly name: "exitQueueIndex";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "leftShares";
+    }, {
+        readonly type: "uint256";
+        readonly name: "claimedShares";
+    }, {
+        readonly type: "uint256";
+        readonly name: "claimedAssets";
+    }];
+}, {
+    readonly name: "getExitQueueIndex";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "positionTicket";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "int256";
+    }];
+}];
+//# sourceMappingURL=stakewise.d.ts.map

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

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

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

@@ -0,0 +1,24 @@
+/** StakedCelo Account — pending-withdrawal enumeration (Celo mainnet
+ *  42220). Account: `0x4aAD04D41FD7fd495503731C5a2579e19054C432`.
+ *
+ *  `getPendingWithdrawals(beneficiary)` returns parallel arrays of
+ *  CELO `values` and LockedGold availability `timestamps` (unix
+ *  seconds) — one entry per pending unlock created by
+ *  `Account.withdraw`. */
+export declare const StCeloAccountWithdrawalAbi: readonly [{
+    readonly name: "getPendingWithdrawals";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "beneficiary";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256[]";
+        readonly name: "values";
+    }, {
+        readonly type: "uint256[]";
+        readonly name: "timestamps";
+    }];
+}];
+//# sourceMappingURL=stcelo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stcelo.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/stcelo.ts"],"names":[],"mappings":"AAAA;;;;;;0BAM0B;AAC1B,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;EAW7B,CAAA"}

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

@@ -0,0 +1,25 @@
+/** StellaSwap stDOT unbonding surface (Moonbeam, lido-dot-ksm). After
+ *  `redeem(amount)` the position enters Polkadot's ~28-day unbond; the
+ *  per-user aggregate is read via `getUnbonded`, which returns two
+ *  buckets — `waiting` (still unbonding) and `unbonded` (matured, ready
+ *  for `claimUnbonded()`). No per-request enumeration / IDs.
+ *
+ *  Verified getter:
+ *    `getUnbonded(address _holder) → (uint256 waiting, uint256 unbonded)` */
+export declare const StellaGetUnbondedAbi: readonly [{
+    readonly name: "getUnbonded";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "_holder";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "waiting";
+    }, {
+        readonly type: "uint256";
+        readonly name: "unbonded";
+    }];
+}];
+//# sourceMappingURL=stella.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stella.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/stella.ts"],"names":[],"mappings":"AAAA;;;;;;;6EAO6E;AAC7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAWvB,CAAA"}

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

@@ -0,0 +1,66 @@
+/** Swell rswEXIT — ERC-721 enumerable withdrawal NFT for rswETH.
+ *  Address on chain 1: `0x58749c46FfE97e4d79508a2c781C440f4756f064`.
+ *
+ *  Verified via on-chain `supportsInterface(0x780e9d63) → true`
+ *  (ERC721Enumerable). The contract inherits `ERC721EnumerableUpgradeable`
+ *  from the Swell v3-core implementation.
+ *
+ *  Per-id detail is `getWithdrawalRequest(tokenId) → WithdrawRequest`
+ *  with `(amount, timestamp, lastTokenIdProcessed, rateWhenCreated)`.
+ *  A request is claimable iff `tokenId <= getLastTokenIdProcessed()`. */
+export declare const SwellRswExitAbi: 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: "getWithdrawalRequest";
+    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: "timestamp";
+        }, {
+            readonly type: "uint256";
+            readonly name: "lastTokenIdProcessed";
+        }, {
+            readonly type: "uint256";
+            readonly name: "rateWhenCreated";
+        }];
+    }];
+}, {
+    readonly name: "getLastTokenIdProcessed";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+//# sourceMappingURL=swell.d.ts.map

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

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

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

@@ -0,0 +1,43 @@
+/** TruFin TruStake vaults — per-(validator, nonce) detail. Shared by
+ *  TruStakeMATICv2 (`0xa43A7c62D56dF036C187E1966c03E2799d8987eD`) and
+ *  TruStakePOL (`0xc10214cdE5d6754Ec1e2220362f2120142c8E5e8`) on
+ *  chain 1, which expose an identical interface.
+ *
+ *  Withdrawals route through Polygon validator unbond; the natural
+ *  request unit is `(validator, unbondNonce)`. No user-keyed
+ *  enumeration storage exists on this contract — caller supplies the
+ *  `(validator, nonce)` pairs captured at withdraw time. */
+export declare const TruFinVaultAbi: readonly [{
+    readonly name: "withdrawals";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "validator";
+    }, {
+        readonly type: "uint256";
+        readonly name: "unbondNonce";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+}, {
+    readonly name: "isClaimable";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "unbondNonce";
+    }, {
+        readonly type: "address";
+        readonly name: "validator";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+//# sourceMappingURL=trufin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trufin.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/trufin.ts"],"names":[],"mappings":"AAAA;;;;;;;;4DAQ4D;AAC5D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBjB,CAAA"}

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

@@ -0,0 +1,46 @@
+/** Valantis stHYPE / wstHYPE — burn-request enumeration on the
+ *  Overseer (`0xb96f07367e69e86d6e9c3f29215885104813eeae`, HyperEVM
+ *  999, VERIFIED via Sourcify).
+ *
+ *  The **paginated** `getBurns(user, start, count)` is used (the no-arg
+ *  `getBurns(user)` / `getBurnIds(user)` overloads REVERT for users
+ *  with zero burns — the common case). It returns the user's `Burn[]`
+ *  (amount/user/completed/sum), the parallel burn `ids`, and a parallel
+ *  `redeemable` bool array. `completed` burns have already been
+ *  redeemed. */
+export declare const ValantisBurnAbi: readonly [{
+    readonly name: "getBurns";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+    }, {
+        readonly type: "uint256";
+        readonly name: "start";
+    }, {
+        readonly type: "uint256";
+        readonly name: "count";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "amount";
+            readonly type: "uint88";
+        }, {
+            readonly name: "user";
+            readonly type: "address";
+        }, {
+            readonly name: "completed";
+            readonly type: "bool";
+        }, {
+            readonly name: "sum";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "uint256[]";
+    }, {
+        readonly type: "bool[]";
+    }];
+}];
+//# sourceMappingURL=valantis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valantis.d.ts","sourceRoot":"","sources":["../../../../../src/vaults/lst/withdrawals/abis/valantis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;gBASgB;AAChB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBlB,CAAA"}