Description:
Proxy contract enabling upgradeable smart contract patterns. Delegates calls to an implementation contract.
Blockchain: Ethereum
Source Code: View Code On The Blockchain
Solidity Source Code:
{{
"language": "Solidity",
"sources": {
"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*
* ==== Security Considerations
*
* There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
* expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
* considered as an intention to spend the allowance in any specific way. The second is that because permits have
* built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
* take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
* generally recommended is:
*
* ```solidity
* function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
* try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
* doThing(..., value);
* }
*
* function doThing(..., uint256 value) public {
* token.safeTransferFrom(msg.sender, address(this), value);
* ...
* }
* ```
*
* Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
* `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
* {SafeERC20-safeTransferFrom}).
*
* Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
* contracts should have entry points that don't rely on permit.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*
* CAUTION: See Security Considerations above.
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
"
},
"@openzeppelin/contracts/token/ERC20/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
"
},
"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev An operation with an ERC20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}
"
},
"@openzeppelin/contracts/utils/Address.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// only check if target is a contract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}
"
},
"@shift-defi/core/contracts/defii/execution/Logic.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.20;
abstract contract Logic {
error NotImplemented();
function claimRewards(address recipient) external payable virtual {
revert NotImplemented();
}
function emergencyExit() external payable virtual {
revert NotImplemented();
}
function withdrawLiquidity(
address recipient,
uint256 amount
) external payable virtual {
revert NotImplemented();
}
function enter() external payable virtual;
function exit(uint256 liquidity) external payable virtual;
function accountLiquidity(
address account
) external view virtual returns (uint256);
}
"
},
"@shift-defi/core/contracts/libraries/Constants.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.20;
library Constants {
uint256 constant BPS = 1e4;
}
"
},
"@shitam/defi-product-templates/contracts/Errors.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.24;
error NotImplemented();
error EnterFailed();
error ExitFailed();
"
},
"@shitam/defi-product-templates/contracts/SelfManagedLogic.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.24;
import {Logic} from "@shift-defi/core/contracts/defii/execution/Logic.sol";
import {UniswapV3Callbacks} from "./UniswapV3Callbacks.sol";
abstract contract SelfManagedLogic is Logic, UniswapV3Callbacks {
error WrongBuildingBlockId(uint256);
function enterWithParams(bytes memory params) external payable virtual {
revert NotImplemented();
}
function exitBuildingBlock(
uint256 buildingBlockId
) external payable virtual;
function allocatedLiquidity(
address account
) external view virtual returns (uint256);
function exitWithRepay(address lending) external virtual {
revert NotImplemented();
}
}
"
},
"@shitam/defi-product-templates/contracts/UniswapV3Callbacks.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.24;
import {NotImplemented} from "./Errors.sol";
abstract contract UniswapV3Callbacks {
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external virtual {
revert NotImplemented();
}
function uniswapV3MintCallback(
uint256 amount0Owed,
uint256 amount1Owed,
bytes calldata data
) external virtual {
revert NotImplemented();
}
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external virtual {
revert NotImplemented();
}
}
"
},
"contracts/constants/ethereum.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.9;
address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
address constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
address constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address constant wstETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
address constant wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant crvUSD = 0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E;
address constant XAI = 0xd7C9F0e536dC865Ae858b0C0453Fe76D13c3bEAc;
address constant FRAX = 0x853d955aCEf822Db058eb8505911ED77F175b99e;
address constant eUSD = 0xA0d69E286B938e21CBf7E51D71F6A4c8918f482F;
address constant GHO = 0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f;
address constant stETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
address constant fxUSD = 0x085780639CC2cACd35E474e71f4d000e2405d8f6;
address constant btcUSD = 0x9D11ab23d33aD026C466CE3c124928fDb69Ba20E;
address constant wBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
address constant CRV = 0xD533a949740bb3306d119CC777fa900bA034cd52;
address constant CVX = 0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B;
address constant MIM = 0x99D8a9C45b2ecA8864373A26D1459e3Dff1e17F3;
address constant sDAI = 0x83F20F44975D03b1b09e64809B757c47f942BEeA;
address constant scrvUSD = 0x0655977FEb2f289A4aB78af67BAB0d17aAb84367;
address constant USDe = 0x4c9EDD5852cd905f086C759E8383e09bff1E68B3;
address constant sUSDe = 0x9D39A5DE30e57443BfF2A8307A4256c8797A3497;
address constant ACX = 0x44108f0223A3C3028F5Fe7AEC7f9bb2E66beF82F;
address constant ETHPlus = 0xE72B141DF173b999AE7c1aDcbF60Cc9833Ce56a8;
address constant rETH = 0xae78736Cd615f374D3085123A210448E74Fc6393;
address constant ETHx = 0xA35b1B31Ce002FBF2058D22F30f95D405200A15b;
address constant sfrxETH = 0xac3E018457B222d93114458476f3E3416Abbe38F;
address constant frxETH = 0x5E8422345238F34275888049021821E8E08CAa1f;
address constant rlUSD = 0x8292Bb45bf1Ee4d140127049757C2E0fF06317eD;
address constant cUSDO = 0xaD55aebc9b8c03FC43cd9f62260391c13c23e7c0;
address constant reUSD = 0x57aB1E0003F623289CD798B1824Be09a793e4Bec;"
},
"contracts/interfaces/ILending.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.9;
interface ILending {
function repay(address[] calldata tokens) external;
function currentDebt(address token) external view returns (uint256);
function totalDebt() external view returns (uint256);
}
"
},
"contracts/logic/ethereum/ConvexCurveEthereumreUSDscrvUSD.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.9;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SelfManagedLogicV4WithUtils} from "../templates/SelfManagedLogicV4WithUtils.sol";
import {reUSD, scrvUSD, crvUSD} from "../../constants/ethereum.sol";
/**
* @title ConvexCurveEthereumreUSDscrvUSD
* @notice DeFi strategy contract for providing liquidity to the reUSD/scrvUSD Curve pool and staking on Convex
* @dev This contract implements a multi-layer yield strategy:
* 1. Deposits crvUSD into scrvUSD vault to earn vault yield
* 2. Provides liquidity to reUSD/scrvUSD Curve pool to earn trading fees
* 3. Stakes Curve LP tokens on Convex to earn CRV and CVX rewards
* 4. Implements intelligent exit routing to maximize returns when unwinding positions
* @dev Exit strategy includes:
* - Comparison between direct pool exit and reUSD redemption routes
* - Multi-pair redemption support across 11 different collateral pairs
* - Automatic selection of best crvUSD->stablecoin swap route (LLAMMA, Curve USDC, or Curve USDT)
*/
contract ConvexCurveEthereumreUSDscrvUSD is SelfManagedLogicV4WithUtils {
/* LOGIC CONSTANTS */
/// @notice Convex pool ID for the reUSD/scrvUSD Curve pool
uint256 public constant POOL_ID = 440;
/// @notice Slippage tolerance for redemptions (1% = 1e16)
uint256 public constant SLIPPAGE_TOLERANCE = 1e16;
/// @notice Precision constant for calculations (1e18)
uint256 private constant PRECISION = 1e18;
/// @notice Index of scrvUSD token in the Curve pool (1 = second token)
int128 private constant SCRVUSD_INDEX = 1;
/// @notice Number of reUSD redemption pairs supported
uint256 private constant PAIR_COUNT = 11;
/* MATH CONSTANTS */
/// @dev Minimum sqrt price ratio for Uniswap V3 swaps (MIN_SQRT_RATIO + 1)
uint160 constant MIN_SQRT_RATIO = 4295128739;
/// @dev Maximum sqrt price ratio for Uniswap V3 swaps (MAX_SQRT_RATIO - 1)
uint160 constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
/* ADDRESSES CONSTANTS */
/// @notice Convex Booster contract for depositing LP tokens
IBooster public constant BOOSTER = IBooster(0xF403C135812408BFbE8713b5A23a04b3D48AAE31);
/// @notice scrvUSD savings vault for depositing crvUSD
IScrvUSDVault public constant SCRVUSD_VAULT = IScrvUSDVault(0x0655977FEb2f289A4aB78af67BAB0d17aAb84367);
/// @notice Resupply redemption handler for redeeming reUSD to underlying assets
IRedemptionHandler public constant REDEMPTION_HANDLER =
IRedemptionHandler(0x99999999A5Dc4695EF303C9EA9e4B3A19367Ed94);
/// @notice Curve NG pool for reUSD/scrvUSD liquidity provision
ICurvePoolNG public immutable CURVE_POOL;
/// @notice Convex reward pool for staking LP tokens and claiming rewards (set in constructor)
IRewardPool public immutable REWARD_POOL;
// Controller addresses for reUSD redemption
address constant CONTROLLER_SUSDE = 0xB536FEa3a01c95Dd09932440eC802A75410139D6;
address constant CONTROLLER_SDOLA_1 = 0xaD444663c6C92B497225c6cE65feE2E7F78BFb86;
address constant CONTROLLER_SFRXUSD = 0x3DE37c38739dFb83b7A902842bF5393040f7BF50;
address constant CONTROLLER_WBTC = 0xcaD85b7fe52B1939DCEebEe9bCf0b2a5Aa0cE617;
address constant CONTROLLER_WETH = 0x23F5a668A9590130940eF55964ead9787976f2CC;
address constant CONTROLLER_SDOLA_2 = 0xCf3DF6C1B4A6b38496661B31170de9508b867C8E;
address constant CONTROLLER_WSTETH = 0x5756A035F276a8095A922931F224F4ed06149608;
address constant CONTROLLER_USDE = 0x2dA313f6DCEE04BA46466E100c4656618E5d3dDd;
address constant CONTROLLER_FXSAVE = 0x8035b16053560b3C351b665b10f6C7dBDb6A1E05;
address constant CONTROLLER_SUSDS = 0x2dA313f6DCEE04BA46466E100c4656618E5d3dDd;
address constant CONTROLLER_TBTC = 0xc572297c5e995692B972c8eEa1D12b56b6399e1e;
// Pair addresses for reUSD redemption
address constant PAIR_SUSDE = 0x39Ea8e7f44E9303A7441b1E1a4F5731F1028505C;
address constant PAIR_SDOLA_1 = 0x08064A8eEecf71203449228f3eaC65E462009fdF;
address constant PAIR_SFRXUSD = 0xC5184cccf85b81EDdc661330acB3E41bd89F34A1;
address constant PAIR_WBTC = 0x2d8ecd48b58e53972dBC54d8d0414002B41Abc9D;
address constant PAIR_WETH = 0xCF1deb0570c2f7dEe8C07A7e5FA2bd4b2B96520D;
address constant PAIR_SDOLA_2 = 0x27AB448a75d548ECfF73f8b4F36fCc9496768797;
address constant PAIR_WSTETH = 0x4A7c64932d1ef0b4a2d430ea10184e3B87095E33;
address constant PAIR_USDE = 0x3b037329Ff77B5863e6a3c844AD2a7506ABe5706;
address constant PAIR_FXSAVE = 0xD42535Cda82a4569BA7209857446222ABd14A82c;
address constant PAIR_SUSDS = 0x57E69699381a651Fb0BBDBB31888F5D655Bf3f06;
address constant PAIR_TBTC = 0xF4A6113FbD71Ac1825751A6fe844A156f60C83EF;
// Pool addresses for crvUSD exit
address constant CRVUSD_USDC_POOL = 0x4DEcE678ceceb27446b35C672dC7d61F30bAD69E;
address constant CRVUSD_USDT_POOL = 0x390f3595bCa2Df7d23783dFd126427CCeb997BF4;
address constant LLAMMA = 0x37417B2238AA52D0DD2D6252d989E728e8f706e4;
address constant WSTETH_WETH_POOL = 0x109830a1AAaD605BbF02a9dFA7B0B92EC2FB7dAa;
address constant WETH_USDC_POOL = 0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640;
address constant UNISWAP_QUOTER = 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6;
address constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
address constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
/**
* @notice Initializes the contract and sets the Convex reward pool
* @dev Retrieves the reward pool address from Convex Booster using POOL_ID
*/
constructor() {
(address lpToken,,, address rewardPool,,) = BOOSTER.poolInfo(POOL_ID);
CURVE_POOL = ICurvePoolNG(lpToken);
REWARD_POOL = IRewardPool(rewardPool);
}
/**
* @notice Enters the full strategy position
* @dev Executes the following steps:
* 1. Converts any crvUSD balance to scrvUSD via the savings vault
* 2. Adds liquidity to the reUSD/scrvUSD Curve pool with available balances
* 3. Stakes all LP tokens on Convex to earn rewards
* @dev Assumes the contract already holds reUSD, scrvUSD, and/or crvUSD tokens
*/
function enter() external payable override {
uint256 crvUSDBalance = IERC20(crvUSD).balanceOf(address(this));
if (crvUSDBalance > 0) {
_approveIfNeeded(crvUSD, address(SCRVUSD_VAULT));
SCRVUSD_VAULT.deposit(crvUSDBalance, address(this));
}
uint256 reUSDBalance = IERC20(reUSD).balanceOf(address(this));
uint256 scrvUSDBalance = IERC20(scrvUSD).balanceOf(address(this));
_approveIfNeeded(reUSD, address(CURVE_POOL));
_approveIfNeeded(scrvUSD, address(CURVE_POOL));
uint256[] memory amounts = new uint256[](2);
amounts[0] = reUSDBalance;
amounts[1] = scrvUSDBalance;
CURVE_POOL.add_liquidity(amounts, 0, address(this));
_approveIfNeeded(address(CURVE_POOL), address(BOOSTER));
BOOSTER.depositAll(POOL_ID, true);
}
/**
* @notice Exits a specific amount of liquidity from the strategy
* @param liquidity Amount of LP tokens to unstake and withdraw
* @dev Executes the following steps:
* 1. Unstakes specified LP tokens from Convex (without claiming rewards)
* 2. Removes liquidity from Curve pool proportionally
* 3. Redeems all scrvUSD to crvUSD via the savings vault
* @dev Does not perform final crvUSD->stablecoin conversion (use building blocks for that)
*/
function exit(uint256 liquidity) public payable override {
REWARD_POOL.withdrawAndUnwrap(liquidity, false);
uint256 lpBalance = CURVE_POOL.balanceOf(address(this));
if (lpBalance > 0) {
uint256[] memory minAmounts = new uint256[](2);
CURVE_POOL.remove_liquidity(lpBalance, minAmounts, address(this));
}
}
// this function should be called in case, when
// default exit() was called by the system and
// trigger executed major exit right after
// - we have no liquidity in this case
// - we have scrvUSD and reUSD in this case
// - we need to redeem from tokens to have crvUSD only for final conversion
function _triggerExitAfterDefaultExit() private {
_redeemToCrvUSD();
// now handle the reUSD->crvUSD conversion
uint256 reUSDBalance = IERC20(reUSD).balanceOf(address(this));
if (reUSDBalance == 0) {
return;
}
(address pair, /*uint256 amount*/ ) = tryFindOnePairRedemption(reUSDBalance);
_approveIfNeeded(reUSD, address(REDEMPTION_HANDLER));
if (pair != address(0)) {
REDEMPTION_HANDLER.redeemFromPair(pair, reUSDBalance, SLIPPAGE_TOLERANCE, address(this), true);
} else {
// pair not found, we have only multipair option
uint256[PAIR_COUNT] memory liqs = _getControllersWLiq();
address[PAIR_COUNT] memory pairs = _getPairs();
uint256 remainingReUSD = reUSDBalance;
for (uint256 i = 0; i < PAIR_COUNT && remainingReUSD > 0; i++) {
if (liqs[i] == 0) continue;
uint256 redeemAmount = remainingReUSD > liqs[i] ? liqs[i] : remainingReUSD;
REDEMPTION_HANDLER.redeemFromPair(pairs[i], redeemAmount, SLIPPAGE_TOLERANCE, address(this), true);
remainingReUSD -= redeemAmount;
}
}
}
/**
* @notice Returns the total liquidity value for an account across all strategy positions
* @param account The address to check
* @return Total liquidity in strategy-native units (prioritizes staked > LP > crvUSD)
* @dev Returns the first non-zero balance in priority order:
* 1. Staked LP tokens on Convex (highest priority - actively earning rewards)
* 2. Unstaked LP tokens in Curve pool
* 3. crvUSD balance (lowest priority - not yet deployed)
*/
function accountLiquidity(address account) public view override returns (uint256) {
uint256 staked = allocatedLiquidity(account);
if (staked > 0) {
return staked;
}
uint256 lpAmount = CURVE_POOL.balanceOf(account);
if (lpAmount > 0) {
return lpAmount;
}
if (IERC20(reUSD).balanceOf(account) > 0) {
return IERC20(reUSD).balanceOf(account);
}
if (IERC20(scrvUSD).balanceOf(account) > 0) {
return IERC20(scrvUSD).balanceOf(account);
}
return IERC20(crvUSD).balanceOf(account);
}
/**
* @notice Returns the amount of LP tokens staked on Convex for an account
* @param account The address to check
* @return Amount of staked LP tokens earning rewards on Convex
*/
function allocatedLiquidity(address account) public view override returns (uint256) {
return REWARD_POOL.balanceOf(account);
}
/**
* @notice Claims all accumulated rewards and transfers them to the recipient
* @param recipient Address to receive the claimed rewards
* @dev Claims both base rewards (CRV) and extra rewards from Convex
* @dev Unwraps stash token wrappers to get the underlying reward tokens
*/
function claimRewards(address recipient) external payable override {
require(recipient != address(0), "recipient zero");
REWARD_POOL.getReward(address(this), true);
uint256 extraRewardLength = REWARD_POOL.extraRewardsLength();
address[] memory rewards = new address[](extraRewardLength + 1);
for (uint256 i = 0; i < extraRewardLength; i++) {
address extraReward = REWARD_POOL.extraRewards(i);
IStashTokenWrapper stashTokenWrapper = IStashTokenWrapper(IExtraReward(extraReward).rewardToken());
rewards[i] = stashTokenWrapper.token();
}
rewards[extraRewardLength] = REWARD_POOL.rewardToken();
for (uint256 i = 0; i < rewards.length; i++) {
if (rewards[i] == address(0)) continue;
_transferAll(rewards[i], recipient);
}
}
/**
* @notice Exits a specific building block of the strategy
* @param buildingBlockId The building block to exit (0-3)
* @dev Building blocks:
* 0 = Convex: Unstake from Convex and exit to LP tokens + optimal routing
* 1 = Curve: Exit Convex, then remove Curve LP and convert crvUSD to stablecoins
* 2 = reUSD: Exit Convex (same as building block 0)
* 3 = crvUSD: Exit Convex + Curve, then convert crvUSD to stablecoins
*/
function exitBuildingBlock(uint256 buildingBlockId) external payable override {
if (buildingBlockId == 0) {
_exitBuildingBlockConvex();
} else if (buildingBlockId == 1) {
_exitBuildingBlockCurve();
} else if (buildingBlockId == 2) {
_exitBuildingBlockReUSD();
} else if (buildingBlockId == 3) {
_exitBuildingBlockCrvUSD();
} else {
revert WrongBuildingBlockId(buildingBlockId);
}
}
/**
* @notice Emergency exit that unstakes from Convex with optimal routing
* @dev Calls _exitBuildingBlockConvex which performs intelligent exit routing
*/
function emergencyExit() external payable override {
_exitBuildingBlockConvex();
}
function _exitBuildingBlockReUSD() internal {
_exitBuildingBlockConvex();
}
function _exitBuildingBlockCurve() internal {
_exitBuildingBlockConvex();
_triggerExitAfterDefaultExit();
_exitCrvUSD();
}
function _exitBuildingBlockCrvUSD() internal {
_exitBuildingBlockCurve();
}
function _redeemToCrvUSD() private {
uint256 scrvUSDBalance = IERC20(scrvUSD).balanceOf(address(this));
if (scrvUSDBalance > 0) {
_approveIfNeeded(scrvUSD, address(SCRVUSD_VAULT));
SCRVUSD_VAULT.redeem(scrvUSDBalance, address(this), address(this));
}
}
function _exitBuildingBlockConvex() internal {
uint256 liquidity = allocatedLiquidity(address(this));
if (liquidity == 0) return;
// Step 1: Unstake LP from Convex
REWARD_POOL.withdrawAndUnwrap(liquidity, true);
uint256 lpBalance = CURVE_POOL.balanceOf(address(this));
if (lpBalance == 0) return;
// Step 2: Get scrvUSD/crvUSD exchange rate
uint256 exchangeRate = getExchangeRate();
// Step 3: Simulate pool exit in scrvUSD only
uint256 poolExitAmount = simulatePoolExitInScrvUSD(lpBalance, exchangeRate);
// Step 4: Simulate direct redemption via Resupply
// Step 4.1: Simulate exit from Curve pool in both tokens, take the amount of reUSD to receive
(bool success, uint256 reUSDSize, uint256 scrvUSDSize) = simulateCurvePool(lpBalance);
// can't exit curve with 2 tokens -> exit via pool with 1 token
if (!success || reUSDSize == 0) {
_exitViaPoolScrvUSD(lpBalance);
_redeemToCrvUSD();
return;
}
// 4.2 simulate exit on first part of the position
uint256 crvUSDSize = scrvUSDSize * exchangeRate / PRECISION;
// 4.3 Find redemption options
uint256[PAIR_COUNT] memory liqs = _getControllersWLiq();
address[PAIR_COUNT] memory pairs = _getPairs();
(address pair, uint256 crvUSDOut) = tryFindOnePairRedemptionWLiq(reUSDSize, liqs, pairs);
uint256 redeemExitAmount;
if (pair != address(0)) {
redeemExitAmount = crvUSDSize + crvUSDOut;
} else {
// If no single pair has enough liquidity, simulate multi-pair redemption
uint256 totalCrvUSD = 0;
uint256 remainingReUSD = reUSDSize;
for (uint256 i = 0; i < PAIR_COUNT && remainingReUSD > 0; i++) {
if (liqs[i] == 0) continue;
uint256 redeemAmount = remainingReUSD > liqs[i] ? liqs[i] : remainingReUSD;
uint256 crvUSDAmount = simulateOnePairRedemption(pairs[i], redeemAmount);
if (crvUSDAmount == 0) continue;
totalCrvUSD += crvUSDAmount;
remainingReUSD -= redeemAmount;
}
if (remainingReUSD > 0) {
// that means we are not able to redeem all reUSD via our pair list
_exitViaPoolScrvUSD(lpBalance);
_redeemToCrvUSD();
return;
}
redeemExitAmount = totalCrvUSD + crvUSDSize;
}
// Step 5: Choose the best route
if (redeemExitAmount > poolExitAmount) {
if (pair != address(0)) {
_exitRedeemOnePair(lpBalance, pair);
} else {
_exitViaRedemption(lpBalance, liqs, pairs);
}
} else {
// Pool exit is better or equal
_exitViaPoolScrvUSD(lpBalance);
}
// Always redeem scrvUSD to crvUSD at the end
_redeemToCrvUSD();
}
/**
* @notice Gets the current scrvUSD to crvUSD exchange rate
* @return Exchange rate with 18 decimals (e.g., 1.05e18 means 1 scrvUSD = 1.05 crvUSD)
*/
function getExchangeRate() public view returns (uint256) {
return SCRVUSD_VAULT.convertToAssets(PRECISION);
}
/**
* @notice Simulates exiting the Curve pool by withdrawing only scrvUSD
* @param lpAmount Amount of LP tokens to simulate exiting
* @param exchangeRate Current scrvUSD to crvUSD exchange rate
* @return Expected crvUSD amount after withdrawing scrvUSD and converting
*/
function simulatePoolExitInScrvUSD(uint256 lpAmount, uint256 exchangeRate) public view returns (uint256) {
if (lpAmount == 0) return 0;
uint256 scrvUSDAmount = CURVE_POOL.calc_withdraw_one_coin(lpAmount, SCRVUSD_INDEX);
return (scrvUSDAmount * exchangeRate) / PRECISION;
}
/**
* @notice Attempts to find a single redemption pair with enough liquidity
* @param reUSDSize Amount of reUSD to redeem
* @return pair Address of the redemption pair (zero address if none found)
* @return crvUSDOut Expected crvUSD output from redemption
* @dev Checks all 11 redemption pairs and returns the first one with sufficient liquidity
*/
function tryFindOnePairRedemption(uint256 reUSDSize) public view returns (address, uint256) {
address[PAIR_COUNT] memory controllers = _getControllers();
address[PAIR_COUNT] memory pairs = _getPairs();
uint256[PAIR_COUNT] memory liqs;
for (uint256 i = 0; i < PAIR_COUNT; i++) {
liqs[i] = IERC20(crvUSD).balanceOf(controllers[i]);
}
return tryFindOnePairRedemptionWLiq(reUSDSize, liqs, pairs);
}
/**
* @notice Attempts to find a single redemption pair with enough liquidity (optimized with pre-fetched liquidity)
* @param reUSDSize Amount of reUSD to redeem
* @param liqs Array of available crvUSD liquidity for each controller
* @param pairs Array of redemption pair addresses
* @return pair Address of the redemption pair (zero address if none found)
* @return crvUSDOut Expected crvUSD output from redemption
*/
function tryFindOnePairRedemptionWLiq(
uint256 reUSDSize,
uint256[PAIR_COUNT] memory liqs,
address[PAIR_COUNT] memory pairs
) public view returns (address, uint256) {
for (uint256 i = 0; i < PAIR_COUNT; i++) {
if (liqs[i] >= reUSDSize) {
uint256 out = simulateOnePairRedemption(pairs[i], reUSDSize);
if (out > 0) {
return (pairs[i], out);
}
}
}
return (address(0), 0);
}
/**
* @notice Simulates redeeming reUSD through a single redemption pair
* @param pair Address of the redemption pair
* @param reUSDSize Amount of reUSD to redeem
* @return Expected crvUSD output (0 if simulation fails)
*/
function simulateOnePairRedemption(address pair, uint256 reUSDSize) public view returns (uint256) {
try REDEMPTION_HANDLER.previewRedeem(pair, reUSDSize) returns (
uint256 returnedUnderlying, uint256, /*returnedCollateral*/ uint256 /*fee*/
) {
return returnedUnderlying;
} catch {
return 0;
}
}
/**
* @notice Simulates redeeming reUSD across multiple pairs to maximize output
* @param reUSDSize Total amount of reUSD to redeem
* @return totalCrvUSD Total crvUSD output from all pairs
* @return remainingReUSD Amount of reUSD that couldn't be redeemed
* @dev Iterates through pairs and redeems as much as possible from each
*/
function simulateMultiPairRedemption(uint256 reUSDSize) public view returns (uint256, uint256) {
address[PAIR_COUNT] memory pairs = _getPairs();
uint256[PAIR_COUNT] memory liqs = _getControllersWLiq();
uint256 totalCrvUSD = 0;
uint256 remainingReUSD = reUSDSize;
for (uint256 i = 0; i < PAIR_COUNT && remainingReUSD > 0; i++) {
if (liqs[i] == 0) continue;
uint256 redeemAmount = remainingReUSD > liqs[i] ? liqs[i] : remainingReUSD;
uint256 crvUSDAmount = simulateOnePairRedemption(pairs[i], redeemAmount);
if (crvUSDAmount == 0) continue;
totalCrvUSD += crvUSDAmount;
remainingReUSD -= redeemAmount;
}
return (totalCrvUSD, remainingReUSD);
}
/**
* @notice Simulates proportional withdrawal from the Curve pool
* @param lpAmount Amount of LP tokens to withdraw
* @return success Whether simulation succeeded
* @return reUSDAmount Expected reUSD output
* @return scrvUSDAmount Expected scrvUSD output
* @dev Calculates proportional amounts based on pool balances and total supply
*/
function simulateCurvePool(uint256 lpAmount) public view returns (bool, uint256, uint256) {
if (lpAmount == 0) return (false, 0, 0);
// Get pool balances
uint256[] memory poolBalances = CURVE_POOL.get_balances();
uint256 totalSupply = CURVE_POOL.totalSupply();
if (totalSupply == 0) return (false, 0, 0);
// not proportional
if (poolBalances[0] == 0 || poolBalances[1] == 0) return (false, 0, 0);
// Calculate proportional amounts (no fees for proportional withdrawal)
// amount = pool_balance * lp_amount / total_supply
uint256 reUSDAmount = (poolBalances[0] * lpAmount) / totalSupply;
uint256 scrvUSDAmount = (poolBalances[1] * lpAmount) / totalSupply;
return (true, reUSDAmount, scrvUSDAmount);
}
function _exitRedeemOnePair(uint256 lpAmount, address pair) internal {
uint256 reUSDSize = _exitPool(lpAmount);
_approveIfNeeded(reUSD, address(REDEMPTION_HANDLER));
REDEMPTION_HANDLER.redeemFromPair(pair, reUSDSize, SLIPPAGE_TOLERANCE, address(this), true);
}
function _exitViaRedemption(uint256 lpAmount, uint256[PAIR_COUNT] memory liqs, address[PAIR_COUNT] memory pairs)
internal
{
uint256 reUSDSize = _exitPool(lpAmount);
_approveIfNeeded(reUSD, address(REDEMPTION_HANDLER));
uint256 remainingReUSD = reUSDSize;
for (uint256 i = 0; i < PAIR_COUNT && remainingReUSD > 0; i++) {
if (liqs[i] == 0) continue;
uint256 redeemAmount = remainingReUSD > liqs[i] ? liqs[i] : remainingReUSD;
REDEMPTION_HANDLER.redeemFromPair(pairs[i], redeemAmount, SLIPPAGE_TOLERANCE, address(this), true);
remainingReUSD -= redeemAmount;
}
}
function _exitPool(uint256 lpAmount) private returns (uint256) {
uint256[] memory minAmounts = new uint256[](2);
uint256[] memory amounts = CURVE_POOL.remove_liquidity(lpAmount, minAmounts, address(this));
return amounts[0];
}
function _exitViaPoolScrvUSD(uint256 lpAmount) internal {
CURVE_POOL.remove_liquidity_one_coin(lpAmount, SCRVUSD_INDEX, 0);
}
function _getPairs() private pure returns (address[PAIR_COUNT] memory) {
return [
PAIR_SUSDE,
PAIR_SDOLA_1,
PAIR_SFRXUSD,
PAIR_WBTC,
PAIR_WETH,
PAIR_SDOLA_2,
PAIR_WSTETH,
PAIR_USDE,
PAIR_FXSAVE,
PAIR_SUSDS,
PAIR_TBTC
];
}
function _getControllers() private pure returns (address[PAIR_COUNT] memory) {
return [
CONTROLLER_SUSDE,
CONTROLLER_SDOLA_1,
CONTROLLER_SFRXUSD,
CONTROLLER_WBTC,
CONTROLLER_WETH,
CONTROLLER_SDOLA_2,
CONTROLLER_WSTETH,
CONTROLLER_USDE,
CONTROLLER_FXSAVE,
CONTROLLER_SUSDS,
CONTROLLER_TBTC
];
}
function _getControllersWLiq() private view returns (uint256[PAIR_COUNT] memory) {
address[PAIR_COUNT] memory controllers = _getControllers();
uint256[PAIR_COUNT] memory liqs;
for (uint256 i = 0; i < PAIR_COUNT; i++) {
liqs[i] = IERC20(crvUSD).balanceOf(controllers[i]);
}
return liqs;
}
/**
* @notice Simulate swap through LLAMMA -> wstETH -> wETH -> USDC path
* @param crvUSDAmount Amount of crvUSD to swap
* @return Expected USDC amount out
*/
function simulateSwapHops(uint256 crvUSDAmount) public returns (uint256) {
if (crvUSDAmount == 0) return 0;
try ILLAMMA(LLAMMA).get_dy(0, 1, crvUSDAmount) returns (uint256 wstETHAmount) {
if (wstETHAmount == 0) return 0;
// Build path: wstETH -> wETH (fee 100) -> USDC (fee 500)
bytes memory path = abi.encodePacked(WSTETH, uint24(100), WETH, uint24(500), USDC);
try IUniswapQuoter(UNISWAP_QUOTER).quoteExactInput(path, wstETHAmount) returns (uint256 usdcAmount) {
return usdcAmount;
} catch {
return 0;
}
} catch {
return 0;
}
}
/**
* @notice Simulates swapping crvUSD to USDC via Curve stable pool
* @param crvUSDAmount Amount of crvUSD to swap
* @return Expected USDC amount out (0 if simulation fails)
*/
function simulateCurveSwapUSDC(uint256 crvUSDAmount) public view returns (uint256) {
if (crvUSDAmount == 0) return 0;
try IStableSwap(CRVUSD_USDC_POOL).get_dy(1, 0, crvUSDAmount) returns (uint256 usdcAmount) {
return usdcAmount;
} catch {
return 0;
}
}
/**
* @notice Simulates swapping crvUSD to USDT via Curve stable pool
* @param crvUSDAmount Amount of crvUSD to swap
* @return Expected USDT amount out (0 if simulation fails)
*/
function simulateCurveSwapUSDT(uint256 crvUSDAmount) public view returns (uint256) {
if (crvUSDAmount == 0) return 0;
try IStableSwap(CRVUSD_USDT_POOL).get_dy(1, 0, crvUSDAmount) returns (uint256 usdtAmount) {
return usdtAmount;
} catch {
return 0;
}
}
/**
* @notice Exit from crvUSD to USDC/USDT using the best available route
* @dev Simulates all three routes and executes the one with maximum output
*/
function _exitCrvUSD() private {
uint256 crvUSDBalance = IERC20(crvUSD).balanceOf(address(this));
if (crvUSDBalance == 0) return;
uint256 hopAmount = simulateSwapHops(crvUSDBalance);
uint256 usdcAmount = simulateCurveSwapUSDC(crvUSDBalance);
uint256 usdtAmount = simulateCurveSwapUSDT(crvUSDBalance);
if (hopAmount >= usdcAmount && hopAmount >= usdtAmount) {
_executeSwapHops(crvUSDBalance);
} else if (usdcAmount >= usdtAmount) {
_executeCurveSwapUSDC(crvUSDBalance);
} else {
_executeCurveSwapUSDT(crvUSDBalance);
}
}
/**
* @notice Execute swap through LLAMMA -> wstETH -> wETH -> USDC path
*/
function _executeSwapHops(uint256 crvUSDAmount) private {
_approveIfNeeded(crvUSD, LLAMMA);
// Step 1: Swap crvUSD -> wstETH via LLAMMA
uint256[2] memory amounts = ILLAMMA(LLAMMA).exchange(0, 1, crvUSDAmount, 0);
uint256 wstETHAmount = amounts[1];
// Step 2: Swap wstETH -> wETH via Uniswap V3
IERC20(WSTETH).approve(WSTETH_WETH_POOL, wstETHAmount);
(, int256 wethAmount) = IUniswapPool(WSTETH_WETH_POOL).swap(
address(this), true, int256(wstETHAmount), MIN_SQRT_RATIO + 1, bytes("")
);
// Step 3: Swap wETH -> USDC via Uniswap V3
IERC20(WETH).approve(WETH_USDC_POOL, uint256(-wethAmount));
IUniswapPool(WETH_USDC_POOL).swap(address(this), false, -wethAmount, MAX_SQRT_RATIO - 1, bytes(""));
}
/**
* @notice Execute swap crvUSD -> USDC via Curve pool
*/
function _executeCurveSwapUSDC(uint256 crvUSDAmount) private {
_approveIfNeeded(crvUSD, CRVUSD_USDC_POOL);
IStableSwap(CRVUSD_USDC_POOL).exchange(1, 0, crvUSDAmount, 0);
}
/**
* @notice Execute swap crvUSD -> USDT via Curve pool
*/
function _executeCurveSwapUSDT(uint256 crvUSDAmount) private {
_approveIfNeeded(crvUSD, CRVUSD_USDT_POOL);
IStableSwap(CRVUSD_USDT_POOL).exchange(1, 0, crvUSDAmount, 0);
}
}
// Interfaces
interface IBooster {
function depositAll(uint256 _pid, bool _stake) external;
function poolInfo(uint256) external view returns (address, address, address, address, address, bool);
}
interface IRewardPool {
function balanceOf(address account) external view returns (uint256);
function withdrawAndUnwrap(uint256 amount, bool claim) external;
function getReward(address account, bool claimExtras) external;
function extraRewardsLength() external view returns (uint256);
function extraRewards(uint256 index) external view returns (address);
function rewardToken() external view returns (address);
}
interface IExtraReward {
function rewardToken() external view returns (address);
}
interface IStashTokenWrapper {
function token() external view returns (address);
}
interface IScrvUSDVault {
function deposit(uint256 assets, address receiver) external returns (uint256);
function convertToAssets(uint256 shares) external view returns (uint256);
function redeem(uint256 shares, address receiver, address owner) external returns (uint256);
}
interface ICurvePoolNG is IERC20 {
function add_liquidity(uint256[] memory amounts, uint256 min_mint_amount, address receiver)
external
returns (uint256);
function remove_liquidity(uint256 burn_amount, uint256[] memory min_amounts, address receiver)
external
returns (uint256[] memory);
function remove_liquidity_one_coin(uint256 burn_amount, int128 i, uint256 min_amount) external returns (uint256);
function calc_withdraw_one_coin(uint256 token_amount, int128 i) external view returns (uint256);
function get_balances() external view returns (uint256[] memory);
}
interface IRedemptionHandler {
function redeemFromPair(
address pair,
uint256 reUSDAmount,
uint256 slippageTolerance,
address recipient,
bool redeemToUnderlying
) external returns (uint256);
function previewRedeem(address pair, uint256 amount)
external
view
returns (uint256 _returnedUnderlying, uint256 _returnedCollateral, uint256 _fee);
}
interface ILLAMMA {
function get_dy(uint256 i, uint256 j, uint256 dx) external view returns (uint256);
function exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy) external returns (uint256[2] memory);
}
interface IStableSwap {
function get_dy(int128 i, int128 j, uint256 dx) external view returns (uint256);
function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) external returns (uint256);
}
interface IUniswapQuoter {
function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut);
}
interface IUniswapPool {
function swap(
address recipient,
bool zeroForOne,
int256 amountSpecified,
uint160 sqrtPriceLimitX96,
bytes calldata data
) external returns (int256 amount0, int256 amount1);
}
"
},
"contracts/logic/templates/SelfManagedLogicV2WithUtils.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.9;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SelfManagedLogic, UniswapV3Callbacks} from "@shitam/defi-product-templates/contracts/SelfManagedLogic.sol";
import {Constants} from "@shift-defi/core/contracts/libraries/Constants.sol";
import {ILending} from "../../interfaces/ILending.sol";
abstract contract SelfManagedLogicV2WithUtils is SelfManagedLogic {
using SafeERC20 for IERC20;
function exit(uint256) public payable override virtual;
function allocatedLiquidity(address) public view override virtual returns(uint256);
function _approveIfNeeded(address token, address recipient) internal {
uint256 allowance = IERC20(token).allowance(address(this), recipient);
if (allowance < type(uint256).max) {
IERC20(token).forceApprove(recipient, type(uint256).max);
}
}
function _transferAll(address token, address recipient) internal {
uint256 balance = IERC20(token).balanceOf(address(this));
if (balance > 0) {
IERC20(token).safeTransfer(recipient, balance);
}
}
function _exitWithRepay(address lending, address[] memory tokens) internal virtual {
require(ILending(lending).totalDebt() > 0);
if (allocatedLiquidity(address(this)) > 0) {
exit(allocatedLiquidity(address(this)));
}
for (uint i = 0; i < tokens.length; i++) {
if (IERC20(tokens[i]).balanceOf(address(this)) > 0) {
_transferAll(tokens[i], lending);
}
}
ILending(lending).repay(tokens);
}
}
"
},
"contracts/logic/templates/SelfManagedLogicV4WithUtils.sol": {
"content": "// SPDX-License-Identifier: SHIFT-1.0
pragma solidity ^0.8.9;
import {SelfManagedLogicV2WithUtils} from "./SelfManagedLogicV2WithUtils.sol";
abstract contract SelfManagedLogicV4WithUtils is SelfManagedLogicV2WithUtils {
function rebalance(bytes calldata) external virtual {
revert NotImplemented();
}
}
"
}
},
"settings": {
"optimizer": {
"enabled": true,
"runs": 1
},
"evmVersion": "paris",
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
}
}
}}Submitted on: 2025-10-29 11:34:34
Comments
Log in to comment.
No comments yet.