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: staking in the vault, vault loans
• Client initialized (→02)

Next steps

• Executing resolution strategies (Role 5, bonds, 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

Examples use the default main, STASIS, whose pair asset is USDG (6 decimals). On another main read 'USDG' as that main's pair asset and use its decimals(). The mains of a deployment are listed in /contracts.json (mains[]).

1. Participant Roles

Traditional prediction platforms give every participant one role: bettor. BASIS opens several 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 a share of the pot on resolution.

Revenue model: A market resolves to a ranking of outcomes. A holder of a ranked outcome gets its cost back plus that rank's share of the profit (the losers' money and the seed), pro rata to shares, by the market's payout ladder (getTrancheBP(market)). On a winner-take-all market ([10000]) this is (your winning shares / total winning shares) × the pot. No $1 cap. The pot is in market tokens; redeem sells your entitlement for the pair asset. 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)

The snippets of this module use three values defined once here: host (the contract the market lives on), inputToken (the market's pair asset) and the quote.

// The market's host and pair asset (define once)
const addresses = await fetch(`${apiDomain}/contracts.json`).then(r => r.json());
const host = isPrivateHost ? addresses.privateMarket : addresses.marketTrading;
const { usdc: inputToken } = await client.predictionMarkets.getMarketData(marketToken); // the market's pair asset

// Quote first: TrancheReader.quoteShares(host, market, outcomeId, inputToken, amount, buyer) → (sharesOut, netToken)
const [sharesOut, netToken] = await client.marketReader.quoteShares(host, marketToken, outcomeId, inputToken, inputAmount, wallet);
const minShares = sharesOut * 98n / 100n; // 2% tolerance
const minTokens = netToken * 98n / 100n;  // floor on the market tokens the input converts to

// Buy: buy(marketToken, outcomeId, inputToken, inputAmount, minTokens, minShares)
await client.predictionMarkets.buy(marketToken, outcomeId, inputToken, inputAmount, minTokens, minShares);

// Redeem after resolution: redeem(market, fractionBps, slices, minOut): all of it, in one slice
await client.predictionMarkets.redeem(marketToken, 10000n, 1n, minOut);

Never estimate shares as amount × 1e18 / pricePerShare: that ignores the conversion, the fee and the bet's own price impact. The fifth argument of buy is a floor in market tokens, not in the pair asset. Neither floor may be 0.

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. pricePerShare is odds × 1e18: 0 for the market price, else 0.001 to 0.999
await client.orderBook.listOrder(marketToken, outcomeId, shareAmount, pricePerShare);

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

// Fill someone else's order: buyOrder(marketToken, orderId, fill, maxCost); fill is a number of shares
const { totalCostToBuyer } = await client.orderBook.getBuyOrderCost(marketToken, orderId, shares); // read as the buyer
await client.orderBook.buyOrder(marketToken, orderId, shares, totalCostToBuyer * 101n / 100n);

// Read open orders before listing: check depth and spread
const openOrders = await client.api.getOrders(marketToken); // on chain: marketOrders(market, id) for id < nextOrderId(market)

A listing fills only while its price is at or below the current AMM odds, so list at or below them.

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, in the units of its main's pair asset, as trading volume flows through the market. Buys increase price; slippage stays in the pool, so sells push the price higher for remaining holders. A sale still receives less than the quoted price, more so on a large sale. Patient sellers exit at the post-resolution peak. It can gain whichever outcome wins, before fees and slippage.

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); the fee is getTaxRate(marketToken, wallet)
await client.trading.buy(predictPlusTokenAddress, inputAmount, minTokensOut);

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

// 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, set a creator fee on its market token and earn it on every bet and token trade for the life of the token: from both sides, regardless of outcome.

Revenue model: The creator fee you set on the market token (0 to 1% on top of the base fee; it is 0 until you call TAXES.setCreatorFee(marketToken, bps), and it can change once per 4 hours), plus 20% of the base part of loan-side fees on the market token and of unwon prize money. An annuity, not a launch fee. No bet required beyond the seed, which is at risk like any bet. 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: The seed, set per main. The floor is minSeed() × unit on the public host and minSeedPublic() / minSeedPrivate() × unit on the private host (public or private event), in steps of seedStep; read unit and seedStep with TrancheReader.sizesFor(host, main, n). For example, where one unit is 1 USDG: 50 USDG public, 10 or 0 USDG private. The seed buys the creator equal shares on every outcome, tax-free: it is a bet at risk that pays back by rank like any other bet, not liquidity for the outcome pools (no liquidity deposit is needed).

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: seedFloor,                     // minSeed() × sizesFor(host, main, n).unit, in steps of seedStep
  trancheBP: [10000],                        // winner takes all; [7000, 2000, 1000] pays the top three
  description: "ETH price prediction.",
  imageUrl: "https://example.com/eth.jpg",
  // + the approval fields (deadline, approvalSignature): Module 08
});

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

On chain this is createMarket(CreateParams, deadline, approvalSignature), payable: msg.value is the factory's creation fee (feeAmount(); 0 when the host is fee-whitelisted). 2 to MAX_OUTCOMES() outcomes (150 by default; read it). endTime is 0 (open-ended) or at least one minute ahead. The end time is part of the moderator approval: an approval is only valid for the exact end time it was signed for, and the platform's market-approval step refuses end times too far out. privateEvent restricts who may buy; every market on the private host is resolved by its creator's voter panel.

Risk: The seed buys shares on every outcome for you; it pays back by rank like any other bet. 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: Proposer

What it does: After the end time, propose the result with proposeRanked(marketToken, [outcomeId], 0), wait for the challenge period, finalize if nobody disputes. The creator may propose at the end time, everyone else 15 minutes later. Full lifecycle in Module 14.

Revenue model: Resolving pays no reward. Uncontested, you get your bond back. If you are disputed and your ranking wins, you get your own bond back plus the disputer's bond up to twice your own bond; anything above that goes to insurance. Voting is for the appointed panel only. The reason to propose is to get a market you hold winning shares in resolved.

Required capital: requiredBond(marketToken, you) in the resolver's BOND_TOKEN() (approve it to the resolver): 5 units, doubled after each EARLY reset, at most 8 doublings (1,280 units), never above BOND_MAX() (8,000 units). A dispute costs the proposer's bond, capped at BOND_CAP() (500 units). Read the values from the resolver.

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");

// non-creators can propose 15 minutes after endTime
// Propose: sends proposeRanked(marketToken, [outcomeId], 0) with the bond approved
await client.resolver.propose(marketToken, outcomeId);

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

Risk: Bond loss if your proposal is disputed and the other ranking wins. See Module 14 for the full dispute mechanics, the panel vote 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 pair asset 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. A 10-day loan pays out the collateral value less 2.05% (today's defaults; read staticFeePercentage() and dynamicFeePercentage() on the main), in the pair asset. No price-based liquidation risk: Predict+ price can only go up in pair-asset units (Stable+ mechanics).

SDK methods:

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

// Step 2: Hub loan on it: takeLoan(main, collateral, collateralAmount, days)
// main = the token's main (token.quoteToken()); collateralAmount is in tokens
await client.loans.takeLoan(main, predictPlusTokenAddress, collateralAmount, 10n);

// Step 3: Buy outcome shares with the borrowed pair asset
await client.predictionMarkets.buy(marketToken, outcomeId, inputToken, borrowed, minTokens, minShares);

// Step 4 (on resolution): redeem → repay loan → collateral returns
await client.predictionMarkets.redeem(marketToken, 10000n, 1n, minOut);
await client.loans.repayLoan(hubId, maxUint256); // 2^256 - 1 repays the whole fullAmount; approve the pair asset to the loan hub

Risk: Loan expiry. After liquidationTime a keeper liquidates the position. Assume it can happen in the first block after the deadline. Until that transaction lands a repay or a paid extension still goes through; do not plan on the gap. After expiry a keeper closes the loan: the collateral that covers the debt is taken to repay it, 10% of the rest is the liquidation fee, and you claim the remainder with client.loans.claimLiquidation(hubId). Claim within 365 days of the liquidation; after that the leftover may no longer be claimable. No price liquidation. Track expiry dates actively. See Loan Risk section below.

Role 7: Capital Recycler

What it does: Buy the main, stake it in that main's vault (or buy with wrapTokens = true to buy and stake at once), borrow from the vault, deploy the borrowed pair asset 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 rewards on the whole stake (the pledged part included), 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 (at least minStake(), 1 STASIS today). Staking STASIS and borrowing from the vault is strongly preferred over a hub loan on unstaked STASIS: the pledged stake keeps earning vault rewards at no extra cost.

SDK methods:

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

// Stake in the main's vault: stake(amount)
await client.vault().stake(stasisAmount);

// Borrow from the vault: borrow(stasisAmount, days) pays out the pair asset; more than 10 days if you will top it up
await client.vault().borrow(stasisToPledge, 30n);

// Deploy the borrowed pair asset into a prediction market bet
await client.predictionMarkets.buy(marketToken, outcomeId, inputToken, borrowed, minTokens, minShares);

Risk: Same loan expiry risk as Role 6. A liquidated vault loan settles inside the liquidation and takes the loss off the stake. A hub loan on unstaked STASIS (takeLoan(main, main, amount, days)) is also valid, but it earns no vault rewards. See Module 06 for the vault.

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, once you have set a creator fee; it starts at 0) + your share of the pot by rank.
• If wrong: creator fees still accumulated from both sides the whole time.

Once you have set a creator fee (it is 0 until you call setCreatorFee), it floors the downside. Creator fees can offset part of a losing bet. For high-volume markets, this is a significant safety net.

// Create the market (options include the approval fields of Role 4)
const market = await client.predictionMarkets.createMarketWithMetadata({ ...options });

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

The Creator-Token Holder

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

• Revenue: Creator fees (from all trading activity, once set) + Predict+ token appreciation (from volume driving Stable+ price up).
• Exit: After resolution, sell wave hits: on Stable+ slippage stays in the pool, so price keeps rising (in pair-asset units) for remaining holders, though each sale receives less than the quoted price. Patient exit at peak.

const market = await client.predictionMarkets.createMarketWithMetadata({ ...options }); // options include the approval fields of Role 4
await client.trading.buy(market.marketTokenAddress, tokenAmount, minOut);

The Full Stack Creator

Create the market + buy Predict+ tokens + bet on an outcome + propose the result yourself when it ends. Three income streams from one market.

1. Creator fees: the creator fee you set on the market token, ongoing for the life of the token
2. Predict+ appreciation: volume-driven Stable+ price increase
3. Outcome winnings: your share of the pot by rank if correct

// 1. Create (options include the approval fields of Role 4)
const market = await client.predictionMarkets.createMarketWithMetadata({ ...options });

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

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

// 4. After end time: propose (as the creator you may propose at the end time), then finalize
await client.resolver.propose(market.marketTokenAddress, winningOutcomeId);
await client.resolver.finalizeUncontested(market.marketTokenAddress); // proposing returns your bond; nothing else is paid

// 5. Redeem outcome shares
await client.predictionMarkets.redeem(market.marketTokenAddress, 10000n, 1n, minOut);

The Leveraged Conviction Play

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

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

// 2. Take loan on them: takeLoan(main, collateral, collateralAmount, days)
await client.loans.takeLoan(main, predictPlusAddress, collateralAmount, 10n);

// 3. Bet outcome shares with the borrowed pair asset
await client.predictionMarkets.buy(marketToken, outcomeId, inputToken, borrowed, minTokens, minShares);

// 4. Win → redeem → repay → retain tokens
await client.predictionMarkets.redeem(marketToken, 10000n, 1n, minOut);
await client.loans.repayLoan(hubId, maxUint256); // 2^256 - 1 repays fullAmount; approve the pair asset to the loan hub
// 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 (once you have set a creator fee; it starts at 0) and token appreciation can cover the small bet loss.
• If underdog wins: On a winner-take-all market, a large payout: a small winning pool takes everything the losers paid, while you still collect 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 on a winner-take-all market, it claims a disproportionately large share of the pot.

The Capital Recycler Loop

Stake STASIS → earn vault rewards → borrow from the vault → deploy into prediction market bets → collect winnings → stake again → 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 the pair asset
2. Buy and stake again (the larger stake earns vault rewards)
3. Top the vault loan up with addToLoan (one loan per wallet; it needs more than 10 days left)
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 (at or below the AMM price: a listing above it does not fill). 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, inputToken, allocationPerOutcome, minTokens[outcomeId], minShares[outcomeId]);
}

// As sentiment shifts: list appreciated outcomes on order book
// pricePerShare: odds × 1e18, 0.001 to 0.999; a listing above the AMM odds does not fill
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, inputAmount, minOut);
// Hold through resolution, then sell at peak
await client.trading.sell(predictPlusAddress, amount, minOut);

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 USDG (the pair asset). Deploy into a module. Some modules return USDG 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, staked STASIS, or outcome shares), wait for resolution or yield
• Bet on outcome: USDG 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 (up to about 37x: read simulateLeverageLocked / simulateLeverageFactoryLocked; an open must exceed 2x). 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 (USDG or Predict+ token) that either ends at a terminal or returns USDG 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 USDG 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. Staking earns vault rewards on the pledged stake at no additional cost. Only skip it 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() loops buy → loan → buy until the borrow is too small to continue. Each loop pays the trade fee, then 2% plus 0.005% a day, prepaid for the chosen term. Leverage reaches up to about 37x: read simulateLeverageLocked(amount, path, days, 100).totalColleteral, or simulateLeverageFactoryLocked for a factory token, where each loop borrows at the floor. An open must exceed 2x (Under 2x), and closing pays 3% of the proceeds above the initial buy.

3.4 Chaining Rules

1. Any module outputting USDG 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 USDG 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 layer keeps about 97.4% (0.60% on the buy, 2.05% on a 10-day loan), before any creator fee and price impact. Calculate cumulative fee cost before constructing deep chains:

   • 1-loan chain: ~97% of input
   • 3-loan chain: ~92% of input
   • 5-loan chain: ~87% of input

7. Cross-pillar exit: any module ending with USDG 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. USDG flows sequentially from one module to the next.

Parallel Split

At any USDG 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: staked STASIS earning vault rewards (part of it pledged)
• 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 the vault loan. Three profit streams unwind from a single initial outlay.

If bet loses: The stake and the Predict+ tokens kept working regardless, but both loans still have to be repaid from other capital.

// Full SDK sequence
await client.trading.buy(stasisAddress, inputAmount, minOut);
await client.vault().stake(stasisAmount);
await client.vault().borrow(stasisToPledge, 30n);
await client.trading.buy(predictPlusAddressA, loanProceeds, minOut);
await client.loans.takeLoan(main, predictPlusAddressA, predictPlusAmount, 10n);
await client.predictionMarkets.buy(marketTokenB, outcomeId, inputToken, borrowed, minTokens, minShares);

Unwind (manual, preferred):

await client.predictionMarkets.redeem(marketTokenB, 10000n, 1n, minOut); // 1. Collect winnings
await client.loans.repayLoan(predictPlusHubId, maxUint256);              // 2. Repay Predict+ loan (2^256 - 1 = all)
// 3. Sell or hold Predict+ tokens
await client.vault().repay();                                            // 4. Repay the vault loan
await client.vault().unstake(amount, false, 0n);                         // 5. Unstake if desired

Example 2: Chain Ending in Leverage

End state: vault stake (rewards), Predict+ in Market A (collateral, volume appreciation), leveraged Predict+ in Market B.

Example 3: Split Play

End state: Predict+ in Market A (collateral), vault stake (rewards), 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 about 94.8% of the original capital, before creator fees and price impact.

await client.trading.buy(predictPlusA, inputAmount, minOut);
await client.loans.takeLoan(main, predictPlusA, collateralAmountA, 10n);
await client.trading.buy(predictPlusB, borrowedA, minOut);
await client.loans.takeLoan(main, predictPlusB, collateralAmountB, 10n);
await client.predictionMarkets.buy(marketTokenC, outcomeId, inputToken, borrowedB, minTokens, 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 USDG 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, staked STASIS). The price of Stable+ tokens cannot decrease in pair-asset units, so there is nothing to liquidate against. Risks in stacked strategies are:

Loan expiry: every loan has a time-based expiration. After liquidationTime a keeper liquidates the position. Assume it can happen in the first block after the deadline. Until that transaction lands a repay or a paid extension still goes through; do not plan on the gap. After expiry a keeper closes the loan: the collateral that covers the debt is taken to repay it, 10% of the rest is the liquidation fee, and the owner claims the remainder (a hub loan with claimLiquidation(hubId), within 365 days of the liquidation; a vault loan settles inside the liquidation and takes the loss off the stake). In a serial chain, one expired loan loses that collateral layer: downstream positions funded by that loan's USDG are unaffected, but the collateral layer is gone.

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

Day fee (0.005% per day, default): prepaid for the whole term when the loan opens; nothing accrues afterwards. Small per loan, meaningful across a deep serial chain with 3–4 active loans.

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 USDG amount.
2. Pick a module (A, B, C, or D).
3. If the module outputs USDG, 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, default) and the prepaid day fee (0.005% per day of each loan's term) 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(host, marketToken);
for (const outcome of outcomes) {
  const allocation = totalCapital / BigInt(outcomes.length);
  const [sharesOut, netToken] = await client.marketReader.quoteShares(host, marketToken, outcome.outcomeId, inputToken, allocation, walletAddress);
  await client.predictionMarkets.buy(marketToken, outcome.outcomeId, inputToken, allocation, netToken * 98n / 100n, sharesOut * 98n / 100n);
}

// Monitor and list appreciated outcomes as probability concentrates
const updated = await client.marketReader.getAllOutcomes(host, marketToken);
const highProb = updated.filter(o => Number(o.probability) / 10000 > 0.6); // probability is in basis points
for (const outcome of highProb) {
  const shares = await client.predictionMarkets.getUserShares(marketToken, walletAddress, outcome.outcomeId);
  // listingPrice: odds × 1e18, 0.001 to 0.999, at or below the current AMM price (pricePerShare)
  await client.orderBook.listOrder(marketToken, outcome.outcomeId, shares / 2n, listingPrice);
}

Volume Arbitrage

Target high-traffic controversial markets for Predict+ token exposure specifically. Stable+ mechanics mean the token appreciates monotonically with every trade, in pair-asset units: 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.volume24hUsdE18) / 1e18 > threshold
);

// Buy Predict+ on the highest-signal market
await client.trading.buy(highSignal[0].address, 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 rallies, Market A pays out. You sacrifice part of the upside in exchange for defined floor protection.

Note: Because BASIS pays each market's pot by its own payout ladder, 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 (inputTokenA / inputTokenB: each market's pair asset)
await client.predictionMarkets.buy(marketTokenA, 0, inputTokenA, primaryAllocation, minTokensA, minSharesA);

// Partial hedge in correlated market, opposite direction
await client.predictionMarkets.buy(marketTokenB, 1, inputTokenB, hedgeAllocation, minTokensB, 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(hostA, marketTokenA);
const outcomesB = await client.marketReader.getAllOutcomes(hostB, marketTokenB);
const impliedProbA = Number(outcomesA[0].probability) / 100; // basis points → percent
const impliedProbB = Number(outcomesB[1].probability) / 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, bonds, 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 rewards on staked STASIS → 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 proposal, dispute, voting and veto 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