预测市场 + SDK — 实现

For Claude: REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.

Goal: Build Polymarket-style prediction market (3 Solidity contracts + tests) and isomorphic TypeScript SDK.

Architecture: Simplified Gnosis CTF (no nesting) + on-chain CLOB (EIP-712) + OracleHub hybrid settlement. SDK uses viem for isomorphic browser+Node.js support.

Tech Stack: Solidity 0.8.26, Foundry, OpenZeppelin ERC1155, TypeScript, viem, vitest, tsup

---

Task 1: Interfaces

Files:

• Create: contracts/src/prediction/interfaces/IConditionalTokens.sol

• Create: contracts/src/prediction/interfaces/ICTFExchange.sol

• Create: contracts/src/prediction/interfaces/IOracleResolver.sol

Step 1: Create IConditionalTokens interface

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IConditionalTokens {
    event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount);
    event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators);
    event PositionSplit(address indexed stakeholder, IERC20 collateralToken, bytes32 indexed conditionId, uint256[] partition, uint256 amount);
    event PositionsMerge(address indexed stakeholder, IERC20 collateralToken, bytes32 indexed conditionId, uint256[] partition, uint256 amount);
    event PayoutRedemption(address indexed redeemer, IERC20 collateralToken, bytes32 indexed conditionId, uint256[] indexSets, uint256 payout);

    function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) external;
    function reportPayouts(bytes32 questionId, uint256[] calldata payouts) external;
    function splitPosition(IERC20 collateralToken, bytes32 conditionId, uint256[] calldata partition, uint256 amount) external;
    function mergePositions(IERC20 collateralToken, bytes32 conditionId, uint256[] calldata partition, uint256 amount) external;
    function redeemPositions(IERC20 collateralToken, bytes32 conditionId, uint256[] calldata indexSets) external;

    function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) external pure returns (bytes32);
    function getPositionId(IERC20 collateralToken, bytes32 conditionId, uint256 indexSet) external pure returns (uint256);
    function getOutcomeSlotCount(bytes32 conditionId) external view returns (uint256);
    function payoutDenominator(bytes32 conditionId) external view returns (uint256);
}

Step 2: Create ICTFExchange interface

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

interface ICTFExchange {
    enum Side { BUY, SELL }
    enum MatchType { COMPLEMENTARY, MINT, MERGE }

    struct Order {
        uint256 salt;
        address maker;
        address signer;
        uint256 tokenId;
        uint256 makerAmount;
        uint256 takerAmount;
        uint256 expiration;
        uint256 nonce;
        uint256 feeRateBps;
        Side side;
    }

    event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee);
    event OrderCancelled(bytes32 indexed orderHash);
    event NonceIncremented(address indexed maker, uint256 newNonce);

    function fillOrder(Order calldata order, uint256 fillAmount, bytes calldata signature) external;
    function matchOrders(Order calldata takerOrder, Order[] calldata makerOrders, uint256 takerFillAmount, uint256[] calldata makerFillAmounts, bytes[] calldata makerSignatures, bytes calldata takerSignature) external;
    function cancelOrder(Order calldata order) external;
    function incrementNonce() external;

    function getOrderHash(Order calldata order) external view returns (bytes32);
    function getOrderStatus(bytes32 orderHash) external view returns (uint256 filled, bool cancelled);
    function nonces(address maker) external view returns (uint256);
}

Step 3: Create IOracleResolver interface

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IOracleResolver {
    enum ResolutionType { PRICE_THRESHOLD, MANUAL }

    struct Market {
        bytes32 conditionId;
        bytes32 questionId;
        ResolutionType resolutionType;
        address creator;
        bool resolved;
        IERC20 collateral;
        uint256 outcomeSlotCount;
        string priceSymbol;
        uint256 priceThreshold;
        uint256 resolutionTime;
        address resolver;
    }

    event MarketCreated(bytes32 indexed marketId, bytes32 indexed conditionId, ResolutionType resolutionType, address creator);
    event MarketResolved(bytes32 indexed marketId, uint256[] payouts);

    function createPriceMarket(string calldata question, string calldata symbol, uint256 threshold, uint256 resolutionTime, IERC20 collateral, uint256 outcomeCount) external returns (bytes32 marketId);
    function createManualMarket(string calldata question, address resolver, IERC20 collateral, uint256 outcomeCount) external returns (bytes32 marketId);
    function resolvePrice(bytes32 marketId) external;
    function resolveManual(bytes32 marketId, uint256[] calldata payouts) external;
    function getMarket(bytes32 marketId) external view returns (Market memory);
}

Step 4: Verify compilation

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: compiles with no errors

Step 5: Commit

git add contracts/src/prediction/
git commit -m "feat(prediction): add interfaces for ConditionalTokens, CTFExchange, OracleResolver"

---

Task 2: ConditionalTokens Contract

Files:

• Create: contracts/src/prediction/ConditionalTokens.sol

Step 1: Write ConditionalTokens

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

import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IConditionalTokens} from "./interfaces/IConditionalTokens.sol";

/// @title ConditionalTokens — Simplified Gnosis CTF (no nesting)
/// @notice ERC-1155 conditional position tokens: split collateral into outcome positions, merge back, redeem after resolution.
contract ConditionalTokens is ERC1155, IConditionalTokens {
    using SafeERC20 for IERC20;

    // conditionId => payoutNumerators (length == outcomeSlotCount; all zero until resolved)
    mapping(bytes32 => uint256[]) internal _payoutNumerators;
    // conditionId => payoutDenominator (0 until resolved)
    mapping(bytes32 => uint256) internal _payoutDenominator;

    constructor() ERC1155("") {}

    // ──────────────────── Pure helpers ────────────────────

    function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(oracle, questionId, outcomeSlotCount));
    }

    function getPositionId(IERC20 collateralToken, bytes32 conditionId, uint256 indexSet) public pure returns (uint256) {
        return uint256(keccak256(abi.encodePacked(address(collateralToken), conditionId, indexSet)));
    }

    function getOutcomeSlotCount(bytes32 conditionId) external view returns (uint256) {
        return _payoutNumerators[conditionId].length;
    }

    function payoutDenominator(bytes32 conditionId) external view returns (uint256) {
        return _payoutDenominator[conditionId];
    }

    function payoutNumerators(bytes32 conditionId) external view returns (uint256[] memory) {
        return _payoutNumerators[conditionId];
    }

    // ──────────────────── Condition lifecycle ────────────────────

    function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) external {
        require(outcomeSlotCount >= 2, "need >=2 outcomes");
        bytes32 conditionId = getConditionId(oracle, questionId, outcomeSlotCount);
        require(_payoutNumerators[conditionId].length == 0, "condition already prepared");
        _payoutNumerators[conditionId] = new uint256[](outcomeSlotCount);
        emit ConditionPreparation(conditionId, oracle, questionId, outcomeSlotCount);
    }

    function reportPayouts(bytes32 questionId, uint256[] calldata payouts) external {
        uint256 outcomeSlotCount = payouts.length;
        require(outcomeSlotCount >= 2, "need >=2 outcomes");
        bytes32 conditionId = getConditionId(msg.sender, questionId, outcomeSlotCount);
        require(_payoutNumerators[conditionId].length == outcomeSlotCount, "condition not prepared");
        require(_payoutDenominator[conditionId] == 0, "already resolved");

        uint256 den;
        for (uint256 i; i < outcomeSlotCount; i++) {
            uint256 num = payouts[i];
            den += num;
            _payoutNumerators[conditionId][i] = num;
        }
        require(den > 0, "payout all zeros");
        _payoutDenominator[conditionId] = den;
        emit ConditionResolution(conditionId, msg.sender, questionId, outcomeSlotCount, _payoutNumerators[conditionId]);
    }

    // ──────────────────── Position operations ────────────────────

    function splitPosition(IERC20 collateralToken, bytes32 conditionId, uint256[] calldata partition, uint256 amount) external {
        require(partition.length > 1, "singleton partition");
        uint256 outcomeSlotCount = _payoutNumerators[conditionId].length;
        require(outcomeSlotCount > 0, "condition not prepared");

        uint256 fullIndexSet = (1 << outcomeSlotCount) - 1;
        uint256 freeIndexSet = fullIndexSet;

        uint256[] memory positionIds = new uint256[](partition.length);
        uint256[] memory amounts = new uint256[](partition.length);

        for (uint256 i; i < partition.length; i++) {
            uint256 indexSet = partition[i];
            require(indexSet > 0 && indexSet < fullIndexSet + 1, "invalid index set");
            require((indexSet & freeIndexSet) == indexSet, "partition not disjoint");
            freeIndexSet ^= indexSet;
            positionIds[i] = getPositionId(collateralToken, conditionId, indexSet);
            amounts[i] = amount;
        }

        require(freeIndexSet == 0, "partition must be full");
        collateralToken.safeTransferFrom(msg.sender, address(this), amount);

        for (uint256 i; i < partition.length; i++) {
            _mint(msg.sender, positionIds[i], amounts[i], "");
        }
        emit PositionSplit(msg.sender, collateralToken, conditionId, partition, amount);
    }

    function mergePositions(IERC20 collateralToken, bytes32 conditionId, uint256[] calldata partition, uint256 amount) external {
        require(partition.length > 1, "singleton partition");
        uint256 outcomeSlotCount = _payoutNumerators[conditionId].length;
        require(outcomeSlotCount > 0, "condition not prepared");

        uint256 fullIndexSet = (1 << outcomeSlotCount) - 1;
        uint256 freeIndexSet = fullIndexSet;

        for (uint256 i; i < partition.length; i++) {
            uint256 indexSet = partition[i];
            require(indexSet > 0 && indexSet < fullIndexSet + 1, "invalid index set");
            require((indexSet & freeIndexSet) == indexSet, "partition not disjoint");
            freeIndexSet ^= indexSet;
            uint256 positionId = getPositionId(collateralToken, conditionId, indexSet);
            _burn(msg.sender, positionId, amount);
        }

        require(freeIndexSet == 0, "partition must be full");
        collateralToken.safeTransfer(msg.sender, amount);
        emit PositionsMerge(msg.sender, collateralToken, conditionId, partition, amount);
    }

    function redeemPositions(IERC20 collateralToken, bytes32 conditionId, uint256[] calldata indexSets) external {
        uint256 den = _payoutDenominator[conditionId];
        require(den > 0, "not resolved");
        uint256 outcomeSlotCount = _payoutNumerators[conditionId].length;

        uint256 totalPayout;
        uint256 fullIndexSet = (1 << outcomeSlotCount) - 1;

        for (uint256 i; i < indexSets.length; i++) {
            uint256 indexSet = indexSets[i];
            require(indexSet > 0 && indexSet <= fullIndexSet, "invalid index set");
            uint256 positionId = getPositionId(collateralToken, conditionId, indexSet);
            uint256 stake = balanceOf(msg.sender, positionId);
            if (stake == 0) continue;

            uint256 payoutNum;
            for (uint256 j; j < outcomeSlotCount; j++) {
                if (indexSet & (1 << j) != 0) {
                    payoutNum += _payoutNumerators[conditionId][j];
                }
            }
            totalPayout += (stake * payoutNum) / den;
            _burn(msg.sender, positionId, stake);
        }

        if (totalPayout > 0) {
            collateralToken.safeTransfer(msg.sender, totalPayout);
        }
        emit PayoutRedemption(msg.sender, collateralToken, conditionId, indexSets, totalPayout);
    }
}

Step 2: Verify compilation

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: compiles with no errors

Step 3: Commit

git add contracts/src/prediction/ConditionalTokens.sol
git commit -m "feat(prediction): add ConditionalTokens ERC-1155 contract"

---

Task 3: ConditionalTokens Tests

Files:

• Create: contracts/test/ConditionalTokens.t.sol

Step 1: Write tests

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

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

contract MockERC20 is ERC20 {
    constructor() ERC20("Mock WETH", "WETH") {}
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

contract ConditionalTokensTest is Test {
    ConditionalTokens ct;
    MockERC20 weth;
    address oracle = address(0xAA);
    address alice = address(0xA1);
    address bob = address(0xB0);
    bytes32 questionId = keccak256("ETH > 3000?");
    bytes32 conditionId;

    function setUp() public {
        ct = new ConditionalTokens();
        weth = new MockERC20();
        conditionId = ct.getConditionId(oracle, questionId, 2);
        weth.mint(alice, 100 ether);
        weth.mint(bob, 100 ether);
        vm.prank(alice);
        weth.approve(address(ct), type(uint256).max);
        vm.prank(bob);
        weth.approve(address(ct), type(uint256).max);
    }

    // ─── getConditionId / getPositionId ───

    function test_getConditionId_deterministic() public view {
        bytes32 expected = keccak256(abi.encodePacked(oracle, questionId, uint256(2)));
        assertEq(ct.getConditionId(oracle, questionId, 2), expected);
    }

    function test_getPositionId_deterministic() public view {
        uint256 expected = uint256(keccak256(abi.encodePacked(address(weth), conditionId, uint256(1))));
        assertEq(ct.getPositionId(IERC20(address(weth)), conditionId, 1), expected);
    }

    // ─── prepareCondition ───

    function test_prepareCondition_success() public {
        ct.prepareCondition(oracle, questionId, 2);
        assertEq(ct.getOutcomeSlotCount(conditionId), 2);
    }

    function test_prepareCondition_revert_lessThan2() public {
        vm.expectRevert("need >=2 outcomes");
        ct.prepareCondition(oracle, questionId, 1);
    }

    function test_prepareCondition_revert_duplicate() public {
        ct.prepareCondition(oracle, questionId, 2);
        vm.expectRevert("condition already prepared");
        ct.prepareCondition(oracle, questionId, 2);
    }

    // ─── splitPosition ───

    function test_splitPosition_binary() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1; // YES
        partition[1] = 2; // NO

        vm.prank(alice);
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 10 ether);

        uint256 yesId = ct.getPositionId(IERC20(address(weth)), conditionId, 1);
        uint256 noId = ct.getPositionId(IERC20(address(weth)), conditionId, 2);
        assertEq(ct.balanceOf(alice, yesId), 10 ether);
        assertEq(ct.balanceOf(alice, noId), 10 ether);
        assertEq(weth.balanceOf(address(ct)), 10 ether);
    }

    function test_splitPosition_revert_notPrepared() public {
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;
        vm.prank(alice);
        vm.expectRevert("condition not prepared");
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 10 ether);
    }

    function test_splitPosition_revert_partialPartition() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory partition = new uint256[](1);
        partition[0] = 1;
        vm.prank(alice);
        vm.expectRevert("singleton partition");
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 10 ether);
    }

    function test_splitPosition_revert_notFullPartition() public {
        ct.prepareCondition(oracle, questionId, 3);
        bytes32 cid3 = ct.getConditionId(oracle, questionId, 3);
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1; // outcome 0
        partition[1] = 2; // outcome 1 (missing outcome 2 = 4)
        vm.prank(alice);
        vm.expectRevert("partition must be full");
        ct.splitPosition(IERC20(address(weth)), cid3, partition, 1 ether);
    }

    // ─── mergePositions ───

    function test_mergePositions_fullCycle() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;

        vm.startPrank(alice);
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 10 ether);
        ct.mergePositions(IERC20(address(weth)), conditionId, partition, 10 ether);
        vm.stopPrank();

        uint256 yesId = ct.getPositionId(IERC20(address(weth)), conditionId, 1);
        assertEq(ct.balanceOf(alice, yesId), 0);
        assertEq(weth.balanceOf(alice), 100 ether);
    }

    function test_mergePositions_revert_insufficientBalance() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;

        vm.startPrank(alice);
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 5 ether);
        vm.expectRevert(); // ERC1155 insufficient balance
        ct.mergePositions(IERC20(address(weth)), conditionId, partition, 10 ether);
        vm.stopPrank();
    }

    // ─── reportPayouts ───

    function test_reportPayouts_success() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory payouts = new uint256[](2);
        payouts[0] = 1;
        payouts[1] = 0;
        vm.prank(oracle);
        ct.reportPayouts(questionId, payouts);
        assertEq(ct.payoutDenominator(conditionId), 1);
    }

    function test_reportPayouts_revert_notOracle() public {
        ct.prepareCondition(oracle, questionId, 2);
        // conditionId includes msg.sender as oracle, so alice's conditionId won't match
        uint256[] memory payouts = new uint256[](2);
        payouts[0] = 1;
        payouts[1] = 0;
        vm.prank(alice);
        vm.expectRevert("condition not prepared");
        ct.reportPayouts(questionId, payouts);
    }

    function test_reportPayouts_revert_alreadyResolved() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory payouts = new uint256[](2);
        payouts[0] = 1;
        payouts[1] = 0;
        vm.prank(oracle);
        ct.reportPayouts(questionId, payouts);
        vm.prank(oracle);
        vm.expectRevert("already resolved");
        ct.reportPayouts(questionId, payouts);
    }

    function test_reportPayouts_revert_allZeros() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory payouts = new uint256[](2);
        vm.prank(oracle);
        vm.expectRevert("payout all zeros");
        ct.reportPayouts(questionId, payouts);
    }

    // ─── redeemPositions ───

    function test_redeemPositions_winnerTakesAll() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;

        vm.prank(alice);
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 10 ether);

        // Resolve: YES wins
        uint256[] memory payouts = new uint256[](2);
        payouts[0] = 1;
        payouts[1] = 0;
        vm.prank(oracle);
        ct.reportPayouts(questionId, payouts);

        // Redeem YES tokens
        uint256[] memory indexSets = new uint256[](1);
        indexSets[0] = 1;
        vm.prank(alice);
        ct.redeemPositions(IERC20(address(weth)), conditionId, indexSets);

        assertEq(weth.balanceOf(alice), 100 ether); // got 10 ether back
    }

    function test_redeemPositions_proportional() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;

        vm.prank(alice);
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 10 ether);

        // Resolve: 70/30 split
        uint256[] memory payouts = new uint256[](2);
        payouts[0] = 7;
        payouts[1] = 3;
        vm.prank(oracle);
        ct.reportPayouts(questionId, payouts);

        // Redeem both
        uint256[] memory indexSets = new uint256[](2);
        indexSets[0] = 1;
        indexSets[1] = 2;
        vm.prank(alice);
        ct.redeemPositions(IERC20(address(weth)), conditionId, indexSets);

        assertEq(weth.balanceOf(alice), 100 ether);
    }

    function test_redeemPositions_revert_notResolved() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory indexSets = new uint256[](1);
        indexSets[0] = 1;
        vm.prank(alice);
        vm.expectRevert("not resolved");
        ct.redeemPositions(IERC20(address(weth)), conditionId, indexSets);
    }

    function test_redeemPositions_loserGetsNothing() public {
        ct.prepareCondition(oracle, questionId, 2);
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;

        vm.prank(alice);
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 10 ether);

        // Transfer YES tokens to bob, alice keeps NO
        uint256 yesId = ct.getPositionId(IERC20(address(weth)), conditionId, 1);
        vm.prank(alice);
        ct.safeTransferFrom(alice, bob, yesId, 10 ether, "");

        // YES wins
        uint256[] memory payouts = new uint256[](2);
        payouts[0] = 1;
        payouts[1] = 0;
        vm.prank(oracle);
        ct.reportPayouts(questionId, payouts);

        // Alice redeems NO → gets nothing
        uint256[] memory indexSets = new uint256[](1);
        indexSets[0] = 2;
        vm.prank(alice);
        ct.redeemPositions(IERC20(address(weth)), conditionId, indexSets);
        assertEq(weth.balanceOf(alice), 90 ether); // no change

        // Bob redeems YES → gets 10 ether
        indexSets[0] = 1;
        vm.prank(bob);
        ct.redeemPositions(IERC20(address(weth)), conditionId, indexSets);
        assertEq(weth.balanceOf(bob), 110 ether);
    }

    // ─── 3-outcome market ───

    function test_threeOutcome_splitAndRedeem() public {
        bytes32 qid3 = keccak256("multi");
        ct.prepareCondition(oracle, qid3, 3);
        bytes32 cid3 = ct.getConditionId(oracle, qid3, 3);

        uint256[] memory partition = new uint256[](3);
        partition[0] = 1; // outcome 0
        partition[1] = 2; // outcome 1
        partition[2] = 4; // outcome 2

        vm.prank(alice);
        ct.splitPosition(IERC20(address(weth)), cid3, partition, 9 ether);

        // outcome 1 wins
        uint256[] memory payouts = new uint256[](3);
        payouts[0] = 0;
        payouts[1] = 1;
        payouts[2] = 0;
        vm.prank(oracle);
        ct.reportPayouts(qid3, payouts);

        uint256[] memory indexSets = new uint256[](1);
        indexSets[0] = 2; // outcome 1
        vm.prank(alice);
        ct.redeemPositions(IERC20(address(weth)), cid3, indexSets);
        assertEq(weth.balanceOf(alice), 100 ether);
    }
}

Step 2: Run tests

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract ConditionalTokensTest -v Expected: all ~18 tests pass

Step 3: Commit

git add contracts/test/ConditionalTokens.t.sol
git commit -m "test(prediction): add ConditionalTokens tests (18 cases)"

---

Task 4: CTFExchange Contract

Files:

• Create: contracts/src/prediction/CTFExchange.sol

Step 1: Write CTFExchange

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/utils/Pausable.sol";
import {ICTFExchange} from "./interfaces/ICTFExchange.sol";
import {IConditionalTokens} from "./interfaces/IConditionalTokens.sol";

/// @title CTFExchange — On-chain CLOB for CTF position tokens
/// @notice Simplified Polymarket CTFExchange: EOA signatures only, no operator proxy, no directed taker orders.
contract CTFExchange is ICTFExchange, EIP712, ERC1155Holder, Ownable, Pausable {
    using SafeERC20 for IERC20;
    using ECDSA for bytes32;

    bytes32 public constant ORDER_TYPEHASH = keccak256(
        "Order(uint256 salt,address maker,address signer,uint256 tokenId,uint256 makerAmount,uint256 takerAmount,uint256 expiration,uint256 nonce,uint256 feeRateBps,uint8 side)"
    );

    IConditionalTokens public immutable ctf;
    IERC20 public immutable collateral;

    // orderHash => filled amount
    mapping(bytes32 => uint256) public orderFilled;
    // orderHash => cancelled
    mapping(bytes32 => bool) public orderCancelled;
    // maker => current nonce
    mapping(address => uint256) public nonces;

    // Fee config (basis points)
    uint256 public makerFeeBps;
    uint256 public takerFeeBps;

    constructor(
        address _ctf,
        address _collateral,
        uint256 _makerFeeBps,
        uint256 _takerFeeBps
    ) EIP712("CTFExchange", "1") Ownable(msg.sender) {
        ctf = IConditionalTokens(_ctf);
        collateral = IERC20(_collateral);
        makerFeeBps = _makerFeeBps;
        takerFeeBps = _takerFeeBps;
    }

    // ──────────────────── Admin ────────────────────

    function setFees(uint256 _makerFeeBps, uint256 _takerFeeBps) external onlyOwner {
        require(_makerFeeBps <= 500 && _takerFeeBps <= 500, "fee too high");
        makerFeeBps = _makerFeeBps;
        takerFeeBps = _takerFeeBps;
    }

    function pause() external onlyOwner { _pause(); }
    function unpause() external onlyOwner { _unpause(); }

    // ──────────────────── Order hashing ────────────────────

    function getOrderHash(Order calldata order) public view returns (bytes32) {
        return _hashTypedDataV4(keccak256(abi.encode(
            ORDER_TYPEHASH,
            order.salt,
            order.maker,
            order.signer,
            order.tokenId,
            order.makerAmount,
            order.takerAmount,
            order.expiration,
            order.nonce,
            order.feeRateBps,
            uint8(order.side)
        )));
    }

    function getOrderStatus(bytes32 orderHash) external view returns (uint256 filled, bool cancelled) {
        return (orderFilled[orderHash], orderCancelled[orderHash]);
    }

    // ──────────────────── Cancel ────────────────────

    function cancelOrder(Order calldata order) external {
        require(msg.sender == order.maker, "not maker");
        bytes32 orderHash = getOrderHash(order);
        require(!orderCancelled[orderHash], "already cancelled");
        orderCancelled[orderHash] = true;
        emit OrderCancelled(orderHash);
    }

    function incrementNonce() external {
        nonces[msg.sender]++;
        emit NonceIncremented(msg.sender, nonces[msg.sender]);
    }

    // ──────────────────── Fill ────────────────────

    function fillOrder(
        Order calldata order,
        uint256 fillAmount,
        bytes calldata signature
    ) external whenNotPaused {
        bytes32 orderHash = _validateOrder(order, signature);
        uint256 remainingAmount = order.makerAmount - orderFilled[orderHash];
        require(fillAmount <= remainingAmount, "fill exceeds remaining");

        uint256 takerAmount = (fillAmount * order.takerAmount) / order.makerAmount;
        require(takerAmount > 0, "zero taker amount");

        orderFilled[orderHash] += fillAmount;

        uint256 fee = (takerAmount * takerFeeBps) / 10_000;

        (uint256 makerAssetId, uint256 takerAssetId) = _deriveAssetIds(order);

        // taker sends takerAsset to maker (minus fee)
        _transferAsset(msg.sender, order.maker, takerAssetId, takerAmount - fee);
        // maker sends makerAsset to taker
        _transferAsset(order.maker, msg.sender, makerAssetId, fillAmount);

        emit OrderFilled(orderHash, order.maker, msg.sender, makerAssetId, takerAssetId, fillAmount, takerAmount, fee);
    }

    // ──────────────────── Match ────────────────────

    function matchOrders(
        Order calldata takerOrder,
        Order[] calldata makerOrders,
        uint256 takerFillAmount,
        uint256[] calldata makerFillAmounts,
        bytes[] calldata makerSignatures,
        bytes calldata takerSignature
    ) external whenNotPaused {
        require(makerOrders.length == makerFillAmounts.length, "length mismatch");
        require(makerOrders.length == makerSignatures.length, "sig length mismatch");

        bytes32 takerHash = _validateOrder(takerOrder, takerSignature);
        uint256 takerRemaining = takerOrder.makerAmount - orderFilled[takerHash];
        require(takerFillAmount <= takerRemaining, "taker fill exceeds");
        orderFilled[takerHash] += takerFillAmount;

        uint256 totalTakerReceived;

        for (uint256 i; i < makerOrders.length; i++) {
            bytes32 makerHash = _validateOrder(makerOrders[i], makerSignatures[i]);
            uint256 makerRemaining = makerOrders[i].makerAmount - orderFilled[makerHash];
            require(makerFillAmounts[i] <= makerRemaining, "maker fill exceeds");

            uint256 makerTakerAmount = (makerFillAmounts[i] * makerOrders[i].takerAmount) / makerOrders[i].makerAmount;
            orderFilled[makerHash] += makerFillAmounts[i];

            (uint256 mMakerAssetId, uint256 mTakerAssetId) = _deriveAssetIds(makerOrders[i]);

            // Execute maker side
            _transferAsset(makerOrders[i].maker, address(this), mMakerAssetId, makerFillAmounts[i]);

            // Determine match type and handle
            MatchType mt = _getMatchType(takerOrder.side, makerOrders[i].side);
            if (mt == MatchType.COMPLEMENTARY) {
                _transferAsset(address(this), makerOrders[i].maker, mTakerAssetId, makerTakerAmount);
            }

            totalTakerReceived += makerFillAmounts[i];

            emit OrderFilled(makerHash, makerOrders[i].maker, msg.sender, mMakerAssetId, mTakerAssetId, makerFillAmounts[i], makerTakerAmount, 0);
        }

        uint256 takerTakerAmount = (takerFillAmount * takerOrder.takerAmount) / takerOrder.makerAmount;
        uint256 fee = (takerTakerAmount * takerFeeBps) / 10_000;

        (uint256 tMakerAssetId, uint256 tTakerAssetId) = _deriveAssetIds(takerOrder);

        _transferAsset(takerOrder.maker, address(this), tMakerAssetId, takerFillAmount);
        _transferAsset(address(this), takerOrder.maker, tTakerAssetId, takerTakerAmount - fee);

        emit OrderFilled(takerHash, takerOrder.maker, msg.sender, tMakerAssetId, tTakerAssetId, takerFillAmount, takerTakerAmount, fee);
    }

    // ──────────────────── Internal ────────────────────

    function _validateOrder(Order calldata order, bytes calldata signature) internal view returns (bytes32) {
        bytes32 orderHash = getOrderHash(order);
        require(!orderCancelled[orderHash], "order cancelled");
        require(block.timestamp <= order.expiration, "order expired");
        require(order.nonce >= nonces[order.maker], "nonce too low");

        address signer = orderHash.recover(signature);
        require(signer == order.signer, "invalid signature");
        return orderHash;
    }

    function _deriveAssetIds(Order calldata order) internal view returns (uint256 makerAssetId, uint256 takerAssetId) {
        if (order.side == Side.BUY) {
            // Maker puts up collateral, wants position tokens
            makerAssetId = 0; // collateral (represented as 0)
            takerAssetId = order.tokenId;
        } else {
            // Maker puts up position tokens, wants collateral
            makerAssetId = order.tokenId;
            takerAssetId = 0; // collateral
        }
    }

    function _transferAsset(address from, address to, uint256 assetId, uint256 amount) internal {
        if (amount == 0) return;
        if (assetId == 0) {
            // Collateral (ERC20)
            if (from == address(this)) {
                collateral.safeTransfer(to, amount);
            } else {
                collateral.safeTransferFrom(from, to, amount);
            }
        } else {
            // Position token (ERC1155)
            IERC1155(address(ctf)).safeTransferFrom(from, to, assetId, amount, "");
        }
    }

    function _getMatchType(Side takerSide, Side makerSide) internal pure returns (MatchType) {
        if (takerSide == Side.BUY && makerSide == Side.BUY) return MatchType.MINT;
        if (takerSide == Side.SELL && makerSide == Side.SELL) return MatchType.MERGE;
        return MatchType.COMPLEMENTARY;
    }
}

Step 2: Verify compilation

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: compiles with no errors

Step 3: Commit

git add contracts/src/prediction/CTFExchange.sol
git commit -m "feat(prediction): add CTFExchange on-chain CLOB with EIP-712"

---

Task 5: CTFExchange Tests

Files:

• Create: contracts/test/CTFExchange.t.sol

Step 1: Write tests

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

import {Test} from "forge-std/Test.sol";
import {ConditionalTokens} from "../src/prediction/ConditionalTokens.sol";
import {CTFExchange} from "../src/prediction/CTFExchange.sol";
import {ICTFExchange} from "../src/prediction/interfaces/ICTFExchange.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";

contract MockWETH is ERC20 {
    constructor() ERC20("Wrapped ETH", "WETH") {}
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

contract CTFExchangeTest is Test {
    ConditionalTokens ct;
    CTFExchange exchange;
    MockWETH weth;

    address oracle = address(0xAA);
    bytes32 questionId = keccak256("ETH > 3000?");
    bytes32 conditionId;
    uint256 yesTokenId;
    uint256 noTokenId;

    // Use vm.addr() derived from private keys
    uint256 makerPk = 0xA11CE;
    address maker;
    uint256 takerPk = 0xB0B;
    address taker;
    address admin = address(this);

    function setUp() public {
        maker = vm.addr(makerPk);
        taker = vm.addr(takerPk);

        ct = new ConditionalTokens();
        weth = new MockWETH();
        exchange = new CTFExchange(address(ct), address(weth), 0, 2); // 0 maker, 2 bps taker

        conditionId = ct.getConditionId(oracle, questionId, 2);
        yesTokenId = ct.getPositionId(IERC20(address(weth)), conditionId, 1);
        noTokenId = ct.getPositionId(IERC20(address(weth)), conditionId, 2);

        ct.prepareCondition(oracle, questionId, 2);

        // Fund and approve
        weth.mint(maker, 1000 ether);
        weth.mint(taker, 1000 ether);

        vm.prank(maker);
        weth.approve(address(ct), type(uint256).max);
        vm.prank(taker);
        weth.approve(address(ct), type(uint256).max);
        vm.prank(maker);
        weth.approve(address(exchange), type(uint256).max);
        vm.prank(taker);
        weth.approve(address(exchange), type(uint256).max);

        // Split positions for maker and taker
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;
        vm.prank(maker);
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 100 ether);
        vm.prank(taker);
        ct.splitPosition(IERC20(address(weth)), conditionId, partition, 100 ether);

        // Approve exchange for ERC1155
        vm.prank(maker);
        ct.setApprovalForAll(address(exchange), true);
        vm.prank(taker);
        ct.setApprovalForAll(address(exchange), true);
    }

    function _signOrder(ICTFExchange.Order memory order, uint256 pk) internal view returns (bytes memory) {
        bytes32 orderHash = exchange.getOrderHash(_toCalldata(order));
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(pk, orderHash);
        return abi.encodePacked(r, s, v);
    }

    // Helper to get calldata-compatible order hash
    function _toCalldata(ICTFExchange.Order memory order) internal pure returns (ICTFExchange.Order memory) {
        return order;
    }

    function _makeOrder(
        address _maker,
        uint256 _tokenId,
        uint256 _makerAmount,
        uint256 _takerAmount,
        ICTFExchange.Side _side
    ) internal view returns (ICTFExchange.Order memory) {
        return ICTFExchange.Order({
            salt: uint256(keccak256(abi.encodePacked(block.timestamp, _maker))),
            maker: _maker,
            signer: _maker,
            tokenId: _tokenId,
            makerAmount: _makerAmount,
            takerAmount: _takerAmount,
            expiration: block.timestamp + 1 hours,
            nonce: 0,
            feeRateBps: 2,
            side: _side
        });
    }

    // ─── Order hashing ───

    function test_getOrderHash_deterministic() public view {
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        bytes32 hash1 = exchange.getOrderHash(order);
        bytes32 hash2 = exchange.getOrderHash(order);
        assertEq(hash1, hash2);
    }

    function test_getOrderHash_differentSaltDifferentHash() public view {
        ICTFExchange.Order memory order1 = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        ICTFExchange.Order memory order2 = order1;
        order2.salt = 999;
        assertNotEq(exchange.getOrderHash(order1), exchange.getOrderHash(order2));
    }

    // ─── fillOrder ───

    function test_fillOrder_sellYes() public {
        // Maker sells 10 YES tokens for 6.5 WETH
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        bytes memory sig = _signOrder(order, makerPk);

        uint256 makerYesBefore = ct.balanceOf(maker, yesTokenId);
        uint256 takerWethBefore = weth.balanceOf(taker);

        vm.prank(taker);
        exchange.fillOrder(order, 10 ether, sig);

        assertEq(ct.balanceOf(maker, yesTokenId), makerYesBefore - 10 ether);
        // taker pays 6.5 WETH minus taker fee (2 bps of 6.5 = 0.0013)
        assertLt(weth.balanceOf(taker), takerWethBefore);
    }

    function test_fillOrder_partialFill() public {
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        bytes memory sig = _signOrder(order, makerPk);

        vm.prank(taker);
        exchange.fillOrder(order, 5 ether, sig);

        bytes32 orderHash = exchange.getOrderHash(order);
        (uint256 filled,) = exchange.getOrderStatus(orderHash);
        assertEq(filled, 5 ether);
    }

    function test_fillOrder_revert_exceedsRemaining() public {
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        bytes memory sig = _signOrder(order, makerPk);

        vm.prank(taker);
        exchange.fillOrder(order, 6 ether, sig);

        vm.prank(taker);
        vm.expectRevert("fill exceeds remaining");
        exchange.fillOrder(order, 6 ether, sig);
    }

    function test_fillOrder_revert_expired() public {
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        order.expiration = block.timestamp - 1;
        bytes memory sig = _signOrder(order, makerPk);

        vm.prank(taker);
        vm.expectRevert("order expired");
        exchange.fillOrder(order, 10 ether, sig);
    }

    function test_fillOrder_revert_invalidSignature() public {
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        bytes memory badSig = _signOrder(order, takerPk); // signed by wrong key

        vm.prank(taker);
        vm.expectRevert("invalid signature");
        exchange.fillOrder(order, 10 ether, badSig);
    }

    // ─── cancelOrder ───

    function test_cancelOrder_success() public {
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        bytes memory sig = _signOrder(order, makerPk);

        vm.prank(maker);
        exchange.cancelOrder(order);

        vm.prank(taker);
        vm.expectRevert("order cancelled");
        exchange.fillOrder(order, 10 ether, sig);
    }

    function test_cancelOrder_revert_notMaker() public {
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        vm.prank(taker);
        vm.expectRevert("not maker");
        exchange.cancelOrder(order);
    }

    // ─── incrementNonce ───

    function test_incrementNonce_invalidatesOldOrders() public {
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        order.nonce = 0;
        bytes memory sig = _signOrder(order, makerPk);

        vm.prank(maker);
        exchange.incrementNonce();

        vm.prank(taker);
        vm.expectRevert("nonce too low");
        exchange.fillOrder(order, 10 ether, sig);
    }

    // ─── Fees ───

    function test_setFees_onlyOwner() public {
        exchange.setFees(10, 20);
        assertEq(exchange.makerFeeBps(), 10);
        assertEq(exchange.takerFeeBps(), 20);
    }

    function test_setFees_revert_notOwner() public {
        vm.prank(maker);
        vm.expectRevert();
        exchange.setFees(10, 20);
    }

    function test_setFees_revert_tooHigh() public {
        vm.expectRevert("fee too high");
        exchange.setFees(501, 0);
    }

    // ─── Pause ───

    function test_pause_blocksFills() public {
        exchange.pause();
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 10 ether, 6.5 ether, ICTFExchange.Side.SELL);
        bytes memory sig = _signOrder(order, makerPk);
        vm.prank(taker);
        vm.expectRevert();
        exchange.fillOrder(order, 10 ether, sig);
    }

    // ─── BUY side ───

    function test_fillOrder_buyYes() public {
        // Maker wants to buy YES: puts up collateral (WETH), wants YES tokens
        ICTFExchange.Order memory order = _makeOrder(maker, yesTokenId, 6.5 ether, 10 ether, ICTFExchange.Side.BUY);
        bytes memory sig = _signOrder(order, makerPk);

        // Taker has YES tokens and wants WETH
        vm.prank(taker);
        exchange.fillOrder(order, 6.5 ether, sig);

        // Maker should have gained YES tokens
        assertGt(ct.balanceOf(maker, yesTokenId), 100 ether);
    }
}

Step 2: Run tests

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-contract CTFExchangeTest -v Expected: all ~14 tests pass

Step 3: Commit

git add contracts/test/CTFExchange.t.sol
git commit -m "test(prediction): add CTFExchange tests (14 cases: fill, cancel, nonce, fees, pause)"

---

Task 6: OracleResolver Contract

Files:

• Create: contracts/src/prediction/OracleResolver.sol

Step 1: Write OracleResolver

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IConditionalTokens} from "./interfaces/IConditionalTokens.sol";
import {IOracleResolver} from "./interfaces/IOracleResolver.sol";
import {IOracleHub} from "../interfaces/IOracleHub.sol";

/// @title OracleResolver — Hybrid settlement: OracleHub auto (price) + admin manual (event)
/// @notice Market factory + resolver. For price markets, reads OracleHub (0x8016) and auto-settles.
contract OracleResolver is IOracleResolver, Ownable {
    IConditionalTokens public immutable conditionalTokens;
    IOracleHub public immutable oracleHub;

    uint256 public constant MAX_STALENESS = 1 hours;

    // marketId => Market
    mapping(bytes32 => Market) internal _markets;
    uint256 public marketCount;

    constructor(address _conditionalTokens, address _oracleHub) Ownable(msg.sender) {
        conditionalTokens = IConditionalTokens(_conditionalTokens);
        oracleHub = IOracleHub(_oracleHub);
    }

    // ──────────────────── Market creation ────────────────────

    function createPriceMarket(
        string calldata question,
        string calldata symbol,
        uint256 threshold,
        uint256 resolutionTime,
        IERC20 collateral_,
        uint256 outcomeCount
    ) external returns (bytes32 marketId) {
        require(resolutionTime > block.timestamp, "resolution in past");
        require(outcomeCount >= 2, "need >=2 outcomes");

        marketCount++;
        bytes32 questionId = keccak256(abi.encodePacked(question, marketCount));
        marketId = keccak256(abi.encodePacked(address(this), questionId));

        conditionalTokens.prepareCondition(address(this), questionId, outcomeCount);
        bytes32 conditionId = conditionalTokens.getConditionId(address(this), questionId, outcomeCount);

        _markets[marketId] = Market({
            conditionId: conditionId,
            questionId: questionId,
            resolutionType: ResolutionType.PRICE_THRESHOLD,
            creator: msg.sender,
            resolved: false,
            collateral: collateral_,
            outcomeSlotCount: outcomeCount,
            priceSymbol: symbol,
            priceThreshold: threshold,
            resolutionTime: resolutionTime,
            resolver: address(0)
        });

        emit MarketCreated(marketId, conditionId, ResolutionType.PRICE_THRESHOLD, msg.sender);
    }

    function createManualMarket(
        string calldata question,
        address resolver,
        IERC20 collateral_,
        uint256 outcomeCount
    ) external returns (bytes32 marketId) {
        require(resolver != address(0), "zero resolver");
        require(outcomeCount >= 2, "need >=2 outcomes");

        marketCount++;
        bytes32 questionId = keccak256(abi.encodePacked(question, marketCount));
        marketId = keccak256(abi.encodePacked(address(this), questionId));

        conditionalTokens.prepareCondition(address(this), questionId, outcomeCount);
        bytes32 conditionId = conditionalTokens.getConditionId(address(this), questionId, outcomeCount);

        _markets[marketId] = Market({
            conditionId: conditionId,
            questionId: questionId,
            resolutionType: ResolutionType.MANUAL,
            creator: msg.sender,
            resolved: false,
            collateral: collateral_,
            outcomeSlotCount: outcomeCount,
            priceSymbol: "",
            priceThreshold: 0,
            resolutionTime: 0,
            resolver: resolver
        });

        emit MarketCreated(marketId, conditionId, ResolutionType.MANUAL, msg.sender);
    }

    // ──────────────────── Resolution ────────────────────

    function resolvePrice(bytes32 marketId) external {
        Market storage market = _markets[marketId];
        require(market.conditionId != bytes32(0), "market not found");
        require(!market.resolved, "already resolved");
        require(market.resolutionType == ResolutionType.PRICE_THRESHOLD, "not price market");
        require(block.timestamp >= market.resolutionTime, "too early");

        (uint256 price, uint256 timestamp) = oracleHub.getLatestPrice(market.priceSymbol);
        require(block.timestamp - timestamp < MAX_STALENESS, "price too stale");

        uint256[] memory payouts = new uint256[](market.outcomeSlotCount);
        if (price >= market.priceThreshold) {
            payouts[0] = 1; // YES wins
        } else {
            payouts[1] = 1; // NO wins
        }

        market.resolved = true;
        conditionalTokens.reportPayouts(market.questionId, payouts);
        emit MarketResolved(marketId, payouts);
    }

    function resolveManual(bytes32 marketId, uint256[] calldata payouts) external {
        Market storage market = _markets[marketId];
        require(market.conditionId != bytes32(0), "market not found");
        require(!market.resolved, "already resolved");
        require(market.resolutionType == ResolutionType.MANUAL, "not manual market");
        require(msg.sender == market.resolver, "not resolver");
        require(payouts.length == market.outcomeSlotCount, "wrong payout length");

        market.resolved = true;
        conditionalTokens.reportPayouts(market.questionId, payouts);
        emit MarketResolved(marketId, payouts);
    }

    // ──────────────────── View ────────────────────

    function getMarket(bytes32 marketId) external view returns (Market memory) {
        return _markets[marketId];
    }
}

Step 2: Verify compilation

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge build Expected: compiles with no errors

Step 3: Commit

git add contracts/src/prediction/OracleResolver.sol
git commit -m "feat(prediction): add OracleResolver hybrid settlement (OracleHub auto + manual)"

---

Task 7: OracleResolver Tests + E2E

Files:

• Create: contracts/test/OracleResolver.t.sol

• Create: contracts/test/PredictionMarketE2E.t.sol

Step 1: Write OracleResolver tests

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

import {Test} from "forge-std/Test.sol";
import {ConditionalTokens} from "../src/prediction/ConditionalTokens.sol";
import {OracleResolver} from "../src/prediction/OracleResolver.sol";
import {IOracleResolver} from "../src/prediction/interfaces/IOracleResolver.sol";
import {IOracleHub} from "../src/interfaces/IOracleHub.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MockOracleHub {
    mapping(string => uint256) public prices;
    mapping(string => uint256) public timestamps;

    function setPrice(string calldata symbol, uint256 price, uint256 ts) external {
        prices[symbol] = price;
        timestamps[symbol] = ts;
    }

    function getLatestPrice(string calldata symbol) external view returns (uint256 price, uint256 timestamp) {
        return (prices[symbol], timestamps[symbol]);
    }
}

contract MockWETH2 is ERC20 {
    constructor() ERC20("WETH", "WETH") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

contract OracleResolverTest is Test {
    ConditionalTokens ct;
    OracleResolver resolver;
    MockOracleHub hub;
    MockWETH2 weth;
    address alice = address(0xA1);
    address bob = address(0xB0);

    function setUp() public {
        ct = new ConditionalTokens();
        hub = new MockOracleHub();
        resolver = new OracleResolver(address(ct), address(hub));
        weth = new MockWETH2();
        weth.mint(alice, 100 ether);
        vm.prank(alice);
        weth.approve(address(ct), type(uint256).max);
    }

    // ─── createPriceMarket ───

    function test_createPriceMarket() public {
        bytes32 marketId = resolver.createPriceMarket("ETH > 3000?", "ETH/USD", 3000e18, block.timestamp + 1 days, IERC20(address(weth)), 2);
        IOracleResolver.Market memory m = resolver.getMarket(marketId);
        assertEq(uint8(m.resolutionType), uint8(IOracleResolver.ResolutionType.PRICE_THRESHOLD));
        assertFalse(m.resolved);
        assertEq(m.priceThreshold, 3000e18);
    }

    function test_createPriceMarket_revert_pastResolution() public {
        vm.expectRevert("resolution in past");
        resolver.createPriceMarket("Q", "ETH/USD", 3000e18, block.timestamp - 1, IERC20(address(weth)), 2);
    }

    // ─── createManualMarket ───

    function test_createManualMarket() public {
        bytes32 marketId = resolver.createManualMarket("Will X happen?", bob, IERC20(address(weth)), 2);
        IOracleResolver.Market memory m = resolver.getMarket(marketId);
        assertEq(uint8(m.resolutionType), uint8(IOracleResolver.ResolutionType.MANUAL));
        assertEq(m.resolver, bob);
    }

    function test_createManualMarket_revert_zeroResolver() public {
        vm.expectRevert("zero resolver");
        resolver.createManualMarket("Q", address(0), IERC20(address(weth)), 2);
    }

    // ─── resolvePrice ───

    function test_resolvePrice_yesWins() public {
        bytes32 marketId = resolver.createPriceMarket("ETH > 3000?", "ETH/USD", 3000e18, block.timestamp + 1, IERC20(address(weth)), 2);

        vm.warp(block.timestamp + 2);
        hub.setPrice("ETH/USD", 3500e18, block.timestamp);

        resolver.resolvePrice(marketId);
        IOracleResolver.Market memory m = resolver.getMarket(marketId);
        assertTrue(m.resolved);
    }

    function test_resolvePrice_noWins() public {
        bytes32 marketId = resolver.createPriceMarket("ETH > 3000?", "ETH/USD", 3000e18, block.timestamp + 1, IERC20(address(weth)), 2);

        vm.warp(block.timestamp + 2);
        hub.setPrice("ETH/USD", 2500e18, block.timestamp);

        resolver.resolvePrice(marketId);
        assertTrue(resolver.getMarket(marketId).resolved);
    }

    function test_resolvePrice_revert_tooEarly() public {
        bytes32 marketId = resolver.createPriceMarket("Q", "ETH/USD", 3000e18, block.timestamp + 1 days, IERC20(address(weth)), 2);
        vm.expectRevert("too early");
        resolver.resolvePrice(marketId);
    }

    function test_resolvePrice_revert_stalePrice() public {
        bytes32 marketId = resolver.createPriceMarket("Q", "ETH/USD", 3000e18, block.timestamp + 1, IERC20(address(weth)), 2);
        vm.warp(block.timestamp + 2);
        hub.setPrice("ETH/USD", 3500e18, block.timestamp - 2 hours);
        vm.expectRevert("price too stale");
        resolver.resolvePrice(marketId);
    }

    function test_resolvePrice_revert_alreadyResolved() public {
        bytes32 marketId = resolver.createPriceMarket("Q", "ETH/USD", 3000e18, block.timestamp + 1, IERC20(address(weth)), 2);
        vm.warp(block.timestamp + 2);
        hub.setPrice("ETH/USD", 3500e18, block.timestamp);
        resolver.resolvePrice(marketId);
        vm.expectRevert("already resolved");
        resolver.resolvePrice(marketId);
    }

    // ─── resolveManual ───

    function test_resolveManual_success() public {
        bytes32 marketId = resolver.createManualMarket("X?", bob, IERC20(address(weth)), 2);
        uint256[] memory payouts = new uint256[](2);
        payouts[0] = 1;
        vm.prank(bob);
        resolver.resolveManual(marketId, payouts);
        assertTrue(resolver.getMarket(marketId).resolved);
    }

    function test_resolveManual_revert_notResolver() public {
        bytes32 marketId = resolver.createManualMarket("X?", bob, IERC20(address(weth)), 2);
        uint256[] memory payouts = new uint256[](2);
        payouts[0] = 1;
        vm.prank(alice);
        vm.expectRevert("not resolver");
        resolver.resolveManual(marketId, payouts);
    }

    function test_resolveManual_revert_wrongLength() public {
        bytes32 marketId = resolver.createManualMarket("X?", bob, IERC20(address(weth)), 2);
        uint256[] memory payouts = new uint256[](3);
        payouts[0] = 1;
        vm.prank(bob);
        vm.expectRevert("wrong payout length");
        resolver.resolveManual(marketId, payouts);
    }

    function test_resolveManual_revert_priceMarket() public {
        bytes32 marketId = resolver.createPriceMarket("Q", "ETH/USD", 3000e18, block.timestamp + 1, IERC20(address(weth)), 2);
        uint256[] memory payouts = new uint256[](2);
        payouts[0] = 1;
        vm.prank(bob);
        vm.expectRevert("not manual market");
        resolver.resolveManual(marketId, payouts);
    }
}

Step 2: Write E2E test

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

import {Test} from "forge-std/Test.sol";
import {ConditionalTokens} from "../src/prediction/ConditionalTokens.sol";
import {CTFExchange} from "../src/prediction/CTFExchange.sol";
import {OracleResolver} from "../src/prediction/OracleResolver.sol";
import {ICTFExchange} from "../src/prediction/interfaces/ICTFExchange.sol";
import {IOracleResolver} from "../src/prediction/interfaces/IOracleResolver.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MockOracleHub3 {
    mapping(string => uint256) public prices;
    mapping(string => uint256) public timestamps;
    function setPrice(string calldata s, uint256 p, uint256 t) external { prices[s] = p; timestamps[s] = t; }
    function getLatestPrice(string calldata s) external view returns (uint256, uint256) { return (prices[s], timestamps[s]); }
}

contract MockWETH3 is ERC20 {
    constructor() ERC20("WETH", "WETH") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

contract PredictionMarketE2ETest is Test {
    ConditionalTokens ct;
    CTFExchange exchange;
    OracleResolver resolver;
    MockOracleHub3 hub;
    MockWETH3 weth;

    uint256 alicePk = 0xA11CE;
    address alice;
    uint256 bobPk = 0xB0B;
    address bob;

    function setUp() public {
        alice = vm.addr(alicePk);
        bob = vm.addr(bobPk);

        ct = new ConditionalTokens();
        weth = new MockWETH3();
        hub = new MockOracleHub3();
        exchange = new CTFExchange(address(ct), address(weth), 0, 0); // no fees for E2E clarity
        resolver = new OracleResolver(address(ct), address(hub));

        weth.mint(alice, 1000 ether);
        weth.mint(bob, 1000 ether);
        vm.prank(alice);
        weth.approve(address(ct), type(uint256).max);
        vm.prank(bob);
        weth.approve(address(ct), type(uint256).max);
        vm.prank(alice);
        weth.approve(address(exchange), type(uint256).max);
        vm.prank(bob);
        weth.approve(address(exchange), type(uint256).max);
        vm.prank(alice);
        ct.setApprovalForAll(address(exchange), true);
        vm.prank(bob);
        ct.setApprovalForAll(address(exchange), true);
    }

    /// @notice Full lifecycle: create market → split → trade → resolve → redeem
    function test_e2e_priceMarket_fullLifecycle() public {
        // 1. Create price market
        bytes32 marketId = resolver.createPriceMarket(
            "ETH > 3000 by June?", "ETH/USD", 3000e18,
            block.timestamp + 1 days, IERC20(address(weth)), 2
        );
        IOracleResolver.Market memory m = resolver.getMarket(marketId);

        // 2. Alice splits 100 WETH → 100 YES + 100 NO
        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;
        vm.prank(alice);
        ct.splitPosition(IERC20(address(weth)), m.conditionId, partition, 100 ether);

        uint256 yesId = ct.getPositionId(IERC20(address(weth)), m.conditionId, 1);
        uint256 noId = ct.getPositionId(IERC20(address(weth)), m.conditionId, 2);
        assertEq(ct.balanceOf(alice, yesId), 100 ether);

        // 3. Alice sells 50 YES to Bob at 0.65 price (via fillOrder)
        ICTFExchange.Order memory order = ICTFExchange.Order({
            salt: 12345,
            maker: alice,
            signer: alice,
            tokenId: yesId,
            makerAmount: 50 ether,
            takerAmount: 32.5 ether, // 50 * 0.65
            expiration: block.timestamp + 1 hours,
            nonce: 0,
            feeRateBps: 0,
            side: ICTFExchange.Side.SELL
        });
        bytes32 orderHash = exchange.getOrderHash(order);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(alicePk, orderHash);
        bytes memory sig = abi.encodePacked(r, s, v);

        vm.prank(bob);
        exchange.fillOrder(order, 50 ether, sig);

        assertEq(ct.balanceOf(alice, yesId), 50 ether);
        assertEq(ct.balanceOf(bob, yesId), 50 ether);

        // 4. Time passes, ETH pumps to 3500
        vm.warp(block.timestamp + 1 days + 1);
        hub.setPrice("ETH/USD", 3500e18, block.timestamp);

        // 5. Resolve: YES wins
        resolver.resolvePrice(marketId);

        // 6. Bob redeems 50 YES → 50 WETH
        uint256[] memory indexSets = new uint256[](1);
        indexSets[0] = 1;
        vm.prank(bob);
        ct.redeemPositions(IERC20(address(weth)), m.conditionId, indexSets);
        assertEq(weth.balanceOf(bob), 1000 ether - 32.5 ether + 50 ether); // profit

        // 7. Alice redeems remaining 50 YES → 50 WETH
        vm.prank(alice);
        ct.redeemPositions(IERC20(address(weth)), m.conditionId, indexSets);
        // Alice also has 100 NO tokens that are worthless
    }

    /// @notice Manual market E2E
    function test_e2e_manualMarket() public {
        address judge = address(0xJJ);
        bytes32 marketId = resolver.createManualMarket(
            "Will BTC hit 100k?", judge, IERC20(address(weth)), 2
        );
        IOracleResolver.Market memory m = resolver.getMarket(marketId);

        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;
        vm.prank(alice);
        ct.splitPosition(IERC20(address(weth)), m.conditionId, partition, 10 ether);

        // Judge resolves: NO wins
        uint256[] memory payouts = new uint256[](2);
        payouts[1] = 1;
        vm.prank(judge);
        resolver.resolveManual(marketId, payouts);

        // Alice redeems NO → gets 10 WETH back
        uint256[] memory indexSets = new uint256[](1);
        indexSets[0] = 2;
        vm.prank(alice);
        ct.redeemPositions(IERC20(address(weth)), m.conditionId, indexSets);
        assertEq(weth.balanceOf(alice), 1000 ether);
    }
}

Step 3: Run all prediction market tests

Run: cd /Users/judybaby/CodeBase/github/Layer2/contracts && forge test --match-path "test/ConditionalTokens.t.sol test/CTFExchange.t.sol test/OracleResolver.t.sol test/PredictionMarketE2E.t.sol" -v Expected: all tests pass (~47 total)

Step 4: Commit

git add contracts/test/OracleResolver.t.sol contracts/test/PredictionMarketE2E.t.sol
git commit -m "test(prediction): add OracleResolver tests + E2E lifecycle tests"

---

Task 8: SDK Scaffold

Files:

• Create: sdk/package.json

• Create: sdk/tsconfig.json

• Create: sdk/tsup.config.ts

• Create: sdk/src/index.ts

Step 1: Initialize package

mkdir -p sdk/src/{contracts,market,did,abis} sdk/test

Step 2: Create package.json

{
  "name": "@babydriver/sdk",
  "version": "0.1.0",
  "description": "BabyDriver L2 SDK — prediction markets, DID, Oracle",
  "type": "module",
  "main": "./dist/index.cjs",
  "module": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "import": "./dist/index.js",
      "require": "./dist/index.cjs",
      "types": "./dist/index.d.ts"
    }
  },
  "scripts": {
    "build": "tsup",
    "test": "vitest run",
    "test:watch": "vitest",
    "typecheck": "tsc --noEmit"
  },
  "dependencies": {
    "viem": "^2.21.0"
  },
  "devDependencies": {
    "tsup": "^8.3.0",
    "typescript": "^5.6.0",
    "vitest": "^2.1.0"
  },
  "engines": {
    "node": ">=18"
  },
  "license": "MIT"
}

Step 3: Create tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "dist",
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "lib": ["ES2022"]
  },
  "include": ["src"],
  "exclude": ["node_modules", "dist", "test"]
}

Step 4: Create tsup.config.ts

import { defineConfig } from "tsup";

export default defineConfig({
  entry: ["src/index.ts"],
  format: ["esm", "cjs"],
  dts: true,
  sourcemap: true,
  clean: true,
  splitting: false,
});

Step 5: Create src/index.ts

export { BabyDriverClient, type BabyDriverClientConfig } from "./client.js";
export * from "./market/types.js";
export * from "./market/helpers.js";

Step 6: Install dependencies and verify

cd sdk && npm install && npx tsc --noEmit

Step 7: Commit

git add sdk/
git commit -m "feat(sdk): scaffold @babydriver/sdk with viem + tsup + vitest"

---

Task 9: SDK Types + Helpers

Files:

• Create: sdk/src/market/types.ts

• Create: sdk/src/market/helpers.ts

Step 1: Write types

// sdk/src/market/types.ts

export enum Side {
  BUY = 0,
  SELL = 1,
}

export enum MatchType {
  COMPLEMENTARY = 0,
  MINT = 1,
  MERGE = 2,
}

export enum ResolutionType {
  PRICE_THRESHOLD = 0,
  MANUAL = 1,
}

export interface Order {
  salt: bigint;
  maker: `0x${string}`;
  signer: `0x${string}`;
  tokenId: bigint;
  makerAmount: bigint;
  takerAmount: bigint;
  expiration: bigint;
  nonce: bigint;
  feeRateBps: bigint;
  side: Side;
}

export interface Market {
  conditionId: `0x${string}`;
  questionId: `0x${string}`;
  resolutionType: ResolutionType;
  creator: `0x${string}`;
  resolved: boolean;
  collateral: `0x${string}`;
  outcomeSlotCount: bigint;
  priceSymbol: string;
  priceThreshold: bigint;
  resolutionTime: bigint;
  resolver: `0x${string}`;
}

export interface Position {
  conditionId: `0x${string}`;
  collateral: `0x${string}`;
  indexSet: number;
  tokenId: bigint;
  balance: bigint;
}

Step 2: Write helpers

// sdk/src/market/helpers.ts

import { encodeAbiParameters, encodePacked, keccak256 } from "viem";
import type { Order } from "./types.js";

export function getConditionId(
  oracle: `0x${string}`,
  questionId: `0x${string}`,
  outcomeSlotCount: number,
): `0x${string}` {
  return keccak256(
    encodePacked(
      ["address", "bytes32", "uint256"],
      [oracle, questionId, BigInt(outcomeSlotCount)],
    ),
  );
}

export function getPositionId(
  collateral: `0x${string}`,
  conditionId: `0x${string}`,
  indexSet: number,
): bigint {
  const hash = keccak256(
    encodePacked(
      ["address", "bytes32", "uint256"],
      [collateral, conditionId, BigInt(indexSet)],
    ),
  );
  return BigInt(hash);
}

export const ORDER_TYPEHASH = keccak256(
  encodePacked(
    ["string"],
    [
      "Order(uint256 salt,address maker,address signer,uint256 tokenId,uint256 makerAmount,uint256 takerAmount,uint256 expiration,uint256 nonce,uint256 feeRateBps,uint8 side)",
    ],
  ),
);

export function hashOrderStruct(order: Order): `0x${string}` {
  return keccak256(
    encodeAbiParameters(
      [
        { type: "bytes32" },
        { type: "uint256" },
        { type: "address" },
        { type: "address" },
        { type: "uint256" },
        { type: "uint256" },
        { type: "uint256" },
        { type: "uint256" },
        { type: "uint256" },
        { type: "uint256" },
        { type: "uint8" },
      ],
      [
        ORDER_TYPEHASH,
        order.salt,
        order.maker,
        order.signer,
        order.tokenId,
        order.makerAmount,
        order.takerAmount,
        order.expiration,
        order.nonce,
        order.feeRateBps,
        order.side,
      ],
    ),
  );
}

/** Build full-set partition for a binary market: [1, 2] */
export function binaryPartition(): number[] {
  return [1, 2];
}

/** Build full-set partition for n outcomes: [1, 2, 4, 8, ...] */
export function fullPartition(outcomeCount: number): number[] {
  return Array.from({ length: outcomeCount }, (_, i) => 1 << i);
}

Step 3: Commit

git add sdk/src/market/
git commit -m "feat(sdk): add market types and helper functions (conditionId, positionId, EIP-712)"

---

Task 10: SDK Helpers Tests

Files:

• Create: sdk/test/helpers.test.ts

Step 1: Write tests

// sdk/test/helpers.test.ts

import { describe, expect, it } from "vitest";
import { encodePacked, keccak256 } from "viem";
import {
  getConditionId,
  getPositionId,
  hashOrderStruct,
  binaryPartition,
  fullPartition,
  ORDER_TYPEHASH,
} from "../src/market/helpers.js";
import { Side, type Order } from "../src/market/types.js";

const ORACLE = "0x00000000000000000000000000000000000000AA" as const;
const WETH = "0x0000000000000000000000000000000000001234" as const;
const QUESTION_ID = keccak256(encodePacked(["string"], ["ETH > 3000?"]));

describe("getConditionId", () => {
  it("matches keccak256(oracle, questionId, outcomeSlotCount)", () => {
    const result = getConditionId(ORACLE, QUESTION_ID, 2);
    const expected = keccak256(
      encodePacked(["address", "bytes32", "uint256"], [ORACLE, QUESTION_ID, 2n]),
    );
    expect(result).toBe(expected);
  });

  it("different oracle produces different conditionId", () => {
    const id1 = getConditionId(ORACLE, QUESTION_ID, 2);
    const id2 = getConditionId(WETH, QUESTION_ID, 2);
    expect(id1).not.toBe(id2);
  });
});

describe("getPositionId", () => {
  it("returns uint256 from keccak256(collateral, conditionId, indexSet)", () => {
    const conditionId = getConditionId(ORACLE, QUESTION_ID, 2);
    const posId = getPositionId(WETH, conditionId, 1);
    expect(typeof posId).toBe("bigint");
    expect(posId).toBeGreaterThan(0n);
  });

  it("YES and NO positions are different", () => {
    const conditionId = getConditionId(ORACLE, QUESTION_ID, 2);
    const yesId = getPositionId(WETH, conditionId, 1);
    const noId = getPositionId(WETH, conditionId, 2);
    expect(yesId).not.toBe(noId);
  });
});

describe("hashOrderStruct", () => {
  const order: Order = {
    salt: 123n,
    maker: ORACLE,
    signer: ORACLE,
    tokenId: 999n,
    makerAmount: 10n * 10n ** 18n,
    takerAmount: 6n * 10n ** 18n,
    expiration: 1700000000n,
    nonce: 0n,
    feeRateBps: 2n,
    side: Side.SELL,
  };

  it("returns deterministic hash", () => {
    const h1 = hashOrderStruct(order);
    const h2 = hashOrderStruct(order);
    expect(h1).toBe(h2);
  });

  it("different salt produces different hash", () => {
    const h1 = hashOrderStruct(order);
    const h2 = hashOrderStruct({ ...order, salt: 456n });
    expect(h1).not.toBe(h2);
  });
});

describe("ORDER_TYPEHASH", () => {
  it("is a bytes32 hex string", () => {
    expect(ORDER_TYPEHASH).toMatch(/^0x[0-9a-f]{64}$/);
  });
});

describe("partition helpers", () => {
  it("binaryPartition returns [1, 2]", () => {
    expect(binaryPartition()).toEqual([1, 2]);
  });

  it("fullPartition(3) returns [1, 2, 4]", () => {
    expect(fullPartition(3)).toEqual([1, 2, 4]);
  });

  it("fullPartition(4) returns [1, 2, 4, 8]", () => {
    expect(fullPartition(4)).toEqual([1, 2, 4, 8]);
  });
});

Step 2: Run tests

Run: cd sdk && npx vitest run Expected: all ~10 tests pass

Step 3: Commit

git add sdk/test/helpers.test.ts
git commit -m "test(sdk): add helpers tests (conditionId, positionId, EIP-712 hashing, partitions)"

---

Task 11: SDK Client + Contract Wrappers

Files:

• Create: sdk/src/client.ts

• Create: sdk/src/contracts/conditional-tokens.ts

• Create: sdk/src/contracts/exchange.ts

• Create: sdk/src/contracts/resolver.ts

• Create: sdk/src/contracts/oracle-hub.ts

Step 1: Write client.ts

// sdk/src/client.ts

import {
  createPublicClient,
  createWalletClient,
  http,
  type PublicClient,
  type WalletClient,
  type Transport,
  type Chain,
  type Account,
} from "viem";
import { ConditionalTokensClient } from "./contracts/conditional-tokens.js";
import { ExchangeClient } from "./contracts/exchange.js";
import { ResolverClient } from "./contracts/resolver.js";
import { OracleHubClient } from "./contracts/oracle-hub.js";

export interface BabyDriverClientConfig {
  rpcUrl: string;
  chain?: Chain;
  account?: Account;
  addresses: {
    conditionalTokens: `0x${string}`;
    exchange: `0x${string}`;
    resolver: `0x${string}`;
    oracleHub: `0x${string}`;
    collateral: `0x${string}`;
  };
}

export class BabyDriverClient {
  public readonly publicClient: PublicClient;
  public readonly walletClient: WalletClient | undefined;
  public readonly positions: ConditionalTokensClient;
  public readonly exchange: ExchangeClient;
  public readonly markets: ResolverClient;
  public readonly oracle: OracleHubClient;

  constructor(config: BabyDriverClientConfig) {
    this.publicClient = createPublicClient({
      chain: config.chain,
      transport: http(config.rpcUrl),
    });

    if (config.account) {
      this.walletClient = createWalletClient({
        chain: config.chain,
        transport: http(config.rpcUrl),
        account: config.account,
      });
    }

    this.positions = new ConditionalTokensClient(
      this.publicClient,
      this.walletClient,
      config.addresses.conditionalTokens,
    );
    this.exchange = new ExchangeClient(
      this.publicClient,
      this.walletClient,
      config.addresses.exchange,
    );
    this.markets = new ResolverClient(
      this.publicClient,
      this.walletClient,
      config.addresses.resolver,
    );
    this.oracle = new OracleHubClient(
      this.publicClient,
      config.addresses.oracleHub,
    );
  }
}

Step 2: Write contract wrappers (each follows same pattern: ABI subset + typed read/write methods)

// sdk/src/contracts/conditional-tokens.ts

import type { PublicClient, WalletClient } from "viem";

const ABI = [
  { type: "function", name: "getConditionId", inputs: [{ type: "address" }, { type: "bytes32" }, { type: "uint256" }], outputs: [{ type: "bytes32" }], stateMutability: "pure" },
  { type: "function", name: "getPositionId", inputs: [{ type: "address" }, { type: "bytes32" }, { type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "pure" },
  { type: "function", name: "getOutcomeSlotCount", inputs: [{ type: "bytes32" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
  { type: "function", name: "payoutDenominator", inputs: [{ type: "bytes32" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
  { type: "function", name: "balanceOf", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
  { type: "function", name: "prepareCondition", inputs: [{ type: "address" }, { type: "bytes32" }, { type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
  { type: "function", name: "splitPosition", inputs: [{ type: "address" }, { type: "bytes32" }, { type: "uint256[]" }, { type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
  { type: "function", name: "mergePositions", inputs: [{ type: "address" }, { type: "bytes32" }, { type: "uint256[]" }, { type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
  { type: "function", name: "redeemPositions", inputs: [{ type: "address" }, { type: "bytes32" }, { type: "uint256[]" }], outputs: [], stateMutability: "nonpayable" },
] as const;

export class ConditionalTokensClient {
  constructor(
    private readonly publicClient: PublicClient,
    private readonly walletClient: WalletClient | undefined,
    private readonly address: `0x${string}`,
  ) {}

  async getOutcomeSlotCount(conditionId: `0x${string}`): Promise<bigint> {
    return this.publicClient.readContract({
      address: this.address, abi: ABI, functionName: "getOutcomeSlotCount", args: [conditionId],
    }) as Promise<bigint>;
  }

  async balanceOf(account: `0x${string}`, tokenId: bigint): Promise<bigint> {
    return this.publicClient.readContract({
      address: this.address, abi: ABI, functionName: "balanceOf", args: [account, tokenId],
    }) as Promise<bigint>;
  }

  async splitPosition(collateral: `0x${string}`, conditionId: `0x${string}`, partition: bigint[], amount: bigint) {
    if (!this.walletClient) throw new Error("No wallet client");
    return this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "splitPosition",
      args: [collateral, conditionId, partition, amount],
    });
  }

  async mergePositions(collateral: `0x${string}`, conditionId: `0x${string}`, partition: bigint[], amount: bigint) {
    if (!this.walletClient) throw new Error("No wallet client");
    return this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "mergePositions",
      args: [collateral, conditionId, partition, amount],
    });
  }

  async redeemPositions(collateral: `0x${string}`, conditionId: `0x${string}`, indexSets: bigint[]) {
    if (!this.walletClient) throw new Error("No wallet client");
    return this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "redeemPositions",
      args: [collateral, conditionId, indexSets],
    });
  }
}

// sdk/src/contracts/exchange.ts

import type { PublicClient, WalletClient } from "viem";
import type { Order } from "../market/types.js";

const ABI = [
  { type: "function", name: "getOrderHash", inputs: [{ type: "tuple", components: [{ name: "salt", type: "uint256" }, { name: "maker", type: "address" }, { name: "signer", type: "address" }, { name: "tokenId", type: "uint256" }, { name: "makerAmount", type: "uint256" }, { name: "takerAmount", type: "uint256" }, { name: "expiration", type: "uint256" }, { name: "nonce", type: "uint256" }, { name: "feeRateBps", type: "uint256" }, { name: "side", type: "uint8" }] }], outputs: [{ type: "bytes32" }], stateMutability: "view" },
  { type: "function", name: "getOrderStatus", inputs: [{ type: "bytes32" }], outputs: [{ type: "uint256" }, { type: "bool" }], stateMutability: "view" },
  { type: "function", name: "fillOrder", inputs: [{ type: "tuple", components: [{ name: "salt", type: "uint256" }, { name: "maker", type: "address" }, { name: "signer", type: "address" }, { name: "tokenId", type: "uint256" }, { name: "makerAmount", type: "uint256" }, { name: "takerAmount", type: "uint256" }, { name: "expiration", type: "uint256" }, { name: "nonce", type: "uint256" }, { name: "feeRateBps", type: "uint256" }, { name: "side", type: "uint8" }], name: "order" }, { name: "fillAmount", type: "uint256" }, { name: "signature", type: "bytes" }], outputs: [], stateMutability: "nonpayable" },
  { type: "function", name: "cancelOrder", inputs: [{ type: "tuple", components: [{ name: "salt", type: "uint256" }, { name: "maker", type: "address" }, { name: "signer", type: "address" }, { name: "tokenId", type: "uint256" }, { name: "makerAmount", type: "uint256" }, { name: "takerAmount", type: "uint256" }, { name: "expiration", type: "uint256" }, { name: "nonce", type: "uint256" }, { name: "feeRateBps", type: "uint256" }, { name: "side", type: "uint8" }], name: "order" }], outputs: [], stateMutability: "nonpayable" },
  { type: "function", name: "incrementNonce", inputs: [], outputs: [], stateMutability: "nonpayable" },
  { type: "function", name: "nonces", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
] as const;

function orderToTuple(order: Order) {
  return {
    salt: order.salt, maker: order.maker, signer: order.signer,
    tokenId: order.tokenId, makerAmount: order.makerAmount, takerAmount: order.takerAmount,
    expiration: order.expiration, nonce: order.nonce, feeRateBps: order.feeRateBps, side: order.side,
  };
}

export class ExchangeClient {
  constructor(
    private readonly publicClient: PublicClient,
    private readonly walletClient: WalletClient | undefined,
    private readonly address: `0x${string}`,
  ) {}

  async getOrderHash(order: Order): Promise<`0x${string}`> {
    return this.publicClient.readContract({
      address: this.address, abi: ABI, functionName: "getOrderHash", args: [orderToTuple(order)],
    }) as Promise<`0x${string}`>;
  }

  async getOrderStatus(orderHash: `0x${string}`): Promise<{ filled: bigint; cancelled: boolean }> {
    const [filled, cancelled] = await this.publicClient.readContract({
      address: this.address, abi: ABI, functionName: "getOrderStatus", args: [orderHash],
    }) as [bigint, boolean];
    return { filled, cancelled };
  }

  async fillOrder(order: Order, fillAmount: bigint, signature: `0x${string}`) {
    if (!this.walletClient) throw new Error("No wallet client");
    return this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "fillOrder",
      args: [orderToTuple(order), fillAmount, signature],
    });
  }

  async cancelOrder(order: Order) {
    if (!this.walletClient) throw new Error("No wallet client");
    return this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "cancelOrder", args: [orderToTuple(order)],
    });
  }

  async incrementNonce() {
    if (!this.walletClient) throw new Error("No wallet client");
    return this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "incrementNonce",
    });
  }
}

// sdk/src/contracts/resolver.ts

import type { PublicClient, WalletClient } from "viem";
import type { Market } from "../market/types.js";

const ABI = [
  { type: "function", name: "createPriceMarket", inputs: [{ type: "string" }, { type: "string" }, { type: "uint256" }, { type: "uint256" }, { type: "address" }, { type: "uint256" }], outputs: [{ type: "bytes32" }], stateMutability: "nonpayable" },
  { type: "function", name: "createManualMarket", inputs: [{ type: "string" }, { type: "address" }, { type: "address" }, { type: "uint256" }], outputs: [{ type: "bytes32" }], stateMutability: "nonpayable" },
  { type: "function", name: "resolvePrice", inputs: [{ type: "bytes32" }], outputs: [], stateMutability: "nonpayable" },
  { type: "function", name: "resolveManual", inputs: [{ type: "bytes32" }, { type: "uint256[]" }], outputs: [], stateMutability: "nonpayable" },
  { type: "function", name: "getMarket", inputs: [{ type: "bytes32" }], outputs: [{ type: "tuple", components: [{ name: "conditionId", type: "bytes32" }, { name: "questionId", type: "bytes32" }, { name: "resolutionType", type: "uint8" }, { name: "creator", type: "address" }, { name: "resolved", type: "bool" }, { name: "collateral", type: "address" }, { name: "outcomeSlotCount", type: "uint256" }, { name: "priceSymbol", type: "string" }, { name: "priceThreshold", type: "uint256" }, { name: "resolutionTime", type: "uint256" }, { name: "resolver", type: "address" }] }], stateMutability: "view" },
] as const;

export class ResolverClient {
  constructor(
    private readonly publicClient: PublicClient,
    private readonly walletClient: WalletClient | undefined,
    private readonly address: `0x${string}`,
  ) {}

  async createPriceMarket(params: {
    question: string; symbol: string; threshold: bigint;
    resolutionTime: bigint; collateral: `0x${string}`; outcomeCount?: number;
  }): Promise<`0x${string}`> {
    if (!this.walletClient) throw new Error("No wallet client");
    const hash = await this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "createPriceMarket",
      args: [params.question, params.symbol, params.threshold, params.resolutionTime, params.collateral, BigInt(params.outcomeCount ?? 2)],
    });
    return hash;
  }

  async createManualMarket(params: {
    question: string; resolver: `0x${string}`; collateral: `0x${string}`; outcomeCount?: number;
  }): Promise<`0x${string}`> {
    if (!this.walletClient) throw new Error("No wallet client");
    return this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "createManualMarket",
      args: [params.question, params.resolver, params.collateral, BigInt(params.outcomeCount ?? 2)],
    });
  }

  async resolvePrice(marketId: `0x${string}`) {
    if (!this.walletClient) throw new Error("No wallet client");
    return this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "resolvePrice", args: [marketId],
    });
  }

  async resolveManual(marketId: `0x${string}`, payouts: bigint[]) {
    if (!this.walletClient) throw new Error("No wallet client");
    return this.walletClient.writeContract({
      address: this.address, abi: ABI, functionName: "resolveManual", args: [marketId, payouts],
    });
  }

  async getMarket(marketId: `0x${string}`): Promise<Market> {
    const result = await this.publicClient.readContract({
      address: this.address, abi: ABI, functionName: "getMarket", args: [marketId],
    });
    return result as unknown as Market;
  }
}

// sdk/src/contracts/oracle-hub.ts

import type { PublicClient } from "viem";

const ABI = [
  { type: "function", name: "getLatestPrice", inputs: [{ type: "string" }], outputs: [{ type: "uint256" }, { type: "uint256" }], stateMutability: "view" },
  { type: "function", name: "isPriceFresh", inputs: [{ type: "string" }], outputs: [{ type: "bool" }], stateMutability: "view" },
] as const;

export class OracleHubClient {
  constructor(
    private readonly publicClient: PublicClient,
    private readonly address: `0x${string}`,
  ) {}

  async getLatestPrice(symbol: string): Promise<{ price: bigint; timestamp: bigint }> {
    const [price, timestamp] = await this.publicClient.readContract({
      address: this.address, abi: ABI, functionName: "getLatestPrice", args: [symbol],
    }) as [bigint, bigint];
    return { price, timestamp };
  }

  async isPriceFresh(symbol: string): Promise<boolean> {
    return this.publicClient.readContract({
      address: this.address, abi: ABI, functionName: "isPriceFresh", args: [symbol],
    }) as Promise<boolean>;
  }
}

Step 3: Update index.ts exports

// sdk/src/index.ts
export { BabyDriverClient, type BabyDriverClientConfig } from "./client.js";
export * from "./market/types.js";
export * from "./market/helpers.js";
export { ConditionalTokensClient } from "./contracts/conditional-tokens.js";
export { ExchangeClient } from "./contracts/exchange.js";
export { ResolverClient } from "./contracts/resolver.js";
export { OracleHubClient } from "./contracts/oracle-hub.js";

Step 4: Type check

Run: cd sdk && npx tsc --noEmit Expected: no errors

Step 5: Commit

git add sdk/src/
git commit -m "feat(sdk): add BabyDriverClient + contract wrappers (CTF, exchange, resolver, oracle)"

---

Task 12: SDK Client Tests

Files:

• Create: sdk/test/client.test.ts

Step 1: Write tests

// sdk/test/client.test.ts

import { describe, expect, it } from "vitest";
import { BabyDriverClient } from "../src/client.js";

const ADDRESSES = {
  conditionalTokens: "0x0000000000000000000000000000000000000001" as const,
  exchange: "0x0000000000000000000000000000000000000002" as const,
  resolver: "0x0000000000000000000000000000000000000003" as const,
  oracleHub: "0x0000000000000000000000000000000000008016" as const,
  collateral: "0x0000000000000000000000000000000000000004" as const,
};

describe("BabyDriverClient", () => {
  it("creates client with public client only (read-only)", () => {
    const client = new BabyDriverClient({
      rpcUrl: "http://localhost:3050",
      addresses: ADDRESSES,
    });
    expect(client.publicClient).toBeDefined();
    expect(client.walletClient).toBeUndefined();
    expect(client.positions).toBeDefined();
    expect(client.exchange).toBeDefined();
    expect(client.markets).toBeDefined();
    expect(client.oracle).toBeDefined();
  });

  it("positions client throws without wallet", async () => {
    const client = new BabyDriverClient({
      rpcUrl: "http://localhost:3050",
      addresses: ADDRESSES,
    });
    await expect(
      client.positions.splitPosition(ADDRESSES.collateral, "0x" + "00".repeat(32) as `0x${string}`, [1n, 2n], 10n),
    ).rejects.toThrow("No wallet client");
  });

  it("exchange client throws without wallet", async () => {
    const client = new BabyDriverClient({
      rpcUrl: "http://localhost:3050",
      addresses: ADDRESSES,
    });
    await expect(client.exchange.incrementNonce()).rejects.toThrow("No wallet client");
  });

  it("markets client throws without wallet", async () => {
    const client = new BabyDriverClient({
      rpcUrl: "http://localhost:3050",
      addresses: ADDRESSES,
    });
    await expect(
      client.markets.resolvePrice("0x" + "00".repeat(32) as `0x${string}`),
    ).rejects.toThrow("No wallet client");
  });
});

Step 2: Run all SDK tests

Run: cd sdk && npx vitest run Expected: all tests pass (~14 total: 10 helpers + 4 client)

Step 3: Build

Run: cd sdk && npx tsup Expected: dist/ contains index.js, index.cjs, index.d.ts

Step 4: Commit

git add sdk/test/client.test.ts
git commit -m "test(sdk): add client initialization + read-only guard tests"

---

Task 13: Update Docs + Final Commit

Files:

• Modify: docs/README.md

• Modify: docs/dev-notes/dev-log.md

Step 1: Update README.md

Add P7 section to plans table and update progress:

### P7-prediction-market/ — 预测市场 + SDK

| 功能 | 文件 |
|------|------|
| 预测市场 + SDK | [design](plans/P7-prediction-market/2026-03-10-prediction-market-sdk-design.md) / [impl](plans/P7-prediction-market/2026-03-10-prediction-market-sdk-impl.md) |

Update progress:

- **Phase 7**: 预测市场 + SDK（ConditionalTokens + CTFExchange + OracleResolver + @babydriver/sdk）✅

Step 2: Add dev-log entry

Append Phase 7 entry with key decisions and contract addresses.

Step 3: Commit

git add docs/
git commit -m "docs: Phase 7 completion — prediction market + SDK docs update"

---

Summary

Task	Component	Tests	Est. Lines
1	3 interfaces	—	~150
2	ConditionalTokens.sol	—	~180
3	ConditionalTokens tests	18	~250
4	CTFExchange.sol	—	~220
5	CTFExchange tests	14	~200
6	OracleResolver.sol	—	~130
7	OracleResolver + E2E tests	15	~280
8	SDK scaffold	—	~50
9	SDK types + helpers	—	~120
10	SDK helpers tests	10	~80
11	SDK client + wrappers	—	~300
12	SDK client tests	4	~50
13	Docs update	—	~30
Total		~61	~2040