Conditional market

A conditional market is a market that depends on a specific outcome of an existing (parent) market. The child market’s positions are backed by the parent’s outcome token, not by the chain’s base collateral. For example: “Will Russia withdraw all troops from Ukrainian territory by end of 2025?” conditional on the parent “Will the war in Ukraine end in 2024?” resolving to Yes (outcome index 0).

You create conditional markets with the same MarketFactory functions as root markets (e.g. createCategoricalMarket), but you set parentMarket and parentOutcome in CreateMarketParams. Split, merge and redeem use the same Router (or chain-specific router) with the parent’s outcome token as the collateral token for the child market. Redeeming a resolved conditional market returns parent outcome tokens; to get base collateral in one go you can use ConditionalRouter.redeemConditionalToCollateral when the parent is a root market.

---

Creating a conditional market

Use any of the four market-creation functions on the MarketFactory and pass a parent market address and parent outcome index in the params. The child market is tied to “parent resolves to this outcome.”

Parameter	Type	Description
parentMarket	address	Parent market contract address. Use address(0) for a root (non-conditional) market.
parentOutcome	uint256	Index of the parent outcome this market is conditional on (e.g. 0 = Yes, 1 = No in a binary market).

Split, merge and redeem

The same Router (or GnosisRouter / MainnetRouter) is used. The important difference is the collateral token:

• Root market: collateral token = base collateral (e.g. sDAI or sUSDS, or the yield-bearing ERC20 you use on that chain).

• Conditional market: collateral token = parent’s wrapped outcome token (the ERC20 for the parent outcome at index parentOutcome).

So for a conditional market you do not use splitFromBase (Gnosis) or splitFromDai (Mainnet); you use splitPosition(collateralToken, market, amount) where collateralToken is the parent outcome ERC20.

Split

You must hold enough parent outcome tokens (from splitting or trading the parent market). Then:

1. Approve the parent’s wrapped outcome token (for the outcome index the child is conditional on) to the Router.

2. Call router.splitPosition(parentWrappedOutcomeToken, conditionalMarket, amount).

You receive a full set of child outcome tokens (one ERC20 per outcome).

Merge

Hold a full set of child outcome tokens (equal amount of each outcome; e.g. 50 of outcome A and 50 of outcome B). Call:

router.mergePositions(parentWrappedOutcomeToken, conditionalMarket, amount).

You receive parent outcome tokens back.

Redeem (after child market is resolved)

Call router.redeemPositions(parentWrappedOutcomeToken, conditionalMarket, outcomeIndexes, amounts) with the winning child outcome index(es) and amounts. You receive parent outcome tokens (not base collateral). To get base collateral you must either:

• Redeem the parent market separately (if the parent is resolved), or

• Use ConditionalRouter.redeemConditionalToCollateral (see below), which redeems child winning positions and then redeems the resulting parent outcome to collateral in one tx. The parent must be a root market (not conditional).

---

ConditionalRouter: redeem to collateral in one call

ConditionalRouter extends Router and adds:

function redeemConditionalToCollateral(
    IERC20 collateralToken,
    Market market,
    uint256[] calldata outcomeIndexes,
    uint256[] calldata parentOutcomeIndexes,
    uint256[] calldata amounts
) public

• outcomeIndexes / amounts: winning child outcome(s) to redeem.

• parentOutcomeIndexes: which parent outcome(s) to redeem when converting the received parent tokens to collateral (e.g. [0] if the parent resolved to outcome 0).

The parent market must be a root market (not conditional). The function redeems the child positions and then the parent outcome tokens, and sends collateral to the user.

---

Nested conditional markets

The framework supports multiple levels: a market can be conditional on another conditional market. Interact with each level the same way (collateral token for a child is always the parent’s wrapped outcome token).

If the parent resolves to an outcome different from the one the child is conditional on, the child market (and any deeper nesting) becomes obsolete: no one can redeem that branch for value.

---

Viem examples

We use the Viem setup: getPublicClient(chain) and getWalletClient(chain, process.env.PRIVATE_KEY). Addresses come from SEER_CONTRACTS[chain.id]. You also need the MarketFactory and Router (or GnosisRouter/MainnetRouter) ABIs, and a parent market already created. The parent can be root or conditional.

1. Create a conditional categorical market

Use the same createMarketParams helper and MarketFactory ABI as in Create a market, and set parentMarket and parentOutcome:

import { getPublicClient, getWalletClient, SEER_CONTRACTS, ERC20_APPROVE_ABI, MARKET_ABI } from "./viem-setup";
import { gnosis } from "viem/chains"; // or mainnet, base, etc.

const chain = gnosis;
const publicClient = getPublicClient(chain);
const walletClient = getWalletClient(chain, process.env.PRIVATE_KEY! as `0x${string}`);
const addresses = SEER_CONTRACTS[chain.id];
const parentMarketAddress = "0x..."; // parent market address
const parentOutcomeIndex = 0;       // e.g. 0 = Yes

const params = createMarketParams({
  marketName: "If the war ends in 2024, will Russia withdraw all troops by end of 2025?",
  outcomes: ["Yes", "No"],
  parentMarket: parentMarketAddress,
  parentOutcome: BigInt(parentOutcomeIndex),
  category: "misc",
  openingTime: Math.floor(Date.now() / 1000) + 86400 * 30,
  minBond: 10000000000000000n,
  tokenNames: ["YES", "NO"],
});

const hash = await walletClient.writeContract({
  address: addresses.MarketFactory,
  abi: marketFactoryAbi,
  functionName: "createCategoricalMarket",
  args: [params],
});
const receipt = await publicClient.waitForTransactionReceipt({ hash });
// Parse NewMarket event to get conditional market address
const conditionalMarketAddress = "0x..."; // from event

2. Get parent wrapped outcome token (for split/merge/redeem)

The “collateral” token for the conditional market in Router calls is the parent’s wrapped outcome ERC20. You can read it from the child market (if the contract exposes it) or from the parent:

const parentMarket = await publicClient.readContract({
  address: conditionalMarketAddress,
  abi: MARKET_ABI,
  functionName: "parentMarket",
});
const parentOutcome = await publicClient.readContract({
  address: conditionalMarketAddress,
  abi: MARKET_ABI,
  functionName: "parentOutcome",
});

const [parentWrappedOutcomeToken] = await publicClient.readContract({
  address: parentMarket,
  abi: MARKET_ABI,
  functionName: "wrappedOutcome",
  args: [parentOutcome],
});
// parentWrappedOutcomeToken is the ERC20 to use as collateralToken in Router calls

3. Split on a conditional market

Approve the parent outcome token to the Router, then call splitPosition with that token and the conditional market. Use addresses.Router (Optimism/Base), addresses.GnosisRouter (Gnosis), or addresses.MainnetRouter (Ethereum) as appropriate for your chain.

const routerAddress = addresses.Router ?? addresses.GnosisRouter ?? addresses.MainnetRouter;
const amount = 1000000000000000000n; // 1e18

await walletClient.writeContract({
  address: parentWrappedOutcomeToken,
  abi: ERC20_APPROVE_ABI,
  functionName: "approve",
  args: [routerAddress, amount],
});

const routerAbi = [
  {
    inputs: [
      { name: "collateralToken", type: "address" },
      { name: "market", type: "address" },
      { name: "amount", type: "uint256" },
    ],
    name: "splitPosition",
    outputs: [],
    stateMutability: "nonpayable",
    type: "function",
  },
  {
    inputs: [
      { name: "collateralToken", type: "address" },
      { name: "market", type: "address" },
      { name: "amount", type: "uint256" },
    ],
    name: "mergePositions",
    outputs: [],
    stateMutability: "nonpayable",
    type: "function",
  },
  {
    inputs: [
      { name: "collateralToken", type: "address" },
      { name: "market", type: "address" },
      { name: "outcomeIndexes", type: "uint256[]" },
      { name: "amounts", type: "uint256[]" },
    ],
    name: "redeemPositions",
    outputs: [],
    stateMutability: "nonpayable",
    type: "function",
  },
] as const;

const hash = await walletClient.writeContract({
  address: routerAddress,
  abi: routerAbi,
  functionName: "splitPosition",
  args: [parentWrappedOutcomeToken, conditionalMarketAddress, amount],
});

4. Merge on a conditional market

You need a full set of child outcome tokens (equal amount of each outcome). Same Router and “collateral” token (parent wrapped outcome). Approve the router to spend amount of each child outcome token before calling merge:

// 1. Approve router to spend `amount` of each child outcome token.
const numOutcomes = await publicClient.readContract({
  address: conditionalMarketAddress,
  abi: MARKET_ABI,
  functionName: "numOutcomes",
  args: [],
});
for (let i = 0n; i < numOutcomes; i++) {
  const [childWrappedToken] = await publicClient.readContract({
    address: conditionalMarketAddress,
    abi: MARKET_ABI,
    functionName: "wrappedOutcome",
    args: [i],
  });
  await walletClient.writeContract({
    address: childWrappedToken,
    abi: ERC20_APPROVE_ABI,
    functionName: "approve",
    args: [routerAddress, amount],
  });
}

// 2. Merge
const hash = await walletClient.writeContract({
  address: routerAddress,
  abi: routerAbi,
  functionName: "mergePositions",
  args: [parentWrappedOutcomeToken, conditionalMarketAddress, amount],
});

5. Redeem (child resolved) → parent outcome tokens

After the child market is resolved, redeem winning child outcome(s). You receive parent outcome tokens. Approve the router to spend each winning child outcome token for the corresponding amount before calling redeem. Use a Router ABI that includes redeemPositions(collateralToken, market, outcomeIndexes, amounts) (see Split, merge and redeem):

const outcomeIndexes = [0n];   // e.g. first outcome won
const amounts = [500000000000000000n];

// 1. Approve router to spend each winning child outcome token.
for (let i = 0; i < outcomeIndexes.length; i++) {
  const [winningChildToken] = await publicClient.readContract({
    address: conditionalMarketAddress,
    abi: MARKET_ABI,
    functionName: "wrappedOutcome",
    args: [outcomeIndexes[i]],
  });
  await walletClient.writeContract({
    address: winningChildToken,
    abi: ERC20_APPROVE_ABI,
    functionName: "approve",
    args: [routerAddress, amounts[i]],
  });
}

// 2. Redeem
const hash = await walletClient.writeContract({
  address: routerAddress,
  abi: routerAbi,
  functionName: "redeemPositions",
  args: [parentWrappedOutcomeToken, conditionalMarketAddress, outcomeIndexes, amounts],
});

6. Redeem to base collateral in one tx (ConditionalRouter)

If the parent is a root market and is already resolved, you can use ConditionalRouter to redeem child winning positions and get collateral in one call. Use addresses.ConditionalRouter. Approve the ConditionalRouter to spend each winning child outcome token for the corresponding amount before calling.

const collateralToken = "0x..."; // base collateral (e.g. sDAI or sUSDS)

const conditionalRouterAbi = [
  {
    inputs: [
      { name: "collateralToken", type: "address" },
      { name: "market", type: "address" },
      { name: "outcomeIndexes", type: "uint256[]" },
      { name: "parentOutcomeIndexes", type: "uint256[]" },
      { name: "amounts", type: "uint256[]" },
    ],
    name: "redeemConditionalToCollateral",
    outputs: [],
    stateMutability: "nonpayable",
    type: "function",
  },
] as const;

const outcomeIndexes = [0n];
const parentOutcomeIndexes = [0n]; // parent outcome that won (e.g. Yes = 0)
const amounts = [500000000000000000n];

// 1. Approve ConditionalRouter to spend each winning child outcome token.
for (let i = 0; i < outcomeIndexes.length; i++) {
  const [winningChildToken] = await publicClient.readContract({
    address: conditionalMarketAddress,
    abi: MARKET_ABI,
    functionName: "wrappedOutcome",
    args: [outcomeIndexes[i]],
  });
  await walletClient.writeContract({
    address: winningChildToken,
    abi: ERC20_APPROVE_ABI,
    functionName: "approve",
    args: [addresses.ConditionalRouter, amounts[i]],
  });
}

// 2. Redeem to collateral
const hash = await walletClient.writeContract({
  address: addresses.ConditionalRouter,
  abi: conditionalRouterAbi,
  functionName: "redeemConditionalToCollateral",
  args: [
    collateralToken,
    conditionalMarketAddress,
    outcomeIndexes,
    parentOutcomeIndexes,
    amounts,
  ],
});

---

Summary

Step	What to use
Create	MarketFactory (e.g. createCategoricalMarket) with parentMarket and parentOutcome in params.
Collateral token for Router	Parent’s wrapped outcome token (read via parent’s wrappedOutcome(parentOutcome) or child’s parent info).
Split	Hold parent outcome tokens → approve parent wrapped token → router.splitPosition(parentWrappedToken, conditionalMarket, amount).
Merge	Hold full set of child outcome tokens (equal amount of each) → router.mergePositions(parentWrappedToken, conditionalMarket, amount) → receive parent outcome tokens.
Redeem	After child resolved → router.redeemPositions(...) → receive parent outcome tokens; or use ConditionalRouter.redeemConditionalToCollateral to get base collateral in one tx (parent must be root and resolved).