Usual Sync Vault

if (tokenIn == USD0) {    oracleRate = SUSDS.previewMint(1e18);    minTokensToReceive = (amountIn * 1e18) / oracleRate;} else {    oracleRate = SUSDS.previewRedeem(1e18);    minTokensToReceive = (amountIn * oracleRate) / 1e18;}

function _computeMinTokensToReceive(    IERC20 tokenIn,    uint256 amountIn)    internal    view    returns (uint256 minTokensToReceive){    uint256 oracleRate;    if (tokenIn == USD0) {        oracleRate = SUSDS.previewMint(1e18);        minTokensToReceive = (amountIn * 1e18) / oracleRate;-   } else {+   } else if (tokenIn == IERC20(address(SUSDS))) {        oracleRate = SUSDS.previewRedeem(1e18);        minTokensToReceive = (amountIn * oracleRate) / 1e18;+   } else {+       revert InvalidInputToken(address(tokenIn));    }    uint256 maxDeviation =        minTokensToReceive * MAX_EXCHANGE_RATE_DEVIATION_BPS / BPS_DIVIDER;    return minTokensToReceive - maxDeviation;}

function _computeMinTokensToReceive(    IERC20 tokenIn,    uint256 amountIn)    internal    view    returns (uint256 minTokensToReceive){-   uint256 oracleRate;-    if (tokenIn == USD0) {-       oracleRate = SUSDS.previewMint(1e18);-       minTokensToReceive = (amountIn * 1e18) / oracleRate;+       minTokensToReceive = SUSDS.previewDeposit(amountIn);    } else {-       oracleRate = SUSDS.previewRedeem(1e18);-       minTokensToReceive = (amountIn * oracleRate) / 1e18;+       minTokensToReceive = SUSDS.previewRedeem(amountIn);    }    uint256 maxDeviation =        minTokensToReceive * MAX_EXCHANGE_RATE_DEVIATION_BPS / BPS_DIVIDER;    return minTokensToReceive - maxDeviation;}

/// @inheritdoc IVaultRouter+ /// @dev Returns the amount of USD0PP received rather than shares burned,+ /// as users interact with final token amounts rather than vault sharesfunction withdraw(    IParaSwapAugustus augustus,    uint256 assets,    address receiver,    uint256 minUSD0PPToReceiveUser,    bytes calldata swapData)    public    whenNotPaused    nonReentrant    returns (uint256 amountUSD0pp)

// SPDX-License-Identifier: MITpragma solidity 0.8.26;
import { BaseIntegrationTest } from "./BaseUnit.integration.t.sol";import { MockAugustus } from "./mocks/MockAugustus.sol";import { IParaSwapAugustus } from "../src/interfaces/IParaSwapAugustus.sol";import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";import { IUSD0ppMinter } from "../src/interfaces/IUSD0ppMinter.sol";import { VaultRouter } from "../src/VaultRouter.sol";import { StdStorage, stdStorage } from "forge-std/StdStorage.sol";import { console } from "forge-std/console.sol";
import { ADDRESS_AUGUSTUS_REGISTRY, BPS_DIVIDER } from "../src/constants.sol";
/** * @title VulnerabilityDemoTest * @notice Tests demonstrating that the May 27, 2025 exploit vulnerability has been fixed * @dev This test suite validates the hotfix implementation that prevents dust swap attacks */contract VulnerabilityDemoTest is BaseIntegrationTest {    using Math for uint256;    using stdStorage for StdStorage;
    MockAugustus public mockAugustus;    IERC20 public USDS;
    function setUp() public override {        super.setUp();
        USDS = IERC20(IERC4626(address(SUSDS)).asset());
        // Deploy and set up mock Augustus        mockAugustus = new MockAugustus();
        // Mock Augustus registry validation        vm.mockCall(            ADDRESS_AUGUSTUS_REGISTRY,            abi.encodeWithSignature("isValidAugustus(address)", address(mockAugustus)),            abi.encode(true)        );
        // Set unlimited unwrap cap for testing        vm.startPrank(unwrapCapAllocator);        IUSD0ppMinter(address(USD0PP)).setUnwrapCap(            address(router), type(uint256).max        );        vm.stopPrank();
        // Label contracts for debugging        vm.label(address(USD0), "USD0");        vm.label(address(USD0PP), "USD0PP");        vm.label(address(SUSDS), "sUSDS");        vm.label(address(mockAugustus), "mockAugustus");        vm.label(address(router), "router");        vm.label(address(vault), "vault");    }
    function setMaxExchangeRateDeviationBps(uint256 bps) public {        stdstore.target(address(router)).sig(            bytes4(keccak256("MAX_EXCHANGE_RATE_DEVIATION_BPS()"))        ).checked_write(bps);        assertEq(router.MAX_EXCHANGE_RATE_DEVIATION_BPS(), bps);    }
    function setWithdrawFeeRateBps(uint256 bps) public {        stdstore.target(address(vault)).sig(            bytes4(keccak256("withdrawFeeRateBps()"))        ).checked_write(bps);        assertEq(vault.withdrawFeeRateBps(), bps);    }
    // Maximum expected USD0++ price deviation    uint256 MIN_USD0_TO_USD0PP_PRICE = 0.9e18;
    // Test the specific exploit scenario with protections enabled    function testExploitWithProtectionsEnabled() public {        _testExploitWithProtectionsEnabled(            1_900_000e18, // Flash loan amount from actual incident            0.995e18,     // Max output deviation ratio (0.5% deviation)            0.97e18,      // USD0++ price            0.005e18      // Fee override (0.5% fee)        );    }
    // Fuzz test to validate protections across parameter ranges    function testExploitWithProtectionsEnabledFuzz(        uint256 L, // Flash loan amount        uint256 r, // Max output deviation ratio          uint256 p  // USD0++ price    ) public {        _testExploitWithProtectionsEnabled(L, r, p, 0);    }        // Core test implementation that validates:    // - Oracle-based minimum amount enforcement    // - Proper fee calculation to prevent profitable exploitation    // - Price deviation bounds    function _testExploitWithProtectionsEnabled(        uint256 L, uint256 r, uint256 p, uint256 feeOverride    ) public {        vm.startPrank(alice);
        // Bound parameters to realistic ranges        p = bound(p, MIN_USD0_TO_USD0PP_PRICE, 1e18); // 0.9% ≤ p ≤ 100%        L = bound(L, 1e18, 1e25); // 1e18 ≤ L ≤ 1e24        r = bound(r, 0.9e18, 0.999e18); // 0.9% ≤ maxDeviation ≤ 99.9%                // Calculate minimum fee required to prevent profitable exploitation        uint256 f = (1e18 * ((1e18 - p) * (1e18 - r)) + p * r - 1) / (p * r);        if (feeOverride > 0) {            f = feeOverride;        }
        console.log("L: %18e", L);        console.log("r: %18e", r);        console.log("p: %18e", p);        console.log("f: %18e", f);                uint256 skL;        uint256 u;        {            // Set withdrawal fees and maximum output deviation            uint256 minWithdrawFeeRateBps = (f * BPS_DIVIDER + 1e18 - 1) / 1e18;            uint256 maxOutputDeviationBps = (1e18 - r) * BPS_DIVIDER / 1e18;
            setWithdrawFeeRateBps(minWithdrawFeeRateBps);            setMaxExchangeRateDeviationBps(maxOutputDeviationBps);
            // Calculate minimum sUSDS required based on oracle rate            uint256 t = (L * 1e18 / IERC4626(address(SUSDS)).previewMint(1e18));            skL = t - t * maxOutputDeviationBps / BPS_DIVIDER;            u = IERC4626(address(SUSDS)).previewMint(skL);        }
        // Setup tokens and approvals        deal(address(USDS), alice, u);        deal(address(USD0PP), alice, L);
        IERC20(USDS).approve(address(SUSDS), u);        IERC20(USD0PP).approve(address(router), L);        IERC20(vault).approve(address(router), type(uint256).max);
        // Prepare sUSDS for mock Augustus        IERC4626(address(SUSDS)).mint(skL, address(alice));        SUSDS.transfer(address(mockAugustus), skL);
        // Mock the manipulated pool swap result        mockAugustus.setSwapResult(            true,            address(USD0),            L, // Input: L USD0            address(SUSDS),            skL, // Output: skL sUSDS            address(router)        );
        // Execute deposit with dust swap attack attempt        router.deposit(            IParaSwapAugustus(address(mockAugustus)),            USD0PP,            L,            1, // minSharesReceived            0, // minAmountReceived            address(alice),            ""        );
        // Transfer extracted USD0 to attacker using MockAugustus transfer function        mockAugustus.transfer(address(USD0), alice, L);
        skip(61); // Skip cooldown period
        // Execute withdrawal        uint256 sUSDSWithdrawAmt = vault.maxWithdraw(alice);        uint256 USDSWithdrawAmt = IERC4626(address(SUSDS)).previewRedeem(sUSDSWithdrawAmt);
        // Mock fair market rate withdrawal swap        deal(address(USD0), address(mockAugustus), USDSWithdrawAmt);        mockAugustus.setSwapResult(            true,            address(SUSDS),            sUSDSWithdrawAmt,            address(USD0),            USDSWithdrawAmt,            address(router)        );
        router.withdraw(            IParaSwapAugustus(address(mockAugustus)),            sUSDSWithdrawAmt,            alice,            0,            ""        );
        // Calculate profit and verify exploit is not profitable        int256 profit = int256(USD0.balanceOf(alice))            + int256(USD0PP.balanceOf(alice) * p / 1e18) - int256(u)            - int256(L * p / 1e18);
        assertLt(profit, 0, "Attacker made a profit - exploit protection failed");    }}
// MockAugustus with transfer capability for testingcontract MockAugustus {    function transfer(address token, address to, uint256 amount) external {        IERC20(token).transfer(to, amount);    }        function setSwapResult(/* swap parameters */) external {        // Mock swap implementation    }}

///*** Mutable constants ***////// @notice The maximum deviation from the oracle rate- uint256 public MAX_EXCHANGE_RATE_DEVIATION_BPS;+ uint256 public immutable MAX_EXCHANGE_RATE_DEVIATION_BPS;