CTFExchange

CTFExchange is a Polymarket-compatible order-matching contract that settles trades against ConditionalTokens. PredictStreet deploys it with the quadratic taker-fee formula fee = k × P × (1−P) × outcomeTokens. See Fees for the math.

Key entry points

Function	Caller	Purpose
`fillOrder(Order, fillAmount)`	`onlyOperator`	Direct fill against a resting order
`matchOrders(takerOrder, makerOrders[], takerFillAmount, makerFillAmounts[])`	`onlyOperator`	Single-taker batch
`batchMatchOrders(takerOrders[], makerOrders[][], takerFillAmounts[], makerFillAmounts[][])`	`onlyOperator`	Multi-taker batch — per-taker reverts caught and emitted as `MatchFailed` so the rest of the batch still settles
`cancelOrders(bytes32[] orderHashes)`	`onlyOperator`	Operator-side cancel by order hash. In normal operation order signers have no on-chain cancel. Cancel through the REST API instead.
`cancelMyOrder(Order)`	owner of the `order.maker` vault	Self-cancel escape hatch. Only available once that vault has initiated an emergency withdraw (`initiateEmergencyWithdraw`).
`registerToken(uint256 token0, uint256 token1, bytes32 conditionId)`	`onlyAdmin`	Register a new market
`pauseTrading()` / `unpauseTrading()`	`onlyAdmin`	Emergency halt
`pauseUser(address user, uint256 duration)`	`onlyAdmin`	Block orders signed by `user` (the signing EOA) for `duration` seconds
`pauseMarket(bytes32 conditionId)`	`onlyAdmin`	Block a specific market
`setVaultFactory(address)`	`onlyAdmin`	Wire the VaultFactory
`addOperator(address)`	`onlyAdmin`	Whitelist an operator key

Fee formula

// ONE = 1e18; BPS_DIVISOR = 10_000
// price = collateral per outcome token, in 1e18 fixed-point (ONE = 1.0)

// BUY: fee charged in outcome tokens
fee_tokens = feeRateBps × (ONE − price) × outcomeTokens / (BPS_DIVISOR × ONE);

// SELL: fee charged in collateral
fee_collateral = feeRateBps × price × (ONE − price) × outcomeTokens / (BPS_DIVISOR × ONE × ONE);

Cap: feeRateBps ≤ MAX_FEE_RATE_BIPS (1000).

Events

event OrderFilled(
    uint64 seq,
    uint64 batchPosition,
    bytes32 indexed orderHash,
    address indexed maker,
    address indexed taker,
    uint256 makerAssetId,
    uint256 takerAssetId,
    uint256 makerAmountFilled,
    uint256 takerAmountFilled,
    uint256 fee,
    uint256 remainingAfter   // 0 = order is now fully filled
);

event OrdersMatched(
    uint64 seq,
    uint64 batchPosition,
    bytes32 indexed takerOrderHash,
    address indexed takerOrderMaker,
    uint256 makerAssetId,
    uint256 takerAssetId,
    uint256 makerAmountFilled,
    uint256 takerAmountFilled
);

event MatchFailed(
    uint64 seq,
    uint256 index,
    bytes32 indexed takerOrderHash,
    address indexed takerMaker,
    address takerSigner,
    uint256 takerTokenId,
    uint256 takerFillAmount,
    uint256 takerRemainingBefore,
    bytes reason
);

event OrderCancelled(uint64 seq, bytes32 indexed orderHash, uint256 remainingBefore);

event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount);

maker (and takerOrderMaker / takerMaker) is the order’s vault address, not the signing EOA.

Security invariants

Signature replay impossible — every filled order’s hash stored in orderStatus[hash].isFilledOrCancelled.
Maker authority cryptographic — the exchange accepts only signatureType = 1 (VAULT). The signature must recover to signer, and maker must equal vaultFactory.vaultOf(signer), so the signer’s vault must already be deployed. signatureType = 0 (EOA, maker == signer) is deprecated and never validates. On-chain such orders revert with InvalidSignature(), and the API rejects them with bad_signature.
Admin can pause but not seize — no admin function transfers user funds.
Operator rotatable — removeOperator(address) disables compromised key.

`MatchFailed` reason codes

When batchMatchOrders catches a per-leg revert, the reason bytes are the 4-byte selector of the original custom error. Common ones:

Selector	Custom error	Cause
`0xc56873ba`	`OrderExpired()`	A maker or taker order’s `expiration` is in the past at execution time. Most common with stale resting LIMITs whose TTL elapsed between match (off-chain) and submit (on-chain).
`0x7b38b76e`	`OrderFilledOrCancelled()`	The order’s hash is already marked filled or cancelled on-chain (replay or duplicate match).
`0xa0b94465`	`MismatchedTokenIds()`	A BUY is matched against a SELL on a different outcome token.
`0x66f8620a`	`InvalidComplement()`	Two BUYs or two SELLs are matched, but their tokens are not the two outcomes of one market.
`0x7f9a6f46`	`NotCrossing()`	The proposed prices don’t cross.
`0x8baa579f`	`InvalidSignature()`	The order failed vault signature checks: `signatureType` is not `1` (VAULT), the signer has no vault, the signature does not recover to `signer`, or `maker` is not `vaultFactory.vaultOf(signer)`.

Decode the bytes with cast 4byte 0x<selector> or by computing bytes4(keccak256(<errorSig>)).

To avoid OrderExpired() settlement failures, sign orders with expiration = 0 (no on-chain expiry — the contract skips the block.timestamp >= expiration check entirely). UIs that need a hard TTL should set it well above worst-case settlement latency.

Source

0x4074c225b296E1E556c565B0C3Ddba305E63E7c4 on Blockscout (testnet). The contract is not source-verified there; request the ABI from your onboarding contact.

Getting Started

Authentication

Vaults

Deposits

Trading

Events & Tags

Markets

Portfolio

Withdrawals

WebSocket

Settlement & Oracle

On-chain Contracts

Partners

Errors

Key entry points

Fee formula

Events

Security invariants

`MatchFailed` reason codes

Source

​Key entry points

​Fee formula

​Events

​Security invariants

​MatchFailed reason codes

​Source

Key entry points

Fee formula

Events

Security invariants

`MatchFailed` reason codes

Source