@sablier/bob 1.0.1

package/src/interfaces/ISablierBobAdapter.sol

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import { UD60x18 } from "@prb/math/src/UD60x18.sol";
+import { IComptrollerable } from "@sablier/evm-utils/src/interfaces/IComptrollerable.sol";
+
+/// @title ISablierBobAdapter
+/// @notice Base interface for adapters used by the SablierBob protocol for generating yield.
+interface ISablierBobAdapter is IComptrollerable, IERC165 {
+    /*//////////////////////////////////////////////////////////////////////////
+                                       EVENTS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Emitted when the comptroller sets a new yield fee.
+    event SetYieldFee(UD60x18 previousFee, UD60x18 newFee);
+
+    /// @notice Emitted when tokens are staked for a user in a vault.
+    event Stake(uint256 indexed vaultId, address indexed user, uint256 depositAmount, uint256 wrappedStakedAmount);
+
+    /// @notice Emitted when staked token attribution is transferred between users.
+    event TransferStakedTokens(uint256 indexed vaultId, address indexed from, address indexed to, uint256 amount);
+
+    /// @notice Emitted when all staked tokens in a vault are converted back to the deposit token.
+    event UnstakeFullAmount(uint256 indexed vaultId, uint128 totalStakedAmount, uint128 amountReceivedFromUnstaking);
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                READ-ONLY FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns the maximum yield fee, denominated in UD60x18, where 1e18 = 100%.
+    /// @dev This is a constant state variable.
+    function MAX_FEE() external view returns (UD60x18);
+
+    /// @notice Returns the address of the SablierBob contract.
+    /// @dev This is an immutable state variable.
+    function SABLIER_BOB() external view returns (address);
+
+    /// @notice Returns the current global fee on yield for new vaults, denominated in UD60x18, where 1e18 = 100%.
+    function feeOnYield() external view returns (UD60x18);
+
+    /// @notice Returns the total amount of yield-bearing tokens held in a vault.
+    /// @param vaultId The ID of the vault.
+    /// @return The total amount of yield-bearing tokens in the vault.
+    function getTotalYieldBearingTokenBalance(uint256 vaultId) external view returns (uint128);
+
+    /// @notice Returns the yield fee stored for a specific vault.
+    /// @param vaultId The ID of the vault.
+    /// @return The yield fee for the vault denominated in UD60x18, where 1e18 = 100%.
+    function getVaultYieldFee(uint256 vaultId) external view returns (UD60x18);
+
+    /// @notice Returns the amount of yield-bearing tokens held for a specific user in a vault.
+    /// @param vaultId The ID of the vault.
+    /// @param user The address of the user.
+    /// @return The amount of yield-bearing tokens the user has claim to.
+    function getYieldBearingTokenBalanceFor(uint256 vaultId, address user) external view returns (uint128);
+
+    /*//////////////////////////////////////////////////////////////////////////
+                              STATE-CHANGING FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Processes a user's token redemption by calculating the transfer amount, clearing the user's
+    /// yield-bearing token balance, and returning the amounts.
+    ///
+    /// Notes:
+    /// - The user's yield-bearing token balance is decremented after calculating the transfer amount. This does not
+    /// decrement the vault total as it is used in the calculation of the transfer amount for other users.
+    ///
+    /// Requirements:
+    /// - The caller must be the SablierBob contract.
+    ///
+    /// @param vaultId The ID of the vault.
+    /// @param user The address of the user.
+    /// @param shareBalance The user's share balance in the vault.
+    /// @return transferAmount The amount to transfer to the user.
+    /// @return feeAmountDeductedFromYield The fee amount taken from the yield.
+    function processRedemption(
+        uint256 vaultId,
+        address user,
+        uint128 shareBalance
+    )
+        external
+        returns (uint128 transferAmount, uint128 feeAmountDeductedFromYield);
+
+    /// @notice Register a new vault with the adapter and snapshot the current fee on yield.
+    ///
+    /// Requirements:
+    /// - The caller must be the SablierBob contract.
+    ///
+    /// @param vaultId The ID of the newly created vault.
+    function registerVault(uint256 vaultId) external;
+
+    /// @notice Sets the fee on yield for future vaults.
+    ///
+    /// @dev Emits a {SetYieldFee} event.
+    ///
+    /// Notes:
+    /// - This only affects future vaults, fee is not updated for existing vaults.
+    ///
+    /// Requirements:
+    /// - The caller must be the comptroller.
+    /// - `newFee` must not exceed MAX_FEE.
+    ///
+    /// @param newFee The new yield fee as UD60x18 where 1e18 = 100%.
+    function setYieldFee(UD60x18 newFee) external;
+
+    /// @notice Stakes tokens deposited by a user in a vault, converting them to yield-bearing tokens.
+    ///
+    /// @dev Emits a {Stake} event.
+    ///
+    /// Requirements:
+    /// - The caller must be the SablierBob contract.
+    /// - The tokens must have been transferred to this contract.
+    ///
+    /// @param vaultId The ID of the vault.
+    /// @param user The address of the user depositing the tokens.
+    /// @param amount The amount of tokens to stake.
+    function stake(uint256 vaultId, address user, uint256 amount) external;
+
+    /// @notice Converts all yield-bearing tokens in a vault back to deposit tokens after settlement.
+    ///
+    /// @dev Emits an {UnstakeFullAmount} event.
+    ///
+    /// Notes:
+    /// - This should only be called once per vault after settlement.
+    ///
+    /// Requirements:
+    /// - The caller must be the SablierBob contract.
+    ///
+    /// @param vaultId The ID of the vault.
+    /// @return wrappedTokenBalance The total amount of yield-bearing tokens that were in the vault.
+    /// @return amountReceivedFromUnstaking The total amount of tokens received from unstaking the yield-bearing tokens.
+    function unstakeFullAmount(uint256 vaultId)
+        external
+        returns (uint128 wrappedTokenBalance, uint128 amountReceivedFromUnstaking);
+
+    /// @notice Updates staked token balance of a user when vault shares are transferred.
+    ///
+    /// Requirements:
+    /// - The caller must be the SablierBob contract.
+    /// - `userShareBalanceBeforeTransfer` must not be zero.
+    /// - The calculated wstETH transfer amount must not be zero.
+    ///
+    /// @param vaultId The ID of the vault.
+    /// @param from The address transferring vault shares.
+    /// @param to The address receiving vault shares.
+    /// @param shareAmountTransferred The number of vault shares being transferred.
+    /// @param userShareBalanceBeforeTransfer The sender's vault share balance before the transfer.
+    function updateStakedTokenBalance(
+        uint256 vaultId,
+        address from,
+        address to,
+        uint256 shareAmountTransferred,
+        uint256 userShareBalanceBeforeTransfer
+    )
+        external;
+}

package/src/interfaces/ISablierBobState.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { AggregatorV3Interface } from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import { Bob } from "../types/Bob.sol";
+import { IBobVaultShare } from "./IBobVaultShare.sol";
+import { ISablierBobAdapter } from "./ISablierBobAdapter.sol";
+
+/// @title ISablierBobState
+/// @notice Contract with state variables for the {SablierBob} contract, their respective getters and modifiers.
+interface ISablierBobState {
+    /*//////////////////////////////////////////////////////////////////////////
+                                READ-ONLY FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns the adapter configured for a specific vault.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function getAdapter(uint256 vaultId) external view returns (ISablierBobAdapter adapter);
+
+    /// @notice Returns the default adapter for a given token.
+    /// @dev Zero address means no adapter is set.
+    /// @param token The ERC-20 token to query the default adapter for.
+    /// @return adapter The default adapter for the token.
+    function getDefaultAdapterFor(IERC20 token) external view returns (ISablierBobAdapter adapter);
+
+    /// @notice Returns the timestamp when the vault expires.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function getExpiry(uint256 vaultId) external view returns (uint40 expiry);
+
+    /// @notice Returns the timestamp when the oracle price was last synced for a vault.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function getLastSyncedAt(uint256 vaultId) external view returns (uint40 lastSyncedAt);
+
+    /// @notice Returns the oracle price stored for a vault.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function getLastSyncedPrice(uint256 vaultId) external view returns (uint128 lastSyncedPrice);
+
+    /// @notice Returns the oracle address set for a vault.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function getOracle(uint256 vaultId) external view returns (AggregatorV3Interface oracle);
+
+    /// @notice Returns the address of the ERC-20 share token for a vault.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function getShareToken(uint256 vaultId) external view returns (IBobVaultShare shareToken);
+
+    /// @notice Returns the target price at which the vault settles.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function getTargetPrice(uint256 vaultId) external view returns (uint128 targetPrice);
+
+    /// @notice Returns the ERC-20 token accepted for deposits in a vault.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function getUnderlyingToken(uint256 vaultId) external view returns (IERC20 token);
+
+    /// @notice Returns whether the vault tokens are staked in an adapter.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function isStakedInAdapter(uint256 vaultId) external view returns (bool stakedInAdapter);
+
+    /// @notice Retrieves the address of the ERC-20 interface of the native token, if it exists.
+    /// @dev The native tokens on some chains have a dual interface as ERC-20. For example, on Polygon the $POL token
+    /// is the native token and has an ERC-20 version at 0x0000000000000000000000000000000000001010. This means
+    /// that `address(this).balance` returns the same value as `balanceOf(address(this))`. To avoid any unintended
+    /// behavior, these tokens cannot be used in Sablier. As an alternative, users can use the Wrapped version of the
+    /// token, i.e. WMATIC, which is a standard ERC-20 token.
+    function nativeToken() external view returns (address);
+
+    /// @notice Counter for vault IDs, incremented every time a new vault is created.
+    function nextVaultId() external view returns (uint256);
+
+    /// @notice Returns the vault status.
+    /// @dev Reverts if `vaultId` references a null vault.
+    function statusOf(uint256 vaultId) external view returns (Bob.Status status);
+}

package/src/interfaces/ISablierEscrow.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { UD60x18 } from "@prb/math/src/UD60x18.sol";
+import { IComptrollerable } from "@sablier/evm-utils/src/interfaces/IComptrollerable.sol";
+
+import { ISablierEscrowState } from "./ISablierEscrowState.sol";
+
+/// @title ISablierEscrow
+/// @notice A peer-to-peer token swap protocol that allows users to swap ERC-20 tokens with each other.
+interface ISablierEscrow is IComptrollerable, ISablierEscrowState {
+    /*//////////////////////////////////////////////////////////////////////////
+                                       EVENTS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Emitted when an order is cancelled by the seller.
+    event CancelOrder(uint256 indexed orderId, address indexed seller, uint128 sellAmount);
+
+    /// @notice Emitted when a new order is created.
+    event CreateOrder(
+        uint256 indexed orderId,
+        address indexed seller,
+        address indexed buyer,
+        IERC20 sellToken,
+        IERC20 buyToken,
+        uint128 sellAmount,
+        uint128 minBuyAmount,
+        uint40 expiryTime
+    );
+
+    /// @notice Emitted when an order is filled.
+    event FillOrder(
+        uint256 indexed orderId,
+        address indexed buyer,
+        address indexed seller,
+        uint128 sellAmount,
+        uint128 buyAmount,
+        uint128 feeDeductedFromBuyerAmount,
+        uint128 feeDeductedFromSellerAmount
+    );
+
+    /// @notice Emitted when the native token address is set by the comptroller.
+    event SetNativeToken(address indexed comptroller, address nativeToken);
+
+    /// @notice Emitted when the trade fee is updated.
+    event SetTradeFee(address indexed caller, UD60x18 previousTradeFee, UD60x18 newTradeFee);
+
+    /*//////////////////////////////////////////////////////////////////////////
+                              STATE-CHANGING FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Cancels an order and returns the escrowed tokens to the caller.
+    ///
+    /// @dev Emits a {CancelOrder} event.
+    ///
+    /// Requirements:
+    /// - The order must exist.
+    /// - The order status must either be OPEN or EXPIRED.
+    /// - The caller must be the seller of the order.
+    ///
+    /// @param orderId The order ID to cancel.
+    function cancelOrder(uint256 orderId) external;
+
+    /// @notice Creates a new order for a peer-to-peer token swap.
+    ///
+    /// @dev Emits a {CreateOrder} event.
+    ///
+    /// Requirements:
+    /// - `sellToken` must not be the zero address.
+    /// - `buyToken` must not be the zero address.
+    /// - `sellToken` and `buyToken` must not be the same token.
+    /// - `sellAmount` must be greater than zero.
+    /// - `minBuyAmount` must be greater than zero.
+    /// - If `expiryTime` is non-zero, it must be in the future. Zero is sentinel for orders that never expire.
+    /// - The caller must have approved this contract to transfer at least `sellAmount` of `sellToken`.
+    ///
+    /// @param sellToken The address of the ERC-20 token to sell.
+    /// @param sellAmount The amount of sell token to exchange.
+    /// @param buyToken The address of the ERC-20 token to receive.
+    /// @param minBuyAmount The minimum amount of buy token to fill this trade.
+    /// @param buyer The designated counterparty address specified by the seller. If its zero address, the order can be
+    /// filled by anyone.
+    /// @param expiryTime The Unix timestamp when the order expires. Zero is sentinel for orders that never expire.
+    /// @return orderId The order ID of the newly created order.
+    function createOrder(
+        IERC20 sellToken,
+        uint128 sellAmount,
+        IERC20 buyToken,
+        uint128 minBuyAmount,
+        address buyer,
+        uint40 expiryTime
+    )
+        external
+        returns (uint256 orderId);
+
+    /// @notice Fill an open order.
+    ///
+    /// @dev Emits an {FillOrder} event.
+    ///
+    /// Requirements:
+    /// - The order must exist.
+    /// - The order must be in OPEN status.
+    /// - If the order has buyer specified, the caller must be the buyer.
+    /// - `buyAmount` must be greater than or equal to the `minBuyAmount`.
+    /// - The caller must have approved this contract to transfer at least `buyAmount` of `buyToken`.
+    ///
+    /// @param orderId The order ID to fill.
+    /// @param buyAmount The amount of buy token to exchange.
+    /// @return amountToTransferToSeller The amount of buy token to transfer to the seller after deducting fees.
+    /// @return amountToTransferToBuyer The amount of sell token to transfer to the buyer after deducting fees.
+    /// @return feeDeductedFromBuyerAmount The amount of sell token deducted from the buyer's amount as fees.
+    /// @return feeDeductedFromSellerAmount The amount of buy token deducted from the seller's amount as fees.
+    function fillOrder(
+        uint256 orderId,
+        uint128 buyAmount
+    )
+        external
+        returns (
+            uint128 amountToTransferToSeller,
+            uint128 amountToTransferToBuyer,
+            uint128 feeDeductedFromBuyerAmount,
+            uint128 feeDeductedFromSellerAmount
+        );
+
+    /// @notice Sets the native token address. Once set, it cannot be changed.
+    /// @dev For more information, see the documentation for {nativeToken}.
+    ///
+    /// Emits a {SetNativeToken} event.
+    ///
+    /// Requirements:
+    /// - `msg.sender` must be the comptroller.
+    /// - `newNativeToken` must not be zero address.
+    /// - The native token must not be already set.
+    /// @param newNativeToken The address of the native token.
+    function setNativeToken(address newNativeToken) external;
+
+    /// @notice Sets the fee to apply on each trade.
+    ///
+    /// @dev Emits a {SetTradeFee} event.
+    ///
+    /// Requirements:
+    /// - The caller must be the comptroller.
+    /// - `newTradeFee` must not exceed the maximum trade fee.
+    ///
+    /// @param newTradeFee The new trade fee to set, denominated in UD60x18, where 1e18 = 100%.
+    function setTradeFee(UD60x18 newTradeFee) external;
+}

package/src/interfaces/ISablierEscrowState.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { UD60x18 } from "@prb/math/src/UD60x18.sol";
+
+import { Escrow } from "../types/Escrow.sol";
+
+/// @title ISablierEscrowState
+/// @notice Interface containing state variables (storage and constants) for the {SablierEscrow} contract, along with
+/// their respective getters.
+interface ISablierEscrowState {
+    /*//////////////////////////////////////////////////////////////////////////
+                                READ-ONLY FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns the maximum trade fee that can be applied, denominated in UD60x18, where 1e18 = 100%.
+    /// @dev This is a constant state variable.
+    function MAX_TRADE_FEE() external view returns (UD60x18);
+
+    /// @notice Retrieves the buyer address for the given order. If its zero address, the order can be filled by any
+    /// address.
+    /// @dev Reverts if `orderId` references a null order.
+    function getBuyer(uint256 orderId) external view returns (address buyer);
+
+    /// @notice Retrieves the address of the ERC-20 token the seller wants to receive.
+    /// @dev Reverts if `orderId` references a null order.
+    function getBuyToken(uint256 orderId) external view returns (IERC20 buyToken);
+
+    /// @notice Retrieves the time when the order expires and can no longer be filled. Zero is sentinel for orders that
+    /// never expire.
+    /// @dev Reverts if `orderId` references a null order.
+    function getExpiryTime(uint256 orderId) external view returns (uint40 expiryTime);
+
+    /// @notice Retrieves the minimum amount of buy token required to fill the order.
+    /// @dev Reverts if `orderId` references a null order.
+    function getMinBuyAmount(uint256 orderId) external view returns (uint128 minBuyAmount);
+
+    /// @notice Retrieves the amount of sell token that the seller is willing to sell.
+    /// @dev Reverts if `orderId` references a null order.
+    function getSellAmount(uint256 orderId) external view returns (uint128 sellAmount);
+
+    /// @notice Retrieves the address of the seller who created the order.
+    /// @dev Reverts if `orderId` references a null order.
+    function getSeller(uint256 orderId) external view returns (address seller);
+
+    /// @notice Retrieves the address of the ERC-20 token that the seller is willing to sell.
+    /// @dev Reverts if `orderId` references a null order.
+    function getSellToken(uint256 orderId) external view returns (IERC20 sellToken);
+
+    /// @notice Retrieves the address of the ERC-20 interface of the native token, if it exists.
+    /// @dev The native tokens on some chains have a dual interface as ERC-20. For example, on Polygon the $POL token
+    /// is the native token and has an ERC-20 version at 0x0000000000000000000000000000000000001010. This means
+    /// that `address(this).balance` returns the same value as `balanceOf(address(this))`. To avoid any unintended
+    /// behavior, these tokens cannot be used in Sablier. As an alternative, users can use the Wrapped version of the
+    /// token, i.e. WMATIC, which is a standard ERC-20 token.
+    function nativeToken() external view returns (address);
+
+    /// @notice Counter for order IDs. It's incremented every time a new order is created.
+    function nextOrderId() external view returns (uint256);
+
+    /// @notice Returns the status of the order.
+    /// @dev Reverts if `orderId` references a null order.
+    function statusOf(uint256 orderId) external view returns (Escrow.Status status);
+
+    /// @notice Returns the fee percentage, denominated in UD60x18, where 1e18 = 100%.
+    /// @dev This trade fee is taken from both the sell and buy amounts in their respective tokens.
+    function tradeFee() external view returns (UD60x18);
+
+    /// @notice Retrieves a flag indicating whether the order was canceled.
+    /// @dev Reverts if `orderId` references a null order.
+    function wasCanceled(uint256 orderId) external view returns (bool);
+
+    /// @notice Retrieves a flag indicating whether the order was filled.
+    /// @dev Reverts if `orderId` references a null order.
+    function wasFilled(uint256 orderId) external view returns (bool);
+}

package/src/interfaces/ISablierLidoAdapter.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { UD60x18 } from "@prb/math/src/UD60x18.sol";
+
+import { ISablierBobAdapter } from "./ISablierBobAdapter.sol";
+
+/// @title ISablierLidoAdapter
+/// @notice Interface for the Lido yield adapter that stakes WETH as wstETH and unstakes it via Curve.
+/// @dev Extends the base adapter interface with Lido and Curve specific functionalities.
+interface ISablierLidoAdapter is ISablierBobAdapter {
+    /*//////////////////////////////////////////////////////////////////////////
+                                       EVENTS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Emitted when the comptroller requests a Lido native withdrawal for a vault.
+    event RequestLidoWithdrawal(
+        uint256 indexed vaultId,
+        address indexed comptroller,
+        uint256 wstETHAmount,
+        uint256 stETHAmount,
+        uint256[] withdrawalRequestIds
+    );
+
+    /// @notice Emitted when the comptroller sets a new slippage tolerance.
+    event SetSlippageTolerance(UD60x18 previousTolerance, UD60x18 newTolerance);
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                READ-ONLY FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns the address of the Curve stETH/ETH pool.
+    /// @dev This is an immutable state variable.
+    function CURVE_POOL() external view returns (address);
+
+    /// @notice Returns the address of the Lido withdrawal queue contract.
+    /// @dev This is an immutable state variable.
+    function LIDO_WITHDRAWAL_QUEUE() external view returns (address);
+
+    /// @notice Returns the maximum slippage tolerance that can be set, denominated in UD60x18, where 1e18 = 100%.
+    /// @dev This is a constant state variable.
+    function MAX_SLIPPAGE_TOLERANCE() external view returns (UD60x18);
+
+    /// @notice Returns the address of the stETH contract.
+    /// @dev This is an immutable state variable.
+    function STETH() external view returns (address);
+
+    /// @notice Returns the address of the Chainlink stETH/ETH oracle used in the calculation of `minEthOut` slippage.
+    /// @dev This is an immutable state variable.
+    function STETH_ETH_ORACLE() external view returns (address);
+
+    /// @notice Returns the address of the WETH contract.
+    /// @dev This is an immutable state variable.
+    function WETH() external view returns (address);
+
+    /// @notice Returns the address of the wstETH contract.
+    /// @dev This is an immutable state variable.
+    function WSTETH() external view returns (address);
+
+    /// @notice Returns the Lido withdrawal request IDs for a vault.
+    /// @dev Multiple request IDs may be generated for a vault if the total amount exceeds the Lido enforced
+    /// per-withdrawal limit.
+    function getLidoWithdrawalRequestIds(uint256 vaultId) external view returns (uint256[] memory);
+
+    /// @notice Returns the total WETH received after unstaking for a vault.
+    /// @param vaultId The ID of the vault.
+    function getWethReceivedAfterUnstaking(uint256 vaultId) external view returns (uint256);
+
+    /// @notice Returns the current slippage tolerance for Curve swaps, denominated in UD60x18, where 1e18 = 100%.
+    function slippageTolerance() external view returns (UD60x18);
+
+    /*//////////////////////////////////////////////////////////////////////////
+                              STATE-CHANGING FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Requests a native Lido withdrawal for a vault's staked tokens, bypassing the Curve swap.
+    ///
+    /// @dev Emits a {RequestLidoWithdrawal} event.
+    ///
+    /// Notes:
+    /// - This unwraps the vault's wstETH to stETH and submits it to Lido's withdrawal queue.
+    /// - Once called, the Curve swap is permanently disabled for `vaultId`.
+    /// - After the queue finalizes the withdrawal, ETH can be redeemed by calling {unstakeFullAmount}.
+    /// - Large amounts are automatically split into multiple requests to comply with Lido's per-request limit.
+    ///
+    /// Requirements:
+    /// - The caller must be the comptroller.
+    /// - The status of the vault must not be ACTIVE.
+    /// - The vault must still be staked in the adapter (not already unstaked via Curve).
+    /// - A withdrawal request must not have already been requested for this vault.
+    /// - The vault must have wstETH to withdraw.
+    /// - The total amount to withdraw must not be less than the minimum amount per request.
+    ///
+    /// @param vaultId The ID of the vault.
+    function requestLidoWithdrawal(uint256 vaultId) external;
+
+    /// @notice Sets the slippage tolerance for Curve swaps.
+    ///
+    /// @dev Emits a {SetSlippageTolerance} event.
+    ///
+    /// Notes:
+    /// - This affects all vaults.
+    ///
+    /// Requirements:
+    /// - The caller must be the comptroller.
+    /// - `newSlippageTolerance` must not exceed MAX_SLIPPAGE_TOLERANCE.
+    ///
+    /// @param newTolerance The new slippage tolerance as UD60x18.
+    function setSlippageTolerance(UD60x18 newTolerance) external;
+}

package/src/interfaces/external/ICurveStETHPool.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// solhint-disable func-name-mixedcase
+pragma solidity >=0.8.22;
+
+/// @title ICurveStETHPool
+/// @notice Minimal interface for the Curve stETH/ETH pool.
+/// @dev The pool has two tokens: ETH (index 0) and stETH (index 1).
+interface ICurveStETHPool {
+    /*//////////////////////////////////////////////////////////////////////////
+                                READ-ONLY FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Get the amount of output coin for a given input.
+    /// @param i The index of the input coin.
+    /// @param j The index of the output coin.
+    /// @param dx The amount of input coin.
+    /// @return dy The expected amount of output coin.
+    function get_dy(int128 i, int128 j, uint256 dx) external view returns (uint256 dy);
+
+    /*//////////////////////////////////////////////////////////////////////////
+                              STATE-CHANGING FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Exchange between two tokens in the pool.
+    /// @param i The index of the input coin (0 = ETH, 1 = stETH).
+    /// @param j The index of the output coin (0 = ETH, 1 = stETH).
+    /// @param dx The amount of input coin to exchange.
+    /// @param minDy The minimum amount of output coin to receive.
+    /// @return dy The actual amount of output coin received.
+    function exchange(int128 i, int128 j, uint256 dx, uint256 minDy) external payable returns (uint256 dy);
+}