// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {BaskVault} from "src/BaskVault.sol";
import {BaskTypes as T} from "src/BaskTypes.sol";

/// @dev A Stock Token whose upgraded code burns every unit of gas it is given, in balanceOf and transfer.
contract BurningToken {
    uint8 public constant decimals = 18;
    mapping(address => uint256) internal balances;
    mapping(address => mapping(address => uint256)) public allowance;
    bool public burnAll;

    function mint(address to, uint256 amount) external {
        balances[to] += amount;
    }

    function setBurn(bool v) external {
        burnAll = v;
    }

    function approve(address to, uint256 amount) external returns (bool) {
        allowance[msg.sender][to] = amount;
        return true;
    }

    function _burn() internal view {
        if (!burnAll) return;
        while (true) {
            assembly ("memory-safe") {
                pop(keccak256(0, 32))
            }
        }
    }

    function balanceOf(address who) external view returns (uint256) {
        _burn();
        return balances[who];
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        _burn();
        allowance[from][msg.sender] -= amount;
        balances[from] -= amount;
        balances[to] += amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        _burn();
        balances[msg.sender] -= amount;
        balances[to] += amount;
        return true;
    }
}

contract StaticFeed {
    uint8 public constant decimals = 8;
    int256 public constant answer = 100e8;
    uint256 public updatedAt;

    function set(uint256 t) external {
        updatedAt = t;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// @notice Settings that satisfy both brief inequalities still let a redeem exceed 28,000,000 gas.
///   maxAssets * (balanceGas + 60,000)            = 350 * 80,000  = 28,000,000
///   directLimit * (balanceGas + payGas + 70,000) =  49 * 570,000 = 27,930,000
/// With 350 listed assets, 49 of them held and hostile, redeem(…) runs out of gas when given 28,000,000.
contract RedeemGasBoundTest is Test {
    BaskVault private vault;
    address private owner = makeAddr("owner");
    address private guardian = makeAddr("guardian");
    address private alice = makeAddr("alice");
    address[] private tokens;
    address[] private feeds;

    function _setting(T.Setting key, uint256 value) private {
        vm.prank(owner);
        uint256 id = vault.propose(T.Action.Setting, address(0), abi.encode(key, value));
        vm.warp(block.timestamp + 2 days);
        vm.prank(owner);
        vault.execute(id);
    }

    function _setup(uint256 count, uint256 active, uint256 balanceGas, uint256 payGas, uint256 directLimit) private {
        vm.warp(1_800_000_000);
        vault = new BaskVault(owner, guardian);
        _setting(T.Setting.DirectLimit, 0);
        _setting(T.Setting.BalanceGas, balanceGas);
        _setting(T.Setting.PayGas, payGas);
        _setting(T.Setting.MaxAssets, count);
        _setting(T.Setting.DirectLimit, directLimit);
        bytes memory tokenCode = address(new BurningToken()).code;
        bytes memory feedCode = address(new StaticFeed()).code;
        address[] memory deposited = new address[](active);
        uint256[] memory amounts = new uint256[](active);
        for (uint256 i; i < count; ++i) {
            address token = address(uint160(0x100000 + i));
            address feed = address(uint160(0x200000 + i));
            vm.etch(token, tokenCode);
            vm.etch(feed, feedCode);
            StaticFeed(feed).set(block.timestamp);
            tokens.push(token);
            feeds.push(feed);
            vm.prank(owner);
            vault.genesisList(token, feed, address(0), address(0), 0);
            if (i < active) {
                BurningToken(token).mint(alice, 1e18);
                vm.prank(alice);
                BurningToken(token).approve(address(vault), type(uint256).max);
                deposited[i] = token;
                amounts[i] = 1e18;
            }
        }
        vm.prank(owner);
        vault.finalizeGenesis();
        vm.prank(alice);
        vault.deposit(deposited, amounts, alice, 0, block.timestamp);
        for (uint256 i; i < active; ++i) {
            BurningToken(tokens[i]).setBurn(true);
        }
        vm.prank(guardian);
        vault.pauseDeposits();
    }

    function _redeemWith28M() private returns (bool ok, uint256 gasUsed) {
        for (uint256 i; i < tokens.length; ++i) {
            vm.cool(tokens[i]);
        }
        vm.cool(address(vault));
        uint256 shares = vault.balanceOf(alice);
        bytes memory input = abi.encodeCall(vault.redeem, (shares / 2, alice, new uint256[](0), block.timestamp));
        vm.prank(alice);
        uint256 start = gasleft();
        (ok,) = address(vault).call{gas: 28_000_000}(input);
        gasUsed = start - gasleft();
        emit log_named_uint("redeem gas", gasUsed);
    }

    function testRedeemFitsIn28MillionAt350Assets49DirectLegalSettings() public {
        _setup(350, 49, 20_000, 480_000, 49);
        assertEq(vault.settings().maxAssets, 350);
        assertEq(vault.settings().directLimit, 49);
        (bool ok,) = _redeemWith28M();
        assertTrue(ok, "redeem must fit in 28,000,000 gas with maxAssets assets in any state");
        assertGt(vault.owed(alice, tokens[48]), 0, "hostile legs are owed, not lost");
    }

    function testRedeemFitsIn28MillionAt350Assets47DirectPayGas500k() public {
        _setup(350, 47, 20_000, 500_000, 47);
        (bool ok,) = _redeemWith28M();
        assertTrue(ok, "redeem must fit in 28,000,000 gas with maxAssets assets in any state");
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {BaskVault} from "src/BaskVault.sol";
import {BaskTypes as T} from "src/BaskTypes.sol";

/// Minimal Stock Token mock: normal until `setHostile(true)`, then every read and
/// transfer burns all the gas it is given (an upgraded, broken token).
contract HostileToken {
    uint8 public constant decimals = 18;
    mapping(address => uint256) internal balances;
    mapping(address => mapping(address => uint256)) public allowance;
    bool public hostile;

    function mint(address to, uint256 amount) external {
        balances[to] += amount;
    }

    function setHostile(bool v) external {
        hostile = v;
    }

    function approve(address to, uint256 amount) external returns (bool) {
        allowance[msg.sender][to] = amount;
        return true;
    }

    function balanceOf(address who) external view returns (uint256) {
        if (hostile) {
            assembly ("memory-safe") { invalid() }
        }
        return balances[who];
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        if (hostile) {
            assembly ("memory-safe") { invalid() }
        }
        balances[msg.sender] -= amount;
        balances[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balances[from] -= amount;
        balances[to] += amount;
        return true;
    }
}

contract SimpleFeed {
    uint8 public constant decimals = 0;
    uint256 public updatedAt;

    function set(uint256 time) external {
        updatedAt = time;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, 100, updatedAt, updatedAt, 1);
    }
}

/// The brief requires: redeem with maxAssets assets in any state fits in 28,000,000 gas,
/// for every setting combination the vault accepts. The two setting inequalities are checked
/// independently, so an accepted combination (maxAssets at its bound, payGas 500,000,
/// directLimit at its bound) lets `directLimit` hostile direct payments plus the remaining
/// empty assets exceed 28,000,000 gas and the redemption runs out of gas.
contract GasBudgetProofTest is Test {
    BaskVault private vault;
    address private owner = makeAddr("gas owner");
    address private guardian = makeAddr("gas guardian");
    address private alice = makeAddr("gas depositor");
    address private receiver = makeAddr("gas receiver");
    address[] private tokens;
    address[] private feeds;
    uint256 private shares;

    /// Proposes and executes a setting if the vault accepts it; returns whether it was applied.
    function _trySetting(T.Setting key, uint256 value) private returns (bool applied) {
        vm.prank(owner);
        (bool ok, bytes memory ret) =
            address(vault).call(abi.encodeCall(vault.propose, (T.Action.Setting, address(0), abi.encode(key, value))));
        if (!ok) return false;
        uint256 id = abi.decode(ret, (uint256));
        vm.warp(block.timestamp + 2 days);
        vm.prank(owner);
        (ok,) = address(vault).call(abi.encodeCall(vault.execute, (id)));
        return ok;
    }

    /// Builds the worst case the current settings allow: maxAssets listed assets, directLimit of
    /// them held (so each is paid directly), every token hostile.
    function _build() private {
        T.Settings memory s = vault.settings();
        uint256 count = s.maxAssets;
        uint256 active = s.directLimit < count ? s.directLimit : count;
        if (active == 0) active = 1; // a fix that rejects the setting leaves directLimit 0; still deposit one asset
        bytes memory tokenCode = address(new HostileToken()).code;
        bytes memory feedCode = address(new SimpleFeed()).code;
        address[] memory deposited = new address[](active);
        uint256[] memory amounts = new uint256[](active);
        for (uint256 i; i < count; ++i) {
            address token = address(uint160(0x100000 + i));
            address feed = address(uint160(0x200000 + i));
            vm.etch(token, tokenCode);
            vm.etch(feed, feedCode);
            SimpleFeed(feed).set(block.timestamp);
            tokens.push(token);
            feeds.push(feed);
            vm.prank(owner);
            vault.genesisList(token, feed, address(0), address(0), 0);
            if (i < active) {
                HostileToken(token).mint(alice, 1e18);
                vm.prank(alice);
                HostileToken(token).approve(address(vault), type(uint256).max);
                deposited[i] = token;
                amounts[i] = 1e18;
            }
        }
        vm.prank(owner);
        vault.finalizeGenesis();
        vm.prank(alice);
        shares = vault.deposit(deposited, amounts, alice, 0, block.timestamp);
        for (uint256 i; i < tokens.length; ++i) {
            HostileToken(tokens[i]).setHostile(true);
        }
    }

    function _redeemFitsBudget() private returns (bool ok, uint256 gasUsed) {
        for (uint256 i; i < tokens.length; ++i) {
            vm.cool(tokens[i]);
            vm.cool(feeds[i]);
        }
        vm.cool(address(vault));
        bytes memory input = abi.encodeCall(vault.redeem, (shares / 2, receiver, new uint256[](0), block.timestamp));
        vm.prank(alice);
        uint256 start = gasleft();
        (ok,) = address(vault).call{gas: 28_000_000}(input);
        gasUsed = start - gasleft();
        emit log_named_uint("maxAssets", vault.settings().maxAssets);
        emit log_named_uint("directLimit", vault.settings().directLimit);
        emit log_named_uint("payGas", vault.settings().payGas);
        emit log_named_uint("balanceGas", vault.settings().balanceGas);
        emit log_named_uint("redeem gas used", gasUsed);
    }

    /// Default balanceGas 50,000 and maxAssets 250 (250 * 110,000 = 27,500,000 <= 28,000,000);
    /// payGas raised to 500,000 and directLimit 45 (45 * 620,000 = 27,900,000 <= 28,000,000).
    /// Both inequalities hold, yet the redemption needs about 28,120,000 gas.
    function testRedeemFitsBudget_Default250_PayGas500k_Direct45() public {
        vm.warp(1_800_000_000);
        vault = new BaskVault(owner, guardian);
        _trySetting(T.Setting.DirectLimit, 0);
        _trySetting(T.Setting.PayGas, 500_000);
        _trySetting(T.Setting.DirectLimit, 45);
        _build();
        (bool ok,) = _redeemFitsBudget();
        assertTrue(ok, "redeem must fit in 28,000,000 gas under accepted settings");
    }

    /// balanceGas 20,000 and maxAssets 350 (350 * 80,000 = 28,000,000);
    /// payGas 500,000 and directLimit 47 (47 * 590,000 = 27,730,000). Needs about 28,440,000 gas.
    function testRedeemFitsBudget_Max350_PayGas500k_Direct47() public {
        vm.warp(1_800_000_000);
        vault = new BaskVault(owner, guardian);
        _trySetting(T.Setting.DirectLimit, 0);
        _trySetting(T.Setting.BalanceGas, 20_000);
        _trySetting(T.Setting.MaxAssets, 350);
        _trySetting(T.Setting.PayGas, 500_000);
        _trySetting(T.Setting.DirectLimit, 47);
        _build();
        (bool ok,) = _redeemFitsBudget();
        assertTrue(ok, "redeem must fit in 28,000,000 gas under accepted settings");
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {BaskVault} from "src/BaskVault.sol";
import {BaskTypes as T} from "src/BaskTypes.sol";

contract PlainToken {
    uint8 public immutable decimals;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint8 d) {
        decimals = d;
    }

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function approve(address to, uint256 amount) external returns (bool) {
        allowance[msg.sender][to] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract PlainFeed {
    uint8 public immutable decimals;
    int256 public answer;
    uint256 public updatedAt;

    constructor(uint8 d, int256 a) {
        decimals = d;
        answer = a;
        updatedAt = block.timestamp;
    }

    function set(int256 a, uint256 t) external {
        answer = a;
        updatedAt = t;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// After any deposit into an asset, `managed[token]` can never return to zero through
/// redemptions: every leg is floor(managed * net / supplyBefore) with net < supplyBefore
/// (1e15 dead shares never redeem), so at least 1 raw unit always remains. `removeRetired`
/// requires managed == 0, so a retired asset that was ever held can never be removed or
/// re-listed, and it keeps costing a full balance read + storage writes in every redeem.
contract RemoveRetiredProofTest is Test {
    BaskVault private vault;
    PlainToken[] private tokens;
    PlainFeed[] private feeds;
    address private owner = makeAddr("owner");
    address private guardian = makeAddr("guardian");
    address private alice = makeAddr("alice");

    function setUp() public {
        vm.warp(1_800_000_000);
        vault = new BaskVault(owner, guardian);
        for (uint256 i; i < 3; ++i) {
            PlainToken t = new PlainToken(18);
            PlainFeed f = new PlainFeed(8, 100e8);
            tokens.push(t);
            feeds.push(f);
            vm.prank(owner);
            vault.genesisList(address(t), address(f), address(0), address(0), 0);
            t.mint(alice, 1_000e18);
            vm.prank(alice);
            t.approve(address(vault), type(uint256).max);
        }
        vm.prank(owner);
        vault.finalizeGenesis();
    }

    function _one(address token) private pure returns (address[] memory a) {
        a = new address[](1);
        a[0] = token;
    }

    function _amount(uint256 x) private pure returns (uint256[] memory a) {
        a = new uint256[](1);
        a[0] = x;
    }

    function _execute(uint256 id) private {
        vm.warp(vault.proposal(id).readyAt);
        for (uint256 i; i < feeds.length; ++i) {
            feeds[i].set(100e8, block.timestamp);
        }
        vm.prank(owner);
        vault.execute(id);
    }

    function testRetiredAssetRemovableAfterHoldersRedeemEverything() public {
        address token = address(tokens[0]);
        // Alice is the only depositor; she deposits 10 tokens, then redeems every share she holds.
        vm.prank(alice);
        uint256 shares = vault.deposit(_one(token), _amount(10e18), alice, 0, block.timestamp);
        vm.prank(alice);
        vault.redeem(shares, alice, new uint256[](0), block.timestamp);
        assertEq(vault.balanceOf(alice), 0);
        assertEq(vault.totalSupply(), 1e15, "only the dead shares remain");

        // Retire the asset (closed at proposal and at execution).
        vm.prank(owner);
        vault.close(token);
        vm.prank(owner);
        uint256 id = vault.propose(T.Action.Retire, token, "");
        _execute(id);
        assertTrue(vault.asset(token).retired);
        assertEq(vault.totalOwed(token), 0);

        // The vault holds only the floor-rounding residue of alice's redemption (1e15/1e18 of 10 tokens).
        emit log_named_uint("managed residue after full redeem", vault.managed(token));

        // Expected per brief: "Anyone may remove a retired asset with managed and totalOwed 0".
        // Actual: managed is 1e13 (never 0 through redeems), so removeRetired reverts InvalidAsset
        // and the token can never be removed nor listed again.
        vault.removeRetired(token);
        assertEq(vault.assetCount(), 2);
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {BaskVault} from "src/BaskVault.sol";
import {BaskTypes as T} from "src/BaskTypes.sol";

/// @dev Minimal Stock Token mock. When `hostile` is set, every balanceOf and transfer burns all gas it is given,
/// which is what an upgraded or bricked token implementation can do.
contract ProofToken {
    uint8 public constant decimals = 18;
    bool public hostile;
    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        balances[to] += amount;
    }

    function setHostile(bool v) external {
        hostile = v;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function balanceOf(address who) external view returns (uint256) {
        if (hostile) {
            assembly ("memory-safe") { invalid() }
        }
        return balances[who];
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        if (hostile) {
            assembly ("memory-safe") { invalid() }
        }
        allowance[from][msg.sender] -= amount;
        balances[from] -= amount;
        balances[to] += amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        if (hostile) {
            assembly ("memory-safe") { invalid() }
        }
        balances[msg.sender] -= amount;
        balances[to] += amount;
        return true;
    }
}

contract ProofFeed {
    uint8 public constant decimals = 8;
    int256 public constant answer = 100e8;
    uint256 public updatedAt;

    function set(uint256 time) external {
        updatedAt = time;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// @notice Redemption must fit in 28,000,000 gas with maxAssets assets in any state.
/// With legal settings balanceGas = 50,000, payGas = 500,000, directLimit = 45 and maxAssets = 254
/// (45 * 620,000 = 27.9M <= 28M and 254 * 110,000 = 27.94M <= 28M), a basket of 45 gas-burning
/// upgraded holdings plus 209 idle listed assets needs about 28.14M gas, so redeem runs out of gas.
/// The test tolerates a fix that tightens the setting bounds: it builds the largest basket the vault
/// accepts and still requires redeem to succeed inside 28M gas.
contract RedeemGasBudgetProofTest is Test {
    BaskVault private vault;
    address private owner = makeAddr("owner");
    address private guardian = makeAddr("guardian");
    address private alice = makeAddr("alice");
    address private receiver = makeAddr("receiver");
    address[] private tokens;
    address[] private feeds;

    /// @dev Applies a setting if the vault accepts it; returns whether it did.
    function _trySetting(T.Setting key, uint256 value) private returns (bool) {
        vm.prank(owner);
        try vault.propose(T.Action.Setting, address(0), abi.encode(key, value)) returns (uint256 id) {
            vm.warp(block.timestamp + 2 days);
            vm.prank(owner);
            try vault.execute(id) {
                return true;
            } catch {}
        } catch {}
        return false;
    }

    /// @dev Largest value at most `from` the vault accepts for the setting.
    function _largest(T.Setting key, uint256 from, uint256 floor) private {
        for (uint256 v = from; v > floor; --v) {
            if (_trySetting(key, v)) return;
        }
    }

    function testRedeemFitsIn28MGasWithMaxAssetsAndMaxDirectLimit() public {
        vm.warp(1_800_000_000);
        vault = new BaskVault(owner, guardian);
        _trySetting(T.Setting.MaxAssets, 3);
        _trySetting(T.Setting.DirectLimit, 0);
        _trySetting(T.Setting.PayGas, 500_000);
        _largest(T.Setting.MaxAssets, 254, 3);
        _largest(T.Setting.DirectLimit, 45, 0);
        T.Settings memory s = vault.settings();
        uint256 count = s.maxAssets;
        uint256 active = s.directLimit == 0 ? 1 : s.directLimit;
        if (active > count) active = count;

        bytes memory tokenCode = address(new ProofToken()).code;
        bytes memory feedCode = address(new ProofFeed()).code;
        address[] memory deposited = new address[](active);
        uint256[] memory amounts = new uint256[](active);
        for (uint256 i; i < count; ++i) {
            address token = address(uint160(0x100000 + i));
            address feed = address(uint160(0x200000 + i));
            vm.etch(token, tokenCode);
            vm.etch(feed, feedCode);
            ProofFeed(feed).set(block.timestamp);
            tokens.push(token);
            feeds.push(feed);
            vm.prank(owner);
            vault.genesisList(token, feed, address(0), address(0), 0);
            if (i < active) {
                ProofToken(token).mint(alice, 1e18);
                vm.prank(alice);
                ProofToken(token).approve(address(vault), type(uint256).max);
                deposited[i] = token;
                amounts[i] = 1e18;
            }
        }
        vm.prank(owner);
        vault.finalizeGenesis();
        vm.prank(alice);
        uint256 shares = vault.deposit(deposited, amounts, alice, 0, block.timestamp);

        // Every Stock Token is upgraded to an implementation that burns all gas on reads and transfers.
        for (uint256 i; i < count; ++i) {
            ProofToken(tokens[i]).setHostile(true);
            vm.cool(tokens[i]);
            vm.cool(feeds[i]);
        }
        vm.cool(address(vault));

        bytes memory input = abi.encodeCall(vault.redeem, (shares / 2, receiver, new uint256[](0), block.timestamp));
        vm.prank(alice);
        uint256 start = gasleft();
        (bool ok, bytes memory data) = address(vault).call{gas: 28_000_000}(input);
        uint256 used = start - gasleft();
        emit log_named_uint("assets", count);
        emit log_named_uint("direct holdings", active);
        emit log_named_uint("redeem gas used", used);
        assertTrue(ok, "redeem must succeed within 28,000,000 gas with maxAssets assets in any state");
        uint256[] memory legs = abi.decode(data, (uint256[]));
        assertEq(legs.length, count);
        assertGt(vault.owed(receiver, tokens[0]), 0);
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {BaskVault} from "src/BaskVault.sol";
import {BaskTypes as T} from "src/BaskTypes.sol";

/// @dev Hostile "upgraded" Stock Token: once hostile, balanceOf and transfer consume all gas given to them.
contract BurnToken {
    uint8 public constant decimals = 18;
    mapping(address => uint256) internal balances;
    mapping(address => mapping(address => uint256)) public allowance;
    bool public hostile;

    function mint(address to, uint256 amount) external {
        balances[to] += amount;
    }

    function setHostile(bool v) external {
        hostile = v;
    }

    function approve(address to, uint256 amount) external returns (bool) {
        allowance[msg.sender][to] = amount;
        return true;
    }

    function balanceOf(address who) external view returns (uint256) {
        if (hostile) {
            assembly ("memory-safe") { invalid() }
        }
        return balances[who];
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(allowance[from][msg.sender] >= amount, "allowance");
        balances[from] -= amount;
        balances[to] += amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        if (hostile) {
            assembly ("memory-safe") { invalid() }
        }
        balances[msg.sender] -= amount;
        balances[to] += amount;
        return true;
    }
}

contract SimpleFeed {
    uint8 public constant decimals = 8;
    int256 public answer;
    uint256 public updatedAt;

    function set(uint256 time) external {
        answer = 100e8;
        updatedAt = time;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// @title Redeem must stay under 28,000,000 gas with maxAssets assets in any state.
/// The vault validates `maxAssets * (balanceGas + 60k) <= 28M` and `directLimit * (balanceGas + payGas + 70k) <= 28M`
/// separately. Both hold for balanceGas 20k, maxAssets 350, directLimit 47, payGas 500k, but a redeem over 350 listed
/// assets with 47 hostile direct legs needs about 28.45M gas and runs out of gas at the 28M budget.
/// The test asks the vault which settings it accepts (so it also passes once the bound or the overhead is fixed),
/// then builds the worst case those settings allow.
contract RedeemGasJointTest is Test {
    BaskVault private vault;
    address private owner = makeAddr("owner");
    address private guardian = makeAddr("guardian");
    address private alice = makeAddr("alice");
    address private receiver = makeAddr("receiver");
    address[] private tokens;
    uint256 private shares;

    function _trySetting(T.Setting key, uint256 value) private returns (bool) {
        vm.prank(owner);
        try vault.propose(T.Action.Setting, address(0), abi.encode(key, value)) returns (uint256 id) {
            vm.warp(vault.proposal(id).readyAt);
            vm.prank(owner);
            try vault.execute(id) {
                return true;
            } catch {
                return false;
            }
        } catch {
            return false;
        }
    }

    function setUp() public {
        vm.warp(1_800_000_000);
        vault = new BaskVault(owner, guardian);
        _trySetting(T.Setting.BalanceGas, 20_000);
        _trySetting(T.Setting.MaxAssets, 350);
        _trySetting(T.Setting.DirectLimit, 47);
        _trySetting(T.Setting.PayGas, 500_000);
        T.Settings memory s = vault.settings();
        // The vault's own validation accepted everything above on the current code.
        assertLe(s.maxAssets * (s.balanceGas + 60_000), 28_000_000);
        assertLe(s.directLimit * (s.balanceGas + s.payGas + 70_000), 28_000_000);

        uint256 count = s.maxAssets;
        uint256 active = s.directLimit < count ? s.directLimit : count;
        bytes memory tokenCode = address(new BurnToken()).code;
        bytes memory feedCode = address(new SimpleFeed()).code;
        address[] memory deposited = new address[](active);
        uint256[] memory amounts = new uint256[](active);
        for (uint256 i; i < count; ++i) {
            address token = address(uint160(0x300000 + i));
            address feed = address(uint160(0x400000 + i));
            vm.etch(token, tokenCode);
            vm.etch(feed, feedCode);
            SimpleFeed(feed).set(vm.getBlockTimestamp());
            tokens.push(token);
            vm.prank(owner);
            vault.genesisList(token, feed, address(0), address(0), 0);
            if (i < active) {
                BurnToken(token).mint(alice, 1e18);
                vm.prank(alice);
                BurnToken(token).approve(address(vault), type(uint256).max);
                deposited[i] = token;
                amounts[i] = 1e18;
            }
        }
        vm.prank(owner);
        vault.finalizeGenesis();
        vm.prank(alice);
        shares = vault.deposit(deposited, amounts, alice, 0, vm.getBlockTimestamp());
        // The held Stock Tokens are then upgraded to hostile code: reads and transfers burn all gas.
        for (uint256 i; i < active; ++i) {
            BurnToken(tokens[i]).setHostile(true);
        }
    }

    function testRedeemFitsIn28MillionGasAtAcceptedSettings() public {
        for (uint256 i; i < tokens.length; ++i) {
            vm.cool(tokens[i]);
        }
        vm.cool(address(vault));
        bytes memory input =
            abi.encodeCall(vault.redeem, (shares / 2, receiver, new uint256[](0), vm.getBlockTimestamp()));
        vm.prank(alice);
        uint256 start = gasleft();
        (bool ok, bytes memory data) = address(vault).call{gas: 28_000_000}(input);
        uint256 used = start - gasleft();
        emit log_named_uint("redeem gas used under a 28,000,000 budget", used);
        assertTrue(ok, "redeem must succeed within 28,000,000 gas at settings the vault accepts");
        uint256[] memory legs = abi.decode(data, (uint256[]));
        assertEq(legs.length, tokens.length);
        assertEq(vault.balanceOf(alice), shares - shares / 2);
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {BaskVault} from "src/BaskVault.sol";
import {BaskTypes as T} from "src/BaskTypes.sol";

/// @dev Stock Token whose upgraded code burns all the gas it is given in balanceOf and transfer.
contract HostileToken {
    uint8 public constant decimals = 18;
    mapping(address => uint256) internal balances;
    mapping(address => mapping(address => uint256)) public allowance;
    bool public hostile;

    function mint(address to, uint256 amount) external {
        balances[to] += amount;
    }

    function setHostile(bool v) external {
        hostile = v;
    }

    function approve(address to, uint256 amount) external returns (bool) {
        allowance[msg.sender][to] = amount;
        return true;
    }

    function balanceOf(address who) external view returns (uint256) {
        if (hostile) {
            assembly ("memory-safe") { invalid() }
        }
        return balances[who];
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(allowance[from][msg.sender] >= amount, "allowance");
        balances[from] -= amount;
        balances[to] += amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        if (hostile) {
            assembly ("memory-safe") { invalid() }
        }
        balances[msg.sender] -= amount;
        balances[to] += amount;
        return true;
    }
}

contract SimpleFeed {
    uint8 public constant decimals = 8;
    uint256 public updatedAt;

    function set(uint256 time) external {
        updatedAt = time;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, 100e8, updatedAt, updatedAt, 1);
    }
}

/// @title Redeem must stay under 28,000,000 gas with maxAssets assets in any state, at every setting the vault accepts.
/// The vault checks `maxAssets * (balanceGas + 60k) <= 28M` and `directLimit * (balanceGas + payGas + 70k) <= 28M`
/// separately, but one redeem pays both: directLimit hostile direct legs plus the loop cost of every other listed asset.
/// Each test asks the vault which settings it accepts (so a fix that tightens the bound or cuts redeem's overhead both
/// make it pass), then builds the worst case those settings allow and requires redeem to succeed inside 28M gas.
contract RedeemGasBoundTest is Test {
    BaskVault private vault;
    address private owner = makeAddr("owner");
    address private guardian = makeAddr("guardian");
    address private alice = makeAddr("alice");
    address private receiver = makeAddr("receiver");
    address[] private tokens;
    address[] private feeds;
    uint256 private shares;

    function _trySetting(T.Setting key, uint256 value) private returns (bool) {
        vm.prank(owner);
        try vault.propose(T.Action.Setting, address(0), abi.encode(key, value)) returns (uint256 id) {
            vm.warp(vault.proposal(id).readyAt);
            vm.prank(owner);
            try vault.execute(id) {
                return true;
            } catch {}
        } catch {}
        return false;
    }

    function _build() private {
        T.Settings memory s = vault.settings();
        assertLe(s.maxAssets * (s.balanceGas + 60_000), 28_000_000);
        assertLe(s.directLimit * (s.balanceGas + s.payGas + 70_000), 28_000_000);
        uint256 count = s.maxAssets;
        uint256 active = s.directLimit < count ? s.directLimit : count;
        if (active == 0) active = 1;
        bytes memory tokenCode = address(new HostileToken()).code;
        bytes memory feedCode = address(new SimpleFeed()).code;
        address[] memory deposited = new address[](active);
        uint256[] memory amounts = new uint256[](active);
        for (uint256 i; i < count; ++i) {
            address token = address(uint160(0x100000 + i));
            address feed = address(uint160(0x200000 + i));
            vm.etch(token, tokenCode);
            vm.etch(feed, feedCode);
            SimpleFeed(feed).set(vm.getBlockTimestamp());
            tokens.push(token);
            feeds.push(feed);
            vm.prank(owner);
            vault.genesisList(token, feed, address(0), address(0), 0);
            if (i < active) {
                HostileToken(token).mint(alice, 1e18);
                vm.prank(alice);
                HostileToken(token).approve(address(vault), type(uint256).max);
                deposited[i] = token;
                amounts[i] = 1e18;
            }
        }
        vm.prank(owner);
        vault.finalizeGenesis();
        vm.prank(alice);
        shares = vault.deposit(deposited, amounts, alice, 0, vm.getBlockTimestamp());
        // The held Stock Tokens are upgraded to code that burns every unit of gas on reads and transfers.
        for (uint256 i; i < count; ++i) {
            HostileToken(tokens[i]).setHostile(true);
        }
    }

    function _redeemWithin28M() private {
        for (uint256 i; i < tokens.length; ++i) {
            vm.cool(tokens[i]);
            vm.cool(feeds[i]);
        }
        vm.cool(address(vault));
        bytes memory input =
            abi.encodeCall(vault.redeem, (shares / 2, receiver, new uint256[](0), vm.getBlockTimestamp()));
        vm.prank(alice);
        uint256 start = gasleft();
        (bool ok, bytes memory data) = address(vault).call{gas: 28_000_000}(input);
        uint256 used = start - gasleft();
        emit log_named_uint("maxAssets", vault.settings().maxAssets);
        emit log_named_uint("directLimit", vault.settings().directLimit);
        emit log_named_uint("balanceGas", vault.settings().balanceGas);
        emit log_named_uint("payGas", vault.settings().payGas);
        emit log_named_uint("redeem gas used under a 28,000,000 budget", used);
        assertTrue(ok, "redeem must succeed within 28,000,000 gas at settings the vault accepts");
        uint256[] memory legs = abi.decode(data, (uint256[]));
        assertEq(legs.length, tokens.length);
        assertEq(vault.balanceOf(alice), shares - shares / 2);
        assertGt(vault.owed(receiver, tokens[0]), 0, "hostile legs are owed, not lost");
    }

    /// balanceGas 20,000, maxAssets 350 (350 * 80,000 = 28,000,000), payGas 500,000, directLimit 47
    /// (47 * 590,000 = 27,730,000): both inequalities hold, redeem needs about 28.44M gas.
    function testRedeemFitsIn28M_350Assets_47Direct_PayGas500k() public {
        vm.warp(1_800_000_000);
        vault = new BaskVault(owner, guardian);
        _trySetting(T.Setting.DirectLimit, 0);
        _trySetting(T.Setting.BalanceGas, 20_000);
        _trySetting(T.Setting.MaxAssets, 350);
        _trySetting(T.Setting.PayGas, 500_000);
        _trySetting(T.Setting.DirectLimit, 47);
        _build();
        _redeemWithin28M();
    }

    /// Default balanceGas 50,000 and maxAssets 254 (254 * 110,000 = 27,940,000), payGas 500,000, directLimit 45
    /// (45 * 620,000 = 27,900,000): both inequalities hold, redeem needs about 28.14M gas.
    function testRedeemFitsIn28M_254Assets_45Direct_PayGas500k() public {
        vm.warp(1_800_000_000);
        vault = new BaskVault(owner, guardian);
        _trySetting(T.Setting.DirectLimit, 0);
        _trySetting(T.Setting.PayGas, 500_000);
        _trySetting(T.Setting.MaxAssets, 254);
        _trySetting(T.Setting.DirectLimit, 45);
        _build();
        _redeemWithin28M();
    }
}