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

import {Test} from "forge-std/Test.sol";
import {Registry} from "src/Registry.sol";
import {Renderer} from "src/Renderer.sol";
import {Composer} from "src/Composer.sol";

/// @notice The launch's protected floor deploys the three applications on an empty chain: the factory is
///         etched, nothing else exists at any address. The Registry constructor calls `curator.isSettled()`
///         and `intake.priceOf(...)` on addresses that hold no code there, so the constructor reverts and
///         the launch parks ("application 2 constructor failed"). This test fails on the current code and
///         passes once the constructor stops calling its dependencies (checking them on first use instead).
contract EmptyChainDeployTest is Test {
    address constant FACTORY = 0x00000000000000000000000000000000000fAc70;
    address constant CURATOR = 0x0919ba50b206C3F31D516De818b1fBc7dA21653D;
    address constant IDMD = 0x2C3013c90a1Bb65573aae9a7C64fafB82697E4e4;
    address constant IMD = 0x44a1Cd38474FB1748400E7DEb5F8D786ccE3F89A;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant ATTESTER = 0x5598Aa9146215Bc13eb26f2c692Ad1461Fd32982;

    function test_registryConstructsOnAnEmptyChainLikeTheLaunchFloor() public {
        vm.chainId(11155111);
        assertEq(CURATOR.code.length, 0, "precondition: no curator code on the rehearsal chain");
        assertEq(INTAKE.code.length, 0, "precondition: no intake code on the rehearsal chain");
        vm.startPrank(FACTORY);
        Renderer renderer = new Renderer();
        Composer composer = new Composer();
        Registry registry =
            new Registry(CURATOR, IDMD, IMD, INTAKE, ATTESTER, address(renderer), address(composer), address(0));
        vm.stopPrank();
        assertGt(address(registry).code.length, 0, "registry runtime missing");
        assertEq(address(registry.curator()), CURATOR);
        assertEq(address(registry.intake()), INTAKE);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Registry} from "src/Registry.sol";
import {Renderer} from "src/Renderer.sol";
import {Composer} from "src/Composer.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {OracleAttestation} from "src/interfaces/IOracleConsumer.sol";

contract SepoliaMockCurator {
    function isSettled() external pure returns (bool) {
        return true;
    }

    function firstHourOf(address) external pure returns (uint256, bool) {
        return (0, false);
    }

    function txCountOf(address) external pure returns (uint256) {
        return 0;
    }

    function contributedBy(address) external pure returns (uint256) {
        return 0;
    }

    function pointsOf(address) external pure returns (uint256) {
        return 0;
    }
}

contract SepoliaMockIDMD {
    function balanceOf(address) external pure returns (uint256) {
        return 0;
    }

    function ownerOf(uint256) external pure returns (address) {
        return address(0);
    }
}

contract SepoliaMockIMD {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

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

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

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

contract SepoliaMockIntake {
    uint256 internal nonce;
    bytes32 public lastId;
    address public target;
    bytes4 public selector;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

    function requestWithFailure(
        bytes32,
        bytes calldata,
        IIntake.Callback calldata callback,
        bytes4,
        address asset,
        uint256 amount
    ) external payable returns (bytes32 requestId) {
        SepoliaMockIMD(asset).transferFrom(msg.sender, address(this), amount);
        requestId = keccak256(abi.encode(++nonce));
        lastId = requestId;
        target = callback.target;
        selector = callback.selector;
    }

    /// @dev Delivers as Intake v2 `complete` does: the stored selector, 200,000 gas, inside a try.
    function complete(bytes calldata args) external returns (bool ok) {
        (ok,) = target.call{gas: 200_000}(abi.encodePacked(selector, args));
    }
}

/// @notice On the Sepolia rehearsal (chain 11155111) every question the registry composes is about Ethereum
///         mainnet (`"chainId": 1` in the body), so the attestation the oracle signs carries `chainId = 1`:
///         the chain the question is about, not the consumer's chain. `Registry._check` compares that field
///         with `block.chainid` and returns reason 3, so every paid request on Sepolia is `Missed` and no
///         oracle trait can ever be verified there. Fails on the current code; passes once check 3 compares
///         the attestation's chain with the question's chain (1) instead of the deployment chain.
contract SepoliaChainIdTest is Test {
    uint256 constant ATTESTER_KEY = 0xA11CE;
    uint64 constant B_H24 = 0x1895395;
    uint64 constant B_END = 0x18984a4;

    SepoliaMockIMD imd;
    SepoliaMockIntake intake;
    Registry registry;
    address claimant = address(0xC1A1);

    event Missed(bytes32 requestId, uint16 traitId, uint8 reason);

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_791_700_000);
        vm.roll(9_900_000);
        SepoliaMockCurator curator = new SepoliaMockCurator();
        SepoliaMockIDMD idmd = new SepoliaMockIDMD();
        imd = new SepoliaMockIMD();
        intake = new SepoliaMockIntake();
        Renderer renderer = new Renderer();
        Composer composer = new Composer();
        registry = new Registry(
            address(curator),
            address(idmd),
            address(imd),
            address(intake),
            vm.addr(ATTESTER_KEY),
            address(renderer),
            address(composer),
            address(0)
        );
    }

    function test_mainnetQuestionAnsweredOnSepoliaVerifies() public {
        imd.mint(claimant, 0.5 ether);
        vm.startPrank(claimant);
        imd.approve(address(registry), type(uint256).max);
        uint16[] memory ids = new uint16[](1);
        ids[0] = 701;
        registry.upgrade(ids, 0.5 ether);
        vm.stopPrank();
        bytes32 requestId = intake.lastId();
        (,,, bytes32 qh) = registry.pendingRequest(requestId);

        // The body the registry just sent asks about Ethereum mainnet.
        (bytes memory body,) = registry.composeBody(701, claimant);
        assertTrue(_contains(body, bytes('"chainId": 1,')), "the composed question is about chain 1");

        OracleAttestation memory a;
        a.requestId = keccak256("uuid");
        a.chainId = 1; // the chain the question is about, as the protocol defines the field
        a.questionHash = qh;
        a.answerType = 3;
        a.answer = abi.encode(uint256(1));
        a.fromBlock = B_H24;
        a.toBlock = B_END;
        a.blockHash = keccak256("block");
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 3;
        a.agreed = 3;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 30 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ATTESTER_KEY, registry.attestationDigest(a));
        bytes memory sig = abi.encodePacked(r, s, v);

        bool delivered = intake.complete(abi.encode(requestId, a, sig));
        assertTrue(delivered, "callback reverted");
        assertTrue(registry.hasTrait(claimant, 701), "a correctly signed mainnet answer was Missed on Sepolia");
    }

    function _contains(bytes memory hay, bytes memory needle) internal pure returns (bool) {
        if (needle.length > hay.length) return false;
        for (uint256 i; i + needle.length <= hay.length; ++i) {
            bool ok = true;
            for (uint256 j; j < needle.length; ++j) {
                if (hay[i + j] != needle[j]) {
                    ok = false;
                    break;
                }
            }
            if (ok) return true;
        }
        return false;
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Registry} from "src/Registry.sol";
import {Renderer} from "src/Renderer.sol";
import {Composer} from "src/Composer.sol";
import {Spec} from "src/Types.sol";

contract MintableIMD {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    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 t, uint256 a) external returns (bool) {
        allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[t] += a;
        return true;
    }
}

/// @dev Sepolia launch state: chain 11155111 at its real height (11,925,589 on 2026-10-16), the launch's
///      constructor arguments. Every question the registry composes is about Ethereum mainnet
///      (QUESTION_CHAIN_ID = 1, "on Ethereum mainnet" in the text), but `registerSpec` compares the
///      spec's mainnet `toBlock` with Sepolia's `block.number`, so a spec over the catalog's own closed
///      mainnet window (0x189378e..0x18984a4, blocks 25.77M..25.79M) is refused with BadSpec("window").
contract SepoliaSpecWindowTest is Test {
    address constant CURATOR = 0x0919ba50b206C3F31D516De818b1fBc7dA21653D;
    address constant IDMD = 0x2C3013c90a1Bb65573aae9a7C64fafB82697E4e4;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant ATTESTER = 0x5598Aa9146215Bc13eb26f2c692Ad1461Fd32982;
    uint64 constant B_DEPLOY = 0x189378e;
    uint64 constant B_END = 0x18984a4;

    Registry registry;
    MintableIMD imd;
    address alice = address(0xA11CE);

    function setUp() public {
        vm.chainId(11155111);
        vm.roll(11_925_589);
        vm.warp(1_792_000_000);
        imd = new MintableIMD();
        Renderer renderer = new Renderer();
        Composer composer = new Composer();
        registry = new Registry(
            CURATOR, IDMD, address(imd), INTAKE, ATTESTER, address(renderer), address(composer), address(0)
        );
        imd.mint(alice, 100 ether);
        vm.prank(alice);
        imd.approve(address(registry), type(uint256).max);
    }

    function _spec(uint8 kind, uint64 from, uint64 to) internal pure returns (Spec memory s) {
        s.kind = kind;
        s.target = kind == 5 ? address(0) : 0xcB0b0531e86A9aC36Fa865cA8e3dbccF047FDA91;
        s.item = kind == 5 ? "" : "event Deposited(address indexed contributor, uint256 indexed hour, uint256 amount)";
        s.arg = kind == 5 ? "" : "contributor";
        s.threshold = 1;
        s.fromBlock = from;
        s.toBlock = to;
        s.name = "Mainnet window";
    }

    /// Fails now: a T1 spec over the catalog's own, long-closed mainnet window reverts BadSpec("window")
    /// on Sepolia. Passes once the recency guard stops measuring a mainnet window against Sepolia's height.
    function test_catalogEraMainnetWindowSpecRegistersOnSepolia() public {
        vm.prank(alice);
        uint16 id = registry.registerSpec(_spec(1, B_DEPLOY, B_END));
        assertEq(id, 10001);
        assertEq(registry.specOf(id).toBlock, B_END);
    }

    /// Fails now: a T5 nonce spec pinned at the Curator deploy block (also 7,200 blocks old on mainnet
    /// months ago) reverts BadSpec("window") on Sepolia.
    function test_catalogEraMainnetNonceSpecRegistersOnSepolia() public {
        vm.prank(alice);
        uint16 id = registry.registerSpec(_spec(5, B_DEPLOY, B_DEPLOY));
        assertEq(id, 10001);
    }

    /// Passes before and after: only windows that end below Sepolia's own height, i.e. mainnet blocks
    /// from 2021 and earlier, are accepted today.
    function test_onlyWindowsBelowSepoliaHeightAreAcceptedToday() public {
        vm.prank(alice);
        uint16 id = registry.registerSpec(_spec(1, 11_900_000, 11_925_588));
        assertEq(id, 10001);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Registry} from "src/Registry.sol";
import {Renderer} from "src/Renderer.sol";
import {Composer} from "src/Composer.sol";
import {Spec} from "src/Types.sol";

/// @dev Minimal ERC-20 so the registry can pull SPEC_FEE; no other dependency is called by registerSpec.
contract FeeToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

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

    function transferFrom(address f, address t, uint256 v) external returns (bool) {
        allowance[f][msg.sender] -= v;
        balanceOf[f] -= v;
        balanceOf[t] += v;
        return true;
    }
}

/// @notice On Sepolia (height ~11.93M on 2026-10-16) `registerSpec` rejects every community spec whose
///         Ethereum-mainnet window ends after Sepolia's current block, because `Composer.validateSpec`
///         compares the mainnet window against the deployment chain's `block.number`. The catalog's own
///         window (25,769,870..25,789,604) is refused with `BadSpec("window")` although the same spec is
///         accepted at mainnet height.
contract SepoliaSpecWindowTest is Test {
    uint64 internal constant B_DEPLOY = 0x189378e;
    uint64 internal constant B_END = 0x18984a4;
    uint256 internal constant SEPOLIA_HEIGHT = 11_925_593;
    uint256 internal constant MAINNET_HEIGHT = 26_200_000;

    FeeToken internal imd;
    Registry internal registry;

    function _deploy() internal {
        imd = new FeeToken();
        Renderer renderer = new Renderer();
        Composer composer = new Composer();
        registry = new Registry(
            0x0919ba50b206C3F31D516De818b1fBc7dA21653D,
            0x2C3013c90a1Bb65573aae9a7C64fafB82697E4e4,
            address(imd),
            0xa43e6F75ee006411F79Ac1C84120606C2330DE82,
            0x5598Aa9146215Bc13eb26f2c692Ad1461Fd32982,
            address(renderer),
            address(composer),
            address(0)
        );
        imd.mint(address(this), 100 ether);
        imd.approve(address(registry), type(uint256).max);
    }

    function _mainnetWindowSpec() internal pure returns (Spec memory s) {
        s.kind = 1;
        s.target = 0xcB0b0531e86A9aC36Fa865cA8e3dbccF047FDA91; // the mainnet Curator the question is about
        s.item = "event Deposited(address indexed contributor, uint256 indexed hour, uint256 amount, uint256 creditedDelta, uint256 weightAdded, uint256 newWeight, uint256 txCount, uint256 hourTotal, uint256 earlyBps)";
        s.arg = "contributor";
        s.threshold = 1;
        s.fromBlock = B_DEPLOY;
        s.toBlock = B_END;
        s.name = "Catalog window";
    }

    /// @dev Sanity: the same spec is accepted where the launch is rehearsed for.
    function test_mainnetHeightAcceptsTheCatalogWindow() public {
        vm.chainId(1);
        vm.roll(MAINNET_HEIGHT);
        _deploy();
        uint16 id = registry.registerSpec(_mainnetWindowSpec());
        assertEq(id, 10001);
    }

    /// @dev Fails on the current code: `BadSpec("window")` because 25,789,604 >= 11,925,593.
    function test_sepoliaHeightAcceptsTheSameMainnetWindow() public {
        vm.chainId(11155111);
        vm.roll(SEPOLIA_HEIGHT);
        _deploy();
        uint16 id = registry.registerSpec(_mainnetWindowSpec());
        assertEq(id, 10001, "a mainnet window that is in mainnet's past must register on the rehearsal chain");
        Spec memory stored = registry.specOf(id);
        assertEq(stored.toBlock, B_END);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Registry} from "src/Registry.sol";
import {Renderer} from "src/Renderer.sol";
import {Composer} from "src/Composer.sol";
import {Spec} from "src/Types.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract TestIMD is ERC20 {
    constructor() ERC20("TestIMD", "IMD") {}

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

/// @notice On Sepolia (chain 11155111) the chain head is far below the mainnet block numbers every
///         catalog window and any current community spec uses (Sepolia head 11,925,590 on 2026-10-16,
///         `eth_blockNumber` = 0xb5f856; mainnet B_END = 0x18984a4 = 25,789,604). `registerSpec` validates
///         the spec's mainnet window against the deployment chain's `block.number`, so on Sepolia a spec
///         whose mainnet window has already closed is refused as "in the future".
contract SepoliaRegisterSpecTest is Test {
    address constant CURATOR = 0x0919ba50b206C3F31D516De818b1fBc7dA21653D;
    address constant IDMD = 0x2C3013c90a1Bb65573aae9a7C64fafB82697E4e4;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant ATTESTER = 0x5598Aa9146215Bc13eb26f2c692Ad1461Fd32982;
    uint64 constant B_DEPLOY = 0x189378e;
    uint64 constant B_END = 0x18984a4;
    uint256 constant SEPOLIA_HEAD = 0xb5f856;

    Registry registry;
    TestIMD imd;
    address author = address(0xA11CE);

    function setUp() public {
        vm.chainId(11155111);
        vm.roll(SEPOLIA_HEAD);
        vm.warp(1_792_000_000);
        imd = new TestIMD();
        Renderer renderer = new Renderer();
        Composer composer = new Composer();
        registry = new Registry(CURATOR, IDMD, address(imd), INTAKE, ATTESTER, address(renderer), address(composer), address(0));
        imd.mint(author, 6.4 ether);
        vm.prank(author);
        imd.approve(address(registry), type(uint256).max);
    }

    function _spec() internal pure returns (Spec memory s) {
        s.kind = 1;
        s.target = 0xcB0b0531e86A9aC36Fa865cA8e3dbccF047FDA91; // the mainnet Curator, a closed mainnet window
        s.item = "event Transfer(address indexed from, address indexed to, uint256 value)";
        s.arg = "to";
        s.threshold = 1;
        s.fromBlock = B_DEPLOY;
        s.toBlock = B_END;
        s.name = "Mainnet window";
    }

    /// @dev Expected: a spec over the catalog's own, already closed, mainnet window registers on Sepolia.
    ///      Actual: `BadSpec("window")` because `s.toBlock (25,789,604) >= block.number (11,925,590)`.
    function test_specOverClosedMainnetWindowRegistersOnSepolia() public {
        vm.prank(author);
        uint16 id = registry.registerSpec(_spec());
        assertEq(id, 10001, "first community spec id");
        assertEq(imd.balanceOf(address(registry)), 6.4 ether, "spec fee collected");
    }

    /// @dev The same spec with kind 5 (panel nonce at one mainnet block) is refused the same way.
    function test_panelSpecAtMainnetBlockRegistersOnSepolia() public {
        Spec memory s;
        s.kind = 5;
        s.threshold = 20;
        s.fromBlock = B_DEPLOY;
        s.toBlock = B_DEPLOY;
        s.name = "Mainnet nonce";
        vm.prank(author);
        uint16 id = registry.registerSpec(s);
        assertEq(id, 10001);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Registry} from "src/Registry.sol";
import {Renderer} from "src/Renderer.sol";
import {Composer} from "src/Composer.sol";
import {Spec} from "src/Types.sol";

/// @dev Minimal IMD stand-in: enough ERC-20 for `safeTransferFrom` to pull the 6.4 IMD spec fee.
contract FeeToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

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

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

/// @notice On Sepolia (chain 11155111, block ~11.93M on 2026-10-16) `registerSpec` refuses every spec whose
///         window is a mainnet block range of the Curator era (25.77M+), because `Composer.validateSpec`
///         compares the mainnet window with the deployment chain's `block.number`. The questions the registry
///         composes are always about Ethereum mainnet (`QUESTION_CHAIN_ID = 1`), so a community spec with the
///         catalog's own window cannot be registered in the rehearsal. Fails on the current code with
///         `BadSpec("window")`; passes once the past-window guard is measured against the question chain.
contract SepoliaSpecWindowTest is Test {
    uint64 internal constant B_DEPLOY = 0x189378e; // mainnet 25,769,870
    uint64 internal constant B_END = 0x18984a4; // mainnet 25,789,604
    uint256 internal constant SEPOLIA_BLOCK = 11_925_593; // ethereum-sepolia-rpc.publicnode.com, 2026-10-16

    FeeToken internal imd;
    Registry internal registry;
    address internal alice = address(0xA11CE);

    function setUp() public {
        vm.chainId(11155111);
        vm.roll(SEPOLIA_BLOCK);
        vm.warp(1_792_000_000);
        imd = new FeeToken();
        Renderer renderer = new Renderer();
        Composer composer = new Composer();
        registry = new Registry(
            0x0919ba50b206C3F31D516De818b1fBc7dA21653D,
            0x2C3013c90a1Bb65573aae9a7C64fafB82697E4e4,
            address(imd),
            0xa43e6F75ee006411F79Ac1C84120606C2330DE82,
            0x5598Aa9146215Bc13eb26f2c692Ad1461Fd32982,
            address(renderer),
            address(composer),
            address(0)
        );
        imd.mint(alice, 20 ether);
        vm.prank(alice);
        imd.approve(address(registry), type(uint256).max);
    }

    function _t1(uint64 from, uint64 to) internal pure returns (Spec memory s) {
        s.kind = 1;
        s.target = 0x0919ba50b206C3F31D516De818b1fBc7dA21653D;
        s.item = "event Deposited(address indexed contributor, uint256 indexed hour, uint256 amount)";
        s.arg = "contributor";
        s.threshold = 1;
        s.fromBlock = from;
        s.toBlock = to;
        s.name = "Catalog window";
    }

    /// The catalog's own mainnet window, 19,735 mainnet blocks ending 2026-10-11, is a valid past window for
    /// the question chain but is refused on Sepolia because 25,789,604 >= Sepolia block 11,925,593.
    function test_sepoliaAcceptsACommunitySpecWithTheCatalogMainnetWindow() public {
        vm.prank(alice);
        uint16 id = registry.registerSpec(_t1(B_DEPLOY, B_END));
        assertEq(id, 10001);
        Spec memory stored = registry.specOf(id);
        assertEq(stored.fromBlock, B_DEPLOY);
        assertEq(stored.toBlock, B_END);
        assertEq(imd.balanceOf(address(registry)), 6.4 ether);
    }

    /// A T5 nonce spec pinned at the Curator deploy block (the catalog's own 1301 window) is refused the same way.
    function test_sepoliaAcceptsAPanelSpecPinnedAtTheCuratorDeployBlock() public {
        Spec memory s;
        s.kind = 5;
        s.threshold = 20;
        s.fromBlock = B_DEPLOY;
        s.toBlock = B_DEPLOY;
        s.name = "Nonce at deploy";
        vm.prank(alice);
        uint16 id = registry.registerSpec(s);
        assertEq(id, 10001);
    }
}