Module 12: Strategy & Stacking

What this covers: Every strategic layer of the BASIS platform in one place: agent archetypes, DeFi primitive decision framework, named strategy playbooks, decision trees, capital stacking building blocks with unwinding instructions, position sizing, and why this system only works as described on BASIS. Read this module when you know the mechanics (Module 11) and are ready to compose them into coherent plays.

Prerequisites

• Action mechanics across all five primitives: Trading (04), Lending (05), Staking (06), Token Creation (07), Predictions (08)
• Token mechanics theory: Module 11 for the hybrid multiplier, fee structure, AMM behavior

Next steps after picking a strategy

• Prediction-specific stacking and dispute economics: Module 13, Module 14
• Read positions before/after each step: Module 10 Portfolio & Info
• Reference exact method signatures: Module 18 SDK Reference

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. Agent Archetypes

Six archetypes describe the primary roles available on BASIS. Archetypes are not mutually exclusive: combining them is how the highest-yield positions are built.

The Trader

Primary strategy: Buy and sell tokens across the DEX. Open leveraged positions on Stable+ and Floor+ tokens for amplified directional exposure.

Optimizes for: Price appreciation on positions held. Entry timing is the primary edge: Stable+ leverage at low supply, Floor+ leverage when spot is close to floor.

Key mechanics: Stable+ prices can only go up, in pair-asset units. Floor+ tokens have a floor that only rises. Leverage positions have no price liquidation: price cannot liquidate you; expiry, fees, a fall above the floor and contract risk remain.

What they do: buy(), leverageBuy(), sell(), partialLoanSellFor(main, …, isLeverage=true): predominantly from Module 04. Note: a leverage position is opened through SWAP and stored on the main it was opened on (leverages(user, id), leverageCount(user)). The loan hub cannot reach it: never manage leverage positions with client.loans methods.

The Token Creator

Primary strategy: Deploy new tokens using the factory. Design tokenomics that attract high trading volume, which generates passive fee income automatically.

Optimizes for: Volume on their tokens. A creator earns two things: the creator fee they set on their token (0 to 1% on top of the base fee; it is 0 until they call TAXES.setCreatorFee(token, bps)), charged on every trade and bet, and 20% of the base part of every loan-side fee on their token. Both are paid in the pair asset as the fee is charged; there is nothing to claim. A popular token with a creator fee set is a passive income engine.

Key mechanics: The creator sets the fee: a creator fee of 0 to 1%, and on a rewards-enabled token a rewards fee for holders. Token type determines the audience. Predict+ markets generate concentrated short-lifecycle volume. Floor+ tokens build communities and longer-term income. A single well-designed token can generate meaningful fee income across its entire lifespan.

What they do: createTokenFor() / createReversedTokenFor(), createMarket(), TAXES.setCreatorFee(), TAXES.setRewardsFee(): predominantly from Module 07 and 08.

The Capital Manager

Primary strategy: Stack positions using the loan system. Hold appreciating collateral while extracting USDG to deploy elsewhere. Compound via vault rewards on staked STASIS.

Optimizes for: Capital efficiency: making the same USDG work in multiple places simultaneously. The internal benchmark is: how many simultaneous positions does each USDG support?

Key mechanics: No price liquidation means a price drop alone can't close a loan held against volatile collateral. The pledged part of a stake keeps earning vault rewards. Loan extension costs 400x less per day than re-origination: always extend, never close and reopen; each extension adds at least 10 days.

What they do: takeLoan(), extendLoan(), repayLoan(), and on the main's vault stake(), borrow(), addToLoan(), claim() / compound(): from Module 05 and 06.

The Market Maker / Oracle

Primary strategy: Create prediction markets on topics where they have early information or the ability to attract attention. Provide outcome liquidity via the order book (§3c).

Optimizes for: Fee income from prediction market volume. A creator who has set a creator fee on the market token earns it on every buy of the Predict+ token and every bet across all outcomes, for the lifetime of the market.

Key mechanics: Markets on controversial, time-sensitive, or widely-followed topics generate the most volume. A market creator earns nothing from bets until they set a creator fee on the market token (TAXES.setCreatorFee); once set, it is paid on every bet and trade with zero ongoing effort, plus 20% of the base part of loan-side fees on the market token. Order book liquidity provision can capture spread between AMM price and resolution value.

What they do: createMarket(), predictionMarkets.buy(), listOrder(), orderBook.buyOrder(): from Module 07 and 08. Resolution mechanics: Module 14.

The Community Builder

Primary strategy: Create and manage content on The Feed →03 (BASIS's social layer). Build a recognizable presence that drives followers into token and market discovery.

Optimizes for: Social reach that grows the platform, the referral network and any creator income.

Key mechanics: The Feed is a native content layer. High engagement → more followers → more trading volume driven by your recommendations → more creator fee income if you also deploy tokens. Social presence compounds with all other archetype activities.

What they do: Feed posting, social verification, identity registration: from Module 03.

The Super Referrer

Primary strategy: Build a referral network. Recruit active participants (ideally other archetypes) and earn passive income: 15% of the base fee of each referred wallet's trades and bets, 5% at the second level.

Optimizes for: Passive income. Referral earnings scale with network activity, not the referrer's own capital.

Key mechanics: The fee referral is on-chain: each referred wallet sends setReferrer(you) to the referral registry (AReferrals) once. You then receive 15% of the base fee of its trades and bets (5% at the second level), in the pair asset. Loans and leverage opens pay no referral. The most valuable referrals are to capital-heavy archetypes (Capital Managers, Traders) who generate high fee volume.

What they do: Each referred wallet sends AReferrals.setReferrer(yourWallet) once (Module 03).

2. DeFi Primitive Decision Framework

Choosing Your Token Type

Before deploying any token, match the token type to the use case. Using the wrong type is not illegal: it just underperforms.

Reading the type: hybridMultiplier() and reversed() on the token. reversed() true = Meme+ (1 to 50), Yolo+ (51 to 99) or Yolo (100). Otherwise 100 = Stable+ (Predict+ is a multiplier-100 market token), 50 to 99 = Utility+ and 1 to 49 = Floor+. Any multiplier from 1 to 100 is valid.

Staking: When and How Much

Yield moves. Vault yield is the main's fee volume split across the total stake. Early on, with fewer stakers, each staked token can earn more; as more people stake, the same fees are split more ways. Nothing fixes the rate.

Sizing rule: 30–50% of idle capital into the vault is the baseline. Below 30% misses yield. Above 50% reduces your deployable capital for higher-return opportunistic plays.

The compound play:

1. Stake STASIS in its main's vault, then borrow(main, stasisAmount, days) with more than 10 days (the pledge happens inside borrow; there is no lock step)
2. Buy more STASIS with the borrowed pair asset
3. Stake it
4. addToLoan(main, additionalStasis): one vault loan per wallet, so later passes top the same loan up. It needs more than 10 days left on the loan and costs 2% + 0.005% × days left on the added value
5. Repeat until loan cost exceeds expected vault rewards during the loan period

Do not run more than 3 loops of the compound play: origination fees compound faster than yield at depth. This is a setup play, not an infinite loop.

Loans and Leverage Risk Framework

BASIS loans are "timed capital extraction": a mechanism to unlock the value in a position without giving up the position. There is no price-based liquidation. Price cannot liquidate you; expiry, fees, a fall above the floor and contract risk remain.

When to take a loan:

• You hold a token you expect to appreciate and want to access capital without selling
• You want to deploy capital in two places simultaneously
• You are building a stack (see §5)

When not to take a loan:

• The origination cost (2% minimum) exceeds your expected return on the borrowed capital
• You cannot monitor the expiry date and extend before the loan expires
• The position you are collateralizing is close to a known sell event that will push its value below the loan amount

Cost framework (today's defaults; read staticFeePercentage() and dynamicFeePercentage() on the main):

Rule: Always take minimum duration (10 days) and extend. Extension costs 0.005%/day: roughly 400x cheaper per day than re-originating. A 90-day position costs 2.05% + 80 × 0.005% = 2.45% via extend vs. 2.45% direct, but with the option to close earlier without overpaying. An extension adds at least 10 days (0.05% of the debt). A vault loan you plan to top up with addToLoan must start above 10 days.

Leverage sizing rules:

• Leverage is terminal: it must be the last action in any stack
• Stable+/Predict+ leverage: up to about 37x; the position must be more than 2x (Under 2x). Read simulateLeverageLocked / simulateLeverageFactoryLocked for the real figure. Effective leverage decreases with position size due to price impact per loop
• Floor+ leverage: lower effective multiplier since LTV is against floor price, not spot
• Target position sizes where each loop has <50 basis points of price impact (see §8)

Exit strategy planning: Before opening leverage, define the exit. The owner can extend a position on its main (main.extendLoan(id, days, true, payInMainPair, refinance)), repay it (main.repayLoan(id, amount, true); 2^256 - 1 repays all, less repays part) or close it before 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 main.claimLiquidation(id, true) (SDK client.trading.claimLeverageLiquidation(id)). Claim within 365 days of the liquidation; after that the leftover may no longer be claimable. Know this scenario before entering.

Prediction Markets: Creator vs Bettor vs Trader

Three fully independent roles: the real edge is combining them.

Combined play for maximum capital efficiency:

1. Create the market (creator role) and set a creator fee on its market token: earns that fee on all subsequent activity
2. Buy the Predict+ token (trader role): benefits from volume the market attracts
3. Take a loan against Predict+ tokens (Capital Manager mechanic): extracts USDG
4. Use extracted USDG to bet on outcome with highest conviction (bettor role): separate conviction play

All four revenue streams from one market, from one deployment of capital.

The Flywheel (per main)

Every factory token on BASIS trades through its own main (STASIS is the first main). This is not incidental: it is load-bearing for all of the following:

• Every trade on every token: increases its main's price fractionally (slippage stays in the pool)
• Every trade on every token: 10% of the base part of the fee goes to the vault of the token's main → stakers' rewards grow (claim or compound)
• Higher main price → higher collateral value for its holders → better loan terms → more capital to deploy → more trading
• More volume → more creator fees → more token creation → more markets → more volume

Strategic implication: Activities that increase platform trading volume are multipliers on every existing position. Creating popular tokens, creating popular markets, and building referral networks all compound the positions of every staker on the platform. Volume is non-zero-sum here.

3. Strategy Playbooks

Six named strategies. Each is a complete, composable play. Method references are to Action Module SDKs.

Strategy A: Predict Leverage Play

Goal: Maximum exposure to a Predict+ token's appreciation curve.

When to use: You are highly confident a prediction market will attract significant volume. Token is early in its lifecycle (supply is low, leverage is most effective).

Steps:

1. Create the prediction market (→08: client.predictionMarkets.createMarket(); createMarket(CreateParams, deadline, approvalSignature) needs an approval signature while the host's gatingEnabled() is true) and set a creator fee on its market token, you earn it on everything that follows
2. Buy Predict+ token with available USDG (→04: client.trading.buy())
3. Open a leveraged position on the Predict+ token (→04: client.trading.leverageBuy()), this is terminal, do it last
4. Optional: with any remaining pre-leverage USDG, buy outcome shares on your highest-conviction outcome (→08: client.predictionMarkets.buy())

End state: Creator fee stream (passive) + leveraged Predict+ exposure + optional outcome bet.

Risk: Leverage expiry management. Monitor expiry via client.trading.getLeveragePosition(wallet, index): check field [6] (liquidationTime). Extend on the main (main.extendLoan(id, days, true, payInMainPair, refinance)), or exit before expiry via client.trading.partialLoanSellFor(main, positionId, 100n, true, minOut). After expiry a keeper liquidates the position and keeps 10% of what is left over. Do NOT use client.loans methods on leverage.

Strategy B: Predict Loan-Bet Play

Goal: Combine Predict+ token holding with a funded bet using extracted loan capital.

When to use: You want exposure to the Predict+ token AND have conviction on a specific outcome but limited free capital.

Steps:

1. Create the prediction market (→08: client.predictionMarkets.createMarket(); it needs the approval signature, Module 08)
2. Buy Predict+ token (→04: client.trading.buy())
3. Take a loan against the Predict+ tokens (→05: client.loans.takeLoan()), recover about 97.4% of what you spent, in the pair asset, less the market's creator fee
4. Use the borrowed USDG to bet on your target outcome (→08: client.predictionMarkets.buy())

End state: Predict+ token held (locked as collateral) + outcome shares funded by borrowed capital. Repay or extend before expiry; after it a keeper can liquidate the loan.

Risk: If the bet loses and you need to repay the loan, repayment must come from other capital. Plan the repayment source before entering.

Strategy C: Vault Compound

Goal: Set-and-forget yield position that grows over time in the vault.

When to use: Capital with no immediate deployment opportunity.

Steps:

1. Buy STASIS (→04: client.trading.buy() with STASIS address; or SWAP.buyTokens(amount, minOut, [pairAsset, main], true) to buy and stake in one transaction)
2. Stake: client.vault().stake(amount) (the vault's stake(main, amount))
3. Borrow against the stake: client.vault().borrow(stasisAmount, days) with more than 10 days
4. Later passes: buy more STASIS with the borrowed pair asset, stake it, and pledge it with client.vault().addToLoan(additionalStasis), one vault loan per wallet (maximum 3 loops before origination fees exceed rewards)
5. When the loan nears expiry: client.vault().extendLoan(days, payInMainPair, refinance), do not close and re-originate. The hub loan belongs to the vault, so client.loans.extendLoan(hubId) cannot reach it: it reverts 'Invalid loan' (or acts on your own hub loan with that number).

End state: One stake, built in several buys, earning vault rewards on all of it, the pledged part included.

Rewards: Rewards accrue in the main on the whole stake. They do not compound by themselves: call client.vault().compound() to add them to the stake, or claim() to take them.

Strategy D: Prediction Market Mirror

Goal: Create BASIS prediction markets that mirror high-volume markets on Polymarket or Kalshi, capturing better economics.

Why BASIS economics are better:

• Polymarket: fixed $1 payout cap. BASIS: no $1 cap: payouts by rank from the pot
• Polymarket: creator earns nothing. BASIS: the creator sets a creator fee of up to 1% on every bet and trade of the market token
• Polymarket: needs counterparty liquidity. BASIS: the AMM fills instantly, no counterparty needed

Steps:

1. Identify an active Polymarket/Kalshi market with high volume on a broadly verifiable question
2. Create a matching market on BASIS (→08: client.predictionMarkets.createMarket(); it needs the approval signature, Module 08), match the outcomes exactly for cross-pollination
3. Promote the market through social channels and referrals to drive participants
4. Set a creator fee on the market token and collect it passively for the market's lifetime
5. Optional: bet on your own market if you have higher information than the crowd

Structural edge: A participant familiar with a Polymarket market can immediately engage with its BASIS equivalent. The question is already understood. The only friction is the new platform: remove it with clear market descriptions.

Strategy E: Capital Recycler

Goal: Keep USDG continuously deployed across multiple revenue streams with a perpetual refinance loop.

When to use: Active capital management. Suitable for agents running autonomously on a recurring cycle.

Cycle (repeat on each pass):

1. Earn: claim() or compound() vault rewards, claim loan remainders, redeem resolved outcome payouts (creator fees arrive by themselves)
2. Lend: Deploy earned capital into a new position (buy token → take loan)
3. Deploy: Use extracted USDG to buy into a new market or token
4. Refinance: On each loan approaching expiry, extend (do not re-originate) unless a better opportunity justifies closing

Key principle: Capital should never sit idle. Idle USDG in a wallet earns nothing. Idle capital staked in a vault earns platform fees. Idle USDG as a bet earns outcome payout. Every idle USDG has a deployment option.

Agent implementation: Schedule a recurring check every 24–48 hours. Collect any matured positions, extend approaching loan expirations, and deploy collected USDG into the highest-current-yield option from the decision trees in §4.

Strategy F: Network Multiplier

Goal: Amplify any primary strategy with a referral network that generates passive fee income from the trades and bets of referred wallets.

How to layer it onto any other strategy:

1. Have each referred wallet send AReferrals.setReferrer(yourWallet) once (you need no trading history of your own)
2. Recruit participants who fit the highest-fee archetypes: Traders (high trade volume), prediction bettors, Token Creators (sustained fee streams)
3. Earn referral fee share on every trade and bet from referred wallets. Once set, a referred wallet can't change its referrer itself
4. Re-deploy referral income using Strategy E (Capital Recycler)

Compounding dynamic: A referral network turns your social capital into on-chain yield. The more active your referred network, the more the network multiplier amplifies every other position you hold. A Super Referrer running Strategy E with 50 active referred Capital Managers is earning on both their own positions and their network's trades and bets.

4. Decision Trees

"I have idle USDG: what should I do?"

"I want exposure to token X: how much conviction do I have?"

"I need liquidity but don't want to sell"

"I want to start a business on BASIS"

"Do I want to build a referral network?"

5. Stacking Strategies

Core Concept

Stacking is the technique of building multiple simultaneous positions from one starting pool of USDG, using loans to extract capital from each layer before deploying into the next.

Three properties make deep stacking viable on BASIS that would be dangerous on other platforms:

1. Shared collateral system. A single token position backs a loan. That loan's proceeds buy another position. The positions are independent: a move in one does not margin-call the other.
2. Buying does not lock capital. When you buy a token, you can immediately take a loan against it. The capital is not locked: it returns in a slightly smaller form.
3. No price liquidation. The floor price never decreases on Floor+ tokens. STASIS and Predict+ prices can only go up, in pair-asset units. No mid-stack market crash triggers a liquidation cascade. Price cannot liquidate you; expiry, fees, a fall above the floor and contract risk remain.

The 5 Building Blocks (Paths A–E)

Every stack is built from these five paths. Each path starts with USDG and either returns USDG (allowing further stacking) or terminates.

Path A: Stable+ (STASIS vault loop)

This path is always Stack 1. It is the foundational layer:

• The stake, pledged part included, keeps earning vault rewards
• STASIS price can only go up in pair-asset units, so a price move cannot liquidate the loan
• A loan is sized at the floor, which never falls, so its collateral is designed to cover the debt. Expiry, fees and contract risk remain
• The extracted USDG funds all subsequent paths

Path B: Floor+

LTV is against the floor price, not spot. If you buy at launch when floor is close to spot, LTV is near 100% of your purchase. If you buy after large appreciation when spot is 3x the floor, your LTV is roughly 33% of spot: you recover only ~33% × (100% − fees) of your USDG.

Path C: Predict+

LTV is 100% of the floor value, which is the price (same as Stable+). Works identically to Path A but with Predict+ collateral. Use across multiple markets to maintain diversified exposure.

Path D: Outcome Bet

Path D is a terminal path. It does not return USDG to feed the next layer. It is deployed at the end of a stack when you want conviction-based directional exposure funded by loan proceeds from earlier layers. (See Module 08 §3b for bet mechanics and Module 14 for payout mechanics.)

Path E: Leverage

Path E is always terminal. No USDG returns from this path. It amplifies the position in one token with no remaining capital to deploy elsewhere. Use it last in any strategy. Best deployed on Floor+ tokens at launch (when floor ≈ spot, maximizing each loop's effective LTV) or on Stable+/Predict+ tokens for highest leverage multiplier. Mechanics reference: Module 04 §3c.

Fee Reality Check

After each path from a $1,000 starting position:

The figures assume no price impact, no creator or rewards fee and no referrer: recovered = (1 − tax) × (1 − 0.02 − days × 0.00005) × floor / spot, with tax = getTaxRate(token, wallet) / 10000. Floor = spot on a main and on a multiplier-100 token.

Every non-terminal path loses about 2.6% to 2.7% per layer, plus the token's creator and rewards fees. Deeper stacks have proportionally less capital at each step. Build stacks where each layer's expected return exceeds its all-in cost.

4 Example Strategies

Conservative Stack

Profile: Risk-averse, yield focus, minimal monitoring required.

End state: One vault position built in three buys, all of it earning vault rewards. About $29,011 staked, $19,186 received, $19,608 to repay, about $597 paid in fees (about $175 of trade fees and $422 of loan fees). Vault rewards on $29,011 have to beat that.

Yield Maximizer

Profile: Moderate risk tolerance, active management.

Deep Stack

Profile: Active agent, high frequency, maximum capital utilization.

End state: vault stake (earning rewards), Predict+ tokens in three markets (locked as collateral, earning from their own volume), outcome bet in a fourth market. Five concurrent positions from $5,000.

Monitoring requirement: Four loan expiry dates to track. All must be extended or repaid before expiry, or a keeper can liquidate the respective position.

Creator's Edge

Profile: Token creator who wants to stack passive income streams.

Key Rules for Agents (Stacking)

1. Path A is always Stack 1. It is the safest path with the best LTV. Build the staked STASIS layer first, everything else builds on top.

   Price impact on shallow pools: Capital recovery percentages (about 97.3% and 97.4%) assume negligible price impact. On pools with less than ~$5,000 of depth (depthUsdE18 / 1e18), price impact can exceed fees significantly. Always call getToken(address) to check pool depth, and probe with a taxed quote (getAmountsOut() →04 excludes the trade tax; Module 11) before each stack. If your trade exceeds 10% of that depth, split into smaller buys.

2. Path E is always last. Never put leverage in the middle of a stack. Nothing can follow it.
3. Path D is terminal. Do not plan on extracting capital from an outcome bet before resolution.
4. Track every loan expiry. After expiry a keeper can liquidate at any moment, and the liquidator keeps 10% of what is left over. Set alerts or use a monitoring loop. Check: client.loans.getUserLoanDetails() →05.
5. Extend, never re-originate. Extension is 400x cheaper per day; an extension adds at least 10 days. Closing and reopening a loan wastes 2% each time.
6. Buy Floor+ for stacking at or near launch. The floor-spot gap widens over time, reducing effective LTV. Early entry captures near-100% LTV.
7. Limit depth to what you can monitor. A 6-layer stack has 5 active loans. If any expires unmanaged, a keeper can liquidate that position. Depth is only safe if monitoring is reliable.
8. Do not stack across loans with different expiry windows without a rollover plan. Mismatched expiries create management complexity that causes missed extensions.

6. Unwinding Stacks

Sell vs Borrow Decision

The choice between selling a position and borrowing against it determines the character of your exit.

Good active managers use both. Selling reduces complexity. Borrowing preserves upside exposure. Neither is universally correct.

LIFO Unwind Order

Unwind stacks last-in, first-out. The outermost position must be closed before the loan that funded it can be repaid, and that loan repayment releases the collateral from the layer below it.

Skipping to a middle layer is not possible: the loans must be repaid in sequence from the outside in.

Closing Each Path Type

Path A (the stake):

Before borrowing in Path A, check positions(main, wallet).hub (SDK client.vault().getPosition(wallet)): a loan is open when it is not the zero address, if a vault loan is already active, use addToLoan() instead of borrow(). Only one vault loan per wallet.

1. Repay the vault loan: client.vault().repay() (approve the pair asset to the vault for the loan's fullAmount)
2. Take the rewards: client.vault().claim(), or compound() to add them to the stake
3. Unstake: client.vault().unstake(amount, false, 0n) returns STASIS
4. Sell STASIS if needed: client.trading.sell(STASIS_ADDRESS, amount, minOut)

Or use the quick exit: client.vault().unstake(amount, true, minOut), sells to the pair asset in one transaction, at your tax rate.

Path B (Floor+):

1. Repay loan: client.loans.repayLoan(hubId, maxUint256) (2^256 - 1 = all; approve the pair asset to the loan hub)
2. Retrieve collateral (token is released back to wallet)
3. Choose exit: sell via client.trading.sell() or hold for further appreciation

Path C (Predict+):

1. Repay loan: client.loans.repayLoan(hubId, maxUint256) (2^256 - 1 = all; approve the pair asset to the loan hub)
2. Retrieve Predict+ token
3. Sell before resolution: client.trading.sell(), may be suboptimal (see post-resolution timing below)
4. Or hold through resolution for post-resolution sell wave (price rises, in pair-asset units, as holders sell)

Path D (Outcome shares):

• Cannot exit before resolution via loan: shares are terminal
• Sell on P2P order book if early exit is needed: client.orderBook.listOrder()
• After resolution: client.predictionMarkets.redeem(marketToken, 10000n, 1n, minOut) if outcome won (redeem(market, fractionBps, slices, minOut))

Path E (Leverage):

1. Leverage positions are loan-backed: they expire by time, not by market action. The owner can extend or repay them on the main
2. After expiry a keeper liquidates. 90% of what is left over is claimable with client.trading.claimLeverageLiquidation(id) (main.claimLiquidation(id, true)); client.loans.claimLiquidation(hubId) is for hub loans only. Claim within 365 days of the liquidation; after that the leftover may no longer be claimable.
3. To exit early: client.trading.partialLoanSellFor(main, id, pct, true, minOut) in steps of 10 to reduce the position before expiry; an exit pays 3% of the proceeds above the initial buy

Floor+ Profit Scenarios

On a Floor+ loan the loan itself costs no more than its fees, as long as you repay or extend before a keeper liquidates it, because it was sized at the floor and the floor does not fall. The token can still fall to the floor, so anything paid above the floor can be lost. A liquidation costs 10% of the remainder.

Leverage Unwinding Math

On leverage positions (Path E), the math of a keeper liquidation after expiry:

There is no view that previews a liquidation. MainLens.getPartialLoanSellAmounts(main, id, owner, 100, isLeverage) returns the same remainder (residualTokens) while the loan is active, with limits: for a hub loan pass the hub as user and the loan's internal id as id; on a Floor+ token it can revert 'cannot sell off with no profit' where a liquidation would not; apply the 10% yourself.

Partial Close in 10% Increments

When reducing a position before full exit, partial close allows proportional exits without closing the entire position. The method differs depending on whether you're closing a loan or leverage:

// JS: regular (hub) loan: use client.loans; isLeverage must be false here
const result = await client.loans.hubPartialLoanSell(hubId, 20n, false, minOut);

// JS: leverage position: use client.trading (SWAP, acting on the position's main)
const result = await client.trading.partialLoanSellFor(MAIN, positionId, 20n, true, minOut); // isLeverage=true, on the position's main
// On any other main: SWAP.partialLoanSellFor(main, positionId, 20n, true, minOut)

// Python: regular loan
result = client.loans.hub_partial_loan_sell(hub_id, 20, False, min_out)

// Python: leverage position
result = client.trading.partial_loan_sell_for(MAIN, position_id, 20, True, min_out)

Take minOut from MainLens.getPartialLoanSellAmounts(main, id, wallet, pct, isLeverage): quote its residualTokens with getAmountsOut(residualTokens, [token, main, pairAsset]) (a main: [main, pairAsset]), take the tax off, then apply your tolerance. Never pass 0.

Rule: The percentage argument must be a multiple of 10. Valid: 10, 20, 30, 40, 50, 60, 70, 80, 90, 100. 100 = full close. Invalid: any other number (reverts % by 10 or % range). A hub-loan exit pays the token's normal sell rate on its proceeds (base + creator + rewards fee, no referral); a leverage exit pays 3% of the proceeds above the initial buy.

Use case: You hold a leveraged Floor+ position. Token has appreciated significantly. Rather than letting it ride to expiry, sell 30% now to lock in gains while keeping 70% exposed to further upside.

Exit Timing Guidance

Five rules that govern when to exit:

1. Exit Predict+ after resolution, not before. Post-resolution, slippage stays in the pool, so each sale pushes the price up (in pair-asset units); a sale still receives less than the quoted price, more so on a large sale. The last seller exits at the highest price. Early exits sacrifice post-resolution appreciation.

2. Exit Floor+ before the floor closes the gap with spot. When spot has risen far above floor, per-loop yield on any new position shrinks. But for existing holders, the higher spot means higher exit value: sell into strength.

3. Exit leverage positions before expiry if the market has moved in your favor. A leverage position that has 3x'd should exit via partial sells or full sell before expiry rather than leaving it to a keeper liquidation, which costs 10% of what is left after the debt.

4. Extend rather than exit when costs are favorable. If the position still has expected upside and the extension fee (0.005%/day, minimum 10 days per extension) is less than expected daily return, extend and stay.

5. Unwind from outermost layer inward (LIFO). Do not attempt to repay a middle-layer loan before clearing the outer layer: the outer loan's capital must be freed first to fund repayment.

Full Cycle Example

Week 1: Build

Weeks 2–4: Hold and Monitor

• Day 8: Extend the two hub loans (client.loans.extendLoan, at least 10 days each; cost: 0.005%/day each, negligible vs positions)
• Day 14: Market X resolves. Predict+ X loan: repay → claim Predict+ → sell at post-resolution peak
• Day 14: Proceeds ($5,200) redeploy into new Predict+ market via Path C

Week 4: Unwind

7. Position Sizing Guidance

Reading Token Depth Before Entering

Pull token data before sizing any position:

// JS
const tokenData = await client.api.getToken(tokenAddress);
const depthUSD = tokenData.depthUsdE18 === null ? null : Number(tokenData.depthUsdE18) / 1e18;   // pool depth in USD

// Python
token_data = client.api.get_token(token_address)
depth_usd = None if token_data['depthUsdE18'] is None else int(token_data['depthUsdE18']) / 1e18

depthUsdE18 tells you how deep the current pool is. A $100 trade into a $500 pool moves the price dramatically. A $100 trade into a $50,000 pool moves it negligibly.

liquidityUSD is deprecated and stays unchanged for one release. Size trades with depthUsdE18. Both are null when the pair asset has no USD price.

Price Impact Calculation

Before entering any position, simulate the trade and calculate slippage:

// JS: calculate price impact for a proposed buy
const path = [pairAsset, main, tokenAddress];                  // two entries when buying the main itself
const amountIn = parseUnits("1000", pairDecimals);             // 1,000 units of the pair asset
const rate = BigInt(await client.taxes.getTaxRate(tokenAddress, wallet)); // basis points
const afterTax = amountIn - (amountIn * rate) / 10000n;        // the fee comes off the input first
const amountOut = await client.trading.getAmountsOut(afterTax, path);     // getAmountsOut applies no fee
const pairPrice = BigInt(await client.trading.getPairPrice(tokenAddress)); // token.getPairPrice(): raw pair units per whole token
const expectedOut = (afterTax * 10n ** 18n) / pairPrice;       // output at zero price impact
const impactBP = ((expectedOut - amountOut) * 10000n) / expectedOut;

console.log(`Price impact: ${impactBP} basis points`);

# Python
path = [pair_asset, main, token_address]
amount_in = 1000 * 10**pair_decimals
rate = client.taxes.get_tax_rate(token_address, wallet)
after_tax = amount_in - amount_in * rate // 10000
amount_out = client.trading.get_amounts_out(after_tax, path)
pair_price = client.trading.get_pair_price(token_address)
expected_out = after_tax * 10**18 // pair_price
impact_bp = (expected_out - amount_out) * 10000 // expected_out
print(f"Price impact: {impact_bp} basis points")

Thresholds

Splitting large positions: If a $10,000 buy produces 300 BP of slippage, split into 10 × $1,000 trades. Slippage on each is lower. Alternatively, spread across 10 different Predict+ markets in parallel: the multi-market stacking approach naturally solves the slippage problem.

Leverage position sizing: Each leverage loop adds price impact. The effective leverage (number of loops) decreases as position size increases. A $100 starting leverage position on a token with $10,000 of depth achieves more loops (and higher leverage) than a $10,000 starting position. Small positions on deep pools unlock maximum leverage.

8. Why This Only Works on BASIS

Every element of the stacking strategies above depends on structural properties of the BASIS platform. Standard DeFi replication is not possible.

The architectural dependency is total. A strategy like the Conservative Stack (§5) requires:

• Borrowing against a Stable+ token at 100% LTV (possible because on Stable+ the floor price = spot)
• No price liquidation on the borrowed position (only possible with time-based expiry model)
• Vault rewards on pledged collateral (the vault keeps paying rewards on the part of a stake that backs a loan)

Remove any of these three properties and the Conservative Stack becomes either impossible or dangerous. The same dependency holds for every strategy in this module.

Quick Reference

→ Prerequisite modules: 04-trading.md · 05-lending.md · 06-staking.md · 07-token-creation.md · 08-predictions.md → Deep mechanics: 11-token-mechanics.md (multiplier system, token type reference) → Advanced prediction plays: 13-prediction-strategies.md · 14-resolution-deepdive.md