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

import {Test} from "forge-std/Test.sol";
import {Workers} from "src/Workers.sol";

/// @dev Stands in for the launch factory: deploys the token (constructor requires msg.sender == factory with code)
/// and answers distributorOf(uint64) the way the factory does.
contract FactoryStub {
    mapping(uint64 => address) public distributorOf;

    function deploy(address manager, uint64 number, address owner) external returns (Workers) {
        return new Workers(address(this), manager, number, owner);
    }

    function send(Workers token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev Minimal copy of the Uniswap v4 PoolManager currency-settlement primitives any unlocker may use:
/// unlock() calls back the caller; sync() records reserves; settle() credits balance - reserves to the caller;
/// take() transfers credited tokens out to any address. No pool, hook or key is needed for these.
contract PoolManagerStub {
    Workers public token;
    uint256 private reserves;
    mapping(address => uint256) public credit;

    function setToken(Workers token_) external {
        token = token_;
    }

    function unlock(bytes calldata data) external returns (bytes memory) {
        return IUnlockCallback(msg.sender).unlockCallback(data);
    }

    function sync() external {
        reserves = token.balanceOf(address(this));
    }

    function settle() external returns (uint256 paid) {
        paid = token.balanceOf(address(this)) - reserves;
        reserves = token.balanceOf(address(this));
        credit[msg.sender] += paid;
    }

    function take(address to, uint256 amount) external {
        credit[msg.sender] -= amount;
        token.transfer(to, amount); // msg.sender == poolManager, from == poolManager
        reserves = token.balanceOf(address(this));
    }
}

interface IUnlockCallback {
    function unlockCallback(bytes calldata data) external returns (bytes memory);
}

/// @dev A registered trading venue, e.g. a Uniswap v2 pair: it holds tokens and sends them wherever the swap's
/// `to` says (pair.swap(amountOut, 0, to, "")). Modelled by a public send.
contract VenueStub {
    function send(Workers token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev Anyone can deploy this. It moves WORK between a user and a registered venue through the PoolManager's
/// sync/settle/take so that no leg of the transfer is taxable.
contract FeeFreeRouter is IUnlockCallback {
    Workers immutable token;
    PoolManagerStub immutable manager;

    constructor(Workers token_, PoolManagerStub manager_) {
        token = token_;
        manager = manager_;
    }

    /// Sell: user -> PoolManager (exempt: to == poolManager) -> venue (exempt: msg.sender/from == poolManager).
    function sellToVenue(VenueStub venue, uint256 amount) external {
        manager.unlock(abi.encode(true, msg.sender, address(venue), amount));
    }

    /// Buy: venue -> PoolManager (exempt: to == poolManager) -> user (exempt: msg.sender/from == poolManager).
    function buyFromVenue(VenueStub venue, uint256 amount) external {
        manager.unlock(abi.encode(false, msg.sender, address(venue), amount));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (bool sell, address user, address venue, uint256 amount) = abi.decode(data, (bool, address, address, uint256));
        manager.sync();
        if (sell) token.transferFrom(user, address(manager), amount);
        else VenueStub(venue).send(token, address(manager), amount);
        uint256 paid = manager.settle();
        manager.take(sell ? venue : user, paid);
        return "";
    }
}

contract PoolManagerRelayBypassTest is Test {
    uint64 constant LAUNCH_NUMBER = 41;

    FactoryStub factory;
    PoolManagerStub manager;
    VenueStub venue;
    Workers token;
    FeeFreeRouter router;

    address admin = makeAddr("requester");
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");

    function setUp() public {
        factory = new FactoryStub();
        manager = new PoolManagerStub();
        venue = new VenueStub();
        token = factory.deploy(address(manager), LAUNCH_NUMBER, admin);
        manager.setToken(token);
        router = new FeeFreeRouter(token, manager);

        vm.startPrank(admin);
        token.setFeeRecipient(treasury);
        token.setTradeVenue(address(venue), true);
        vm.stopPrank();
    }

    /// A direct sell into the venue pays 2%: treasury 2e18, venue 98e18 (sanity check of intended behaviour).
    function test_directSellPaysFee() public {
        factory.send(token, alice, 100 ether);
        vm.prank(alice);
        token.transfer(address(venue), 100 ether);
        assertEq(token.balanceOf(treasury), 2 ether);
        assertEq(token.balanceOf(address(venue)), 98 ether);
    }

    /// The same sell routed through the PoolManager must still pay the 2% fee. On the current code it pays nothing.
    function test_sellRoutedThroughPoolManagerStillPaysFee() public {
        factory.send(token, alice, 100 ether);
        vm.startPrank(alice);
        token.approve(address(router), 100 ether);
        router.sellToVenue(venue, 100 ether);
        vm.stopPrank();

        assertEq(token.balanceOf(alice), 0, "alice sold everything");
        assertEq(token.balanceOf(address(manager)), 0, "nothing stays in the manager");
        assertEq(token.balanceOf(treasury), 2 ether, "the 2% trade fee was bypassed via the PoolManager relay");
        assertEq(token.balanceOf(address(venue)), 98 ether, "venue received the gross amount untaxed");
    }

    /// The same buy routed through the PoolManager must still pay the 2% fee. On the current code it pays nothing.
    function test_buyRoutedThroughPoolManagerStillPaysFee() public {
        factory.send(token, address(venue), 100 ether);
        vm.prank(alice);
        router.buyFromVenue(venue, 100 ether);

        assertEq(token.balanceOf(address(venue)), 0, "venue paid out everything");
        assertEq(token.balanceOf(address(manager)), 0, "nothing stays in the manager");
        assertEq(token.balanceOf(treasury), 2 ether, "the 2% trade fee was bypassed via the PoolManager relay");
        assertEq(token.balanceOf(alice), 98 ether, "buyer received the gross amount untaxed");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Workers} from "src/Workers.sol";

/// @dev Stands in for the launch factory: deploys the token and answers distributorOf.
contract FactoryStub {
    mapping(uint64 => address) public distributorOf;

    function deploy(address manager, uint64 number, address owner) external returns (Workers) {
        return new Workers(address(this), manager, number, owner);
    }

    function send(Workers token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

interface IUnlockCallback {
    function unlockCallback(bytes calldata data) external returns (bytes memory);
}

/// @dev Minimal model of Uniswap v4 PoolManager's permissionless settlement surface:
/// unlock -> callback, sync/settle credit whatever arrived, take pays out against that credit.
/// Anyone may call these; the real manager only requires the deltas to net to zero.
contract PoolManagerStub {
    Workers public token;
    uint256 private reserves;
    bool private unlocked;
    mapping(address => int256) public delta;

    function setToken(Workers token_) external {
        token = token_;
    }

    function unlock(bytes calldata data) external returns (bytes memory result) {
        require(!unlocked, "already unlocked");
        unlocked = true;
        result = IUnlockCallback(msg.sender).unlockCallback(data);
        require(delta[msg.sender] == 0, "currency not settled");
        unlocked = false;
    }

    function sync() external {
        reserves = token.balanceOf(address(this));
    }

    function settle() external returns (uint256 paid) {
        require(unlocked, "locked");
        paid = token.balanceOf(address(this)) - reserves;
        delta[msg.sender] += int256(paid);
    }

    function take(address to, uint256 amount) external {
        require(unlocked, "locked");
        delta[msg.sender] -= int256(amount);
        token.transfer(to, amount);
    }
}

/// @dev A registered trading venue (think: a Uniswap v2 pair). Its swap pays out to whatever
/// address the caller names, exactly as a v2 pair's swap(amount0Out, amount1Out, to, data) does.
contract VenueStub {
    Workers public token;

    constructor(Workers token_) {
        token = token_;
    }

    function swapOut(address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev An ordinary trader that routes a venue buy through the pool manager's sync/settle/take.
contract RelayTrader is IUnlockCallback {
    PoolManagerStub public manager;
    VenueStub public venue;
    Workers public token;

    constructor(PoolManagerStub manager_, VenueStub venue_, Workers token_) {
        manager = manager_;
        venue = venue_;
        token = token_;
    }

    function buyFromVenue(uint256 amount) external {
        manager.unlock(abi.encode(amount));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        uint256 amount = abi.decode(data, (uint256));
        manager.sync();
        // The venue pays its swap output straight into the pool manager: from == venue, to == poolManager.
        venue.swapOut(address(manager), amount);
        uint256 credited = manager.settle();
        // The pool manager pays the trader out whatever was credited: msg.sender == poolManager.
        manager.take(address(this), credited);
        return "";
    }
}

contract PoolManagerRelayBypassTest is Test {
    FactoryStub factory;
    PoolManagerStub manager;
    VenueStub venue;
    Workers token;
    address admin = makeAddr("requester");
    address treasury = makeAddr("treasury");

    function setUp() public {
        factory = new FactoryStub();
        manager = new PoolManagerStub();
        token = factory.deploy(address(manager), 41, admin);
        manager.setToken(token);
        venue = new VenueStub(token);

        vm.startPrank(admin);
        token.setFeeRecipient(treasury);
        token.setTradeVenue(address(venue), true);
        vm.stopPrank();

        factory.send(token, address(venue), 1_000 ether);
    }

    /// @dev A direct buy from the registered venue pays the 2% fee.
    function test_directVenueBuyPaysFee() public {
        address direct = makeAddr("direct");
        venue.swapOut(direct, 100 ether);
        assertEq(token.balanceOf(direct), 98 ether);
        assertEq(token.balanceOf(treasury), 2 ether);
    }

    /// @dev The same buy routed through the pool manager's settlement surface must pay the same fee.
    /// On the current code it pays nothing: the venue -> poolManager leg and the poolManager -> trader
    /// leg are both exempt, so the pool manager is a fee-free relay around every registered venue.
    function test_venueBuyRoutedThroughPoolManagerStillPaysFee() public {
        RelayTrader trader = new RelayTrader(manager, venue, token);
        trader.buyFromVenue(100 ether);

        assertEq(token.balanceOf(address(venue)), 900 ether, "venue paid out the gross amount");
        assertEq(token.balanceOf(address(manager)), 0, "nothing stays in the pool manager");
        assertEq(token.balanceOf(treasury), 2 ether, "trade fee was bypassed by relaying through the pool manager");
        assertEq(token.balanceOf(address(trader)), 98 ether, "trader received the gross amount fee-free");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Workers} from "src/Workers.sol";

/// @dev Stands in for the launch factory: deploys the token and answers distributorOf.
contract FactoryStub {
    mapping(uint64 => address) public distributorOf;

    function deploy(address manager, uint64 number, address owner) external returns (Workers) {
        return new Workers(address(this), manager, number, owner);
    }

    function send(Workers token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev Minimal model of Uniswap v4 PoolManager settlement: anyone may sync, pay in, settle and take.
/// The real PoolManager exposes exactly this permissionless sync/settle/take surface inside unlock().
contract PoolManagerStub {
    Workers internal token;
    uint256 internal reserves;
    mapping(address => uint256) public credit;

    function sync(Workers token_) external {
        token = token_;
        reserves = token_.balanceOf(address(this));
    }

    function settle() external returns (uint256 paid) {
        paid = token.balanceOf(address(this)) - reserves;
        credit[msg.sender] += paid;
    }

    function take(address to, uint256 amount) external {
        credit[msg.sender] -= amount;
        token.transfer(to, amount);
    }
}

/// @dev A registered, fee-aware venue (v2-style pair): it delivers swap output to whatever recipient the trader names.
contract PairStub {
    function swap(Workers token, address to, uint256 amountOut) external {
        token.transfer(to, amountOut);
    }
}

contract WorkersFeeBypassTest is Test {
    uint256 internal constant SUPPLY = 1_000_000_000 ether;

    FactoryStub internal factory;
    PoolManagerStub internal manager;
    PairStub internal pair;
    Workers internal token;
    address internal admin = makeAddr("admin");
    address internal treasury = makeAddr("treasury");
    address internal attacker = makeAddr("attacker");

    function setUp() public {
        factory = new FactoryStub();
        manager = new PoolManagerStub();
        pair = new PairStub();
        token = factory.deploy(address(manager), 41, admin);
        vm.startPrank(admin);
        token.setFeeRecipient(treasury);
        token.setTradeVenue(address(pair), true);
        vm.stopPrank();
        factory.send(token, address(pair), 1_000 ether);
        factory.send(token, attacker, 1_000 ether);
    }

    /// @dev A direct buy from the venue pays the 2% fee. This is the behaviour the owner expects for every buy.
    function test_DirectBuyFromVenuePaysFee() public {
        vm.prank(attacker);
        pair.swap(token, attacker, 100 ether);
        assertEq(token.balanceOf(attacker), 1_098 ether);
        assertEq(token.balanceOf(treasury), 2 ether);
    }

    /// @dev The same buy, with the venue's output routed through the PoolManager (sync -> pair pays the manager ->
    /// settle -> take), pays nothing: venue -> manager is exempt (to == poolManager) and manager -> attacker is exempt
    /// (msg.sender == poolManager). The attacker nets the full 100 WORK and the treasury gets 0.
    function test_BuyRoutedThroughPoolManagerSkipsFee() public {
        vm.startPrank(attacker);
        manager.sync(token);
        pair.swap(token, address(manager), 100 ether);
        uint256 credited = manager.settle();
        manager.take(attacker, credited);
        vm.stopPrank();
        assertEq(token.balanceOf(attacker), 1_098 ether, "attacker received the gross amount, fee was skipped");
        assertEq(token.balanceOf(treasury), 2 ether, "treasury received no fee on a venue buy");
    }

    /// @dev Selling into the venue via the PoolManager: the attacker pays the manager (exempt, to == poolManager), then
    /// takes straight into the venue (exempt, msg.sender == poolManager). The venue receives 100 WORK instead of 98.
    function test_SellRoutedThroughPoolManagerSkipsFee() public {
        vm.startPrank(attacker);
        manager.sync(token);
        token.transfer(address(manager), 100 ether);
        manager.settle();
        manager.take(address(pair), 100 ether);
        vm.stopPrank();
        assertEq(token.balanceOf(address(pair)), 1_098 ether, "venue received the gross amount, fee was skipped");
        assertEq(token.balanceOf(treasury), 2 ether, "treasury received no fee on a venue sell");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Workers} from "src/Workers.sol";

/// @dev Stands in for the launch factory: deploys the token and answers distributorOf.
contract FactoryStub {
    mapping(uint64 => address) public distributorOf;

    function deploy(address manager, uint64 number, address owner) external returns (Workers) {
        return new Workers(address(this), manager, number, owner);
    }
}

/// @dev A registered trading venue (think: a Uniswap v2 pair). It only needs to be able to send tokens.
contract VenueStub {
    function send(Workers token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

interface IUnlockCallback {
    function unlockCallback(bytes calldata data) external returns (bytes memory);
}

/// @dev Minimal model of the Uniswap v4 PoolManager flash-accounting surface that matters here:
/// anyone may `unlock`, and inside the callback may `sync` + transfer + `settle` to earn credit for a
/// currency, then `take(currency, to, amount)` to ANY `to`, as long as the net delta is zero at the end.
/// The real PoolManager exposes exactly these functions with the same permissions (take is
/// `onlyWhenUnlocked`, not restricted to pools or to the caller's own address).
contract PoolManagerModel {
    address internal locker;
    address internal syncedCurrency;
    uint256 internal syncedReserve;
    int256 internal delta; // positive = credit owed to locker, negative = debt

    function unlock(bytes calldata data) external returns (bytes memory result) {
        require(locker == address(0), "already unlocked");
        locker = msg.sender;
        result = IUnlockCallback(msg.sender).unlockCallback(data);
        require(delta == 0, "currency not settled");
        locker = address(0);
    }

    function sync(address currency) external {
        syncedCurrency = currency;
        syncedReserve = Workers(currency).balanceOf(address(this));
    }

    function settle() external returns (uint256 paid) {
        require(msg.sender == locker, "not locker");
        paid = Workers(syncedCurrency).balanceOf(address(this)) - syncedReserve;
        delta += int256(paid);
    }

    function take(address currency, address to, uint256 amount) external {
        require(msg.sender == locker, "not locker");
        delta -= int256(amount);
        Workers(currency).transfer(to, amount);
    }
}

/// @dev An ordinary user who relays WORK through the PoolManager instead of transferring directly.
contract Relayer is IUnlockCallback {
    PoolManagerModel internal immutable manager;
    Workers internal immutable token;

    constructor(PoolManagerModel manager_, Workers token_) {
        manager = manager_;
        token = token_;
    }

    /// Sell path: user -> venue, but routed user -> manager -> venue.
    function sellVia(address venue, uint256 amount) external {
        manager.unlock(abi.encode(uint8(0), venue, amount));
    }

    /// Buy path: venue -> user, but routed venue -> manager -> user.
    function buyVia(VenueStub venue, uint256 amount) external {
        manager.unlock(abi.encode(uint8(1), address(venue), amount));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (uint8 kind, address venue, uint256 amount) = abi.decode(data, (uint8, address, uint256));
        manager.sync(address(token));
        if (kind == 0) {
            // to == poolManager: the token exempts this hop.
            token.transfer(address(manager), amount);
            manager.settle();
            // msg.sender == poolManager: the token exempts this hop too, although `to` is a venue.
            manager.take(address(token), venue, amount);
        } else {
            // from == venue, to == poolManager: exempt because of the manager.
            VenueStub(venue).send(token, address(manager), amount);
            uint256 credited = manager.settle();
            // msg.sender == poolManager: exempt. The relayer takes whatever the manager credited.
            manager.take(address(token), address(this), credited);
        }
        return "";
    }
}

contract PoolManagerRelayBypassTest is Test {
    uint256 constant SUPPLY = 1_000_000_000 ether;

    FactoryStub factory;
    PoolManagerModel manager;
    VenueStub venue;
    Workers token;
    Relayer relayer;
    address admin = makeAddr("admin");
    address treasury = makeAddr("treasury");

    function setUp() public {
        factory = new FactoryStub();
        manager = new PoolManagerModel();
        venue = new VenueStub();
        token = factory.deploy(address(manager), 7, admin);
        vm.startPrank(admin);
        token.setFeeRecipient(treasury);
        token.setTradeVenue(address(venue), true);
        vm.stopPrank();
        relayer = new Relayer(manager, token);
    }

    /// A direct sell into the venue pays the fee: this is the behaviour the relay must also produce.
    function test_directSellIntoVenuePaysTwoPercent() public {
        vm.prank(address(factory));
        token.transfer(address(relayer), 100 ether);
        vm.prank(address(relayer));
        token.transfer(address(venue), 100 ether);
        assertEq(token.balanceOf(address(venue)), 98 ether);
        assertEq(token.balanceOf(treasury), 2 ether);
    }

    /// Same economic action (100 WORK from a user into the venue), relayed through the PoolManager.
    /// Expected: the venue receives 98 WORK and the treasury 2 WORK. Actual on current code: the venue
    /// receives 100 WORK and the treasury 0.
    function test_sellRelayedThroughPoolManagerStillPaysTwoPercent() public {
        vm.prank(address(factory));
        token.transfer(address(relayer), 100 ether);

        relayer.sellVia(address(venue), 100 ether);

        assertEq(token.balanceOf(address(relayer)), 0, "relayer kept tokens");
        assertEq(token.balanceOf(address(manager)), 0, "manager kept tokens");
        assertEq(token.balanceOf(treasury), 2 ether, "fee bypassed on sell relayed through the PoolManager");
        assertEq(token.balanceOf(address(venue)), 98 ether, "venue received the gross amount");
    }

    /// Same for the buy direction: 100 WORK from the venue to a user, relayed through the PoolManager.
    function test_buyRelayedThroughPoolManagerStillPaysTwoPercent() public {
        vm.prank(address(factory));
        token.transfer(address(venue), 100 ether);

        relayer.buyVia(venue, 100 ether);

        assertEq(token.balanceOf(address(venue)), 0, "venue kept tokens");
        assertEq(token.balanceOf(address(manager)), 0, "manager kept tokens");
        assertEq(token.balanceOf(treasury), 2 ether, "fee bypassed on buy relayed through the PoolManager");
        assertEq(token.balanceOf(address(relayer)), 98 ether, "buyer received the gross amount");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Workers} from "src/Workers.sol";

/// @dev Stands in for the launch factory: deploys the token (constructor requires msg.sender == factory with code)
/// and answers distributorOf(uint64) the way the factory does.
contract FactoryStub {
    mapping(uint64 => address) public distributorOf;

    function deploy(address manager, uint64 number, address owner) external returns (Workers) {
        return new Workers(address(this), manager, number, owner);
    }

    function send(Workers token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev Minimal copy of the Uniswap v4 PoolManager currency-settlement primitives any unlocker may use:
/// unlock() calls back the caller; sync() records reserves; settle() credits balance - reserves to the caller;
/// take() transfers credited tokens out to any address. No pool, hook or key is needed for these.
contract PoolManagerStub {
    Workers public token;
    uint256 private reserves;
    mapping(address => uint256) public credit;

    function setToken(Workers token_) external {
        token = token_;
    }

    function unlock(bytes calldata data) external returns (bytes memory) {
        return IUnlockCallback(msg.sender).unlockCallback(data);
    }

    function sync() external {
        reserves = token.balanceOf(address(this));
    }

    function settle() external returns (uint256 paid) {
        paid = token.balanceOf(address(this)) - reserves;
        reserves = token.balanceOf(address(this));
        credit[msg.sender] += paid;
    }

    function take(address to, uint256 amount) external {
        credit[msg.sender] -= amount;
        token.transfer(to, amount); // msg.sender == poolManager, from == poolManager
        reserves = token.balanceOf(address(this));
    }
}

interface IUnlockCallback {
    function unlockCallback(bytes calldata data) external returns (bytes memory);
}

/// @dev A registered trading venue, e.g. a Uniswap v2 pair: it holds tokens and sends them wherever the swap's
/// `to` says (pair.swap(amountOut, 0, to, "")). Modelled by a public send.
contract VenueStub {
    function send(Workers token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev Anyone can deploy this. It moves WORK between a user and a registered venue through the PoolManager's
/// sync/settle/take so that no leg of the transfer is taxable.
contract FeeFreeRouter is IUnlockCallback {
    Workers immutable token;
    PoolManagerStub immutable manager;

    constructor(Workers token_, PoolManagerStub manager_) {
        token = token_;
        manager = manager_;
    }

    /// Sell: user -> PoolManager (exempt: to == poolManager) -> venue (exempt: msg.sender/from == poolManager).
    function sellToVenue(VenueStub venue, uint256 amount) external {
        manager.unlock(abi.encode(true, msg.sender, address(venue), amount));
    }

    /// Buy: venue -> PoolManager (exempt: to == poolManager) -> user (exempt: msg.sender/from == poolManager).
    function buyFromVenue(VenueStub venue, uint256 amount) external {
        manager.unlock(abi.encode(false, msg.sender, address(venue), amount));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (bool sell, address user, address venue, uint256 amount) = abi.decode(data, (bool, address, address, uint256));
        manager.sync();
        if (sell) token.transferFrom(user, address(manager), amount);
        else VenueStub(venue).send(token, address(manager), amount);
        uint256 paid = manager.settle();
        manager.take(sell ? venue : user, paid);
        return "";
    }
}

contract PoolManagerRelayBypassTest is Test {
    uint64 constant LAUNCH_NUMBER = 41;

    FactoryStub factory;
    PoolManagerStub manager;
    VenueStub venue;
    Workers token;
    FeeFreeRouter router;

    address admin = makeAddr("requester");
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");

    function setUp() public {
        factory = new FactoryStub();
        manager = new PoolManagerStub();
        venue = new VenueStub();
        token = factory.deploy(address(manager), LAUNCH_NUMBER, admin);
        manager.setToken(token);
        router = new FeeFreeRouter(token, manager);

        vm.startPrank(admin);
        token.setFeeRecipient(treasury);
        token.setTradeVenue(address(venue), true);
        vm.stopPrank();
    }

    /// A direct sell into the venue pays 2%: treasury 2e18, venue 98e18 (sanity check of intended behaviour).
    function test_directSellPaysFee() public {
        factory.send(token, alice, 100 ether);
        vm.prank(alice);
        token.transfer(address(venue), 100 ether);
        assertEq(token.balanceOf(treasury), 2 ether);
        assertEq(token.balanceOf(address(venue)), 98 ether);
    }

    /// The same sell routed through the PoolManager must still pay the 2% fee. On the current code it pays nothing.
    function test_sellRoutedThroughPoolManagerStillPaysFee() public {
        factory.send(token, alice, 100 ether);
        vm.startPrank(alice);
        token.approve(address(router), 100 ether);
        router.sellToVenue(venue, 100 ether);
        vm.stopPrank();

        assertEq(token.balanceOf(alice), 0, "alice sold everything");
        assertEq(token.balanceOf(address(manager)), 0, "nothing stays in the manager");
        assertEq(token.balanceOf(treasury), 2 ether, "the 2% trade fee was bypassed via the PoolManager relay");
        assertEq(token.balanceOf(address(venue)), 98 ether, "venue received the gross amount untaxed");
    }

    /// The same buy routed through the PoolManager must still pay the 2% fee. On the current code it pays nothing.
    function test_buyRoutedThroughPoolManagerStillPaysFee() public {
        factory.send(token, address(venue), 100 ether);
        vm.prank(alice);
        router.buyFromVenue(venue, 100 ether);

        assertEq(token.balanceOf(address(venue)), 0, "venue paid out everything");
        assertEq(token.balanceOf(address(manager)), 0, "nothing stays in the manager");
        assertEq(token.balanceOf(treasury), 2 ether, "the 2% trade fee was bypassed via the PoolManager relay");
        assertEq(token.balanceOf(alice), 98 ether, "buyer received the gross amount untaxed");
    }
}