Forkchoice Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import {BaseCurveRewardVaultStrategy} from "./BaseCurveRewardVaultStrategy.sol";
import {IYieldStrategy} from "../interfaces/IYieldStrategy.sol";
import {IChainlinkOracle} from "../interfaces/IChainlinkOracle.sol";
import {IAccountant} from "../interfaces/IAccountant.sol";
import {ICrvSwapper} from "../interfaces/ICrvSwapper.sol";
import {ICurveStableSwap} from "../interfaces/ICurveStableSwap.sol";
import {ICurveStableSwapNG} from "../interfaces/ICurveStableSwapNG.sol";
import {IERC20} from "../interfaces/IERC20.sol";
import {IStakeDaoRewardVault} from "../interfaces/IStakeDaoRewardVault.sol";
import {CurveUsdtSwapLib} from "../libraries/CurveUsdtSwapLib.sol";

/// @title PmUsdCrvUsdStrategy
/// @notice USDT -> crvUSD -> pmUSD/crvUSD LP -> Stake DAO RewardVault
/// @dev Accepts USDT debt, swaps to crvUSD, provides single-sided liquidity to pmUSD/crvUSD pool,
///      stakes LP in Stake DAO reward vault, and harvests CRV rewards back into the strategy
contract PmUsdCrvUsdStrategy is BaseCurveRewardVaultStrategy {
    error SwapFailed();
    // ============ Constants ============

    uint256 public constant DEFAULT_SLIPPAGE = 1e16; // 1% for stablecoin swaps
    uint256 public constant MAX_SLIPPAGE = 5e16; // 5% governance max
    uint256 public constant EMERGENCY_SLIPPAGE = 1e17; // 10% emergency
    uint256 public constant LP_SLIPPAGE = 5e15; // 0.5% for LP ops (stable pairs)
    uint256 public constant MIN_HARVEST_THRESHOLD = 1e17; // 0.1 CRV minimum
    uint256 public constant MAX_ORACLE_STALENESS = 90000; // 25 hours

    // ============ Immutables ============

    IERC20 public immutable crvUSD;
    IERC20 public immutable crv;
    ICurveStableSwap public immutable usdtCrvUsdPool;
    ICurveStableSwapNG public immutable lpPool;
    IChainlinkOracle public immutable crvUsdOracle;
    IChainlinkOracle public immutable usdtOracle;
    ICrvSwapper public immutable crvSwapper;
    address public immutable gauge;

    int128 public immutable usdtIndex;
    int128 public immutable crvUsdIndex;
    int128 public immutable lpCrvUsdIndex;

    // ============ State ============

    uint256 public slippageTolerance = DEFAULT_SLIPPAGE;

    // ============ Events ============

    event SlippageUpdated(uint256 oldSlippage, uint256 newSlippage);
    event SwappedUsdtToCrvUsd(uint256 usdtAmount, uint256 crvUsdReceived);
    event SwappedCrvUsdToUsdt(uint256 crvUsdAmount, uint256 usdtReceived);
    event LiquidityAdded(uint256 crvUsdAmount, uint256 lpReceived);
    event LiquidityRemoved(uint256 lpBurned, uint256 crvUsdReceived);
    event RewardsHarvested(uint256 crvAmount, uint256 crvUsdCompounded);

    // ============ Constructor ============

    /// @param _usdt USDT token address (debt asset)
    /// @param _crvUsd crvUSD token address
    /// @param _crv CRV token address
    /// @param _vault Zenji vault address
    /// @param _usdtCrvUsdPool Curve USDT/crvUSD StableSwap pool
    /// @param _lpPool Curve pmUSD/crvUSD StableSwapNG pool
    /// @param _rewardVault Stake DAO ERC4626 reward vault
    /// @param _crvSwapper CRV -> crvUSD swapper address
    /// @param _gauge Curve gauge for pmUSD/crvUSD LP (for accountant claims)
    /// @param _usdtIndex USDT coin index in USDT/crvUSD pool
    /// @param _crvUsdIndex crvUSD coin index in USDT/crvUSD pool
    /// @param _lpCrvUsdIndex crvUSD coin index in pmUSD/crvUSD pool
    /// @param _crvUsdOracle Chainlink crvUSD/USD oracle
    /// @param _usdtOracle Chainlink USDT/USD oracle
    constructor(
        address _usdt,
        address _crvUsd,
        address _crv,
        address _vault,
        address _usdtCrvUsdPool,
        address _lpPool,
        address _rewardVault,
        address _crvSwapper,
        address _gauge,
        int128 _usdtIndex,
        int128 _crvUsdIndex,
        int128 _lpCrvUsdIndex,
        address _crvUsdOracle,
        address _usdtOracle
    ) BaseCurveRewardVaultStrategy(_usdt, _vault, _rewardVault) {
        if (_crvUsd == address(0) || _crv == address(0)) revert InvalidAddress();
        if (_usdtCrvUsdPool == address(0) || _lpPool == address(0)) revert InvalidAddress();
        if (_crvSwapper == address(0)) revert InvalidAddress();
        if (_gauge == address(0)) revert InvalidAddress();
        if (_crvUsdOracle == address(0) || _usdtOracle == address(0)) revert InvalidAddress();

        crvUSD = IERC20(_crvUsd);
        crv = IERC20(_crv);
        usdtCrvUsdPool = ICurveStableSwap(_usdtCrvUsdPool);
        lpPool = ICurveStableSwapNG(_lpPool);
        crvSwapper = ICrvSwapper(_crvSwapper);
        gauge = _gauge;
        usdtIndex = _usdtIndex;
        crvUsdIndex = _crvUsdIndex;
        lpCrvUsdIndex = _lpCrvUsdIndex;
        crvUsdOracle = IChainlinkOracle(_crvUsdOracle);
        usdtOracle = IChainlinkOracle(_usdtOracle);
    }

    // ============ Admin ============

    function setSlippage(uint256 newSlippage) external onlyVault {
        if (newSlippage > MAX_SLIPPAGE) revert SlippageExceeded();
        uint256 oldSlippage = slippageTolerance;
        slippageTolerance = newSlippage;
        emit SlippageUpdated(oldSlippage, newSlippage);
    }

    // ============ View Functions ============

    /// @inheritdoc IYieldStrategy
    function underlyingAsset() external view override returns (address) {
        return address(lpToken);
    }

    /// @inheritdoc IYieldStrategy
    function name() external pure override returns (string memory) {
        return "USDT -> pmUSD/crvUSD LP Strategy";
    }

    /// @inheritdoc IYieldStrategy
    function balanceOf() public view override returns (uint256) {
        uint256 lpTokens = _rewardVaultBalance();
        if (lpTokens < 1) return 0;

        // LP -> crvUSD value via virtual_price (manipulation-resistant)
        uint256 virtualPrice = lpPool.get_virtual_price();
        uint256 crvUsdValue = (lpTokens * virtualPrice) / 1e18;

        return CurveUsdtSwapLib.convertCrvUsdToUsdt(
            crvUsdValue, crvUsdOracle, usdtOracle, MAX_ORACLE_STALENESS
        );
    }

    /// @inheritdoc IYieldStrategy
    function pendingRewards() external view override returns (uint256) {
        address accountant = rewardVault.ACCOUNTANT();
        try IAccountant(accountant).getPendingRewards(address(rewardVault), address(this)) returns (uint256 pendingCrv)
        {
            return pendingCrv / 2e12; // rough CRV->USDT view conversion
        } catch {
            return 0;
        }
    }

    // ============ Internal: Core Strategy ============

    function _deposit(uint256 usdtAmount) internal override returns (uint256 underlyingDeposited) {
        // Auto-compound any pending CRV rewards
        _claimAndCompound();

        // 1. Swap USDT -> crvUSD
        uint256 crvUsdReceived = _swapUsdtToCrvUsd(usdtAmount, slippageTolerance);

        // 2. Add single-sided liquidity to pmUSD/crvUSD pool
        uint256 lpReceived = _addLiquidity(crvUsdReceived);

        // 3. Stake LP tokens in reward vault
        _depositToRewardVault(lpReceived);

        // Return value in USDT terms
        underlyingDeposited = lpReceived;
    }

    function _withdraw(uint256 usdtAmount) internal override returns (uint256 usdtReceived) {
        // Auto-compound any pending CRV rewards
        _claimAndCompound();

        uint256 currentValue = balanceOf();
        if (currentValue < 1) return 0;

        uint256 shares = rewardVault.balanceOf(address(this));
        if (shares < 1) return 0;

        // Calculate proportional shares to redeem
        uint256 sharesToRedeem = (shares * usdtAmount) / currentValue;
        if (sharesToRedeem > shares) sharesToRedeem = shares;
        if (sharesToRedeem < 1) return 0;

        // 1. Unstake from reward vault
        uint256 lpReceived = _redeemFromRewardVault(sharesToRedeem);

        // 2. Remove liquidity (single-sided crvUSD)
        uint256 crvUsdReceived = _removeLiquidity(lpReceived, slippageTolerance);

        // 3. Swap crvUSD -> USDT
        if (crvUsdReceived > 0) {
            usdtReceived = _swapCrvUsdToUsdt(crvUsdReceived, slippageTolerance);
        }
    }

    function _withdrawAll() internal override returns (uint256 usdtReceived) {
        // 1. Unstake all LP tokens
        uint256 lpReceived = _redeemAllFromRewardVault();
        if (lpReceived < 1) return 0;

        // 2. Remove all liquidity for crvUSD
        uint256 crvUsdReceived = _removeLiquidity(lpReceived, slippageTolerance);

        // 3. Swap all crvUSD -> USDT
        if (crvUsdReceived > 0) {
            usdtReceived = _swapCrvUsdToUsdt(crvUsdReceived, slippageTolerance);
        }
    }

    function _harvest() internal override returns (uint256 rewardsValue) {
        uint256 crvUsdCompounded = _claimAndCompound();
        rewardsValue = CurveUsdtSwapLib.convertCrvUsdToUsdt(
            crvUsdCompounded, crvUsdOracle, usdtOracle, MAX_ORACLE_STALENESS
        );
    }

    /// @notice Claim CRV from accountant, swap to crvUSD, and compound back into LP
    /// @return crvUsdCompounded Amount of crvUSD compounded (0 if nothing to harvest)
    function _claimAndCompound() internal returns (uint256 crvUsdCompounded) {
        _accountantClaim();

        uint256 crvBalance = crv.balanceOf(address(this));
        if (crvBalance < MIN_HARVEST_THRESHOLD) return 0;

        crv.transfer(address(crvSwapper), crvBalance);
        uint256 crvUsdReceived = _swapCrv(crvBalance);
        if (crvUsdReceived < 1) return 0;

        emit RewardsHarvested(crvBalance, crvUsdReceived);

        uint256 lpReceived = _addLiquidity(crvUsdReceived);
        _depositToRewardVault(lpReceived);

        crvUsdCompounded = crvUsdReceived;
    }

    function _swapCrv(uint256 amount) internal returns (uint256 crvUsdReceived) {
        try crvSwapper.swap(amount) returns (uint256 received) {
            crvUsdReceived = received;
        } catch {
            revert SwapFailed();
        }
    }

    function _accountantClaim() internal {
        address accountant = rewardVault.ACCOUNTANT();
        address[] memory gauges = new address[](1);
        gauges[0] = gauge;
        bytes[] memory harvestData = new bytes[](1);
        harvestData[0] = bytes("");
        // NoPendingRewards is expected when nothing has accrued yet
        try IAccountant(accountant).claim(gauges, harvestData, address(this)) {} catch {}
    }

    function _emergencyWithdraw() internal override returns (uint256 usdtReceived) {
        // 1. Unstake all LP tokens
        uint256 lpReceived = _redeemAllFromRewardVault();
        if (lpReceived < 1) return 0;

        // 2. Remove all liquidity with emergency slippage
        uint256 crvUsdReceived = _removeLiquidity(lpReceived, EMERGENCY_SLIPPAGE);

        // 3. Swap all crvUSD -> USDT with emergency slippage
        if (crvUsdReceived > 0) {
            usdtReceived = _swapCrvUsdToUsdt(crvUsdReceived, EMERGENCY_SLIPPAGE);
        }
    }

    // ============ Internal: LP Operations ============

    /// @notice Add single-sided crvUSD liquidity to pmUSD/crvUSD pool
    function _addLiquidity(uint256 crvUsdAmount) internal returns (uint256 lpReceived) {
        _ensureApprove(address(crvUSD), address(lpPool), crvUsdAmount);

        // Build amounts array: only crvUSD side
        uint256[] memory amounts = new uint256[](2);
        amounts[uint256(uint128(lpCrvUsdIndex))] = crvUsdAmount;

        uint256 expectedLp = lpPool.calc_token_amount(amounts, true);
        uint256 minLp = (expectedLp * (PRECISION - LP_SLIPPAGE)) / PRECISION;

        lpReceived = lpPool.add_liquidity(amounts, minLp);
        emit LiquidityAdded(crvUsdAmount, lpReceived);
    }

    /// @notice Remove single-sided crvUSD liquidity from pmUSD/crvUSD pool
    function _removeLiquidity(uint256 lpAmount, uint256 slippage) internal returns (uint256 crvUsdReceived) {
        uint256 expectedOut = lpPool.calc_withdraw_one_coin(lpAmount, lpCrvUsdIndex);
        uint256 minOut = (expectedOut * (PRECISION - slippage)) / PRECISION;

        _ensureApprove(address(lpToken), address(lpPool), lpAmount);
        crvUsdReceived = lpPool.remove_liquidity_one_coin(lpAmount, lpCrvUsdIndex, minOut);
        emit LiquidityRemoved(lpAmount, crvUsdReceived);
    }

    // ============ Internal: USDT/crvUSD Swaps ============

    function _swapUsdtToCrvUsd(uint256 usdtAmount, uint256 slippage) internal returns (uint256 crvUsdReceived) {
        _ensureApprove(address(debtAsset), address(usdtCrvUsdPool), usdtAmount);
        crvUsdReceived =
            CurveUsdtSwapLib.swapUsdtToCrvUsd(usdtCrvUsdPool, usdtIndex, crvUsdIndex, usdtAmount, slippage);
        emit SwappedUsdtToCrvUsd(usdtAmount, crvUsdReceived);
    }

    function _swapCrvUsdToUsdt(uint256 crvUsdAmount, uint256 slippage) internal returns (uint256 usdtReceived) {
        _ensureApprove(address(crvUSD), address(usdtCrvUsdPool), crvUsdAmount);
        usdtReceived =
            CurveUsdtSwapLib.swapCrvUsdToUsdt(usdtCrvUsdPool, crvUsdIndex, usdtIndex, crvUsdAmount, slippage);
        emit SwappedCrvUsdToUsdt(crvUsdAmount, usdtReceived);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import {BaseYieldStrategy} from "./BaseYieldStrategy.sol";
import {IStakeDaoRewardVault} from "../interfaces/IStakeDaoRewardVault.sol";
import {IERC20} from "../interfaces/IERC20.sol";

/// @title BaseCurveRewardVaultStrategy
/// @notice Abstract base for strategies that stake Curve LP tokens in ERC4626 reward vaults
/// @dev Provides shared deposit/redeem/balance helpers for Stake DAO-style reward vaults
abstract contract BaseCurveRewardVaultStrategy is BaseYieldStrategy {
    // ============ Immutables ============

    /// @notice Stake DAO ERC4626 reward vault
    IStakeDaoRewardVault public immutable rewardVault;

    /// @notice The Curve LP token staked in the reward vault
    IERC20 public immutable lpToken;

    // ============ Constructor ============

    constructor(address _debtAsset, address _vault, address _rewardVault)
        BaseYieldStrategy(_debtAsset, _vault)
    {
        if (_rewardVault == address(0)) revert InvalidAddress();
        rewardVault = IStakeDaoRewardVault(_rewardVault);
        lpToken = IERC20(rewardVault.asset());
    }

    // ============ Reward Vault Helpers ============

    /// @notice Deposit LP tokens into the reward vault
    /// @param lpAmount Amount of LP tokens to deposit
    /// @return shares Vault shares minted
    function _depositToRewardVault(uint256 lpAmount) internal returns (uint256 shares) {
        _ensureApprove(address(lpToken), address(rewardVault), lpAmount);
        shares = rewardVault.deposit(lpAmount, address(this));
    }

    /// @notice Redeem specific number of shares from reward vault
    /// @param shares Number of shares to redeem
    /// @return lpReceived Amount of LP tokens received
    function _redeemFromRewardVault(uint256 shares) internal returns (uint256 lpReceived) {
        lpReceived = rewardVault.redeem(shares, address(this), address(this));
    }

    /// @notice Redeem all shares from reward vault
    /// @return lpReceived Amount of LP tokens received
    function _redeemAllFromRewardVault() internal returns (uint256 lpReceived) {
        uint256 shares = rewardVault.balanceOf(address(this));
        if (shares < 1) return 0;
        lpReceived = rewardVault.redeem(shares, address(this), address(this));
    }

    /// @notice Claim all pending rewards from the reward vault
    /// @return amounts Array of reward amounts claimed
    function _claimRewards() internal returns (uint256[] memory amounts) {
        amounts = rewardVault.claim();
    }

    /// @notice Get total LP token balance in reward vault
    /// @return LP token amount (converted from shares)
    function _rewardVaultBalance() internal view returns (uint256) {
        uint256 shares = rewardVault.balanceOf(address(this));
        if (shares < 1) return 0;
        return rewardVault.convertToAssets(shares);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title IYieldStrategy
/// @notice Interface for yield strategies used by Zenji
/// @dev All strategies accept the debt asset from the vault and deploy to yield-generating protocols
interface IYieldStrategy {
    // ============ Events ============

    event Deposited(uint256 debtAssetAmount, uint256 underlyingDeposited);
    event Withdrawn(uint256 debtAssetAmount, uint256 debtAssetReceived);
    event Harvested(uint256 rewardsValue);
    event EmergencyWithdrawn(uint256 debtAssetReceived);
    event StrategyPauseToggled(bool paused, uint256 debtAssetReceived);

    // ============ Errors ============

    error Unauthorized();
    error ZeroAmount();
    error StrategyPaused();
    error SlippageExceeded();
    error TransferFailed();
    error InvalidAddress();

    // ============ Core Functions ============

    /// @notice Deposit debt asset into the yield strategy
    /// @param debtAssetAmount Amount of debt asset to deposit
    /// @return underlyingDeposited Amount deposited into the underlying protocol
    function deposit(uint256 debtAssetAmount) external returns (uint256 underlyingDeposited);

    /// @notice Withdraw debt asset from the yield strategy
    /// @param debtAssetAmount Amount of debt asset to withdraw
    /// @return debtAssetReceived Actual debt asset received (may differ due to slippage)
    function withdraw(uint256 debtAssetAmount) external returns (uint256 debtAssetReceived);

    /// @notice Withdraw all assets from the yield strategy
    /// @return debtAssetReceived Total debt asset received
    function withdrawAll() external returns (uint256 debtAssetReceived);

    /// @notice Harvest rewards and compound them back into the strategy
    /// @return rewardsValue Value of rewards harvested (in debt asset terms)
    function harvest() external returns (uint256 rewardsValue);

    /// @notice Emergency withdraw all assets, bypassing slippage checks
    /// @return debtAssetReceived Total debt asset received
    function emergencyWithdraw() external returns (uint256 debtAssetReceived);

    /// @notice Toggle pause state for the strategy
    /// @dev When pausing, should unwind all deployed assets back to the vault
    /// @return debtAssetReceived Total debt asset received if unwound (0 when unpausing)
    function pauseStrategy() external returns (uint256 debtAssetReceived);

    // ============ View Functions ============

    /// @notice Returns the asset accepted by the strategy (debt asset)
    function asset() external view returns (address);

    /// @notice Returns the underlying asset of the yield protocol (debt asset or swapped asset)
    function underlyingAsset() external view returns (address);

    /// @notice Returns the current value of the strategy holdings in debt asset terms
    function balanceOf() external view returns (uint256);

    /// @notice Returns the total debt asset deposited (cost basis)
    function costBasis() external view returns (uint256);

    /// @notice Returns unrealized profit (current value - cost basis)
    function unrealizedProfit() external view returns (uint256);

    /// @notice Returns pending rewards value in debt asset terms
    function pendingRewards() external view returns (uint256);

    /// @notice Returns whether the strategy is paused
    function paused() external view returns (bool);

    /// @notice Returns the strategy name
    function name() external view returns (string memory);

    /// @notice Returns the vault address
    function vault() external view returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title IChainlinkOracle
/// @notice Interface for Chainlink price feeds
interface IChainlinkOracle {
    /// @notice Get the latest round data
    /// @return roundId The round ID
    /// @return answer The price answer
    /// @return startedAt Timestamp when the round started
    /// @return updatedAt Timestamp when the round was updated
    /// @return answeredInRound The round in which the answer was computed
    function latestRoundData()
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );

    /// @notice Get decimals of the price feed
    /// @return Decimals
    function decimals() external view returns (uint8);

    /// @notice Get description of the price feed
    /// @return Description string
    function description() external view returns (string memory);

    /// @notice Get the latest answer
    /// @return Latest price
    function latestAnswer() external view returns (int256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import { IStrategy } from "src/interfaces/IStrategy.sol";

interface IAccountant {
    function checkpoint(
        address gauge,
        address from,
        address to,
        uint128 amount,
        IStrategy.PendingRewards calldata pendingRewards,
        IStrategy.HarvestPolicy policy
    ) external;

    function checkpoint(
        address gauge,
        address from,
        address to,
        uint128 amount,
        IStrategy.PendingRewards calldata pendingRewards,
        IStrategy.HarvestPolicy policy,
        address referrer
    ) external;

    function totalSupply(address asset) external view returns (uint128);
    function balanceOf(address asset, address account) external view returns (uint128);

    function claim(address[] calldata _gauges, bytes[] calldata harvestData) external;
    function claim(address[] calldata _gauges, bytes[] calldata harvestData, address receiver)
        external;
    function claim(
        address[] calldata _gauges,
        address account,
        bytes[] calldata harvestData,
        address receiver
    ) external;

    function claimProtocolFees() external;
    function harvest(address[] calldata _gauges, bytes[] calldata _harvestData, address _receiver)
        external;

    function REWARD_TOKEN() external view returns (address);

    function getPendingRewards(address vault) external view returns (uint128);
    function getPendingRewards(address vault, address account) external view returns (uint256);

    function SCALING_FACTOR() external view returns (uint128);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title ICrvSwapper
/// @notice Minimal interface for CRV -> crvUSD swapper contracts
interface ICrvSwapper {
    /// @notice Swap CRV into crvUSD
    /// @param amount CRV amount to swap
    /// @return crvUsdReceived Amount of crvUSD received
    function swap(uint256 amount) external returns (uint256 crvUsdReceived);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title ICurveStableSwap
/// @notice Interface for Curve StableSwap pools (used for crvUSD/USDC swaps)
interface ICurveStableSwap {
    /// @notice Exchange tokens
    /// @param i Index of input token
    /// @param j Index of output token
    /// @param dx Amount of input token
    /// @param min_dy Minimum amount of output token
    /// @return Amount of output token received
    function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) external returns (uint256);

    /// @notice Get expected output amount
    /// @param i Index of input token
    /// @param j Index of output token
    /// @param dx Amount of input token
    /// @return Expected output amount
    function get_dy(int128 i, int128 j, uint256 dx) external view returns (uint256);

    /// @notice Get coin address by index
    /// @param i Coin index
    /// @return Coin address
    function coins(uint256 i) external view returns (address);

    /// @notice Get pool balances
    /// @param i Coin index
    /// @return Balance of coin at index
    function balances(uint256 i) external view returns (uint256);

    /// @notice Get virtual price of LP token
    /// @return Virtual price scaled by 1e18
    function get_virtual_price() external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title ICurveStableSwapNG
/// @notice Interface for Curve StableSwapNG pools (e.g., pmUSD/crvUSD)
/// @dev Uses uint256 indices instead of int128 (NG pools use uint256)
interface ICurveStableSwapNG {
    /// @notice Add liquidity to the pool
    /// @param amounts Array of token amounts to deposit [coin0, coin1]
    /// @param min_mint_amount Minimum LP tokens to mint
    /// @return LP tokens minted
    function add_liquidity(uint256[] calldata amounts, uint256 min_mint_amount) external returns (uint256);

    /// @notice Remove liquidity in a single coin
    /// @param burn_amount Amount of LP tokens to burn
    /// @param i Index of coin to withdraw
    /// @param min_received Minimum amount of coin to receive
    /// @return Amount of coin received
    function remove_liquidity_one_coin(uint256 burn_amount, int128 i, uint256 min_received)
        external
        returns (uint256);

    /// @notice Calculate expected LP tokens from deposit
    /// @param amounts Array of token amounts [coin0, coin1]
    /// @param is_deposit True for deposit, false for withdrawal
    /// @return Expected LP token amount
    function calc_token_amount(uint256[] calldata amounts, bool is_deposit) external view returns (uint256);

    /// @notice Calculate expected output from removing liquidity in one coin
    /// @param burn_amount Amount of LP tokens to burn
    /// @param i Index of coin to withdraw
    /// @return Expected amount of coin received
    function calc_withdraw_one_coin(uint256 burn_amount, int128 i) external view returns (uint256);

    /// @notice Get the virtual price of the LP token
    /// @return Virtual price scaled by 1e18
    function get_virtual_price() external view returns (uint256);

    /// @notice Get coin address by index
    /// @param i Coin index
    /// @return Coin address
    function coins(uint256 i) external view returns (address);

    /// @notice Get pool balances
    /// @param i Coin index
    /// @return Balance of coin at index
    function balances(uint256 i) external view returns (uint256);

    /// @notice Exchange tokens
    /// @param i Index of input token
    /// @param j Index of output token
    /// @param dx Amount of input token
    /// @param min_dy Minimum amount of output token
    /// @return Amount of output token received
    function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) external returns (uint256);

    /// @notice Get expected output amount for exchange
    /// @param i Index of input token
    /// @param j Index of output token
    /// @param dx Amount of input token
    /// @return Expected output amount
    function get_dy(int128 i, int128 j, uint256 dx) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title IERC20
/// @notice Standard ERC20 interface
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function name() external view returns (string memory);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import {ICurveRewardVault} from "./ICurveRewardVault.sol";

/// @title IStakeDaoRewardVault
/// @notice Minimal extension for Stake DAO reward vaults exposing the accountant address
interface IStakeDaoRewardVault is ICurveRewardVault {
    /// @notice Stake DAO accountant contract
    /// @return accountant address
    function ACCOUNTANT() external view returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import {ICurveStableSwap} from "../interfaces/ICurveStableSwap.sol";
import {ICurveStableSwapWithReceiver} from "../interfaces/ICurveStableSwapWithReceiver.sol";
import {IChainlinkOracle} from "../interfaces/IChainlinkOracle.sol";

/// @title CurveUsdtSwapLib
/// @notice Shared USDT/crvUSD swap + oracle conversion logic
library CurveUsdtSwapLib {
    uint256 internal constant PRECISION = 1e18;

    error ExchangeFailed();

    /// @notice Swap USDT to crvUSD via Curve StableSwap
    function swapUsdtToCrvUsd(
        ICurveStableSwap pool,
        int128 usdtIndex,
        int128 crvUsdIndex,
        uint256 usdtAmount,
        uint256 slippage
    ) internal returns (uint256 crvUsdReceived) {
        uint256 expectedOut = pool.get_dy(usdtIndex, crvUsdIndex, usdtAmount);
        uint256 minOut = (expectedOut * (PRECISION - slippage)) / PRECISION;
        crvUsdReceived = exchange(pool, usdtIndex, crvUsdIndex, usdtAmount, minOut);
    }

    /// @notice Swap crvUSD to USDT via Curve StableSwap
    function swapCrvUsdToUsdt(
        ICurveStableSwap pool,
        int128 crvUsdIndex,
        int128 usdtIndex,
        uint256 crvUsdAmount,
        uint256 slippage
    ) internal returns (uint256 usdtReceived) {
        uint256 expectedOut = pool.get_dy(crvUsdIndex, usdtIndex, crvUsdAmount);
        uint256 minOut = (expectedOut * (PRECISION - slippage)) / PRECISION;
        usdtReceived = exchange(pool, crvUsdIndex, usdtIndex, crvUsdAmount, minOut);
    }

    /// @notice Exchange on Curve with receiver fallback
    function exchange(ICurveStableSwap pool, int128 i, int128 j, uint256 dx, uint256 minOut)
        internal
        returns (uint256 amountOut)
    {
        try ICurveStableSwapWithReceiver(address(pool)).exchange(i, j, dx, minOut, address(this))
        returns (uint256 outWithReceiver) {
            amountOut = outWithReceiver;
        } catch {
            try pool.exchange(i, j, dx, minOut) returns (uint256 outStandard) {
                amountOut = outStandard;
            } catch {
                revert ExchangeFailed();
            }
        }
    }

    /// @notice Convert crvUSD value (18 dec) to USDT value (6 dec) using oracles
    function convertCrvUsdToUsdt(
        uint256 crvUsdValue,
        IChainlinkOracle crvUsdOracle,
        IChainlinkOracle usdtOracle,
        uint256 maxStaleness
    ) internal view returns (uint256) {
        if (crvUsdValue < 1) return 0;

        (uint80 crvRoundId, int256 crvUsdPrice,, uint256 crvUsdUpdatedAt, uint80 crvAnswered) =
            crvUsdOracle.latestRoundData();
        if (
            crvUsdPrice <= 0 || crvAnswered < crvRoundId
                || block.timestamp - crvUsdUpdatedAt > maxStaleness
        ) {
            return crvUsdValue / 1e12; // fallback to 1:1
        }

        (uint80 usdtRoundId, int256 usdtPrice,, uint256 usdtUpdatedAt, uint80 usdtAnswered) =
            usdtOracle.latestRoundData();
        if (
            usdtPrice <= 0 || usdtAnswered < usdtRoundId
                || block.timestamp - usdtUpdatedAt > maxStaleness
        ) {
            return crvUsdValue / 1e12; // fallback to 1:1
        }

        return (crvUsdValue * uint256(crvUsdPrice)) / (uint256(usdtPrice) * 1e12);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import {IYieldStrategy} from "../interfaces/IYieldStrategy.sol";
import {IERC20} from "../interfaces/IERC20.sol";
import {SafeTransferLib} from "../libraries/SafeTransferLib.sol";

/// @title BaseYieldStrategy
/// @notice Abstract base contract for yield strategies with cost basis tracking
/// @dev All strategies inherit from this and implement protocol-specific logic
abstract contract BaseYieldStrategy is IYieldStrategy {
    using SafeTransferLib for IERC20;

    // ============ Constants ============

    uint256 public constant PRECISION = 1e18;

    // ============ Immutables ============

    /// @notice The debt asset token (asset accepted/returned by this strategy)
    IERC20 public immutable debtAsset;

    // ============ State ============

    /// @notice The vault that owns this strategy
    address public override vault;

    /// @notice Deployer address for deferred vault initialization
    address public initializer;

    /// @notice Total debt asset deposited (cost basis for profit calculation)
    uint256 internal _costBasis;

    /// @notice Whether the strategy is paused
    bool public override paused;

    /// @notice Reentrancy guard
    uint256 private _status;
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    // ============ Events ============

    event VaultInitialized(address indexed vault);

    // ============ Modifiers ============

    modifier onlyVault() {
        if (msg.sender != vault) revert Unauthorized();
        _;
    }

    modifier whenNotPaused() {
        if (paused) revert StrategyPaused();
        _;
    }

    modifier nonReentrant() {
        if (_status == _ENTERED) revert Unauthorized();
        _status = _ENTERED;
        _;
        _status = _NOT_ENTERED;
    }

    // ============ Constructor ============

    /// @param _debtAsset The debt asset token address
    /// @param _vault The vault address (or zero for deferred initialization)
    constructor(address _debtAsset, address _vault) {
        if (_debtAsset == address(0)) revert InvalidAddress();
        debtAsset = IERC20(_debtAsset);
        if (_vault != address(0)) {
            vault = _vault;
            initializer = address(0);
        } else {
            initializer = msg.sender;
        }
        _status = _NOT_ENTERED;
    }

    // ============ Deferred Initialization ============

    /// @notice Initialize the vault address (can only be called once by deployer)
    function initializeVault(address newVault) external {
        if (vault != address(0)) revert InvalidAddress();
        if (newVault == address(0)) revert InvalidAddress();
        if (msg.sender != initializer) revert Unauthorized();

        vault = newVault;
        initializer = address(0);
        emit VaultInitialized(newVault);
    }

    // ============ Core Functions ============

    /// @inheritdoc IYieldStrategy
    function deposit(uint256 amount)
        external
        override
        onlyVault
        whenNotPaused
        nonReentrant
        returns (uint256 underlyingDeposited)
    {
        if (amount == 0) revert ZeroAmount();

        debtAsset.safeTransferFrom(msg.sender, address(this), amount);
        _costBasis += amount;
        underlyingDeposited = _deposit(amount);
        emit Deposited(amount, underlyingDeposited);
    }

    /// @inheritdoc IYieldStrategy
    function withdraw(uint256 amount)
        external
        override
        onlyVault
        nonReentrant
        returns (uint256 received)
    {
        if (amount == 0) revert ZeroAmount();

        uint256 currentValue = this.balanceOf();
        if (currentValue == 0) return 0;
        if (amount > currentValue) amount = currentValue;

        uint256 basisReduction = (_costBasis * amount) / currentValue;
        received = _withdraw(amount);
        _costBasis = _costBasis > basisReduction ? _costBasis - basisReduction : 0;

        if (received > 0) {
            debtAsset.safeTransfer(vault, received);
        }

        emit Withdrawn(amount, received);
    }

    /// @inheritdoc IYieldStrategy
    function withdrawAll() external override onlyVault nonReentrant returns (uint256 received) {
        received = _withdrawAll();
        _costBasis = 0;

        uint256 balance = debtAsset.balanceOf(address(this));
        if (balance > 0) {
            debtAsset.safeTransfer(vault, balance);
        }

        emit Withdrawn(type(uint256).max, received);
    }

    /// @inheritdoc IYieldStrategy
    function harvest()
        external
        override
        onlyVault
        whenNotPaused
        nonReentrant
        returns (uint256 rewardsValue)
    {
        rewardsValue = _harvest();
        emit Harvested(rewardsValue);
    }

    /// @inheritdoc IYieldStrategy
    function emergencyWithdraw()
        external
        override
        onlyVault
        nonReentrant
        returns (uint256 received)
    {
        received = _emergencyWithdraw();
        _costBasis = 0;

        uint256 balance = debtAsset.balanceOf(address(this));
        if (balance > 0) {
            debtAsset.safeTransfer(vault, balance);
        }

        emit EmergencyWithdrawn(received);
    }

    /// @inheritdoc IYieldStrategy
    function pauseStrategy() external override onlyVault nonReentrant returns (uint256 received) {
        paused = !paused;

        if (paused) {
            received = _withdrawAll();
            _costBasis = 0;

            uint256 balance = debtAsset.balanceOf(address(this));
            if (balance > 0) {
                debtAsset.safeTransfer(vault, balance);
            }
        }

        emit StrategyPauseToggled(paused, received);
    }

    // ============ View Functions ============

    /// @inheritdoc IYieldStrategy
    function asset() external view override returns (address) {
        return address(debtAsset);
    }

    /// @inheritdoc IYieldStrategy
    function costBasis() external view override returns (uint256) {
        return _costBasis;
    }

    /// @inheritdoc IYieldStrategy
    function balanceOf() public view virtual override returns (uint256);

    /// @inheritdoc IYieldStrategy
    function unrealizedProfit() external view override returns (uint256) {
        uint256 currentValue = this.balanceOf();
        return currentValue > _costBasis ? currentValue - _costBasis : 0;
    }

    // ============ Internal Functions (to be implemented by derived contracts) ============

    function _deposit(uint256 amount) internal virtual returns (uint256 underlyingDeposited);
    function _withdraw(uint256 amount) internal virtual returns (uint256 received);
    function _withdrawAll() internal virtual returns (uint256 received);
    function _harvest() internal virtual returns (uint256 rewardsValue);
    function _emergencyWithdraw() internal virtual returns (uint256 received);

    // ============ Helper Functions ============

    function _ensureApprove(address token, address spender, uint256 amount) internal {
        IERC20(token).ensureApproval(spender, amount);
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.33;

import "src/interfaces/IAllocator.sol";

interface IStrategy {
    /// @notice The policy for harvesting rewards.
    enum HarvestPolicy {
        CHECKPOINT,
        HARVEST
    }

    struct PendingRewards {
        uint128 feeSubjectAmount;
        uint128 totalAmount;
    }

    function deposit(IAllocator.Allocation calldata allocation, HarvestPolicy policy)
        external
        returns (PendingRewards memory pendingRewards);
    function withdraw(
        IAllocator.Allocation calldata allocation,
        HarvestPolicy policy,
        address receiver
    ) external returns (PendingRewards memory pendingRewards);

    function balanceOf(address gauge) external view returns (uint256 balance);

    function harvest(address gauge, bytes calldata extraData)
        external
        returns (PendingRewards memory pendingRewards);
    function flush() external;

    function shutdown(address gauge) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title ICurveRewardVault
/// @notice Interface for Stake DAO ERC4626 reward vaults
/// @dev These vaults wrap Curve LP tokens and distribute CRV/SDT rewards
interface ICurveRewardVault {
    // ============ ERC4626 Functions ============

    function asset() external view returns (address);
    function totalAssets() external view returns (uint256);
    function convertToShares(uint256 assets) external view returns (uint256);
    function convertToAssets(uint256 shares) external view returns (uint256);
    function maxDeposit(address receiver) external view returns (uint256);
    function maxWithdraw(address owner) external view returns (uint256);
    function maxRedeem(address owner) external view returns (uint256);
    function previewDeposit(uint256 assets) external view returns (uint256);
    function previewWithdraw(uint256 assets) external view returns (uint256);
    function previewRedeem(uint256 shares) external view returns (uint256);
    function deposit(uint256 assets, address receiver) external returns (uint256 shares);
    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);

    // ============ ERC20 Functions ============

    function balanceOf(address account) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function totalSupply() external view returns (uint256);

    // ============ Reward Functions ============

    /// @notice Claim all pending rewards for the caller
    /// @return Array of reward amounts claimed (ordered by rewardTokens())
    function claim() external returns (uint256[] memory);

    /// @notice Get pending rewards for an account
    /// @param account Address to check
    /// @param token Reward token address
    /// @return Pending reward amount
    function earned(address account, address token) external view returns (uint256);

    /// @notice Get all reward token addresses
    /// @return Array of reward token addresses
    function rewardTokens(uint256 index) external view returns (address);

    /// @notice Get the number of reward tokens
    /// @return Number of reward tokens
    function rewardTokensLength() external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title ICurveStableSwapWithReceiver
/// @notice Optional Curve exchange variant that supports specifying a receiver
interface ICurveStableSwapWithReceiver {
    /// @notice Exchange tokens to a receiver
    /// @param i Index of input token
    /// @param j Index of output token
    /// @param dx Amount of input token
    /// @param min_dy Minimum amount of output token
    /// @param receiver Address to receive the output token
    /// @return Amount of output token received
    function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy, address receiver)
        external
        returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import { IERC20 } from "../interfaces/IERC20.sol";

/// @title SafeTransferLib
/// @notice Gas-efficient safe transfer functions for ERC20 tokens
library SafeTransferLib {
    error TransferFailed();

    /// @notice Safe transfer that reverts on failure
    function safeTransfer(IERC20 token, address to, uint256 amount) internal {
        (bool success, bytes memory data) =
            address(token).call(abi.encodeWithSelector(token.transfer.selector, to, amount));
        if (!success || (data.length != 0 && !abi.decode(data, (bool)))) {
            revert TransferFailed();
        }
    }

    /// @notice Safe transferFrom that reverts on failure
    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {
        (bool success, bytes memory data) = address(token).call(
            abi.encodeWithSelector(token.transferFrom.selector, from, to, amount)
        );
        if (!success || (data.length != 0 && !abi.decode(data, (bool)))) {
            revert TransferFailed();
        }
    }

    /// @notice Ensure approval is sufficient, set to max if not
    /// @dev Uses safeApprove pattern for USDT compatibility (non-standard ERC20)
    function ensureApproval(IERC20 token, address spender, uint256 amount) internal {
        if (token.allowance(address(this), spender) < amount) {
            safeApprove(token, spender, type(uint256).max);
        }
    }

    /// @notice Safe approve that handles non-standard ERC20 tokens like USDT
    /// @dev USDT requires setting allowance to 0 first before setting a new non-zero value
    ///      and returns void instead of bool
    function safeApprove(IERC20 token, address spender, uint256 amount) internal {
        // For USDT: first reset to 0 if there's existing allowance and we're setting non-zero
        if (amount > 0 && token.allowance(address(this), spender) > 0) {
            (bool resetSuccess,) =
                address(token).call(abi.encodeWithSelector(token.approve.selector, spender, 0));
            // Ignore return value for void-returning tokens like USDT
            if (!resetSuccess) revert TransferFailed();
        }

        (bool success, bytes memory data) =
            address(token).call(abi.encodeWithSelector(token.approve.selector, spender, amount));
        // Handle both standard (returns bool) and non-standard (returns nothing) ERC20
        if (!success || (data.length != 0 && !abi.decode(data, (bool)))) {
            revert TransferFailed();
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.7;

interface IAllocator {
    struct Allocation {
        address asset;
        address gauge;
        address[] targets;
        uint256[] amounts;
    }

    function getDepositAllocation(address asset, address gauge, uint256 amount)
        external
        view
        returns (Allocation memory);
    function getWithdrawalAllocation(address asset, address gauge, uint256 amount)
        external
        view
        returns (Allocation memory);
    function getRebalancedAllocation(address asset, address gauge, uint256 amount)
        external
        view
        returns (Allocation memory);

    function getAllocationTargets(address gauge) external view returns (address[] memory);
}