Module 13: Prediction Strategies

What this covers: Advanced prediction market strategies — participant roles, combined multi-route plays, and the composable strategy stacking reference for building valid multi-position trees from a single capital input.

Prerequisites

• Basic prediction market mechanics — buying shares, payout structure, fee distribution
• Token mechanics — especially Stable+ mechanics for Predict+ tokens
• Trading basics — buy, sell, getAmountsOut, slippage protection
• Lending fundamentals — LTV, origination fees, loan extensions
• Staking & vault yield — wSTASIS wrapping, vault loan mechanics
• Client initialized (→02)

Next steps

• Executing resolution strategies (Roles 5, bounty hunting, disputes) → Module 14 Resolution
• Full capital stacking framework across all token types → Module 12 Strategy & Stacking
• Complete SDK method signatures and error reference
• Single-pillar deep dives → Module 04 Trading, Module 05 Lending, Module 06 Staking

1. Participant Roles

Traditional prediction platforms give every participant one role: bettor. BASIS opens at least seven distinct ways to engage with a single prediction market. Each role generates revenue independently. The real edge is stacking them — combining multiple roles from the same market.

Role 1: Bettor

What it does: Buy outcome shares against the AMM, back conviction on a specific outcome, collect proportional share of the one big pot on resolution.

Revenue model: (your winning shares / total winning shares) × entire merged pot. No $1 cap. The more capital that flowed into losing outcomes, the larger the pot, and the larger your payout. Uncapped from trade one.

Required capital: Any amount. Minimum practical entry is whatever produces non-trivial shares at current AMM price.

SDK methods: (see Module 18 for full signatures)

// Preview price and calculate slippage before buying
const outcomes = await client.marketReader.getAllOutcomes(routerAddress, marketToken);
const price = outcomes[outcomeId].pricePerShare;
const expectedShares = inputAmount * BigInt(1e18) / price;
const minShares = expectedShares * 98n / 100n; // 2% slippage tolerance

// Buy
await client.predictionMarkets.buy(marketToken, outcomeId, USDB, inputAmount, 0n, minShares);

// Redeem after resolution
await client.predictionMarkets.redeem(marketToken);

Risk: Full loss of bet if outcome is wrong. Outcome positions are terminal — no loan capacity, no yield while waiting.

When to use: High conviction on a specific outcome, especially early when shares are cheap and the potential pot is large relative to current position size.

Role 2: Trader

What it does: Buy shares early at low implied probability, sell them on the order book at a profit as sentiment shifts — without needing to be right about the final outcome.

Revenue model: Spread between entry price and exit price on the P2P order book. Because resolution value can vastly exceed AMM buy price (e.g., bought at 5c, resolution value $4+), both sides of an order book trade can be genuinely profitable. Unlike fixed-payout platforms, the buyer of your shares at 90c may still be buying at a meaningful discount to potential resolution value.

Required capital: Any amount. Edge is sharpest on early entry when shares are cheapest.

SDK methods:

// List shares for sale
await client.orderBook.listOrder(marketToken, outcomeId, shareAmount, pricePerShare);

// Cancel an unfilled order
await client.orderBook.cancelOrder(marketToken, orderId);

// Fill someone else's order
await client.orderBook.buyOrder(marketToken, orderId, usdbFill);

// Read open orders before listing — check depth and spread
const openOrders = await client.orderBook.getOpenOrders(marketToken, outcomeId);

Risk: Shares may not appreciate if sentiment does not shift. Listing on the order book is free and cancellation is free — no cost to placing unfilled orders.

Role 3: Token Trader (Outsider)

What it does: Buy the Predict+ token — the market-level Stable+ token — instead of outcome shares. Not a bet on any outcome. A bet that the market will attract volume.

Revenue model: Predict+ is a Stable+ token: price only goes up as trading volume flows through the market. Buys increase price; sells burn tokens and push price higher for remaining holders. Patient sellers exit at the post-resolution peak. Profitable regardless of which outcome wins.

Required capital: Any amount. Edge is on controversial, high-traffic markets where volume is structurally predictable.

SDK methods:

// Buy Predict+ token (same as buying any Basis token on the DEX)
await client.trading.buy(predictPlusTokenAddress, USDB, inputAmount, minTokensOut);

// Sell Predict+ token on the DEX
await client.trading.sell(predictPlusTokenAddress, amount);

// Check current price and volume
const tokenData = await client.api.getToken(predictPlusTokenAddress);

Risk: Market may have low volume if the question generates no controversy. If capital is locked in the Predict+ token instead of deployed as collateral, opportunity cost applies — see Role 5 (Leveraged Player) for the better version.

Role 4: Creator

What it does: Launch a prediction market. Earn 20% of net trading fees on all trading activity forever — from both sides, regardless of outcome.

Revenue model: 20% of net trading fees in that market, forever. No bet required. No outcome risk. Volume from all participants across all outcomes generates creator revenue. Dead markets cost gas with zero return; high-controversy markets generate passive income indefinitely.

Required capital: Seed amount in $10 increments. Minimums vary by tier: Basis-managed public = 50 USDB, creator public = 10 USDB, creator private = 0 (no minimum). The seed funds the resolution bounty + general pot — it is not liquidity for the outcome pools (those are virtual at launch).

SDK methods:

await client.predictionMarkets.createMarketWithMetadata({
  marketName: "Will ETH reach $10k before May 2026?",
  symbol: "ETH10K",                          // MUST BE CAPITALISED
  endTime: BigInt(Math.floor(Date.now() / 1000) + 86400 * 30),
  optionNames: ["Yes", "No"],
  maintoken: client.mainTokenAddress,
  seedAmount: parseUnits("50", 18),
  description: "ETH price prediction.",
  imageUrl: "https://example.com/eth.jpg",
});

// For private markets (creator-managed resolution):
await client.privateMarkets.createMarketWithMetadata({ ...params, privateEvent: true });

Risk: Seed capital is consumed as AMM liquidity. Low-volume markets return only trading fees, which may not cover seed opportunity cost. Optimal when creator has strong read on what generates genuine disagreement.

Role 5: Resolver

What it does: After market end time, propose the correct outcome (5 USDB bond), wait for the challenge period, finalize if uncontested, and collect the bounty pool. Full lifecycle in Module 14.

Revenue model: 100% of the bounty pool if uncontested. If disputed: bonds go to the correct side, bounty splits to correct voters. Bounty pool scales with market volume — high-volume market = large bounty = strong financial incentive for accurate, timely resolution.

Required capital: 5 USDB bond (returned if uncontested or if you proposed correctly in a dispute). Dispute also costs 5 USDB.

SDK methods:

// Find markets awaiting resolution
const markets = await client.api.getTokens({ isPrediction: true, limit: 100 });
const pending = markets.data.filter(m => m.predictionStatus === "awaiting_proposal");

// Propose outcome
await client.resolver.proposeOutcome(marketToken, outcomeId);

// Finalize if uncontested after challenge period
await client.resolver.finalizeUncontested(marketToken);

// Claim bounty
await client.resolver.claimBounty(marketToken);

Risk: Bond loss if proposal is wrong and disputed successfully. See Module 14 for full dispute mechanics, voting strategy, and veto plays.

Role 6: Leveraged Player

What it does: Buy Predict+ tokens, take a loan against them (token locked as collateral), use the borrowed USDB to buy outcome shares. Original capital works twice simultaneously: once as appreciating collateral (Predict+ appreciating from volume), once as an active bet on an outcome.

Revenue model: Two independent income streams from one capital outlay — Predict+ token appreciation (volume-driven, outcome-agnostic) + outcome share payout (resolution-dependent, uncapped). Win the bet, repay the loan, still own the Predict+ tokens. This is a form of capital stacking.

Required capital: Any amount. Loan returns approximately 98% of Predict+ value in USDB (2% origination fee). No price-based liquidation risk — Predict+ price can only go up (Stable+ mechanics).

SDK methods:

// Step 1: Buy Predict+ token
await client.trading.buy(predictPlusTokenAddress, USDB, inputAmount, minOut);

// Step 2: Take loan on Predict+ token (collateral locked, USDB returned)
await client.loans.takeLoan(predictPlusTokenAddress, loanAmount);

// Step 3: Buy outcome shares with borrowed USDB
await client.predictionMarkets.buy(marketToken, outcomeId, USDB, borrowedUsdb, 0n, minShares);

// Step 4 (on resolution): redeem → repay loan → unlock collateral
await client.predictionMarkets.redeem(marketToken);
await client.loans.repayLoan(loanId, repayAmount);

Risk: Loan expiry — if loan is not repaid or extended before expiry, collateral is automatically burned to cover the debt. No price liquidation. Track expiry dates actively. See Loan Risk section below.

Role 7: Capital Recycler

What it does: Stake STASIS (earning vault yield), wrap to wSTASIS, borrow against it, deploy borrowed USDB into prediction market bets. Capital earns yield, generates loan capacity, AND is deployed into active positions simultaneously — instead of sitting locked in one binary position doing one thing. See Module 12 for the general framework.

Revenue model: Three simultaneous streams — vault yield on locked wSTASIS, Predict+ appreciation if deployed into tokens, outcome share payout if deployed into bets. Capital is never idle between cycles: winnings restake, generate new loan capacity, redeploy.

Required capital: Any amount. Wrapping STASIS to wSTASIS before taking a loan is strongly preferred — wSTASIS earns vault yield on locked collateral at no extra cost.

SDK methods:

// Buy STASIS
await client.trading.buy(stasisTokenAddress, USDB, inputAmount, minOut);

// Wrap to wSTASIS (earns vault yield while locked)
await client.staking.wrap(stasisTokenAddress, amount);

// Take loan on wSTASIS
await client.loans.takeLoan(wStasisTokenAddress, loanAmount);

// Deploy borrowed USDB into prediction market bet
await client.predictionMarkets.buy(marketToken, outcomeId, USDB, borrowedUsdb, 0n, minShares);

Risk: Same loan expiry risk as Role 6. Wrapping to wSTASIS before taking the loan is the preferred path — same collateral capacity, same loan terms, but the locked collateral earns vault yield for free. See Module 06 for wSTASIS mechanics.

2. Combined Routes

Each role works standalone. The real alpha is combining them — stacking independent income streams from a single market position.

The Creator-Bettor

Create a market on a topic you have strong conviction on. Bet on the outcome you believe in.

• If right: creator fees (ongoing from all trading) + proportional share of the merged pot.
• If wrong: creator fees still accumulated from both sides the whole time.

Creator fee floors the downside. You can only lose money if your bet loss exceeds your accumulated creator fees. For high-volume markets, this is a significant safety net.

// Create the market
const market = await client.predictionMarkets.createMarketWithMetadata({ ...options });

// Bet on the outcome you believe in
await client.predictionMarkets.buy(market.marketTokenAddress, 0, USDB, betAmount, 0n, minShares);

The Creator-Token Holder

Create the market, buy the Predict+ token, do not bet on any outcome. Zero outcome risk.

• Revenue: Creator fees (from all trading activity) + Predict+ token appreciation (from volume driving Stable+ price up).
• Exit: After resolution, sell wave hits — Stable+ mechanics mean selling burns tokens and price continues rising for remaining holders. Patient exit at peak.

const market = await client.predictionMarkets.createMarketWithMetadata({ ...options });
await client.trading.buy(market.marketTokenAddress, USDB, tokenAmount, minOut);

The Full Stack Creator

Create the market + buy Predict+ tokens + bet on an outcome + resolve it yourself when it ends. Maximum extraction: four independent income streams from one market.

1. Creator fees — 20% of net trading fees, ongoing
2. Predict+ appreciation — volume-driven Stable+ price increase
3. Outcome winnings — proportional share of the merged pot if correct
4. Resolver bounty — 100% of the bounty pool if uncontested

// 1. Create
const market = await client.predictionMarkets.createMarketWithMetadata({ ...options });

// 2. Buy Predict+ tokens
await client.trading.buy(market.marketTokenAddress, USDB, tokenAmount, minOut);

// 3. Bet on an outcome
await client.predictionMarkets.buy(market.marketTokenAddress, outcomeId, USDB, betAmount, 0n, minShares);

// 4. After end time: propose, finalize, claim
await client.resolver.proposeOutcome(market.marketTokenAddress, winningOutcomeId);
await client.resolver.finalizeUncontested(market.marketTokenAddress);
await client.resolver.claimBounty(market.marketTokenAddress);

// 5. Redeem outcome shares
await client.predictionMarkets.redeem(market.marketTokenAddress);

The Leveraged Conviction Play

Buy Predict+ tokens → take loan → use borrowed USDB to buy outcome shares. Two independent income streams from one capital outlay.

// 1. Buy Predict+ tokens
await client.trading.buy(predictPlusAddress, USDB, inputAmount, minOut);

// 2. Take loan on them
await client.loans.takeLoan(predictPlusAddress, loanAmount);

// 3. Bet outcome shares with borrowed USDB
await client.predictionMarkets.buy(marketToken, outcomeId, USDB, loanAmount, 0n, minShares);

// 4. Win → redeem → repay → retain tokens
await client.predictionMarkets.redeem(marketToken);
await client.loans.repayLoan(loanId, repayAmount);
// Still own the Predict+ tokens — sell or hold

The Hedged Creator

Create the market + buy Predict+ tokens + bet on the LEAST likely outcome (cheapest shares).

• If favourite wins: Creator fees and token appreciation more than cover the small bet loss.
• If underdog wins: Massive payout from the merged pot (your small winning share pool claims the entire pot) while still collecting creator fees and token gains.

Asymmetric risk structure with built-in safety net. The underdog bet is cheap precisely because it is unlikely — but if it wins, it claims a disproportionately large share of the one big pot.

The Capital Recycler Loop

Stake STASIS → earn vault yield → borrow against wSTASIS → deploy into prediction market bets → collect winnings → restake → borrow more → redeploy. This is the canonical capital stacking loop adapted for predictions.

Capital is never idle — earning yield, generating loan capacity, and deployed in active bets simultaneously. Each cycle:

1. Winnings come in as USDB
2. Restake into wSTASIS (earning yield on the new position)
3. Borrow against new wSTASIS
4. Deploy into next market

No equivalent on traditional platforms: nothing to stake, nothing to borrow against, winnings just sit in a wallet.

The Market Maker Spread

Buy shares across multiple outcomes early when they are cheap. As sentiment shifts and certain outcomes gain traction, sell appreciated shares on the order book to latecomers. Keep the cheapest shares in the outcome you actually believe in.

De-risk mechanism: Taking profit on momentum trades partially funds your core conviction position via other participants' FOMO. You exit uncertainty positions and concentrate into conviction positions, using the spread to lower your net cost basis.

// Buy shares across multiple outcomes early
for (const outcomeId of [0, 1, 2]) {
  await client.predictionMarkets.buy(marketToken, outcomeId, USDB, allocationPerOutcome, 0n, minShares[outcomeId]);
}

// As sentiment shifts: list appreciated outcomes on order book
await client.orderBook.listOrder(marketToken, 0, sharesToSell, pricePerShare); // sell the shifted outcome
// Hold shares in the outcome you believe in

The Outsider

Do not bet. Buy the Predict+ token on high-profile markets. Zero outcome exposure.

You are betting on controversy and volume, not outcomes. The more people argue, trade, and switch sides, the more the token appreciates. Sell after resolution when the post-resolution wave peaks.

await client.trading.buy(predictPlusAddress, USDB, inputAmount, minOut);
// Hold through resolution, then sell at peak
await client.trading.sell(predictPlusAddress, amount);

3. The Strategy Stacking Reference

What this covers: Formal rules for constructing multi-position capital stacks on prediction markets. Composable, machine-readable modules suitable for AI agents generating valid strategy trees. For the full cross-pillar framework see Module 12.

Core concept: Start with USDB. Deploy into a module. Some modules return USDB via a loan, which feeds the next module. Chain until every branch hits a terminal. Result: a multi-layered position stack from one capital input.

3.1 The 9 Actions

Corresponding SDK calls: (full signatures in Module 18)

3.2 Terminals

These actions end a branch. Nothing can follow a terminal.

• Hold — retain the position (Predict+ token, STASIS, wSTASIS, or outcome shares), wait for resolution or yield
• Bet on outcome — USDB or Predict+ token is consumed as shares; no capital remains to extract
• Leverage buy — all capital is consumed in the recursive buy → loan → buy loop (~20x; bounded by 2% origination fee per loop). Nothing remains to chain. See Module 04 for the full mechanism.

Rule: Leverage MUST be the final action in its branch. No exceptions.

3.3 Modules

A module is a self-contained sequence starting with capital (USDB or Predict+ token) that either ends at a terminal or returns USDB via a loan.

Module A: Predict+ (Quick Stack entry)

Option 3 is the Quick Stack — the minimum viable capital stack on BASIS. Two positions from one bag: Predict+ appreciating from volume, plus whatever the borrowed USDB funds.

Betting with Predict+ directly (Option 2): The token itself is consumed as the bet input. Use when you have high conviction on a specific outcome and want maximum share allocation rather than retaining the token for appreciation or collateral.

Module B: STASIS

Agent preference: Default to Option 3b over Option 2. Wrapping earns vault yield on the locked collateral at no additional cost. Only skip wrapping for time sensitivity or gas optimization.

Module C: Bet (always terminal)

No capital output — shares are the terminal position. Payout only occurs if outcome wins, on resolution.

Module D: Leverage (always terminal)

client.trading.leverageBuy() recursively loops: buy → loan → buy → loan until the 2% origination fee per loop fully consumes the balance. A $10 input produces approximately a $200 position (~20x). Daily interest rate of 0.005% per loan applies across the position lifetime.

3.4 Chaining Rules

1. Any module outputting USDB can feed any other module — including the same module type in a different market (e.g., two Module A entries across different prediction markets).

2. Every chain must end at a terminal — hold, bet, or leverage.

3. Leverage is always last — if used, nothing follows.

4. Splitting is allowed — at any USDB output point, divide capital across multiple parallel branches. Each branch is independent.

5. Multi-market exposure — repeat Module A across different prediction markets, or different outcomes within the same market.

6. Loan capital decays with depth — each loan costs 2% origination. Calculate cumulative fee cost before constructing deep chains:

   • 1-loan chain: ~98% of input
   • 3-loan chain: ~94% of input
   • 5-loan chain: ~90% of input

7. Cross-pillar exit — any module ending with USDB output can exit prediction markets entirely and deploy into other BASIS token types (e.g., buy a Floor+ token). Valid terminal branch for diversification — see Module 12.

3.5 Structure Types

Serial Chain (One-Bag Deep Stack)

Modules connected end-to-end. USDB flows sequentially from one module to the next.

Parallel Split

At any USDB output point, divide capital across independent branches.

Full Tree

Combination of serial chains and parallel splits.

3.6 Example Plays

Example 1: The One-Bag Deep Stack

End state: Three simultaneous layers from one starting capital:

• Layer 1: wSTASIS earning vault yield (locked as collateral)
• Layer 2: Predict+ in Market A appreciating from volume (locked as collateral)
• Layer 3: Outcome shares in Market B with uncapped payout potential

If bet wins: Collect outcome winnings → repay Predict+ loan → sell or hold Predict+ tokens → repay wSTASIS loan → unlock wSTASIS. Three profit streams unwind from a single initial outlay.

If bet loses: wSTASIS and Predict+ kept working regardless. Only the outcome bet capital is at risk.

// Full SDK sequence
await client.trading.buy(stasisAddress, USDB, inputAmount, minOut);
await client.staking.wrap(stasisAddress, stasisAmount);
await client.loans.takeLoan(wStasisAddress, wStasisLoanAmount);
await client.trading.buy(predictPlusAddressA, USDB, loanProceeds, minOut);
await client.loans.takeLoan(predictPlusAddressA, predictPlusLoanAmount);
await client.predictionMarkets.buy(marketTokenB, outcomeId, USDB, borrowedUsdb, 0n, minShares);

Unwind (manual, preferred):

await client.predictionMarkets.redeem(marketTokenB);           // 1. Collect winnings
await client.loans.repayLoan(predictPlusLoanId, repayAmt);   // 2. Repay Predict+ loan
// 3. Sell or hold Predict+ tokens
await client.loans.repayLoan(wStasisLoanId, repayAmt);       // 4. Repay wSTASIS loan
await client.staking.unwrap(wStasisAddress, wStasisAmount);    // 5. Unwrap if desired

Example 2: Chain Ending in Leverage

End state: wSTASIS staking position (yield), Predict+ in Market A (collateral, volume appreciation), ~20x leveraged Predict+ in Market B.

Example 3: Split Play

End state: Predict+ in Market A (collateral), wSTASIS earning yield, ~20x leveraged Predict+ in Market C.

Example 4: Multi-Market Exposure

End state: Exposure to three different prediction markets from one starting capital. Two loans applied → Market C bet is funded with ~96% of original capital.

await client.trading.buy(predictPlusA, USDB, inputAmount, minOut);
await client.loans.takeLoan(predictPlusA, loanAmountA);
await client.trading.buy(predictPlusB, USDB, loanAmountA, minOut);
await client.loans.takeLoan(predictPlusB, loanAmountB);
await client.predictionMarkets.buy(marketTokenC, outcomeId, USDB, loanAmountB, 0n, minShares);

Example 5: Betting with a Predict+ Token

End state: Shares in Market A outcome. The Predict+ token was used directly as the bet input — bypasses USDB conversion. Optimal when you have high conviction and want maximum share allocation rather than retaining the token for appreciation or collateral use.

3.7 Loan Risk and Expiry Management

BASIS has no price-based liquidation on Stable+ collateral (Predict+, STASIS, wSTASIS). The price of Stable+ tokens cannot decrease, so there is nothing to liquidate against. Risks in stacked strategies are:

Loan expiry — every loan has a time-based expiration. If not repaid or extended before expiry, the position auto-closes: collateral is burned (Stable+) to cover the debt, and the remainder is claimable. In a serial chain, one expired loan loses that collateral layer — downstream positions funded by that loan's USDB are unaffected, but the collateral layer is gone.

Origination fees (2% per loan) — the primary capital decay in deep chains. Calculate whether the additional exposure from a deeper chain justifies the cumulative fee cost.

Daily interest (0.005% per loan) — small per loan, meaningful across a deep serial chain with 3–4 active loans. Calculate aggregate daily cost across the full tree before deploying.

Stake lock interaction — if you stake to vote on a dispute (Role 5 / Resolver), staked tokens are locked for 24 hours. Check all loan expiry dates before voting — you cannot unstake to repay a loan during the lock window.

Agent rule: Track expiry dates across all active loans in the strategy tree. Set extension or repayment triggers. A loan expiring mid-chain does not cascade to other loans — each loan is independent — but it does mean the collateral layer is lost.

3.8 Agent Instructions

To generate a valid strategy tree:

1. Start with a USDB amount.
2. Pick a module (A, B, C, or D).
3. If the module outputs USDB, optionally split and pick the next module(s) for each branch.
4. Repeat until every branch hits a terminal.
5. Validate: leverage is only at end of its branch; prerequisites are met for every action; no action follows a terminal.
6. Track all loan expiry dates across the tree. Set extension or repayment triggers before deployment.
7. Calculate total origination fees (2% per loan) and total daily interest (0.005% per loan) across the full tree.

Decision factors:

4. Advanced Plays

Spread Capture

Buy outcome shares across all outcomes early when prices are low (high uncertainty, cheap shares across the board). As the market matures and sentiment concentrates into one or two outcomes:

• Sell appreciated shares in the higher-probability outcomes on the order book
• Keep (or add to) positions in the outcome you believe will win
• The sales from appreciated shares partially fund your conviction position, lowering net cost basis

The uncapped resolution value means the buyer of your high-probability shares is not getting a compressed trade — they are buying at a discount to potential resolution payout. Both sides can win.

// Buy across all outcomes at market open
const outcomes = await client.marketReader.getAllOutcomes(routerAddress, marketToken);
for (const outcome of outcomes) {
  const allocation = totalCapital / BigInt(outcomes.length);
  await client.predictionMarkets.buy(marketToken, outcome.id, USDB, allocation, 0n, minSharesForOutcome);
}

// Monitor and list appreciated outcomes as probability concentrates
const updated = await client.marketReader.getAllOutcomes(routerAddress, marketToken);
const highProb = updated.filter(o => Number(o.probability) / 1e18 > 0.6);
for (const outcome of highProb) {
  const shares = await client.predictionMarkets.getUserShares(marketToken, walletAddress, outcome.id);
  await client.orderBook.listOrder(marketToken, outcome.id, shares / 2n, listingPrice);
}

Volume Arbitrage

Target high-traffic controversial markets for Predict+ token exposure specifically. The Stable+ price curve means the token appreciates monotonically with every trade — you are not picking an outcome, you are picking markets with structurally high expected volume.

Signals of high-volume markets:

• Binary outcome on a highly contested public question
• Short duration with fast-moving news cycle
• Large seedAmount (creator has high conviction the market will attract activity)
• Active order book depth before market end

Entry: Buy Predict+ early, before volume accumulates. Exit: After resolution, during the post-resolution sell wave peak.

// Find active markets and filter by volume signals
const markets = await client.api.getTokens({ isPrediction: true, limit: 100 });
const highSignal = markets.data.filter(m =>
  m.predictionStatus === "active" &&
  Number(m.volume24h) > threshold
);

// Buy Predict+ on the highest-signal market
await client.trading.buy(highSignal[0].address, USDB, allocationAmount, minOut);

// Check current price and volume trajectory before sizing
const tokenData = await client.api.getToken(highSignal[0].address);

Cross-Market Hedging

Take opposite positions in correlated but distinct markets to create a structurally hedged exposure.

Example: Market A asks "Will ETH hit $10k by Q2?" and Market B asks "Will ETH stay below $8k by Q2?" A bullish position on Market A can be partially hedged by a small position on Market B's "Yes" outcome. If ETH crashes, Market B pays out. If ETH surges, Market A pays out. You sacrifice part of the upside in exchange for defined floor protection.

Note: Because BASIS uses proportional pot payouts, this is not a perfect hedge (the pot sizes and participant distributions differ per market). Treat it as directional risk reduction, not guaranteed 1:1 offset.

// Primary conviction position
await client.predictionMarkets.buy(marketTokenA, 0, USDB, primaryAllocation, 0n, minSharesA);

// Partial hedge in correlated market, opposite direction
await client.predictionMarkets.buy(marketTokenB, 1, USDB, hedgeAllocation, 0n, minSharesB);

// Track both separately — different redemption calls, different resolution times
const marketAData = await client.predictionMarkets.getMarketData(marketTokenA);
const marketBData = await client.predictionMarkets.getMarketData(marketTokenB);

Monitoring:

// Check probability drift in both markets
const outcomesA = await client.marketReader.getAllOutcomes(routerAddress, marketTokenA);
const outcomesB = await client.marketReader.getAllOutcomes(routerAddress, marketTokenB);
const impliedProbA = Number(outcomesA[0].probability) / 1e18 * 100;
const impliedProbB = Number(outcomesB[1].probability) / 1e18 * 100;

If probabilities shift such that the hedge is no longer necessary (e.g., primary conviction is confirmed by overwhelming market consensus), list the hedge position on the order book at a profit rather than waiting for resolution.

Key Facts (Quick Reference)

Cross-references:

• Basic buying, payout mechanics, fee distribution → Module 08 Predictions
• Full resolution mechanics, dispute strategies, bounty hunting, veto plays → Module 14 Resolution
• Complete SDK method signatures and error reference → Module 18 SDK Reference
• Token type mechanics for Predict+ (Stable+) → Module 11 Token Mechanics
• Loan mechanics and interest calculation → Module 05 Lending
• Vault yield on wSTASIS → Module 06 Staking
• Full cross-pillar capital stacking framework → Module 12 Strategy & Stacking

See Also

• Module 08 — Predictions: Prediction market fundamentals — buying shares, payout structure, fees
• Module 14 — Resolution Deep Dive: Complete dispute, voting, veto, and bounty-hunting lifecycle
• Module 12 — Strategy & Stacking: Cross-pillar capital stacking (trading, lending, staking, predictions)
• Module 11 — Token Mechanics: Stable+ / Floor+ mechanics underlying Predict+ tokens
• Module 05 — Lending: Loans, LTV, origination fees, loan extensions
• Module 04 — Trading: Buy, sell, leverage mechanics for Predict+ and STASIS
• Module 18 — SDK Reference: Full method signatures and error reverse index