// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Strike} from "src/Strike.sol";

contract ScratchIMD is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}
}

/// @dev Stands in for the Uniswap v4 PoolManager's permissionless `take(currency, to, amount)` and
/// `sync/settle` surface: any unlocker can make the manager transfer a currency it holds to any
/// address, and can credit itself for tokens that arrive at the manager. No admin, no owner.
contract PassThroughManager {
    function take(IERC20 token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev A minimal constant-product-free "pair" that just forwards what it is asked to, so the test
/// only measures Strike's tax decision, not AMM math. It plays the role of `market`.
contract ExemptPassThroughTest is Test {
    Strike internal token;
    ScratchIMD internal imd;
    PassThroughManager internal manager;
    address internal market;
    address internal trader = address(0x7A4D);

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new ScratchIMD();
        manager = new PassThroughManager();
        token = new Strike(
            address(this),
            address(manager),
            7,
            address(imd),
            address(0xFAC7),
            keccak256("init-code"),
            address(0x51),
            1 ether,
            1 ether
        );
        market = token.market();
        // Give the market (V2 pair) and the trader inventory. Factory sends are exempt by design.
        token.transfer(market, 1_000_000 ether);
        token.transfer(trader, 1_000_000 ether);
        token.transfer(address(manager), 1_000_000 ether);
    }

    /// Baseline: an ordinary sell into the market pays dues. This passes before and after a fix.
    function test_ordinarySellIntoMarketPaysDues() public {
        vm.prank(trader);
        token.transfer(market, 10_000 ether);
        assertEq(token.pendingFund(), 100 ether, "1% to fund");
        assertEq(token.pendingImdBurn(), 50 ether, "0.5% to IMD burn");
    }

    /// A trader who holds STRIKE credit inside the PoolManager (bought on the required v4 pool, or
    /// settled there) calls `take(STRIKE, market, amount)` during unlock. The transfer is
    /// poolManager -> market, which `_exempt` waves through, so the sell into the taxed market
    /// pays nothing. Expected: a sell into `market` by anyone who is not the token itself pays dues.
    function test_sellIntoMarketViaPoolManagerTakeIsTaxed() public {
        uint256 marketBefore = token.balanceOf(market);
        uint256 supplyBefore = token.totalSupply();
        vm.prank(trader);
        manager.take(IERC20(address(token)), market, 10_000 ether);
        assertEq(token.pendingFund(), 100 ether, "sell routed through poolManager escaped the 1% fund dues");
        assertEq(token.pendingImdBurn(), 50 ether, "sell routed through poolManager escaped the 0.5% IMD burn dues");
        assertEq(supplyBefore - token.totalSupply(), 50 ether, "no STRIKE was burned on the sell");
        assertEq(token.balanceOf(market) - marketBefore, 9_800 ether, "market received the untaxed gross amount");
    }

    /// The mirror image: the market pays STRIKE out to the PoolManager (pair.swap(..., to=manager)
    /// inside a sync/settle), which `_exempt` also waves through. Expected: a buy from `market`
    /// delivered to anyone who is not the token itself pays dues.
    function test_buyFromMarketDeliveredToPoolManagerIsTaxed() public {
        vm.prank(market);
        token.transfer(address(manager), 10_000 ether);
        assertEq(token.pendingFund(), 100 ether, "buy delivered to poolManager escaped the 1% fund dues");
        assertEq(token.pendingImdBurn(), 50 ether, "buy delivered to poolManager escaped the 0.5% IMD burn dues");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Strike} from "src/Strike.sol";
import {V2TwapSwap} from "src/V2TwapSwap.sol";

/// @dev Plain IMD stand-in.
contract ProofIMD is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}

    function mint(address who, uint256 amount) external {
        _mint(who, amount);
    }
}

/// @dev A Uniswap V2 pair reduced to the parts the adapter touches, with the checks the genuine
/// UniswapV2Pair.swap performs. The one that matters here is
///   require(to != token0 && to != token1, 'UniswapV2: INVALID_TO');
/// which every V2 core pair (Uniswap, Sushi, Pancake, ...) enforces and which the repository's
/// test/PairModel.sol omits.
contract GenuineV2Pair {
    address public factory;
    address public token0;
    address public token1;
    uint112 private reserve0;
    uint112 private reserve1;
    uint32 private blockTimestampLast;
    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;
    uint256 private unlocked = 1;

    modifier lock() {
        require(unlocked == 1, "UniswapV2: LOCKED");
        unlocked = 0;
        _;
        unlocked = 1;
    }

    constructor() {
        factory = msg.sender;
    }

    function initialize(address _token0, address _token1) external {
        require(msg.sender == factory, "UniswapV2: FORBIDDEN");
        token0 = _token0;
        token1 = _token1;
    }

    function getReserves() public view returns (uint112, uint112, uint32) {
        return (reserve0, reserve1, blockTimestampLast);
    }

    function _update(uint256 balance0, uint256 balance1, uint112 _reserve0, uint112 _reserve1) private {
        require(balance0 <= type(uint112).max && balance1 <= type(uint112).max, "UniswapV2: OVERFLOW");
        uint32 blockTimestamp = uint32(block.timestamp % 2 ** 32);
        unchecked {
            uint32 timeElapsed = blockTimestamp - blockTimestampLast;
            if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
                price0CumulativeLast += ((uint256(_reserve1) << 112) / _reserve0) * timeElapsed;
                price1CumulativeLast += ((uint256(_reserve0) << 112) / _reserve1) * timeElapsed;
            }
        }
        reserve0 = uint112(balance0);
        reserve1 = uint112(balance1);
        blockTimestampLast = blockTimestamp;
    }

    function sync() external lock {
        _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
    }

    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata) external lock {
        require(amount0Out > 0 || amount1Out > 0, "UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT");
        (uint112 _reserve0, uint112 _reserve1,) = getReserves();
        require(amount0Out < _reserve0 && amount1Out < _reserve1, "UniswapV2: INSUFFICIENT_LIQUIDITY");
        address _token0 = token0;
        address _token1 = token1;
        require(to != _token0 && to != _token1, "UniswapV2: INVALID_TO");
        if (amount0Out > 0) IERC20(_token0).transfer(to, amount0Out);
        if (amount1Out > 0) IERC20(_token1).transfer(to, amount1Out);
        uint256 balance0 = IERC20(_token0).balanceOf(address(this));
        uint256 balance1 = IERC20(_token1).balanceOf(address(this));
        uint256 amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
        uint256 amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
        require(amount0In > 0 || amount1In > 0, "UniswapV2: INSUFFICIENT_INPUT_AMOUNT");
        uint256 balance0Adjusted = balance0 * 1000 - amount0In * 3;
        uint256 balance1Adjusted = balance1 * 1000 - amount1In * 3;
        require(balance0Adjusted * balance1Adjusted >= uint256(_reserve0) * _reserve1 * 1000 ** 2, "UniswapV2: K");
        _update(balance0, balance1, _reserve0, _reserve1);
    }
}

contract GenuineV2Factory {
    mapping(address => mapping(address => address)) public getPair;

    function createPair(address tokenA, address tokenB) external returns (address pair) {
        require(tokenA != tokenB, "UniswapV2: IDENTICAL_ADDRESSES");
        (address t0, address t1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(t0 != address(0), "UniswapV2: ZERO_ADDRESS");
        require(getPair[t0][t1] == address(0), "UniswapV2: PAIR_EXISTS");
        bytes memory bytecode = type(GenuineV2Pair).creationCode;
        bytes32 salt = keccak256(abi.encodePacked(t0, t1));
        assembly ("memory-safe") {
            pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
        }
        GenuineV2Pair(pair).initialize(t0, t1);
        getPair[t0][t1] = pair;
        getPair[t1][t0] = pair;
    }
}

/// @notice Fails on the current code: Strike._swap names the token itself as the pair's swap
/// recipient, which a genuine V2 pair rejects with INVALID_TO. Passes once treasury swaps deliver
/// to an address that is not one of the pair's tokens.
contract InvalidToProofTest is Test {
    Strike internal token;
    ProofIMD internal imd;
    V2TwapSwap internal adapter;
    GenuineV2Pair internal pair;
    GenuineV2Factory internal factory;
    address internal alice = address(0xA11CE);
    uint256 internal signerKey = 0x1234;

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new ProofIMD();
        factory = new GenuineV2Factory();
        token = new Strike(
            address(this),
            address(0x4444),
            1,
            address(imd),
            address(factory),
            keccak256(type(GenuineV2Pair).creationCode),
            vm.addr(signerKey),
            1 ether,
            1 ether
        );
        adapter = V2TwapSwap(address(token.swapAdapter()));
        adapter.prepareMarket();
        pair = GenuineV2Pair(token.market());
        token.transfer(address(pair), 10_000_000 ether);
        imd.mint(address(pair), 10_000_000 ether);
        pair.sync();
        token.transfer(alice, 1_000_000 ether);
        imd.mint(alice, 1_000_000 ether);
        adapter.updateOracle();
        vm.warp(vm.getBlockTimestamp() + 30 minutes);
        adapter.updateOracle();
    }

    function test_processFeesConvertsDuesOnAGenuineV2Pair() public {
        // A user trade against the genuine pair works: the recipient is an ordinary wallet.
        vm.startPrank(alice);
        token.approve(address(adapter), 1000 ether);
        adapter.swap(address(token), 1000 ether, 970 ether, alice);
        vm.stopPrank();
        assertEq(token.pendingFund(), 10 ether, "dues were not collected");
        assertEq(token.pendingImdBurn(), 5 ether, "dues were not collected");

        // The treasury conversion must also work. On the current code it reverts with
        // 'UniswapV2: INVALID_TO' because the pair is asked to pay the Strike token contract.
        token.processFees(type(uint256).max, type(uint256).max);
        assertEq(token.pendingFund(), 0, "fund dues were not converted");
        assertEq(token.pendingImdBurn(), 0, "burn dues were not converted");
        assertGt(token.fund(), 0, "the Strike Fund never received IMD");
        assertGt(imd.balanceOf(token.DEAD()), 0, "no IMD was burned");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Strike} from "src/Strike.sol";

contract PlainToken is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}
}

/// @dev Models the two PoolManager primitives any unlocker may call: `take(currency, to, amount)`
/// (the manager transfers tokens it holds to any `to`, msg.sender == manager) and the sync/settle
/// path (the unlocker transfers tokens *to* the manager). Debt bookkeeping is omitted: the attacker
/// settles honestly, the point is only who `msg.sender`/`to` is on each ERC-20 transfer.
contract PoolManagerModel {
    function take(address currency, address to, uint256 amount) external {
        IERC20(currency).transfer(to, amount);
    }
}

contract PoolManagerRoutedDuesTest is Test {
    Strike internal token;
    PlainToken internal imd;
    PoolManagerModel internal manager;
    address internal market;
    address internal attacker = address(0xA77);

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new PlainToken();
        manager = new PoolManagerModel();
        token = new Strike(
            address(this), address(manager), 1, address(imd), address(0xFAC), keccak256("init"), address(0x51), 1, 1
        );
        market = token.market();
        token.transfer(attacker, 2_000 ether);
        token.transfer(market, 1_000_000 ether);
    }

    /// A direct sell into the V2 market pays dues; the same sell routed through the PoolManager does not.
    function test_sellIntoV2MarketThroughPoolManagerPaysNoDues() public {
        // Control: ordinary sell transfer to the market is taxed 2%.
        uint256 marketBefore = token.balanceOf(market);
        vm.prank(attacker);
        token.transfer(market, 1_000 ether);
        assertEq(token.balanceOf(market) - marketBefore, 980 ether, "control sell should be taxed");
        assertEq(token.pendingFund(), 10 ether);
        assertEq(token.pendingImdBurn(), 5 ether);

        // Bypass: unlock -> take(STRIKE, v2pair, amount) -> pair.swap -> sync/settle the STRIKE debt.
        // Step 1 (settle): attacker's STRIKE goes to the PoolManager; to == poolManager is exempt.
        vm.prank(attacker);
        token.transfer(address(manager), 1_000 ether);
        assertEq(token.balanceOf(address(manager)), 1_000 ether, "settle transfer was taxed");
        // Step 2 (take): PoolManager delivers it to the V2 pair; msg.sender == poolManager is exempt.
        marketBefore = token.balanceOf(market);
        manager.take(address(token), market, 1_000 ether);
        assertEq(token.balanceOf(market) - marketBefore, 1_000 ether, "pair received the full amount");
        // Expected: the second sell pays the same dues as the first. Actual: nothing accrued.
        assertEq(token.pendingFund(), 20 ether, "second sell paid no fund dues");
        assertEq(token.pendingImdBurn(), 10 ether, "second sell paid no IMD-burn dues");
    }

    /// A buy from the V2 market delivered to the PoolManager (then taken by the attacker) also pays nothing.
    function test_buyFromV2MarketThroughPoolManagerPaysNoDues() public {
        // pair.swap(..., to = poolManager): from == market, to == poolManager -> exempt.
        vm.prank(market);
        token.transfer(address(manager), 1_000 ether);
        // take(STRIKE, attacker, amount): from == poolManager -> exempt.
        manager.take(address(token), attacker, 1_000 ether);
        assertEq(token.balanceOf(attacker), 3_000 ether, "attacker received the full untaxed buy");
        // Expected 2% dues on a market buy (10 fund + 5 burn); actual: zero.
        assertEq(token.pendingFund(), 10 ether, "buy paid no fund dues");
        assertEq(token.pendingImdBurn(), 5 ether, "buy paid no IMD-burn dues");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Strike} from "src/Strike.sol";
import {V2TwapSwap} from "src/V2TwapSwap.sol";

contract PlainToken is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Minimal Uniswap V2 pair: reserves, cumulative prices, 0.3% adjusted-K swap, plus a
/// liquidity-removal helper standing in for `burn()` (LP tokens omitted).
contract PairModel {
    address public token0;
    address public token1;
    address public immutable factory = msg.sender;
    uint112 private reserve0;
    uint112 private reserve1;
    uint32 private last;
    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;

    function initialize(address a, address b) external {
        require(msg.sender == factory && token0 == address(0), "initialize");
        (token0, token1) = a < b ? (a, b) : (b, a);
    }

    function getReserves() external view returns (uint112, uint112, uint32) {
        return (reserve0, reserve1, last);
    }

    function sync() external {
        _update();
    }

    /// Liquidity provider pulls reserves out (what `burn(to)` does for an LP holder).
    function removeLiquidity(address to, uint256 amount0, uint256 amount1) external {
        IERC20(token0).transfer(to, amount0);
        IERC20(token1).transfer(to, amount1);
        _update();
    }

    function _update() private {
        unchecked {
            uint32 elapsed = uint32(block.timestamp) - last;
            if (reserve0 != 0 && reserve1 != 0) {
                price0CumulativeLast += ((uint256(reserve1) << 112) / reserve0) * elapsed;
                price1CumulativeLast += ((uint256(reserve0) << 112) / reserve1) * elapsed;
            }
        }
        reserve0 = uint112(IERC20(token0).balanceOf(address(this)));
        reserve1 = uint112(IERC20(token1).balanceOf(address(this)));
        last = uint32(block.timestamp);
    }

    function swap(uint256 out0, uint256 out1, address to, bytes calldata) external {
        require((out0 > 0 || out1 > 0) && out0 < reserve0 && out1 < reserve1, "output");
        if (out0 != 0) IERC20(token0).transfer(to, out0);
        if (out1 != 0) IERC20(token1).transfer(to, out1);
        uint256 b0 = IERC20(token0).balanceOf(address(this));
        uint256 b1 = IERC20(token1).balanceOf(address(this));
        uint256 in0 = b0 > reserve0 - out0 ? b0 - (reserve0 - out0) : 0;
        uint256 in1 = b1 > reserve1 - out1 ? b1 - (reserve1 - out1) : 0;
        require(in0 > 0 || in1 > 0, "input");
        require((b0 * 1000 - in0 * 3) * (b1 * 1000 - in1 * 3) >= uint256(reserve0) * reserve1 * 1_000_000, "K");
        _update();
    }
}

contract FactoryModel {
    mapping(address => mapping(address => address)) public getPair;

    function createPair(address a, address b) external returns (address pair) {
        (address first, address second) = a < b ? (a, b) : (b, a);
        pair = address(new PairModel{salt: keccak256(abi.encodePacked(first, second))}());
        PairModel(pair).initialize(first, second);
        getPair[a][b] = pair;
        getPair[b][a] = pair;
    }
}

contract OvertimeSwapTooLargeTest is Test {
    Strike internal token;
    PlainToken internal imd;
    V2TwapSwap internal adapter;
    PairModel internal pair;
    uint256 internal signerKey = 0x5151;
    address internal lp = address(0x1b);
    address internal trader = address(0x7a);

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new PlainToken();
        FactoryModel factory = new FactoryModel();
        token = new Strike(
            address(this),
            address(0x4444),
            1,
            address(imd),
            address(factory),
            keccak256(type(PairModel).creationCode),
            vm.addr(signerKey),
            1 ether, // jobsRate: 1 IMD per accepted job
            100 ether // fallbackDaily: 100 IMD minimum
        );
        adapter = V2TwapSwap(address(token.swapAdapter()));
        adapter.prepareMarket();
        pair = PairModel(token.market());
        // Deep market at 1 STRIKE = 1 IMD, then fees accumulate from ordinary selling.
        token.transfer(address(pair), 10_000_000 ether);
        imd.mint(address(pair), 10_000_000 ether);
        pair.sync();
        token.transfer(trader, 100_000 ether);
        _warm();
        vm.prank(trader);
        token.transfer(address(pair), 40_000 ether); // sell: 400 STRIKE fund dues, 200 burn dues
        token.processFees(type(uint256).max, type(uint256).max);
        assertGt(token.fund(), 395 ether);
        assertLt(token.fund(), 400 ether);
    }

    function _warm() private {
        vm.warp(vm.getBlockTimestamp() + 30 minutes);
        adapter.updateOracle();
        vm.warp(vm.getBlockTimestamp() + 30 minutes);
        adapter.updateOracle();
        assertTrue(adapter.ready());
    }

    /// Liquidity providers (not the protocol) take their V2 liquidity out, leaving 100/100. The free
    /// fund (~400 IMD) is now 4x the pair's IMD reserve, so the fixed 1%/2% spends can no longer clear
    /// the 97%-of-TWAP floor and every swap-backed overtime or bargain reverts.
    function _thinOutMarket() private {
        uint256 b0 = IERC20(pair.token0()).balanceOf(address(pair));
        uint256 b1 = IERC20(pair.token1()).balanceOf(address(pair));
        pair.removeLiquidity(lp, b0 - 100 ether, b1 - 100 ether);
        _warm();
        (uint112 r0, uint112 r1,) = pair.getReserves();
        assertLe(uint256(r0), 100 ether);
        assertLe(uint256(r1), 100 ether);
        assertGt(token.fund(), 390 ether);
    }

    function test_signedOvertimeCannotExecuteWhenFundExceedsMarketDepth() public {
        _thinOutMarket();
        uint256 now_ = vm.getBlockTimestamp();
        uint256 day = now_ / 1 days;
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerKey, token.answerDigest(1000, now_, day));
        // Expected: the day's signed answer is processed (possibly with a bounded or deferred burn).
        // Actual: SwapFailed, because spend/2 = ~4 IMD against a 100 IMD reserve returns < 97% of TWAP.
        token.submitOvertime(1000, now_, day, abi.encodePacked(r, s, v));
        assertTrue(token.usedDay(day));
    }

    function test_fallbackOvertimeCannotExecuteWhenFundExceedsMarketDepth() public {
        _thinOutMarket();
        vm.warp(vm.getBlockTimestamp() + 2 days);
        _warm();
        token.fallbackOvertime();
    }

    function test_defaultBargainCannotExecuteWhenFundExceedsMarketDepth() public {
        _thinOutMarket();
        vm.warp(token.genesis() + 7 days + 1 hours);
        _warm();
        // Week 0 had no voters; the tie resolves to A (buy and burn STRIKE), which reverts.
        token.executeBargain(0);
        (, bool executed) = token.ballot(0);
        assertTrue(executed);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Strike} from "src/Strike.sol";

contract PlainToken is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}
}

contract FallbackCrowdsOutSignerTest is Test {
    Strike internal token;
    uint256 internal signerKey = 0x5151;
    address internal bot = address(0xB07);

    function setUp() public {
        vm.warp(1_700_000_000);
        PlainToken imd = new PlainToken();
        token = new Strike(
            address(this), address(0x4444), 1, address(imd), address(0xFAC), keccak256("init"), vm.addr(signerKey), 1, 1
        );
    }

    function _signed(uint256 jobs) private returns (bool ok) {
        uint256 now_ = vm.getBlockTimestamp();
        uint256 day = now_ / 1 days;
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerKey, token.answerDigest(jobs, now_, day));
        (ok,) = address(token).call(
            abi.encodeCall(Strike.submitOvertime, (jobs, now_, day, abi.encodePacked(r, s, v)))
        );
    }

    /// The oracle is silent for 48h once (e.g. at launch). From then on an unprivileged bot that calls
    /// fallbackOvertime() at the first permitted second of every day consumes `usedDay`, so the signer's
    /// answer for that day is rejected and `lastAnswerAt` never advances: the signed path is dead forever.
    function test_signedAnswerIsRejectedAfterDailyFallbackEvenThoughSignerIsLive() public {
        // 48h of silence makes the first fallback legitimate.
        vm.warp(vm.getBlockTimestamp() + 2 days + 1);
        vm.prank(bot);
        token.fallbackOvertime();

        // Next day: the bot repeats at the earliest cadence boundary, then the signer's answer arrives.
        vm.warp(vm.getBlockTimestamp() + 1 days);
        vm.prank(bot);
        (bool botOk,) = address(token).call(abi.encodeCall(Strike.fallbackOvertime, ()));
        botOk;
        // Expected: a live signer's fresh, correctly signed answer for today is accepted.
        // Actual: InvalidAnswer, usedDay[day] was taken by the fallback; lastAnswerAt is still genesis.
        assertTrue(_signed(1000), "signed answer rejected");
        assertEq(token.lastAnswerAt(), vm.getBlockTimestamp(), "signed liveness not recorded");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Strike} from "src/Strike.sol";
import {V2TwapSwap} from "src/V2TwapSwap.sol";

contract InvalidToIMD is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}

    function mint(address who, uint256 amount) external {
        _mint(who, amount);
    }
}

/// @dev Constant-product pair model that keeps the canonical UniswapV2Pair.swap guard the project's
/// test/PairModel.sol omits:
///     require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
/// Everything else (0.3% adjusted-K check, cumulative prices, reserves) matches the project's model.
contract InvalidToPair {
    address public token0;
    address public token1;
    address public immutable factory = msg.sender;
    uint112 private reserve0;
    uint112 private reserve1;
    uint32 private last;
    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;

    function initialize(address a, address b) external {
        require(msg.sender == factory && token0 == address(0), "initialize");
        (token0, token1) = a < b ? (a, b) : (b, a);
    }

    function getReserves() external view returns (uint112, uint112, uint32) {
        return (reserve0, reserve1, last);
    }

    function sync() external {
        _update();
    }

    function _update() private {
        unchecked {
            uint32 elapsed = uint32(block.timestamp) - last;
            if (elapsed > 0 && reserve0 != 0 && reserve1 != 0) {
                price0CumulativeLast += ((uint256(reserve1) << 112) / reserve0) * elapsed;
                price1CumulativeLast += ((uint256(reserve0) << 112) / reserve1) * elapsed;
            }
        }
        uint256 b0 = IERC20(token0).balanceOf(address(this));
        uint256 b1 = IERC20(token1).balanceOf(address(this));
        require(b0 <= type(uint112).max && b1 <= type(uint112).max, "UniswapV2: OVERFLOW");
        reserve0 = uint112(b0);
        reserve1 = uint112(b1);
        last = uint32(block.timestamp);
    }

    function swap(uint256 out0, uint256 out1, address to, bytes calldata) external {
        require(out0 > 0 || out1 > 0, "UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT");
        require(out0 < reserve0 && out1 < reserve1, "UniswapV2: INSUFFICIENT_LIQUIDITY");
        require(to != token0 && to != token1, "UniswapV2: INVALID_TO");
        if (out0 != 0) IERC20(token0).transfer(to, out0);
        if (out1 != 0) IERC20(token1).transfer(to, out1);
        uint256 b0 = IERC20(token0).balanceOf(address(this));
        uint256 b1 = IERC20(token1).balanceOf(address(this));
        uint256 in0 = b0 > reserve0 - out0 ? b0 - (reserve0 - out0) : 0;
        uint256 in1 = b1 > reserve1 - out1 ? b1 - (reserve1 - out1) : 0;
        require(in0 > 0 || in1 > 0, "UniswapV2: INSUFFICIENT_INPUT_AMOUNT");
        require((b0 * 1000 - in0 * 3) * (b1 * 1000 - in1 * 3) >= uint256(reserve0) * reserve1 * 1_000_000, "UniswapV2: K");
        _update();
    }
}

contract InvalidToFactory {
    mapping(address => mapping(address => address)) public getPair;

    function createPair(address a, address b) external returns (address pair) {
        require(a != b && a != address(0) && b != address(0) && getPair[a][b] == address(0), "pair");
        (address first, address second) = a < b ? (a, b) : (b, a);
        pair = address(new InvalidToPair{salt: keccak256(abi.encodePacked(first, second))}());
        InvalidToPair(pair).initialize(first, second);
        getPair[a][b] = pair;
        getPair[b][a] = pair;
    }
}

/// @notice Fails on the current code: every treasury swap names the STRIKE token itself as the pair's
/// `to`, which a genuine Uniswap V2 pair refuses with INVALID_TO. Dues can therefore never be converted,
/// the fund stays at zero, and overtime / bargaining never spend anything. Passes once Strike's swaps
/// deliver output to an address that is not one of the pair's two tokens (for example, the adapter
/// receives and forwards it).
contract InvalidToTest is Test {
    Strike internal token;
    InvalidToIMD internal imd;
    V2TwapSwap internal adapter;
    InvalidToPair internal pair;
    InvalidToFactory internal factory;
    address internal alice = address(0xA11CE);
    uint256 internal signerKey = 0x1234;

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new InvalidToIMD();
        factory = new InvalidToFactory();
        token = new Strike(
            address(this),
            address(0x4444),
            1,
            address(imd),
            address(factory),
            keccak256(type(InvalidToPair).creationCode),
            vm.addr(signerKey),
            1 ether,
            1 ether
        );
        adapter = V2TwapSwap(address(token.swapAdapter()));
        pair = InvalidToPair(token.market());
        adapter.prepareMarket();
        token.transfer(address(pair), 10_000_000 ether);
        imd.mint(address(pair), 10_000_000 ether);
        token.transfer(alice, 1_000_000 ether);
        pair.sync();
        adapter.updateOracle();
        vm.warp(vm.getBlockTimestamp() + 30 minutes);
        adapter.updateOracle();
        assertTrue(adapter.ready(), "oracle warmed");
    }

    function test_processFeesConvertsDuesOnAGenuineV2Pair() public {
        // A taxed sell into the market accrues dues inside the token contract.
        vm.prank(alice);
        token.transfer(address(pair), 100_000 ether);
        pair.sync();
        assertEq(token.pendingFund(), 1000 ether);
        assertEq(token.pendingImdBurn(), 500 ether);

        // The treasury's own conversion must succeed and fill the fund. On the current code the pair
        // reverts with "UniswapV2: INVALID_TO" because the recipient is the STRIKE token.
        token.processFees(type(uint256).max, type(uint256).max);
        assertEq(token.pendingFund(), 0, "dues were not converted");
        assertGt(token.fund(), 0, "fund never receives IMD");
        assertGt(imd.balanceOf(token.DEAD()), 0, "IMD burn leg never executes");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Strike} from "src/Strike.sol";
import {V2TwapSwap} from "src/V2TwapSwap.sol";

/// @dev Plain IMD stand-in.
contract ProofIMD is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}

    function mint(address who, uint256 amount) external {
        _mint(who, amount);
    }
}

/// @dev A Uniswap V2 pair reduced to the parts the adapter touches, with the checks the genuine
/// UniswapV2Pair.swap performs. The one that matters here is
///   require(to != token0 && to != token1, 'UniswapV2: INVALID_TO');
/// which every V2 core pair (Uniswap, Sushi, Pancake, ...) enforces and which the repository's
/// test/PairModel.sol omits.
contract GenuineV2Pair {
    address public factory;
    address public token0;
    address public token1;
    uint112 private reserve0;
    uint112 private reserve1;
    uint32 private blockTimestampLast;
    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;
    uint256 private unlocked = 1;

    modifier lock() {
        require(unlocked == 1, "UniswapV2: LOCKED");
        unlocked = 0;
        _;
        unlocked = 1;
    }

    constructor() {
        factory = msg.sender;
    }

    function initialize(address _token0, address _token1) external {
        require(msg.sender == factory, "UniswapV2: FORBIDDEN");
        token0 = _token0;
        token1 = _token1;
    }

    function getReserves() public view returns (uint112, uint112, uint32) {
        return (reserve0, reserve1, blockTimestampLast);
    }

    function _update(uint256 balance0, uint256 balance1, uint112 _reserve0, uint112 _reserve1) private {
        require(balance0 <= type(uint112).max && balance1 <= type(uint112).max, "UniswapV2: OVERFLOW");
        uint32 blockTimestamp = uint32(block.timestamp % 2 ** 32);
        unchecked {
            uint32 timeElapsed = blockTimestamp - blockTimestampLast;
            if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
                price0CumulativeLast += ((uint256(_reserve1) << 112) / _reserve0) * timeElapsed;
                price1CumulativeLast += ((uint256(_reserve0) << 112) / _reserve1) * timeElapsed;
            }
        }
        reserve0 = uint112(balance0);
        reserve1 = uint112(balance1);
        blockTimestampLast = blockTimestamp;
    }

    function sync() external lock {
        _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
    }

    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata) external lock {
        require(amount0Out > 0 || amount1Out > 0, "UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT");
        (uint112 _reserve0, uint112 _reserve1,) = getReserves();
        require(amount0Out < _reserve0 && amount1Out < _reserve1, "UniswapV2: INSUFFICIENT_LIQUIDITY");
        address _token0 = token0;
        address _token1 = token1;
        require(to != _token0 && to != _token1, "UniswapV2: INVALID_TO");
        if (amount0Out > 0) IERC20(_token0).transfer(to, amount0Out);
        if (amount1Out > 0) IERC20(_token1).transfer(to, amount1Out);
        uint256 balance0 = IERC20(_token0).balanceOf(address(this));
        uint256 balance1 = IERC20(_token1).balanceOf(address(this));
        uint256 amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
        uint256 amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
        require(amount0In > 0 || amount1In > 0, "UniswapV2: INSUFFICIENT_INPUT_AMOUNT");
        uint256 balance0Adjusted = balance0 * 1000 - amount0In * 3;
        uint256 balance1Adjusted = balance1 * 1000 - amount1In * 3;
        require(balance0Adjusted * balance1Adjusted >= uint256(_reserve0) * _reserve1 * 1000 ** 2, "UniswapV2: K");
        _update(balance0, balance1, _reserve0, _reserve1);
    }
}

contract GenuineV2Factory {
    mapping(address => mapping(address => address)) public getPair;

    function createPair(address tokenA, address tokenB) external returns (address pair) {
        require(tokenA != tokenB, "UniswapV2: IDENTICAL_ADDRESSES");
        (address t0, address t1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(t0 != address(0), "UniswapV2: ZERO_ADDRESS");
        require(getPair[t0][t1] == address(0), "UniswapV2: PAIR_EXISTS");
        bytes memory bytecode = type(GenuineV2Pair).creationCode;
        bytes32 salt = keccak256(abi.encodePacked(t0, t1));
        assembly ("memory-safe") {
            pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
        }
        GenuineV2Pair(pair).initialize(t0, t1);
        getPair[t0][t1] = pair;
        getPair[t1][t0] = pair;
    }
}

/// @notice Fails on the current code: Strike._swap names the token itself as the pair's swap
/// recipient, which a genuine V2 pair rejects with INVALID_TO. Passes once treasury swaps deliver
/// to an address that is not one of the pair's tokens.
contract InvalidToProofTest is Test {
    Strike internal token;
    ProofIMD internal imd;
    V2TwapSwap internal adapter;
    GenuineV2Pair internal pair;
    GenuineV2Factory internal factory;
    address internal alice = address(0xA11CE);
    uint256 internal signerKey = 0x1234;

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new ProofIMD();
        factory = new GenuineV2Factory();
        token = new Strike(
            address(this),
            address(0x4444),
            1,
            address(imd),
            address(factory),
            keccak256(type(GenuineV2Pair).creationCode),
            vm.addr(signerKey),
            1 ether,
            1 ether
        );
        adapter = V2TwapSwap(address(token.swapAdapter()));
        adapter.prepareMarket();
        pair = GenuineV2Pair(token.market());
        token.transfer(address(pair), 10_000_000 ether);
        imd.mint(address(pair), 10_000_000 ether);
        pair.sync();
        token.transfer(alice, 1_000_000 ether);
        imd.mint(alice, 1_000_000 ether);
        adapter.updateOracle();
        vm.warp(vm.getBlockTimestamp() + 30 minutes);
        adapter.updateOracle();
    }

    function test_processFeesConvertsDuesOnAGenuineV2Pair() public {
        // A user trade against the genuine pair works: the recipient is an ordinary wallet.
        vm.startPrank(alice);
        token.approve(address(adapter), 1000 ether);
        adapter.swap(address(token), 1000 ether, 970 ether, alice);
        vm.stopPrank();
        assertEq(token.pendingFund(), 10 ether, "dues were not collected");
        assertEq(token.pendingImdBurn(), 5 ether, "dues were not collected");

        // The treasury conversion must also work. On the current code it reverts with
        // 'UniswapV2: INVALID_TO' because the pair is asked to pay the Strike token contract.
        token.processFees(type(uint256).max, type(uint256).max);
        assertEq(token.pendingFund(), 0, "fund dues were not converted");
        assertEq(token.pendingImdBurn(), 0, "burn dues were not converted");
        assertGt(token.fund(), 0, "the Strike Fund never received IMD");
        assertGt(imd.balanceOf(token.DEAD()), 0, "no IMD was burned");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Strike} from "src/Strike.sol";

contract ScratchIMD is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}
}

/// @dev Stands in for the Uniswap v4 PoolManager's permissionless `take(currency, to, amount)` and
/// `sync/settle` surface: any unlocker can make the manager transfer a currency it holds to any
/// address, and can credit itself for tokens that arrive at the manager. No admin, no owner.
contract PassThroughManager {
    function take(IERC20 token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev A minimal constant-product-free "pair" that just forwards what it is asked to, so the test
/// only measures Strike's tax decision, not AMM math. It plays the role of `market`.
contract ExemptPassThroughTest is Test {
    Strike internal token;
    ScratchIMD internal imd;
    PassThroughManager internal manager;
    address internal market;
    address internal trader = address(0x7A4D);

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new ScratchIMD();
        manager = new PassThroughManager();
        token = new Strike(
            address(this),
            address(manager),
            7,
            address(imd),
            address(0xFAC7),
            keccak256("init-code"),
            address(0x51),
            1 ether,
            1 ether
        );
        market = token.market();
        // Give the market (V2 pair) and the trader inventory. Factory sends are exempt by design.
        token.transfer(market, 1_000_000 ether);
        token.transfer(trader, 1_000_000 ether);
        token.transfer(address(manager), 1_000_000 ether);
    }

    /// Baseline: an ordinary sell into the market pays dues. This passes before and after a fix.
    function test_ordinarySellIntoMarketPaysDues() public {
        vm.prank(trader);
        token.transfer(market, 10_000 ether);
        assertEq(token.pendingFund(), 100 ether, "1% to fund");
        assertEq(token.pendingImdBurn(), 50 ether, "0.5% to IMD burn");
    }

    /// A trader who holds STRIKE credit inside the PoolManager (bought on the required v4 pool, or
    /// settled there) calls `take(STRIKE, market, amount)` during unlock. The transfer is
    /// poolManager -> market, which `_exempt` waves through, so the sell into the taxed market
    /// pays nothing. Expected: a sell into `market` by anyone who is not the token itself pays dues.
    function test_sellIntoMarketViaPoolManagerTakeIsTaxed() public {
        uint256 marketBefore = token.balanceOf(market);
        uint256 supplyBefore = token.totalSupply();
        vm.prank(trader);
        manager.take(IERC20(address(token)), market, 10_000 ether);
        assertEq(token.pendingFund(), 100 ether, "sell routed through poolManager escaped the 1% fund dues");
        assertEq(token.pendingImdBurn(), 50 ether, "sell routed through poolManager escaped the 0.5% IMD burn dues");
        assertEq(supplyBefore - token.totalSupply(), 50 ether, "no STRIKE was burned on the sell");
        assertEq(token.balanceOf(market) - marketBefore, 9_800 ether, "market received the untaxed gross amount");
    }

    /// The mirror image: the market pays STRIKE out to the PoolManager (pair.swap(..., to=manager)
    /// inside a sync/settle), which `_exempt` also waves through. Expected: a buy from `market`
    /// delivered to anyone who is not the token itself pays dues.
    function test_buyFromMarketDeliveredToPoolManagerIsTaxed() public {
        vm.prank(market);
        token.transfer(address(manager), 10_000 ether);
        assertEq(token.pendingFund(), 100 ether, "buy delivered to poolManager escaped the 1% fund dues");
        assertEq(token.pendingImdBurn(), 50 ether, "buy delivered to poolManager escaped the 0.5% IMD burn dues");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Strike} from "src/Strike.sol";

contract DisplaceIMD is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}
}

/// @notice Fails on the current code: once 48h have passed without a signed answer (true from
/// deployment), `fallbackOvertime` never advances `lastAnswerAt`, so an unprivileged bot can consume
/// every UTC day with the fallback ahead of the relayer and the signer's fresh, valid answer is
/// rejected with InvalidAnswer, day after day. Passes once a live signer's answer is accepted on a
/// day a fallback was attempted (for example: fallback requires 48h since the last overtime of either
/// kind, or a signed answer may still land on a fallback-consumed day).
contract FallbackDisplaceProofTest is Test {
    Strike internal token;
    DisplaceIMD internal imd;
    uint256 internal signerKey = 0x5151;
    address internal bot = address(0xBAD);

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new DisplaceIMD();
        token = new Strike(
            address(this), address(0x4444), 1, address(imd), address(0xFAC), keccak256("init"), vm.addr(signerKey), 1 ether, 1 ether
        );
    }

    function _sig(uint256 jobs, uint256 observedAt, uint256 day) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerKey, token.answerDigest(jobs, observedAt, day));
        return abi.encodePacked(r, s, v);
    }

    function test_signedAnswerIsAcceptedDespiteDailyFallbackRace() public {
        // Fund is zero, so no swap is involved: only cadence and replay markers matter.
        // 48h after deployment with no signed answer: the fallback is legitimately open.
        vm.warp(token.genesis() + 2 days + 1);
        vm.prank(bot);
        token.fallbackOvertime();

        // Every following day the bot is first in the block. The relayer's fresh, correctly signed
        // answer for the same day must still be accepted at least once in three days.
        bool accepted;
        for (uint256 i; i < 3 && !accepted; ++i) {
            vm.warp(vm.getBlockTimestamp() + 1 days);
            vm.prank(bot);
            (bool ok,) = address(token).call(abi.encodeCall(Strike.fallbackOvertime, ()));
            ok; // whether or not the bot's call succeeds is not the property under test
            uint256 now_ = vm.getBlockTimestamp();
            uint256 day = now_ / 1 days;
            (accepted,) = address(token).call(abi.encodeCall(Strike.submitOvertime, (15, now_, day, _sig(15, now_, day))));
        }
        assertTrue(accepted, "signed answer was displaced by the fallback on every day");
        assertGt(token.lastAnswerAt(), token.genesis(), "lastAnswerAt never advanced");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Strike} from "src/Strike.sol";
import {V2TwapSwap} from "src/V2TwapSwap.sol";

contract DepthIMD is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}

    function mint(address who, uint256 amount) external {
        _mint(who, amount);
    }
}

/// @dev Constant-product pair with the real 0.3% adjusted-K check and cumulative prices. The
/// INVALID_TO guard of a genuine pair is deliberately omitted so this test isolates the swap-size
/// defect from the separate recipient defect.
contract DepthPair {
    address public token0;
    address public token1;
    address public immutable factory = msg.sender;
    uint112 private reserve0;
    uint112 private reserve1;
    uint32 private last;
    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;

    function initialize(address a, address b) external {
        require(msg.sender == factory && token0 == address(0), "initialize");
        (token0, token1) = a < b ? (a, b) : (b, a);
    }

    function getReserves() external view returns (uint112, uint112, uint32) {
        return (reserve0, reserve1, last);
    }

    function sync() external {
        _update();
    }

    function _update() private {
        unchecked {
            uint32 elapsed = uint32(block.timestamp) - last;
            if (reserve0 != 0 && reserve1 != 0) {
                price0CumulativeLast += ((uint256(reserve1) << 112) / reserve0) * elapsed;
                price1CumulativeLast += ((uint256(reserve0) << 112) / reserve1) * elapsed;
            }
        }
        uint256 b0 = IERC20(token0).balanceOf(address(this));
        uint256 b1 = IERC20(token1).balanceOf(address(this));
        require(b0 <= type(uint112).max && b1 <= type(uint112).max, "overflow");
        reserve0 = uint112(b0);
        reserve1 = uint112(b1);
        last = uint32(block.timestamp);
    }

    function swap(uint256 out0, uint256 out1, address to, bytes calldata) external {
        require((out0 > 0 || out1 > 0) && out0 < reserve0 && out1 < reserve1, "output");
        if (out0 != 0) IERC20(token0).transfer(to, out0);
        if (out1 != 0) IERC20(token1).transfer(to, out1);
        uint256 b0 = IERC20(token0).balanceOf(address(this));
        uint256 b1 = IERC20(token1).balanceOf(address(this));
        uint256 in0 = b0 > reserve0 - out0 ? b0 - (reserve0 - out0) : 0;
        uint256 in1 = b1 > reserve1 - out1 ? b1 - (reserve1 - out1) : 0;
        require(in0 > 0 || in1 > 0, "input");
        require((b0 * 1000 - in0 * 3) * (b1 * 1000 - in1 * 3) >= uint256(reserve0) * reserve1 * 1_000_000, "K");
        _update();
    }
}

contract DepthFactory {
    mapping(address => mapping(address => address)) public getPair;

    function createPair(address a, address b) external returns (address pair) {
        require(a != b && a != address(0) && b != address(0) && getPair[a][b] == address(0), "pair");
        (address first, address second) = a < b ? (a, b) : (b, a);
        pair = address(new DepthPair{salt: keccak256(abi.encodePacked(first, second))}());
        DepthPair(pair).initialize(first, second);
        getPair[a][b] = pair;
        getPair[b][a] = pair;
    }
}

/// @notice Fails on the current code: `_overtime` and `executeBargain` (winner A) size their IMD->STRIKE
/// swap from the fund (fund/100 at the cap) with no regard to the pair's depth, and require >= 97% of
/// TWAP. With fund = 5,000 IMD against a 1,000 IMD reserve, the 50 IMD swap cannot clear the floor,
/// so the signed daily answer and the default weekly bargain both revert; the fund cannot shrink by any
/// other route except B/C votes. Passes once the swap leg is bounded by pool depth (remainder deferred)
/// or a failing burn leg no longer reverts the whole overtime/bargain.
contract DepthBoundProofTest is Test {
    Strike internal token;
    DepthIMD internal imd;
    V2TwapSwap internal adapter;
    DepthPair internal pair;
    uint256 internal signerKey = 0x5151;
    uint256 internal constant FUND_SLOT = 10; // forge inspect Strike storage-layout: fund -> slot 10

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new DepthIMD();
        DepthFactory factory = new DepthFactory();
        token = new Strike(
            address(this),
            address(0x4444),
            1,
            address(imd),
            address(factory),
            keccak256(type(DepthPair).creationCode),
            vm.addr(signerKey),
            1 ether,
            1 ether
        );
        adapter = V2TwapSwap(address(token.swapAdapter()));
        pair = DepthPair(adapter.prepareMarket());
        token.transfer(address(pair), 1_000 ether);
        imd.mint(address(pair), 1_000 ether);
        pair.sync();
        adapter.updateOracle();
        vm.warp(vm.getBlockTimestamp() + 30 minutes);
        adapter.updateOracle();
        assertTrue(adapter.ready());
        // The fund holds 5,000 IMD (reachable through accrued dues, LP withdrawal, or both).
        imd.mint(address(token), 5_000 ether);
        vm.store(address(token), bytes32(FUND_SLOT), bytes32(uint256(5_000 ether)));
        assertEq(token.fund(), 5_000 ether, "fund slot");
    }

    function _sig(uint256 jobs, uint256 observedAt, uint256 day) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerKey, token.answerDigest(jobs, observedAt, day));
        return abi.encodePacked(r, s, v);
    }

    function test_signedOvertimeExecutesWhenFundExceedsPoolDepth() public {
        uint256 now_ = vm.getBlockTimestamp();
        uint256 day = now_ / 1 days;
        // cap = fund/50 = 100 IMD; burn leg = 50 IMD into a 1,000 IMD reserve -> output < 97% of TWAP.
        token.submitOvertime(1000, now_, day, _sig(1000, now_, day));
        assertTrue(token.usedDay(day), "the day's answer was not recorded");
        assertLt(token.fund(), 5_000 ether, "nothing was spent");
    }

    function test_defaultBargainExecutesWhenFundExceedsPoolDepth() public {
        vm.warp(token.genesis() + 7 days + 1);
        adapter.updateOracle();
        vm.warp(vm.getBlockTimestamp() + 30 minutes);
        adapter.updateOracle();
        assertTrue(adapter.ready());
        // No votes -> winner A -> swap fund/100 = 50 IMD -> cannot clear the 97% floor.
        token.executeBargain(0);
        (, bool executed) = token.ballot(0);
        assertTrue(executed, "week 0 bargain never executed");
    }
}