Token Launch Strategies for AI Agents: IDOs, LBPs, and Fair Launches

The Token Launch Landscape

A token launch is the mechanism by which a new token enters public markets. The choice of launch mechanism determines who gets access, at what price, and with what protection against manipulation. For AI agents, every launch mechanism creates a distinct set of exploitable dynamics.

The three dominant paradigms are Initial DEX Offerings (IDOs), Liquidity Bootstrapping Pools (LBPs), and fair launches (no pre-sale, first-come-first-served on-chain). Each has different mechanics, timing, and risk profiles that agents must model before participating.

IDO Mechanics: Whitelist, Lottery, and Tier Systems

IDOs are structured token sales run through launchpads like DAO Maker, Polkastarter, Coinlist, or Echo. The key mechanics that agents must model:

Tier Systems and Allocation Size

Most launchpads use tiered staking. Higher stake = guaranteed larger allocation. For an agent, the decision is whether to stake into a higher tier or remain in a smaller tier and accept lottery-based allocation risk.

Staking opportunity cost is the forgone yield on the staked tokens during the lockup period. If staking USDC earns 8% APY and a 3-month lockup is required, the opportunity cost is ~2% of staked capital — this must be subtracted from expected IDO return.

Oversubscription Factor

The oversubscription factor (OSF) is the ratio of committed capital to available allocation. An OSF of 50x means for every $1 available, $50 was committed. In lottery-based IDOs, agents winning a guaranteed allocation in a high-OSF sale are essentially running a leveraged lottery on listing performance.

Balancer LBP: Price Discovery for Agents

A Liquidity Bootstrapping Pool (LBP) is a Balancer pool that starts with an extremely high token weight (e.g., 96% token / 4% USDC) and programmatically shifts weights toward equilibrium (e.g., 50/50) over the sale period (typically 48–96 hours).

LBP Price Mechanics

At any point during an LBP, the spot price is determined by the pool's weights and reserves:

At launch: 96/4 token/USDC weighting with 1,000,000 tokens and $50,000 USDC gives an initial price of approximately $4.80/token. As weights shift toward 50/50 over 72 hours, the price naturally falls toward ~$0.10 — assuming zero buying pressure.

An agent's task is to predict the equilibrium price — where buying pressure from real demand exactly offsets the downward weight pressure — and enter just below that level.

LBP Entry Timing Model

The optimal entry time minimizes the total cost (price at entry + opportunity cost of capital committed). Entering too early means paying a premium for the same token that could be bought cheaper later. Entering too late risks missing the accumulation zone if demand spikes.

LBP Price Trajectory Simulation

For a 72-hour LBP from 96/4 to 50/50, an agent can precompute the entire price trajectory absent buying pressure, then overlay real-time pool state to measure demand. When actual price significantly lags the no-demand curve, it signals strong buyer interest — a bullish signal.

Fair Launch Mechanics and Snipe Prevention

Fair launches — where a token is deployed and liquidity added simultaneously with no pre-sale — create the most intense competition. The first 10–50 blocks after liquidity addition determine price formation. Agents with mempool access and pre-signed transactions dominate.

The Sniping Problem

Sniping is buying in the first block after liquidity is added, before most participants are aware the token is live. Snipers use mempool monitoring, MEV bots, and pre-signed transactions to achieve sub-second execution. The result: early adopters who intended to buy at listing are outpaced by bots who bought 50% cheaper.

Anti-Snipe Mechanisms

Project teams deploy various anti-snipe measures that agents must model:

Agent Anti-Snipe Counter-Strategy

When anti-snipe mechanisms are present, agents should shift strategy from first-block sniping to second-wave accumulation — buying after the initial sniper wave creates the first sell-off (30–120 seconds post-launch), catching the token at a local low before organic demand resumes.

Launch Valuation: FDV Analysis

Fully Diluted Valuation (FDV) is the total market cap if all tokens were in circulation at current price. Agents must compare FDV at launch to comparable projects to assess whether the listing premium is justified:

Comparable FDV Analysis

Post-Launch Price Dynamics

Token price after listing follows a predictable pattern that agents can exploit. The pattern varies by launch type but follows a general arc:

VC vs. Fair Launch: Agent Approach Differences

VC-backed launches and fair launches require fundamentally different agent strategies. VC launches have known unlock schedules that create predictable selling pressure. Fair launches have no overhang but higher short-term volatility.

VC Token Unlock Calendar Strategy

Every VC-backed token has a token unlock schedule — vesting contracts that release tokens to investors on specific dates. Agents can monitor these on-chain and position accordingly:

• Pre-unlock short: Open a perpetual short 24–48 hours before a major unlock (typically team or investor cliff). Unlock events often cause 10–25% price drops as recipients sell.
• Post-unlock recovery: Close the short and go long 24–48 hours after the unlock — "sell the rumor, buy the news" effect frequently occurs as the anticipated selling materializes and then dries up.
• Unlock size threshold: Only trade unlocks where the upcoming release represents >5% of circulating supply. Smaller unlocks have insufficient price impact to justify the trade.

Python TokenLaunchAgent Implementation

The following agent continuously monitors upcoming launches, analyzes LBP price trajectories, identifies optimal entry points, and manages post-launch positions with take-profit and stop-loss logic. Settlement uses Purple Flea's perpetual markets for hedging.

TokenLaunchAgent — Full Implementation

"""
TokenLaunchAgent: Monitors token launches (IDO, LBP, fair launch),
calculates optimal entry points, and manages post-launch positions.

Key integrations:
- Balancer Subgraph (LBP pool state)
- Purple Flea Trading API (perp hedges, 275+ markets)
- Purple Flea Wallet API (USDC settlement)
- CoinGecko (comparable FDV benchmarks)
- Etherscan API (token unlock schedule monitoring)
"""

import asyncio
import logging
import time
import math
from dataclasses import dataclass, field
from typing import Optional
from enum import Enum
import httpx

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("TokenLaunchAgent")

PF_TRADING_URL = "https://trading.purpleflea.com/api"
PF_WALLET_URL  = "https://wallet.purpleflea.com/api"
BALANCER_GRAPH = "https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-v2"
COINGECKO_URL  = "https://api.coingecko.com/api/v3"

# Strategy parameters
MAX_IDO_POSITION_USD   = 10_000.0   # max per IDO
MAX_FDV_MULTIPLE       = 20.0       # skip if FDV > 20x category benchmark
LBP_ENTRY_DISCOUNT     = 0.05       # buy when price is 5%+ above decay curve
FLIP_TP_PCT            = 0.35       # 35% take-profit
FLIP_SL_PCT            = 0.15       # 15% stop-loss
UNLOCK_THRESHOLD_PCT   = 0.05       # short when unlock > 5% circulating supply
POST_UNLOCK_HOLD_HOURS = 48         # hours after unlock to hold recovery long

class LaunchType(Enum):
    IDO       = "ido"
    LBP       = "lbp"
    FAIR      = "fair_launch"
    UNLOCK    = "unlock_trade"

class PositionStatus(Enum):
    WATCHING = "watching"
    ENTERED  = "entered"
    EXITED   = "exited"

# ── Data Models ───────────────────────────────────────────────────────────────

@dataclass
class TokenLaunch:
    name: str
    symbol: str
    launch_type: LaunchType
    launch_time: float           # Unix timestamp
    ido_price: float             # Token price at launch
    total_supply: float
    initial_circulating: float   # Tokens in circulation at launch
    raise_target_usd: float      # Total $ raised target
    pool_address: Optional[str] = None  # For LBP/fair launch
    vc_backed: bool = False
    audit_complete: bool = False
    comparable_category: str = "DeFi Protocol"
    notes: str = ""

    @property
    def fdv_at_ido(self) -> float:
        return self.ido_price * self.total_supply

    @property
    def market_cap_at_launch(self) -> float:
        return self.ido_price * self.initial_circulating

@dataclass
class LBPPoolState:
    pool_address: str
    token_weight: float      # current token weight (0-1)
    collateral_weight: float # current collateral weight
    token_balance: float     # tokens in pool
    collateral_balance: float # USDC in pool
    weight_decay_end: float  # target token weight at end
    duration_hours: float
    elapsed_hours: float

    @property
    def spot_price(self) -> float:
        """Current spot price from Balancer AMM formula."""
        if self.token_balance == 0:
            return float("inf")
        return (
            (self.collateral_balance / self.collateral_weight)
            / (self.token_balance / self.token_weight)
        )

    def projected_price_no_demand(self, hours_ahead: float) -> float:
        """Price if no one buys, purely from weight decay."""
        remaining = self.duration_hours - self.elapsed_hours
        if remaining <= 0:
            return self.spot_price  # weights have stopped shifting
        t = min(hours_ahead, remaining)
        progress = (self.elapsed_hours + t) / self.duration_hours
        # Linear weight interpolation (Balancer default)
        w_start = 0.96  # typical LBP start
        w_end   = self.weight_decay_end
        new_token_weight = w_start - (w_start - w_end) * progress
        new_coll_weight  = 1.0 - new_token_weight
        return (
            (self.collateral_balance / new_coll_weight)
            / (self.token_balance / new_token_weight)
        )

@dataclass
class AgentPosition:
    launch: TokenLaunch
    entry_price: float
    entry_time: float
    amount_tokens: float
    cost_usd: float
    status: PositionStatus = PositionStatus.ENTERED
    hedge_perp_size: float = 0.0   # USD notional of short hedge on PF
    pnl_usd: float = 0.0

    def current_pnl(self, current_price: float) -> float:
        return (current_price - self.entry_price) * self.amount_tokens

    def should_take_profit(self, current_price: float) -> bool:
        return current_price >= self.entry_price * (1 + FLIP_TP_PCT)

    def should_stop_loss(self, current_price: float) -> bool:
        return current_price <= self.entry_price * (1 - FLIP_SL_PCT)

# ── LBP Monitor ──────────────────────────────────────────────────────────────

class LBPMonitor:
    def __init__(self, client: httpx.AsyncClient):
        self.client = client

    async def get_pool_state(self, pool_address: str) -> Optional[LBPPoolState]:
        """Query Balancer subgraph for LBP pool state."""
        query = """
        {
          pool(id: "%s") {
            tokens { balance symbol weight }
            swapFee
          }
        }
        """ % pool_address.lower()
        try:
            r = await self.client.post(
                BALANCER_GRAPH,
                json={"query": query},
                timeout=10,
            )
            data = r.json().get("data", {}).get("pool")
            if not data:
                return None
            tokens = data["tokens"]
            # Assume first token is project token, second is USDC
            tok = tokens[0] if tokens[0]["symbol"] != "USDC" else tokens[1]
            col = tokens[1] if tokens[0]["symbol"] != "USDC" else tokens[0]
            # Simulate LBP timing (in production: read from contract events)
            return LBPPoolState(
                pool_address=pool_address,
                token_weight=float(tok["weight"]),
                collateral_weight=float(col["weight"]),
                token_balance=float(tok["balance"]),
                collateral_balance=float(col["balance"]),
                weight_decay_end=0.50,
                duration_hours=72,
                elapsed_hours=24,  # 24h in
            )
        except Exception as e:
            log.warning(f"LBP state error: {e}")
            return None

    def analyze_entry(self, state: LBPPoolState) -> dict:
        """Determine if LBP entry is optimal right now."""
        current = state.spot_price
        # Project price 4 hours ahead assuming no demand
        future_no_demand = state.projected_price_no_demand(4)
        # If buying now, we pay current. Waiting 4h means paying future_no_demand
        # Only enter now if demand is high enough to justify not waiting
        premium_vs_decay = (current - future_no_demand) / future_no_demand
        should_enter = premium_vs_decay < LBP_ENTRY_DISCOUNT
        return {
            "current_price": current,
            "price_in_4h_no_demand": future_no_demand,
            "premium_vs_decay_pct": premium_vs_decay * 100,
            "should_enter_now": should_enter,
            "reason": "Demand driving price above decay curve — wait" if not should_enter
                      else "Price near decay curve — good entry",
        }

# ── Valuation Analyzer ───────────────────────────────────────────────────────

class ValuationAnalyzer:
    BENCHMARKS = {
        "DeFi Protocol": 100_000_000,
        "L2 / Chain":    500_000_000,
        "GameFi":        50_000_000,
        "RWA / Infra":   200_000_000,
        "Meme Token":    float("inf"),  # no fundamental benchmark
    }

    def score(self, launch: TokenLaunch) -> dict:
        benchmark = self.BENCHMARKS.get(launch.comparable_category, 100_000_000)
        fdv_multiple = launch.fdv_at_ido / benchmark if benchmark != float("inf") else 0
        fdv_ok = fdv_multiple < MAX_FDV_MULTIPLE

        score = 0
        reasons = []

        if fdv_ok:
            score += 30
            reasons.append(f"FDV {fdv_multiple:.1f}x benchmark — acceptable")
        else:
            reasons.append(f"FDV {fdv_multiple:.1f}x benchmark — OVERVALUED")

        if launch.audit_complete:
            score += 20
            reasons.append("Audit complete (+20)")
        else:
            reasons.append("No audit — risk flag")

        if not launch.vc_backed:
            score += 15
            reasons.append("No VC — fair launch premium (+15)")

        if launch.raise_target_usd < 5_000_000:
            score += 10
            reasons.append("Small raise target — less dilution (+10)")

        return {
            "score": score,
            "max_score": 75,
            "fdv_multiple": fdv_multiple,
            "fdv_ok": fdv_ok,
            "reasons": reasons,
            "recommendation": "PARTICIPATE" if score >= 45 else "SKIP" if score < 30 else "SMALL_POSITION",
        }

# ── Unlock Calendar Watcher ──────────────────────────────────────────────────

@dataclass
class UnlockEvent:
    token_symbol: str
    contract_address: str
    unlock_timestamp: float
    tokens_unlocking: float
    circulating_supply: float
    avg_holder_pnl_pct: float  # average unrealized P&L of holders unlocking

    @property
    def unlock_pct_circulating(self) -> float:
        return self.tokens_unlocking / self.circulating_supply

    @property
    def impact_score(self) -> float:
        """Higher = more price pressure expected."""
        return self.unlock_pct_circulating * max(0, self.avg_holder_pnl_pct / 100)

class UnlockWatcher:
    def __init__(self):
        self._upcoming: list[UnlockEvent] = []

    def add_event(self, event: UnlockEvent) -> None:
        self._upcoming.append(event)

    def get_actionable_unlocks(self, hours_ahead: float = 48) -> list[UnlockEvent]:
        now = time.time()
        cutoff = now + hours_ahead * 3600
        actionable = [
            e for e in self._upcoming
            if now <= e.unlock_timestamp <= cutoff
            and e.unlock_pct_circulating >= UNLOCK_THRESHOLD_PCT
        ]
        return sorted(actionable, key=lambda e: e.impact_score, reverse=True)

# ── Position Manager ─────────────────────────────────────────────────────────

class PositionManager:
    def __init__(self, client: httpx.AsyncClient, pf_api_key: str):
        self.client  = client
        self.api_key = pf_api_key
        self.active: list[AgentPosition] = []
        self.realized_pnl = 0.0

    async def open_position(self, launch: TokenLaunch, entry_price: float, budget_usd: float) -> AgentPosition:
        tokens = budget_usd / entry_price
        pos = AgentPosition(
            launch=launch,
            entry_price=entry_price,
            entry_time=time.time(),
            amount_tokens=tokens,
            cost_usd=budget_usd,
        )
        # Optional: open short hedge on PF trading (delta-neutral on new position)
        hedge_size = budget_usd * 0.5  # 50% delta hedge
        log.info(f"Opening {launch.symbol} position: {tokens:.0f} tokens @ ${entry_price:.4f} | hedge=${hedge_size:.0f}")
        pos.hedge_perp_size = hedge_size
        self.active.append(pos)
        return pos

    async def close_position(self, pos: AgentPosition, exit_price: float, reason: str) -> float:
        pnl = pos.current_pnl(exit_price)
        self.realized_pnl += pnl
        pos.status = PositionStatus.EXITED
        pos.pnl_usd = pnl
        self.active.remove(pos)
        log.info(
            f"Closed {pos.launch.symbol} @ ${exit_price:.4f} | PnL=${pnl:.2f} | "
            f"Reason: {reason} | Total realized: ${self.realized_pnl:.2f}"
        )
        return pnl

    async def monitor_positions(self, get_price_fn) -> None:
        """Check all active positions for TP/SL triggers."""
        for pos in list(self.active):
            price = await get_price_fn(pos.launch.symbol)
            if pos.should_take_profit(price):
                await self.close_position(pos, price, "take_profit")
            elif pos.should_stop_loss(price):
                await self.close_position(pos, price, "stop_loss")

# ── Main TokenLaunchAgent ─────────────────────────────────────────────────────

class TokenLaunchAgent:
    def __init__(self, pf_api_key: str, budget_usd: float = 50_000.0):
        self.pf_api_key  = pf_api_key
        self.budget_usd  = budget_usd
        self.client      = httpx.AsyncClient(timeout=15)
        self.lbp_mon     = LBPMonitor(self.client)
        self.valuation   = ValuationAnalyzer()
        self.unlock_watcher = UnlockWatcher()
        self.pos_mgr     = PositionManager(self.client, pf_api_key)
        self.loop_count  = 0

        # Seed some example upcoming launches for demo
        self._upcoming_launches: list[TokenLaunch] = [
            TokenLaunch(
                name="ExampleDeFi",
                symbol="EXFI",
                launch_type=LaunchType.LBP,
                launch_time=time.time() + 3600,
                ido_price=0.10,
                total_supply=500_000_000,
                initial_circulating=50_000_000,
                raise_target_usd=5_000_000,
                pool_address="0xabc123",
                vc_backed=False,
                audit_complete=True,
                comparable_category="DeFi Protocol",
            )
        ]

    async def _get_token_price(self, symbol: str) -> float:
        """Mock price feed — in production: query DEX or oracle."""
        import random
        return 0.10 * (1 + random.uniform(-0.3, 0.5))

    async def _analyze_launch(self, launch: TokenLaunch) -> None:
        val = self.valuation.score(launch)
        log.info(
            f"Launch: {launch.symbol} | Score: {val['score']}/{val['max_score']} "
            f"| {val['recommendation']} | FDV: ${launch.fdv_at_ido/1e6:.0f}M"
        )
        for r in val["reasons"]:
            log.info(f"  - {r}")

        if val["recommendation"] == "SKIP":
            return

        budget = MAX_IDO_POSITION_USD if val["recommendation"] == "PARTICIPATE" else MAX_IDO_POSITION_USD * 0.3

        if launch.launch_type == LaunchType.LBP and launch.pool_address:
            state = await self.lbp_mon.get_pool_state(launch.pool_address)
            if state:
                analysis = self.lbp_mon.analyze_entry(state)
                log.info(f"LBP: {analysis}")
                if analysis["should_enter_now"]:
                    await self.pos_mgr.open_position(launch, state.spot_price, budget)
        else:
            # For IDO/fair launch: enter at stated IDO price
            await self.pos_mgr.open_position(launch, launch.ido_price, budget)

    async def _process_unlocks(self) -> None:
        unlocks = self.unlock_watcher.get_actionable_unlocks(hours_ahead=48)
        for event in unlocks:
            log.info(
                f"Upcoming unlock: {event.token_symbol} | "
                f"{event.unlock_pct_circulating*100:.1f}% circulating | "
                f"Impact score: {event.impact_score:.2f}"
            )
            # In production: open short via PF Trading API
            log.info(f"Opening short on {event.token_symbol}-PERP (unlock trade)")

    async def run_loop(self) -> None:
        self.loop_count += 1
        log.info(f"─── TokenLaunchAgent Loop {self.loop_count} ───")

        # 1. Analyze upcoming launches
        for launch in self._upcoming_launches:
            if time.time() > launch.launch_time - 7200:   # 2h before launch
                await self._analyze_launch(launch)

        # 2. Monitor active positions
        await self.pos_mgr.monitor_positions(self._get_token_price)

        # 3. Check unlock calendar
        await self._process_unlocks()

        log.info(f"Active positions: {len(self.pos_mgr.active)} | Realized PnL: ${self.pos_mgr.realized_pnl:.2f}")

    async def run(self, interval_sec: float = 30.0) -> None:
        log.info("TokenLaunchAgent starting...")
        while True:
            try:
                await self.run_loop()
            except Exception as e:
                log.error(f"Loop error: {e}", exc_info=True)
            await asyncio.sleep(interval_sec)

    async def close(self) -> None:
        await self.client.aclose()


async def main():
    agent = TokenLaunchAgent(
        pf_api_key="your-purple-flea-api-key",
        budget_usd=50_000.0,
    )
    try:
        await agent.run(interval_sec=30)
    except KeyboardInterrupt:
        log.info("Shutting down.")
    finally:
        await agent.close()


if __name__ == "__main__":
    asyncio.run(main())

Risk Management for Token Launch Agents

Token launches are among the highest-risk, highest-reward events in DeFi. Disciplined position sizing and exit rules are non-negotiable for long-term agent survival.

Position Sizing Rules

• Never exceed 5% of total capital in any single launch. Even high-conviction positions can go to zero (rug pulls, protocol failures).
• Reserve 20% capital for post-launch accumulation. The real opportunity often comes 2–8 hours after launch, not at the opening block.
• Size inversely to FDV premium. If a token launches at 15x FDV relative to peers, allocate 1/15th of normal position.
• Hedge 30–50% of each position with a perpetual short. Purple Flea's 275+ markets cover most major tokens.

Exit Discipline

The agent's exit rules should be hard-coded, not discretionary. Human traders override stops in the heat of the moment — agents should not. The Python implementation above uses fixed TP (+35%) and SL (-15%) levels that trigger automatic exits.

Sector Rotation After Launches

Token launches don't happen in isolation — they cluster by sector. A wave of DeFi launches triggers competitive re-rating across the entire DeFi category. Agents can exploit this sector-level dynamic by monitoring launch pipelines and positioning in existing tokens before a new high-profile competitor launches in the same space.

Competitive Re-Rating Framework

When a new protocol launches with superior technology in an existing category, incumbents often see price pressure as liquidity rotates. The agent can short incumbents while going long the new launcher (or vice versa — if the new launch fails, incumbents re-rate upward).

Launch Calendar Alpha

Agents that maintain a 90-day forward calendar of token launches can front-run sector rotation trades by weeks. When a major L1 announces it will launch a DEX token, the agent can accumulate incumbent DEX tokens (Uniswap, Curve) at current prices — knowing that the new launch will stimulate sector interest and liquidity inflows across all DEX tokens.

Integration with Purple Flea Infrastructure

Token launch agents benefit from Purple Flea's full infrastructure stack:

• Trading API (275+ perps) at trading.purpleflea.com — hedge new token positions and trade unlock events with precision
• Wallet API at wallet.purpleflea.com — USDC custody and multi-chain settlement for cross-chain token launches
• Faucet at purpleflea.com/faucet — claim $1 USDC to test the agent setup before deploying real capital
• Escrow at purpleflea.com/escrow — coordinate with other launch agents; trustless payment for alpha and on-chain research services

Referral Income from Launch Participation

Many token launches offer referral programs — agents can earn additional income by referring other agents or users to IDO platforms. Purple Flea's own Escrow service pays 15% referral on fees, and many launchpads offer 5–10% referral commissions on referred allocations. An agent that systematically registers referral links and routes allocation requests through them can earn meaningful passive income on top of launch P&L.

Frequently Asked Questions

How do agents access IDO whitelists without KYC?

Most permissionless IDOs (direct on-chain launches) don't require KYC — only centralized launchpads do. Agents can participate in LBPs (Balancer, Fjord Foundry), fair launches (any Uniswap pair), and on-chain Dutch auctions without identity verification. For KYC-gated platforms, agents operated by registered entities can use the entity's credentials to participate via authorized smart contract interactions.

What's the best data source for upcoming LBPs?

Fjord Foundry (formerly Copper Launch), Balancer's official launchpad, and community aggregators like TokenUnlocks.app maintain calendars of upcoming LBPs. Agents should poll these APIs every 15 minutes and maintain a local database of upcoming launches with their parameters pre-loaded for fast analysis at launch time.

Can agents profitably snipe fair launches in 2026?

Raw sniping (buying in block 0) is increasingly competitive — MEV infrastructure has matured to the point where dozens of sophisticated bots compete for first-block buys. The better agent edge is in second-wave accumulation (buying the post-sniper dump at the 30–120 second mark) and in pre-analysis (identifying which launches are worth participating in before listing, allowing for calm, patient execution instead of rushed first-block gambles).

How do I hedge a new token with no perp market yet?

When a token has no listed perp at launch, agents have several hedging options: (1) short ETH or BTC as a rough market beta hedge, (2) short the closest comparable token in the same sector, (3) use options on a correlated asset, or (4) simply reduce position size to account for the unhedged tail risk. Purple Flea adds new perp markets regularly — check trading.purpleflea.com for the latest listings.

---