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

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

/// @dev The part of Uniswap v4's PoolManager flash accounting a relay uses, with v4's semantics:
/// sync snapshots the reserve, settle credits the caller with what arrived since, take pays a
/// credited currency out to any address. No pool is needed for any of it.
contract FlashAccountingManager {
    address public synced;
    uint256 public reserves;
    mapping(address => int256) public delta;

    function sync(address currency) external {
        synced = currency;
        reserves = DCAToken(currency).balanceOf(address(this));
    }

    function settle() external returns (uint256 paid) {
        paid = DCAToken(synced).balanceOf(address(this)) - reserves;
        delta[msg.sender] += int256(paid);
        synced = address(0);
    }

    function take(address currency, address to, uint256 amount) external {
        delta[msg.sender] -= int256(amount);
        require(delta[msg.sender] >= 0, "CurrencyNotSettled");
        DCAToken(currency).transfer(to, amount);
    }
}

/// @dev What any holder can deploy: hand it tokens, it relays them through the manager.
contract Relay {
    function send(DCAToken token, FlashAccountingManager manager, address to, uint256 amount) external {
        manager.sync(address(token));
        token.transferFrom(msg.sender, address(manager), amount);
        manager.settle();
        manager.take(address(token), to, amount);
    }
}

contract PoolManagerRelayTest is Test {
    address constant TREASURY = 0xc51fe7cD475a668C05fB9Cff741fBb7b6f7726Db;
    address constant OWNER = address(0x0A11CE);
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);

    DCAToken token;
    FlashAccountingManager manager;
    Relay relay;

    function setUp() public {
        manager = new FlashAccountingManager();
        relay = new Relay();
        token = new DCAToken(OWNER, address(this), address(manager), 1);
        token.transfer(ALICE, 1_000_000 ether); // factory send, untaxed
    }

    /// @dev README: "The tax applies to wallet-to-wallet transfers". Alice pays Bob 1,000,000 DCA.
    /// A direct transfer pays 45,000 to the treasury; the same payment through the PoolManager
    /// pays it nothing.
    function test_walletToWalletPaymentThroughThePoolManagerSkipsTheTax() public {
        uint256 amount = 1_000_000 ether;
        uint256 treasuryBefore = token.balanceOf(TREASURY);

        vm.startPrank(ALICE);
        token.approve(address(relay), amount);
        relay.send(token, manager, BOB, amount);
        vm.stopPrank();

        assertEq(token.balanceOf(ALICE), 0, "Alice paid the whole amount");
        // On the code as it is, Bob receives 1,000,000 whole and the treasury receives 0.
        assertEq(
            token.balanceOf(TREASURY) - treasuryBefore,
            (amount * 450) / 10_000,
            "a wallet-to-wallet payment reached Bob without paying the treasury its 4.5%"
        );
    }
}

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

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

interface IERC20Min {
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

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

/// @notice The subset of the Uniswap v4 PoolManager that any address may use without a pool:
///         unlock -> sync -> (ERC-20 transfer in) -> settle -> take. The real manager exposes the
///         same functions, permissionlessly, guarded only by the unlock lock and a zero net delta.
contract RelayPoolManager {
    address locker;
    address synced;
    uint256 reserves;
    int256 delta;

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

    function sync(address currency) external {
        synced = currency;
        reserves = IERC20Min(currency).balanceOf(address(this));
    }

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

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

/// @notice Anyone's relay: moves `amount` of `token` from itself to `to` through the manager.
contract Relay is IUnlockCb {
    RelayPoolManager immutable manager;

    constructor(RelayPoolManager m) {
        manager = m;
    }

    function send(address token, address to, uint256 amount) external {
        manager.unlock(abi.encode(token, to, amount));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (address token, address to, uint256 amount) = abi.decode(data, (address, address, uint256));
        manager.sync(token);
        IERC20Min(token).transfer(address(manager), amount); // to == POOL_MANAGER: untaxed
        manager.settle();
        manager.take(token, to, amount); // from == POOL_MANAGER: untaxed
        return "";
    }
}

contract PoolManagerRelayTest is Test {
    address constant OWNER = address(0x0A11CE);
    address constant POOL_MANAGER = address(0x900C);
    address constant FACTORY = address(0xFAC7);
    address constant BOB = address(0xB0B);

    DCAToken token;
    Relay relay;

    function setUp() public {
        vm.etch(POOL_MANAGER, address(new RelayPoolManager()).code);
        vm.prank(FACTORY);
        token = new DCAToken(OWNER, FACTORY, POOL_MANAGER, 7);
        relay = new Relay(RelayPoolManager(POOL_MANAGER));
        // Alice's wallet is the relay contract; it holds 1,000 DCA received tax-free from the factory.
        vm.prank(FACTORY);
        token.transfer(address(relay), 1_000 ether);
    }

    /// @dev An ordinary holder moves 1,000 DCA to Bob through the PoolManager and pays no tax.
    ///      The documented behaviour is that a wallet-to-wallet transfer pays 5%: Bob 950, treasury 45,
    ///      5 burned. Fails on the current code because Bob receives 1,000 and the treasury 0.
    function test_relayThroughPoolManagerIsTaxed() public {
        uint256 supplyBefore = token.totalSupply();
        relay.send(address(token), BOB, 1_000 ether);

        assertEq(token.balanceOf(address(relay)), 0, "sender paid the full amount");
        assertEq(token.balanceOf(POOL_MANAGER), 0, "the manager keeps nothing");
        assertEq(token.balanceOf(token.TREASURY()), 45 ether, "treasury should have received 4.5%");
        assertEq(token.balanceOf(BOB), 950 ether, "recipient should have received 95%");
        assertEq(supplyBefore - token.totalSupply(), 5 ether, "0.5% should have been burned");
    }
}

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

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

/// @dev Deploys the token so the supply is minted to this contract, like the factory, and answers
///      `distributorOf` with nothing recorded.
contract FactoryStub {
    mapping(uint64 => address) public distributorOf;

    function deploy(address owner, address poolManager, uint64 launchNumber) external returns (DCAToken) {
        return new DCAToken(owner, address(this), poolManager, launchNumber);
    }

    function move(IERC20 token, address to, uint256 amount) external returns (bool) {
        return token.transfer(to, amount);
    }
}

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

/// @dev The Uniswap v4 PoolManager flows the token exempts, reduced to the three primitives any
///      locker may call with no pool involved at all: `sync` records the reserve, `settle` credits
///      the locker with whatever arrived since, `take` sends tokens out to any address. The real
///      manager does exactly this (Currency transfers in `take`, balance deltas in `settle`) and
///      requires the locker's delta to be zero when the lock closes.
contract PoolManagerStub {
    IERC20 public immutable token;
    address private locker;
    uint256 private reserve;
    int256 private delta;

    constructor(IERC20 token_) {
        token = token_;
    }

    function unlock(bytes calldata data) external returns (bytes memory result) {
        require(locker == address(0), "AlreadyUnlocked");
        locker = msg.sender;
        result = IUnlockCallback(msg.sender).unlockCallback(data);
        require(delta == 0, "CurrencyNotSettled");
        locker = address(0);
    }

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

    function settle() external returns (uint256 paid) {
        require(msg.sender == locker, "ManagerLocked");
        paid = token.balanceOf(address(this)) - reserve;
        reserve = token.balanceOf(address(this));
        delta += int256(paid);
    }

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

/// @dev What any holder can deploy: moves `amount` from the caller to `to` through the manager,
///      entering as a sell would and leaving as a buy would, without touching a pool.
contract PassThroughRelay is IUnlockCallback {
    PoolManagerStub public immutable manager;
    IERC20 public immutable token;

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

    function send(address to, uint256 amount) external {
        manager.unlock(abi.encode(msg.sender, to, amount));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not the manager");
        (address from, address to, uint256 amount) = abi.decode(data, (address, address, uint256));
        manager.sync();
        require(token.transferFrom(from, address(manager), amount), "pull failed");
        manager.settle();
        manager.take(to, amount);
        return "";
    }
}

contract PoolManagerPassThroughTest is Test {
    address constant OWNER = address(0x0A11CE);
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);
    uint64 constant LAUNCH_NUMBER = 7;

    FactoryStub factory;
    DCAToken token;
    PoolManagerStub manager;
    PassThroughRelay relay;

    function setUp() public {
        factory = new FactoryStub();
        // The manager's address must be known before the token is built; precompute it.
        address predictedManager = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 1);
        token = factory.deploy(OWNER, predictedManager, LAUNCH_NUMBER);
        manager = new PoolManagerStub(IERC20(address(token)));
        require(address(manager) == predictedManager, "manager prediction mismatch");
        relay = new PassThroughRelay(manager, IERC20(address(token)));
        assertTrue(factory.move(IERC20(address(token)), ALICE, 1_000 ether));
    }

    /// @dev A wallet-to-wallet transfer is supposed to pay 5%: 4.5% to the treasury, 0.5% burned.
    ///      Routed through the manager it pays nothing: Bob receives the whole 1000, the treasury
    ///      receives 0 and nothing is burned. Fails on the current code; passes once a transfer
    ///      that leaves the manager for an ordinary address is taxed like any other transfer.
    function test_passThroughTheManagerIsTaxedLikeAnOrdinaryTransfer() public {
        uint256 supplyBefore = token.totalSupply();
        assertEq(token.balanceOf(token.TREASURY()), 0);

        vm.prank(ALICE);
        token.approve(address(relay), 1_000 ether);
        vm.prank(ALICE);
        relay.send(BOB, 1_000 ether);

        assertEq(token.balanceOf(ALICE), 0, "Alice paid the gross amount");
        assertEq(token.balanceOf(address(manager)), 0, "the manager kept nothing");
        assertEq(token.balanceOf(token.TREASURY()), 45 ether, "the treasury did not receive 4.5%");
        assertEq(token.balanceOf(BOB), 950 ether, "Bob received more than 95%");
        assertEq(token.totalSupply(), supplyBefore - 5 ether, "the 0.5% slice was not burned");
    }
}