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

import {Test} from "forge-std/Test.sol";
import {LARPBurner} from "src/LARPBurner.sol";
import {IMDNames} from "src/IMDNames.sol";
import {ILARP} from "src/ILARP.sol";
import {SwarmPrices, Attestation, IIntake} from "src/SwarmPrices.sol";

/// @dev A plain ERC-20 ($IMD stand-in).
contract Token {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
        totalSupply += a;
    }

    function approve(address s, uint256 a) external returns (bool) {
        allowance[msg.sender][s] = a;
        return true;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }

    function transferFrom(address f, address to, uint256 a) external returns (bool) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[to] += a;
        return true;
    }
}

/// @dev IMD's Intake as far as propose() uses it: takes the fee and hands back a request id.
contract Intake {
    uint256 public count;

    function requestWithFailure(bytes32, bytes calldata, IIntake.Callback calldata, bytes4, address asset, uint256 amount)
        external
        returns (bytes32 id)
    {
        Token(asset).transferFrom(msg.sender, address(this), amount);
        id = keccak256(abi.encode("request", ++count));
    }
}

/// @title A signed verdict is not bound to the proposal it is delivered for
/// @notice onVerdict(requestId, a, signature) looks the proposal up by its `requestId` parameter but never checks
/// `a.requestId == requestId`, although the oracle signs `a.requestId`. One signature made for proposal A therefore
/// approves proposal A and, delivered again under B's id, proposal B (and every other pending proposal of this
/// contract). Fails on the code as it is (the second delivery is accepted); passes once onVerdict refuses an
/// attestation whose requestId is not the one it is delivered for.
contract Proof_VerdictNotBoundToRequest is Test {
    Token imd;
    Intake intake;
    IMDNames names;
    uint256 oracleKey = 0x0A11CE0;
    address oracleSigner;

    function setUp() public {
        imd = new Token();
        intake = new Intake();
        oracleSigner = vm.addr(oracleKey);
        LARPBurner burner = new LARPBurner(
            address(0xB0B), address(imd), 10_000, 60, address(0), 10_000, 200, address(0x6900), 0, 60, address(0), address(0)
        );
        names = new IMDNames(address(1), ILARP(address(2)), address(burner), address(0), address(intake), oracleSigner);
        imd.mint(address(this), 10 ether);
        imd.approve(address(names), type(uint256).max);
    }

    function _p(uint64 short, uint64 four, uint64 long_, uint64 crew) internal pure returns (SwarmPrices.Prices memory) {
        return SwarmPrices.Prices(short, four, long_, crew, 690);
    }

    /// @dev An attestation as IMD's oracle signs it (EIP-712 "IdentityMD Oracle" v2, for `names`), for `requestId`.
    function _yes(bytes32 requestId) internal view returns (Attestation memory a, bytes memory sig) {
        a = Attestation({
            requestId: requestId,
            chainId: block.chainid,
            questionHash: keccak256("the question"),
            answerType: 0,
            answer: abi.encode(true),
            figure: 0,
            fromBlock: 0,
            toBlock: uint64(block.number),
            blockHash: bytes32(0),
            panelJobId: bytes32(bytes16(keccak256("panel job"))),
            panelSize: 9,
            quorum: 7,
            agreed: 9,
            issuedAt: uint64(vm.getBlockTimestamp()),
            expiresAt: uint64(vm.getBlockTimestamp() + 1 days)
        });
        bytes32 structHash = keccak256(
            bytes.concat(
                abi.encode(
                    keccak256(
                        "OracleAttestation(bytes32 requestId,uint256 chainId,bytes32 questionHash,uint8 answerType,bytes answer,uint256 figure,uint64 fromBlock,uint64 toBlock,bytes32 blockHash,bytes32 panelJobId,uint16 panelSize,uint16 quorum,uint16 agreed,uint64 issuedAt,uint64 expiresAt)"
                    ),
                    a.requestId,
                    a.chainId,
                    a.questionHash,
                    a.answerType,
                    keccak256(a.answer),
                    a.figure,
                    a.fromBlock,
                    a.toBlock
                ),
                abi.encode(a.blockHash, a.panelJobId, a.panelSize, a.quorum, a.agreed, a.issuedAt, a.expiresAt)
            )
        );
        bytes32 domain = keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256("IdentityMD Oracle"),
                keccak256("2"),
                block.chainid,
                address(names)
            )
        );
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(oracleKey, keccak256(abi.encodePacked("\x19\x01", domain, structHash)));
        sig = abi.encodePacked(r, s, v);
    }

    function test_AVerdictSignedForOneProposalIsRefusedForAnother() public {
        bytes32 idA = names.propose(_p(0.005 ether, 0.0012 ether, 0.0005 ether, 0.0005 ether), 0.5 ether);
        bytes32 idB = names.propose(_p(0.008 ether, 0.002 ether, 0.0008 ether, 0.0008 ether), 0.5 ether);
        assertTrue(idA != idB);
        (Attestation memory a, bytes memory sig) = _yes(idA); // the oracle answered A

        vm.prank(address(intake));
        names.onVerdict(idA, a, sig); // delivered for A: fine
        assertEq(uint8(names.proposal(idA).status), uint8(SwarmPrices.Status.Approved));

        // the same signed answer, delivered for B: must not count as B's verdict
        vm.prank(address(intake));
        vm.expectRevert();
        names.onVerdict(idB, a, sig);
        assertEq(uint8(names.proposal(idB).status), uint8(SwarmPrices.Status.Pending), "B is still undecided");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LARP} from "src/LARP.sol";
import {LARPLinks} from "src/LARPLinks.sol";
import {IIMDNames} from "src/IIMDNames.sol";
import {ILARP} from "src/ILARP.sol";

/// @dev identity.md, as far as LARP reads it.
contract IdentityNFT {
    mapping(uint256 => address) public ownerOf;

    function mint(address to, uint256 id) external {
        ownerOf[id] = to;
    }
}

/// @dev IMD Names, as far as LARPLinks reads it: a crew price of zero, so no burner is needed.
contract FreeNames {
    function crewPrice() external pure returns (uint256) {
        return 0;
    }

    function nameOf(uint256) external pure returns (string memory) {
        return "";
    }
}

/// @dev Accepts the (empty) crew fee.
contract SinkBurner {
    function burn(uint256) external payable returns (uint256) {
        return 0;
    }
}

/// An agent's authority is meant to lapse when the owner revokes it (README: "The owner can replace or remove it
/// at any time"). Every other agent action is reversible by the owner, but `passCaptain` lets the agent hand the
/// owner's crew to the agent's own identity for good: after revocation the owner can no longer disband it.
contract AgentKeepsCrewTest is Test {
    IdentityNFT identity;
    LARP larp;
    LARPLinks links;
    address alice = makeAddr("alice");
    address agent = makeAddr("agent");

    function setUp() public {
        identity = new IdentityNFT();
        larp = new LARP(address(identity));
        FreeNames names = new FreeNames();
        SinkBurner burner = new SinkBurner();
        links = new LARPLinks(
            address(identity), makeAddr("launcher"), ILARP(address(larp)), IIMDNames(address(names)), address(burner)
        );
        identity.mint(alice, 1); // the owner's identity
        identity.mint(agent, 2); // the agent's own identity
    }

    function test_ARevokedAgentDoesNotKeepTheOwnersCrew() public {
        vm.prank(alice);
        larp.setAgent(1, agent);
        vm.prank(alice);
        uint256 crewId = links.foundCrew(1, bytes32("frens"), true, 0);

        // the agent joins with its own identity and passes the owner's captaincy to it
        vm.startPrank(agent);
        links.join(2, crewId);
        links.passCaptain(crewId, 2);
        vm.stopPrank();

        // the owner revokes the agent
        vm.prank(alice);
        larp.setAgent(1, address(0));
        (bool live,) = larp.canAct(1, agent);
        assertFalse(live, "the agent is revoked");

        // ...but the owner's crew (and its unique name) is now the agent's: the owner cannot disband or reclaim it,
        // and cannot found another crew with that name
        (uint256 captain,,,,) = links.crew(crewId);
        assertEq(captain, 1, "the owner's identity should still captain the crew it paid for");
        vm.prank(alice);
        links.disband(crewId);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockERC20} from "forge-std/mocks/MockERC20.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {PoolKey as V4PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";

import {LARP} from "src/LARP.sol";
import {IMDNames} from "src/IMDNames.sol";
import {LARPBurner} from "src/LARPBurner.sol";

contract Token is MockERC20 {
    constructor(string memory n) {
        initialize(n, n, 18);
    }

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

    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }
}

contract IdentityNFT {
    mapping(uint256 => address) public ownerOf;
}

/// @dev Adds full-range liquidity to a v4 pool, paid by the caller.
contract LiquidityAdder {
    IPoolManager immutable pm;

    constructor(IPoolManager pm_) {
        pm = pm_;
    }

    function add(V4PoolKey memory key, int256 liquidity) external payable {
        pm.unlock(abi.encode(key, liquidity, msg.sender));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (V4PoolKey memory key, int256 liquidity, address payer) = abi.decode(data, (V4PoolKey, int256, address));
        (BalanceDelta delta,) = pm.modifyLiquidity(
            key,
            ModifyLiquidityParams(
                TickMath.minUsableTick(key.tickSpacing), TickMath.maxUsableTick(key.tickSpacing), liquidity, 0
            ),
            ""
        );
        _pay(key.currency0, uint256(uint128(-delta.amount0())), payer);
        _pay(key.currency1, uint256(uint128(-delta.amount1())), payer);
        if (address(this).balance > 0) payable(payer).transfer(address(this).balance);
        return "";
    }

    function _pay(Currency currency, uint256 amount, address payer) internal {
        if (Currency.unwrap(currency) == address(0)) {
            pm.settle{value: amount}();
        } else {
            pm.sync(currency);
            Token(Currency.unwrap(currency)).transferFrom(payer, address(pm), amount);
            pm.settle();
        }
    }

    receive() external payable {}
}

/// `burn(minImd)` compares `minImd` with the $IMD bought for own + waiting ETH, so a payer's floor for its own fee
/// does not bound the fee's sale while ETH is waiting in the burner: a floor five times the fair quote for a
/// 0.00069 ETH fee passes, because 0.0993 ETH of someone else's royalties were sold in the same call.
contract MinImdWaitingTest is Test {
    Token imd;
    Token imd6900;
    PoolManager pm;
    LARPBurner burner;
    IMDNames names;
    address alice = makeAddr("alice");

    function setUp() public {
        IdentityNFT identity = new IdentityNFT();
        imd = new Token("IMD");
        imd6900 = new Token("IMD6900");
        pm = new PoolManager(address(this));
        LiquidityAdder adder = new LiquidityAdder(IPoolManager(address(pm)));
        V4PoolKey memory pool4 =
            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 60, IHooks(address(0)));
        V4PoolKey memory backup =
            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 200, IHooks(address(0)));
        pm.initialize(pool4, TickMath.getSqrtPriceAtTick(76_020)); // ~2,000 IMD per ETH
        pm.initialize(backup, TickMath.getSqrtPriceAtTick(76_000));
        bool imdIs0 = address(imd) < address(imd6900);
        V4PoolKey memory pair = imdIs0
            ? V4PoolKey(Currency.wrap(address(imd)), Currency.wrap(address(imd6900)), 0, 60, IHooks(address(0)))
            : V4PoolKey(Currency.wrap(address(imd6900)), Currency.wrap(address(imd)), 0, 60, IHooks(address(0)));
        pm.initialize(pair, TickMath.getSqrtPriceAtTick(imdIs0 ? int24(92_100) : int24(-92_100)));

        // the burner knows IMD Names before it exists (two creations later: LARP, IMDNames)
        address namesAt = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 2);
        burner = new LARPBurner(
            address(pm), address(imd), 10_000, 60, address(0), 10_000, 200, address(imd6900), 0, 60, address(0), namesAt
        );
        LARP larp = new LARP(address(identity));
        names = new IMDNames(
            address(identity), larp, address(burner), makeAddr("artist"), makeAddr("intake"), makeAddr("signer")
        );
        assertEq(address(names), namesAt);

        imd.mint(address(this), 1e30);
        imd.approve(address(adder), type(uint256).max);
        imd6900.mint(address(this), 1e33);
        imd6900.approve(address(adder), type(uint256).max);
        vm.deal(address(this), 10_000 ether);
        adder.add{value: 1_000 ether}(pool4, 1e21);
        adder.add{value: 1_000 ether}(backup, 1e21);
        adder.add(pair, 1e23);
    }

    function test_AFloorForTheFeeBindsTheFee() public {
        (bool ok,) = address(burner).call{value: 0.0993 ether}(""); // royalties waiting
        assertTrue(ok);
        bytes32 l = bytes32("alice");
        uint256 price = names.priceOf(l); // 0.00069 ETH
        uint256 floor = burner.quoteImd(price) * 5; // unreachable for the fee alone
        vm.deal(alice, price);
        vm.prank(alice);
        vm.expectRevert(LARPBurner.TooLittleIMD.selector);
        names.register{value: price}(l, alice, floor);
    }

    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {MockERC20} from "forge-std/mocks/MockERC20.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {PoolKey as V4PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";

import {LARP} from "src/LARP.sol";
import {IMDNames} from "src/IMDNames.sol";
import {LARPBurner} from "src/LARPBurner.sol";

contract Token is MockERC20 {
    constructor(string memory n) {
        initialize(n, n, 18);
    }

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

    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }
}

contract IdentityNFT {
    mapping(uint256 => address) public ownerOf;
}

/// @dev Adds full-range liquidity to a v4 pool, paid by the caller.
contract LiquidityAdder {
    IPoolManager immutable pm;

    constructor(IPoolManager pm_) {
        pm = pm_;
    }

    function add(V4PoolKey memory key, int256 liquidity) external payable {
        pm.unlock(abi.encode(key, liquidity, msg.sender));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (V4PoolKey memory key, int256 liquidity, address payer) = abi.decode(data, (V4PoolKey, int256, address));
        (BalanceDelta delta,) = pm.modifyLiquidity(
            key,
            ModifyLiquidityParams(
                TickMath.minUsableTick(key.tickSpacing), TickMath.maxUsableTick(key.tickSpacing), liquidity, 0
            ),
            ""
        );
        _pay(key.currency0, uint256(uint128(-delta.amount0())), payer);
        _pay(key.currency1, uint256(uint128(-delta.amount1())), payer);
        if (address(this).balance > 0) payable(payer).transfer(address(this).balance);
        return "";
    }

    function _pay(Currency currency, uint256 amount, address payer) internal {
        if (Currency.unwrap(currency) == address(0)) {
            pm.settle{value: amount}();
        } else {
            pm.sync(currency);
            Token(Currency.unwrap(currency)).transferFrom(payer, address(pm), amount);
            pm.settle();
        }
    }

    receive() external payable {}
}

/// `burn(minImd)` compares `minImd` with the $IMD bought for own + waiting ETH, so a payer's floor for its own fee
/// does not bound the fee's sale while ETH is waiting in the burner: a floor five times the fair quote for a
/// 0.00069 ETH fee passes, because 0.0993 ETH of someone else's royalties were sold in the same call.
contract MinImdWaitingTest is Test {
    Token imd;
    Token imd6900;
    PoolManager pm;
    LARPBurner burner;
    IMDNames names;
    address alice = makeAddr("alice");

    function setUp() public {
        IdentityNFT identity = new IdentityNFT();
        imd = new Token("IMD");
        imd6900 = new Token("IMD6900");
        pm = new PoolManager(address(this));
        LiquidityAdder adder = new LiquidityAdder(IPoolManager(address(pm)));
        V4PoolKey memory pool4 =
            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 60, IHooks(address(0)));
        V4PoolKey memory backup =
            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 200, IHooks(address(0)));
        pm.initialize(pool4, TickMath.getSqrtPriceAtTick(76_020)); // ~2,000 IMD per ETH
        pm.initialize(backup, TickMath.getSqrtPriceAtTick(76_000));
        bool imdIs0 = address(imd) < address(imd6900);
        V4PoolKey memory pair = imdIs0
            ? V4PoolKey(Currency.wrap(address(imd)), Currency.wrap(address(imd6900)), 0, 60, IHooks(address(0)))
            : V4PoolKey(Currency.wrap(address(imd6900)), Currency.wrap(address(imd)), 0, 60, IHooks(address(0)));
        pm.initialize(pair, TickMath.getSqrtPriceAtTick(imdIs0 ? int24(92_100) : int24(-92_100)));

        // the burner knows IMD Names before it exists (two creations later: LARP, IMDNames)
        address namesAt = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 2);
        burner = new LARPBurner(
            address(pm), address(imd), 10_000, 60, address(0), 10_000, 200, address(imd6900), 0, 60, address(0), namesAt
        );
        LARP larp = new LARP(address(identity));
        names = new IMDNames(
            address(identity), larp, address(burner), makeAddr("artist"), makeAddr("intake"), makeAddr("signer")
        );
        assertEq(address(names), namesAt);

        imd.mint(address(this), 1e30);
        imd.approve(address(adder), type(uint256).max);
        imd6900.mint(address(this), 1e33);
        imd6900.approve(address(adder), type(uint256).max);
        vm.deal(address(this), 10_000 ether);
        adder.add{value: 1_000 ether}(pool4, 1e21);
        adder.add{value: 1_000 ether}(backup, 1e21);
        adder.add(pair, 1e23);
    }

    function test_AFloorForTheFeeBindsTheFee() public {
        (bool ok,) = address(burner).call{value: 0.0993 ether}(""); // royalties waiting
        assertTrue(ok);
        bytes32 l = bytes32("alice");
        uint256 price = names.priceOf(l); // 0.00069 ETH
        uint256 floor = burner.quoteImd(price) * 5; // unreachable for the fee alone
        vm.deal(alice, price);
        vm.prank(alice);
        vm.expectRevert(LARPBurner.TooLittleIMD.selector);
        names.register{value: price}(l, alice, floor);
    }

    receive() external payable {}
}