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

import {Test} from "forge-std/Test.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} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Hook} from "src/Hook.sol";
import {HookFlags} from "src/HookFlags.sol";
import {Token} from "src/Token.sol";
import {PrayRouter} from "src/PrayRouter.sol";
import {StakingVault} from "src/StakingVault.sol";

/// @dev Stand-in for FWA: any address may mint, transfers unrestricted (the hook never transfers FWA
/// wallet-to-wallet, so the restriction is irrelevant to this scenario).
contract ScratchFWA is ERC20 {
    constructor() ERC20("Fake World Assets", "FWA") {}

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

/// @notice An unblessed seller who stakes PRAY one block ahead recaptures almost the whole
/// sinners' tax: the brief's 50% sell fee collapses to ~5% (the treasury's 10% share) for any
/// holder with a dominant share of the stake, with no plea and no panel.
contract SinnerSelfStakeTest is Test, IUnlockCallback {
    address internal constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;

    IPoolManager internal manager;
    Token internal token;
    Hook internal hook;
    PrayRouter internal router;
    StakingVault internal staking;
    PoolKey internal key;
    address internal bob;
    address internal carol;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        bob = makeAddr("bob");
        carol = makeAddr("carol");
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new ScratchFWA()).code);
        token = new Token();

        bytes memory creation =
            abi.encodePacked(type(Hook).creationCode, abi.encode(manager, address(token), address(this)));
        bytes32 hash = keccak256(creation);
        for (uint256 salt = 0; salt < 200_000; ++salt) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), hash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.PRAY)) continue;
            address deployed;
            assembly ("memory-safe") {
                deployed := create2(0, add(creation, 32), mload(creation), salt)
            }
            require(deployed == predicted, "deploy failed");
            hook = Hook(deployed);
            break;
        }
        require(address(hook) != address(0), "mine failed");
        router = hook.router();
        staking = hook.staking();

        bool pray0 = address(token) < FWA;
        key = PoolKey(
            Currency.wrap(pray0 ? address(token) : FWA),
            Currency.wrap(pray0 ? FWA : address(token)),
            12500,
            60,
            IHooks(address(hook))
        );
        manager.initialize(key, 1 << 96);

        ScratchFWA(FWA).mint(address(this), 100_000_000 ether);
        manager.unlock(abi.encode(ModifyLiquidityParams(-887220, 887220, 50_000_000 ether, bytes32(0))));

        token.transfer(bob, 2_000_000 ether);
        token.transfer(carol, 100_000 ether);
        vm.startPrank(bob);
        token.approve(address(router), type(uint256).max);
        token.approve(address(staking), type(uint256).max);
        vm.stopPrank();
        vm.prank(carol);
        token.approve(address(staking), type(uint256).max);

        // Past the launch decay; the swarm is awake, so an unblessed sell is a sinner's sell.
        vm.warp(hook.launchedAt() + 1800);
        assertFalse(hook.registry().sleeping());
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (BalanceDelta d,) = manager.modifyLiquidity(key, abi.decode(data, (ModifyLiquidityParams)), "");
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return "";
    }

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

    function _sell(address who, uint256 amount) private returns (uint256 received) {
        bool zeroForOne = Currency.unwrap(key.currency0) == address(token);
        uint160 lim = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        vm.prank(who, who);
        (, received) = router.swap(PrayRouter.Trade(false, -int256(amount), amount, 1, lim, block.timestamp));
    }

    function testSinnerRecapturesOwnTaxByStakingOneBlockAhead() public {
        // Carol is an honest staker with 100,000 PRAY.
        vm.prank(carol);
        staking.stake(100_000 ether);

        // Bob holds 2,000,000 PRAY, has no blessing, and wants to dump 100,000 PRAY.
        // Block N: he stakes the 1,900,000 PRAY he is not selling.
        vm.prank(bob);
        staking.stake(1_900_000 ether);
        vm.roll(block.number + 1);
        vm.warp(block.timestamp + 12);

        // Block N+1: unblessed exact-input sell of 100,000 PRAY.
        uint256 received = _sell(bob, 100_000 ether);
        uint256 fee = hook.totalFees();
        uint256 gross = received + fee;
        assertApproxEqAbs(fee, gross / 2, 1, "hook charged 50% of gross");
        assertEq(hook.stakingFees(), fee - fee / 10, "90% of the tax went to the staking vault");

        // Bob immediately holds 95% of the stakers' share as claimable FWA.
        uint256 bobPending = staking.pending(bob);
        assertApproxEqAbs(bobPending, (fee - fee / 10) * 19 / 20, 2, "bob's pro-rata share");

        vm.prank(bob);
        uint256 claimed = staking.claim();
        assertEq(claimed, bobPending);

        // Block N+2: Bob leaves. No lock applies.
        vm.roll(block.number + 1);
        vm.prank(bob);
        staking.unstake(1_900_000 ether);

        // Bob's effective hook fee on an *unblessed* sell: what he paid minus what the tax
        // handed straight back to him.
        uint256 effective = fee - claimed;
        uint256 effectiveBps = effective * 10_000 / gross;
        emit log_named_uint("gross FWA proceeds", gross);
        emit log_named_uint("hook fee charged", fee);
        emit log_named_uint("tax returned to seller", claimed);
        emit log_named_uint("effective sell fee bps", effectiveBps);

        // The brief: unblessed sells pay 50%. A sinner who stakes pays ~7% here, and ~5% as the
        // sole staker. This assertion fails on the current code and passes once the seller cannot
        // collect its own tax (e.g. the tax is streamed over time, or the seller's own stake is
        // excluded from the distribution of its own sell).
        assertGe(effectiveBps, 4_000, "an unblessed seller must not recapture its own sinners' tax");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.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} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Hook} from "src/Hook.sol";
import {HookFlags} from "src/HookFlags.sol";
import {Token} from "src/Token.sol";
import {PrayRouter} from "src/PrayRouter.sol";
import {StakingVault} from "src/StakingVault.sol";

/// @dev Stand-in for FWA: ordinary ERC-20 that only allows transfers with the PoolManager on one side.
contract ScratchFWA is ERC20 {
    address public manager;
    constructor() ERC20("FWA", "FWA") {}
    function setManager(address m) external { manager = m; }
    function mint(address to, uint256 amount) external { _mint(to, amount); }
    function _update(address from, address to, uint256 amount) internal override {
        if (from != address(0) && to != address(0) && from != manager && to != manager) revert("InvalidTransfer");
        super._update(from, to, amount);
    }
}

contract ScratchSeeder is IUnlockCallback {
    IPoolManager immutable manager;
    constructor(IPoolManager m) { manager = m; }
    function seed(PoolKey memory k, int256 liquidity, int24 lower, int24 upper) external {
        manager.unlock(abi.encode(k, ModifyLiquidityParams(lower, upper, liquidity, bytes32(0)), msg.sender));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory k, ModifyLiquidityParams memory p, address payer) =
            abi.decode(data, (PoolKey, ModifyLiquidityParams, address));
        (BalanceDelta d,) = manager.modifyLiquidity(k, p, "");
        _settle(k.currency0, d.amount0(), payer);
        _settle(k.currency1, d.amount1(), payer);
        return "";
    }
    function _settle(Currency c, int128 d, address payer) private {
        if (d < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transferFrom(payer, address(manager), uint256(-int256(d)));
            manager.settle();
        } else if (d > 0) {
            manager.take(c, payer, uint256(int256(d)));
        }
    }
}

contract SinnerRecaptureProof is Test {
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    IPoolManager manager;
    Token token;
    Hook hook;
    PrayRouter router;
    StakingVault staking;
    PoolKey key;
    address whale = makeAddr("whale");
    address small = makeAddr("small");

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new ScratchFWA()).code);
        ScratchFWA(FWA).setManager(address(manager));
        token = new Token();
        bytes memory creation =
            abi.encodePacked(type(Hook).creationCode, abi.encode(manager, address(token), address(this)));
        bytes32 hash = keccak256(creation);
        for (uint256 salt = 0; salt < 300_000; ++salt) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), hash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.PRAY)) continue;
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(creation, 32), mload(creation), salt) }
            require(deployed == predicted, "deploy");
            hook = Hook(deployed);
            break;
        }
        require(address(hook) != address(0), "mine");
        router = hook.router();
        staking = hook.staking();
        bool pray0 = address(token) < FWA;
        key = PoolKey(
            Currency.wrap(pray0 ? address(token) : FWA),
            Currency.wrap(pray0 ? FWA : address(token)),
            12500,
            60,
            IHooks(address(hook))
        );
        manager.initialize(key, 1 << 96);
        ScratchSeeder seeder = new ScratchSeeder(manager);
        ScratchFWA(FWA).mint(address(this), 100_000_000 ether);
        token.approve(address(seeder), type(uint256).max);
        IERC20(FWA).approve(address(seeder), type(uint256).max);
        seeder.seed(key, 50_000_000 ether, -887220, 887220);
        token.transfer(whale, 10_000_000 ether);
        token.transfer(small, 10_000 ether);
        vm.startPrank(whale);
        token.approve(address(router), type(uint256).max);
        token.approve(address(staking), type(uint256).max);
        vm.stopPrank();
        vm.startPrank(small);
        token.approve(address(router), type(uint256).max);
        token.approve(address(staking), type(uint256).max);
        vm.stopPrank();
        vm.warp(hook.launchedAt() + 1800);
    }

    function sell(address who, uint256 amount) internal returns (uint256 received) {
        bool pray0 = address(token) < FWA;
        uint160 lim = pray0 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        vm.prank(who, who);
        (, received) = router.swap(PrayRouter.Trade(false, -int256(amount), amount, 1, lim, block.timestamp));
    }

    /// A seller who stakes the rest of their holdings one block earlier takes the sinners' tax back.
    function testSinnerTakesOwnTaxBackThroughStaking() public {
        // A small honest staker is present.
        vm.prank(small);
        staking.stake(10_000 ether);
        // The whale stakes 9.9M PRAY in block N and sells 100k PRAY unblessed in block N+1.
        vm.prank(whale);
        staking.stake(9_900_000 ether);
        vm.roll(block.number + 1);
        uint256 received = sell(whale, 100_000 ether);
        uint256 tax = hook.totalFees();
        uint256 toStakers = hook.stakingFees();
        assertEq(toStakers, tax - tax / 10);
        uint256 whalePending = staking.pending(whale);
        uint256 smallPending = staking.pending(small);
        emit log_named_uint("FWA received by seller", received);
        emit log_named_uint("sinners tax", tax);
        emit log_named_uint("tax routed to stakers", toStakers);
        emit log_named_uint("tax recaptured by the seller", whalePending);
        emit log_named_uint("tax reaching the honest staker", smallPending);
        emit log_named_uint("effective tax bps", (tax - whalePending) * 10000 / (received + tax));
        // The sinner must not be paid their own sinners' tax: the honest staker should get it all.
        assertEq(whalePending, 0, "seller recaptured the sinners' tax through the staking vault");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.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} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Hook} from "src/Hook.sol";
import {HookFlags} from "src/HookFlags.sol";
import {Token} from "src/Token.sol";
import {PrayRouter} from "src/PrayRouter.sol";
import {StakingVault} from "src/StakingVault.sol";

/// Finding: the sinners' tax is credited to whoever is staked at the moment of the sell, with no
/// stake age, cooldown or streaming. A holder who stakes the rest of their PRAY one block before an
/// unblessed sell and leaves one block after takes back almost all of their own tax. Expected: a seller
/// cannot recover a material share (here: under 10%) of the tax they just paid by staking around the
/// sell. Actual: with 9.9M PRAY staked against 100k community stake, the seller recovers ~89% of the
/// tax and pays an effective 5.4% instead of 50%.

contract FwaMock is ERC20 {
    address public manager;

    constructor() ERC20("FWA", "FWA") {}

    function setManager(address m) external {
        manager = m;
    }

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

    function _update(address from, address to, uint256 amount) internal override {
        if (from != address(0) && to != address(0) && from != manager && to != manager) revert("InvalidTransfer");
        super._update(from, to, amount);
    }
}

contract Seeder is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function seed(PoolKey memory k, int256 liquidity) external {
        manager.unlock(abi.encode(k, liquidity, msg.sender));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (PoolKey memory k, int256 liquidity, address payer) = abi.decode(data, (PoolKey, int256, address));
        (BalanceDelta d,) = manager.modifyLiquidity(k, ModifyLiquidityParams(-887220, 887220, liquidity, 0), "");
        _pay(k.currency0, d.amount0(), payer);
        _pay(k.currency1, d.amount1(), payer);
        return "";
    }

    function _pay(Currency c, int128 d, address payer) private {
        if (d >= 0) return;
        manager.sync(c);
        require(IERC20(Currency.unwrap(c)).transferFrom(payer, address(manager), uint256(-int256(d))));
        manager.settle();
    }
}

contract SelfStakeProof is Test {
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    IPoolManager manager;
    Token token;
    Hook hook;
    PrayRouter router;
    StakingVault staking;
    PoolKey key;
    address whale = makeAddr("whale");
    address carol = makeAddr("carol");

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(30_000_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new FwaMock()).code);
        FwaMock(FWA).setManager(address(manager));
        token = new Token();
        bytes memory creation = abi.encodePacked(type(Hook).creationCode, abi.encode(manager, address(token), address(this)));
        bytes32 h = keccak256(creation);
        for (uint256 salt = 0; salt < 300_000; ++salt) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), h)))));
            if (!HookFlags.matches(predicted, HookFlags.PRAY)) continue;
            address deployed;
            assembly ("memory-safe") {
                deployed := create2(0, add(creation, 32), mload(creation), salt)
            }
            hook = Hook(deployed);
            break;
        }
        router = hook.router();
        staking = hook.staking();
        key = PoolKey(
            Currency.wrap(address(token) < FWA ? address(token) : FWA),
            Currency.wrap(address(token) < FWA ? FWA : address(token)),
            12500,
            60,
            IHooks(address(hook))
        );
        manager.initialize(key, 1 << 96);
        Seeder seeder = new Seeder(manager);
        FwaMock(FWA).mint(address(this), 100_000_000 ether);
        token.approve(address(seeder), type(uint256).max);
        IERC20(FWA).approve(address(seeder), type(uint256).max);
        seeder.seed(key, 50_000_000 ether);
        vm.warp(block.timestamp + 1800);
        token.transfer(whale, 10_000_000 ether);
        token.transfer(carol, 100_000 ether);
        vm.startPrank(carol);
        token.approve(address(staking), type(uint256).max);
        staking.stake(100_000 ether);
        vm.stopPrank();
        vm.startPrank(whale);
        token.approve(address(staking), type(uint256).max);
        token.approve(address(router), type(uint256).max);
        vm.stopPrank();
    }

    function testSellerCannotTakeBackTheirOwnTaxByStakingAroundTheSell() public {
        // Block N: stake everything that is not about to be sold.
        vm.prank(whale);
        staking.stake(9_900_000 ether);
        vm.roll(block.number + 1);
        // Block N+1: the unblessed sell.
        bool zeroForOne = address(token) < FWA;
        uint160 lim = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        vm.prank(whale, whale);
        (, uint256 received) = router.swap(PrayRouter.Trade(false, -100_000 ether, 100_000 ether, 1, lim, block.timestamp));
        uint256 fee = hook.totalFees();
        assertEq(fee, (received + fee) / 2, "fixture: 50% sinners' tax charged");
        // Block N+2: leave with the tax.
        vm.roll(block.number + 1);
        vm.prank(whale);
        uint256 recovered = staking.claim();
        vm.prank(whale);
        staking.unstake(9_900_000 ether);
        assertLt(recovered * 10, fee, "the seller recovered 10% or more of the tax they just paid");
    }
}