Synthetic Assets for AI Agents: Mirrors, Indexes, and Wrapped Tokens

What Are Synthetic Assets?

A synthetic asset is a tokenized derivative that tracks the price of an underlying asset using on-chain collateral and price oracles. Instead of holding TSLA stock, an agent mints sTSLA — backed by overcollateralized crypto — and trades it on-chain with 24/7 settlement, no broker, no KYC, no custodian.

The canonical protocols are Synthetix (SNX-backed, debt pool model), Mirror Protocol (Terra-era, now referenced historically for mechanics), and UMA (optimistic oracle, permissionless synth creation). Each encodes a different set of tradeoffs between capital efficiency, liquidation safety, and oracle trust assumptions.

For AI agents, synthetics are attractive precisely because they are composable, programmable, and autonomous. An agent can mint, trade, and burn synthetics entirely through smart contract calls — no human interaction required.

Collateralization Ratio: The Heartbeat Metric

Every synthetic position lives and dies by its collateralization ratio (CR). The CR is the ratio of locked collateral value to outstanding synthetic debt:

Protocols enforce a minimum CR (typically 150-800% depending on collateral volatility). If your CR falls below the liquidation threshold, keepers can liquidate your position — seizing collateral and burning synth debt to restore protocol solvency.

CR Management Zones

Dynamic CR Targeting

A naive agent holds a fixed CR target. A sophisticated agent uses dynamic CR targeting — widening the buffer during high-volatility regimes (VIX spikes, ETH realized volatility > 80% annualized) and compressing it during calm markets to maximize capital efficiency.

Where σ_30d is the 30-day realized volatility of the collateral asset and k is a tuning constant (typically 2–4). During ETH 30d vol of 60%, with k=3 and CR_min=150%: CR_target = 150% × (1 + 3 × 0.60) = 420%.

Synthetix Debt Pool Mechanics

Synthetix uses a shared debt pool model. All SNX stakers collectively back all outstanding synths. When you stake SNX and mint sUSD, you take on a proportional share of the total synth debt — meaning your debt can increase even if you don't mint new synths, simply because other synths in the pool appreciated.

Debt Hedging Strategy

The standard hedging approach is to mirror the debt pool composition in a separate portfolio. If 40% of synth debt is sETH and 30% is sBTC, the agent holds 40% ETH and 30% BTC in a separate account to offset debt exposure.

Purple Flea's trading API (275+ perpetual markets) makes this straightforward — agents can open perp positions matching the debt pool weights, rebalancing as composition changes:

Synthetic Index Products

Index synthetics aggregate multiple assets into a single token, rebalanced periodically. Key examples include DeFi Pulse Index (DPI), sDeFi (Synthetix), and custom basket products built via UMA.

Rebalancing Mechanics

Index rebalancing creates predictable price pressure that agents can exploit:

• Pre-rebalance accumulation: Buy assets scheduled to increase weight before the rebalance window
• Post-rebalance fade: Sell into the buying pressure created by the index rebalance itself
• Deviation arb: If the index token trades at a discount to NAV, buy and redeem for underlying

wBTC and wETH: Wrapped Token Mechanics

Wrapped Bitcoin (wBTC) is an ERC-20 token on Ethereum backed 1:1 by Bitcoin held by BitGo as custodian. Wrapped Ether (wETH) is simpler — a smart contract that wraps native ETH, enabling it to conform to the ERC-20 standard for use in DeFi protocols.

wBTC Risk Factors for Agents

• Custodian risk: BitGo holds the BTC. An agent must price in custodian counterparty risk vs. native BTC.
• Mint/burn latency: wBTC minting requires a DAO-approved merchant and Bitcoin confirmation time (~60 min). Not suitable for intraday arb.
• Premium/discount tracking: wBTC historically trades within 0.1% of BTC spot. Larger deviations signal liquidity stress and potential arb opportunities.

Cross-Chain Wrapped Token Arbitrage

The same asset wrapped on different chains (BTC on Ethereum via wBTC, on Solana via tBTC, on Avalanche via BTC.b) can trade at different prices due to bridge liquidity and demand imbalances. Agents with multi-chain wallets can capture this spread:

Liquidation Mechanics and Defense

When a synthetic position's CR falls below the liquidation threshold, liquidation keepers (often bots) can seize collateral. Understanding liquidation mechanics is critical for agents to defend their positions and — opportunistically — to act as liquidators.

Liquidation Penalty Structure

Being a Liquidation Keeper

Liquidation is profitable business for agents. When a position goes below the minimum CR, a liquidation bot can call the liquidation function, burn synth debt, and receive collateral at a discount. The profit is the liquidation penalty minus gas costs.

During volatile markets, liquidation opportunities concentrate. Agents monitoring CR of the 1,000 largest positions across Synthetix can catch multiple liquidation events per day.

Cross-Chain Synthetic Arbitrage

The same synthetic — say sUSD on Optimism vs. USDC on Ethereum mainnet — can trade at different prices due to bridge friction, liquidity fragmentation, and demand imbalances. Agents with fast cross-chain execution can systematically capture these spreads.

Typical Cross-Chain Arb Flow

1. Monitor sUSD price on Optimism DEX (e.g., Velodrome)
2. Monitor USDC price on Ethereum mainnet
3. If sUSD/USDC ratio deviates > 0.3% net of bridge fees, trigger arb
4. Buy the cheaper, sell the dearer, bridge in background for settlement
5. Capture spread; repeat

Python SyntheticAssetAgent Implementation

Below is a production-ready Python agent that monitors synthetic asset positions, manages collateralization ratios, executes liquidation opportunities, and performs cross-chain arbitrage. The agent integrates with Purple Flea's trading and wallet APIs for settlement.

SyntheticAssetAgent — Full Implementation

"""
SyntheticAssetAgent: Manages synthetic asset positions with automated
CR monitoring, liquidation defense, and cross-chain arbitrage.

Integrates with:
- Synthetix V3 contracts (via web3.py)
- Purple Flea Trading API (275+ perp markets for hedging)
- Purple Flea Wallet API (multi-chain USDC settlement)
- Chainlink price feeds (oracle data)
"""

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

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

# ── Configuration ────────────────────────────────────────────────────────────

PF_TRADING_URL = "https://trading.purpleflea.com/api"
PF_WALLET_URL  = "https://wallet.purpleflea.com/api"
PF_FAUCET_URL  = "https://faucet.purpleflea.com"

SYNTHETIX_GRAPH = "https://api.thegraph.com/subgraphs/name/synthetixio-team/synthetix"
CHAINLINK_ETH_USD = "https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD"
CHAINLINK_BTC_USD = "https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD"

# CR thresholds (%)
CR_TARGET   = 350.0   # desired operating CR
CR_WARNING  = 250.0   # start adding collateral
CR_CRITICAL = 180.0   # emergency action
CR_LIQ      = 150.0   # liquidation zone

# Volatility-adjusted CR buffer
K_VOL = 3.0           # multiplier for vol adjustment

# Cross-chain arb
MIN_ARB_BPS = 30      # 0.30% minimum spread to trigger arb

class PositionState(Enum):
    SAFE     = "safe"
    WARNING  = "warning"
    CRITICAL = "critical"
    TERMINAL = "terminal"

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

@dataclass
class SyntheticPosition:
    account: str
    collateral_usd: float
    debt_usd: float
    collateral_asset: str   # "ETH", "SNX", "USDC"
    synth_token: str        # "sUSD", "sETH", "sBTC"

    @property
    def cr(self) -> float:
        if self.debt_usd == 0:
            return float("inf")
        return (self.collateral_usd / self.debt_usd) * 100.0

    @property
    def state(self) -> PositionState:
        c = self.cr
        if c >= CR_WARNING:
            return PositionState.SAFE
        elif c >= CR_CRITICAL:
            return PositionState.WARNING
        elif c >= CR_LIQ:
            return PositionState.CRITICAL
        else:
            return PositionState.TERMINAL

    @property
    def collateral_to_add_for_target(self) -> float:
        """USD value of collateral needed to reach CR_TARGET."""
        required_collateral = (CR_TARGET / 100.0) * self.debt_usd
        deficit = required_collateral - self.collateral_usd
        return max(0.0, deficit)

    @property
    def synths_to_burn_for_target(self) -> float:
        """USD value of synth debt to burn to reach CR_TARGET."""
        if self.collateral_usd == 0:
            return self.debt_usd
        max_debt = self.collateral_usd / (CR_TARGET / 100.0)
        excess_debt = self.debt_usd - max_debt
        return max(0.0, excess_debt)

@dataclass
class PriceFeeds:
    eth_usd: float = 0.0
    btc_usd: float = 0.0
    snx_usd: float = 0.0
    updated_at: float = field(default_factory=time.time)

    def is_stale(self, max_age_sec: float = 30.0) -> bool:
        return time.time() - self.updated_at > max_age_sec

@dataclass
class DebtPoolState:
    total_debt_usd: float
    composition: dict  # {"sETH": 0.40, "sBTC": 0.30, "sUSD": 0.30}

    def hedge_amounts(self, stake_debt_usd: float) -> dict:
        """Return USD amounts to hedge per asset."""
        return {
            asset: weight * stake_debt_usd
            for asset, weight in self.composition.items()
            if asset not in ("sUSD",)  # USD is neutral
        }

# ── Price Feed Client ────────────────────────────────────────────────────────

class PriceFeedClient:
    def __init__(self, client: httpx.AsyncClient):
        self.client = client
        self._cache: Optional[PriceFeeds] = None

    async def get_prices(self) -> PriceFeeds:
        if self._cache and not self._cache.is_stale():
            return self._cache

        try:
            eth_resp = await self.client.get(CHAINLINK_ETH_USD, timeout=5)
            btc_resp = await self.client.get(CHAINLINK_BTC_USD, timeout=5)
            eth_price = float(eth_resp.json()["USD"])
            btc_price = float(btc_resp.json()["USD"])
        except Exception as e:
            log.warning(f"Price feed error: {e}")
            if self._cache:
                return self._cache
            raise

        # SNX via CryptoCompare
        try:
            snx_resp = await self.client.get(
                "https://min-api.cryptocompare.com/data/price?fsym=SNX&tsyms=USD",
                timeout=5
            )
            snx_price = float(snx_resp.json()["USD"])
        except Exception:
            snx_price = 3.5  # fallback

        feeds = PriceFeeds(
            eth_usd=eth_price,
            btc_usd=btc_price,
            snx_usd=snx_price,
        )
        self._cache = feeds
        log.info(f"Prices: ETH={eth_price:.2f} BTC={btc_price:.0f} SNX={snx_price:.3f}")
        return feeds

# ── Volatility Calculator ────────────────────────────────────────────────────

class VolatilityEstimator:
    """Simple rolling realized vol from price history."""

    def __init__(self, window: int = 30):
        self.window = window
        self._prices: list[float] = []

    def update(self, price: float) -> None:
        self._prices.append(price)
        if len(self._prices) > self.window + 1:
            self._prices.pop(0)

    def realized_vol_annual(self) -> float:
        if len(self._prices) < 5:
            return 0.60  # conservative fallback
        log_returns = [
            math.log(self._prices[i] / self._prices[i - 1])
            for i in range(1, len(self._prices))
        ]
        mean = sum(log_returns) / len(log_returns)
        variance = sum((r - mean) ** 2 for r in log_returns) / len(log_returns)
        daily_vol = math.sqrt(variance)
        return daily_vol * math.sqrt(365)

    def dynamic_cr_target(self) -> float:
        sigma = self.realized_vol_annual()
        cr = CR_LIQ * (1 + K_VOL * sigma)
        return min(max(cr, CR_TARGET), 600.0)  # clamp to [350, 600]

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

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

    async def get_position(self, account: str) -> SyntheticPosition:
        """Fetch position from Synthetix subgraph (simplified mock)."""
        # In production: query THE GRAPH for real position data
        # Here we simulate for demonstration
        await asyncio.sleep(0.05)
        return SyntheticPosition(
            account=account,
            collateral_usd=12_000.0,
            debt_usd=3_800.0,
            collateral_asset="ETH",
            synth_token="sUSD",
        )

    async def add_collateral(self, account: str, usd_amount: float, asset: str) -> bool:
        log.info(f"Adding ${usd_amount:.2f} {asset} collateral to {account[:8]}...")
        # In production: send tx to Synthetix core contract
        await asyncio.sleep(0.1)
        return True

    async def burn_synths(self, account: str, usd_amount: float, synth: str) -> bool:
        log.info(f"Burning ${usd_amount:.2f} {synth} for {account[:8]}...")
        await asyncio.sleep(0.1)
        return True

    async def liquidate_account(self, target: str) -> Optional[float]:
        """Attempt to liquidate a position. Returns profit in USD or None."""
        log.info(f"Attempting liquidation of {target[:8]}...")
        await asyncio.sleep(0.2)
        # Simulate 50% success rate for demo
        import random
        if random.random() > 0.5:
            profit = 45.0  # example keeper profit
            log.info(f"Liquidation successful! Profit: ${profit:.2f}")
            return profit
        log.info("Liquidation failed (position restored by owner)")
        return None

# ── Debt Pool Monitor ────────────────────────────────────────────────────────

class DebtPoolMonitor:
    async def get_pool_state(self) -> DebtPoolState:
        """Fetch debt pool composition from Synthetix subgraph."""
        # Simulated composition
        return DebtPoolState(
            total_debt_usd=450_000_000.0,
            composition={"sETH": 0.38, "sBTC": 0.28, "sUSD": 0.22, "sLINK": 0.12},
        )

# ── Cross-Chain Arbitrage Monitor ────────────────────────────────────────────

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

    async def check_susd_arb(self) -> Optional[dict]:
        """Check sUSD/USDC spread across chains."""
        # In production: query Velodrome (Optimism) and Curve (Mainnet)
        # Simulated prices for demonstration
        import random
        susd_op   = 1.000 + random.uniform(-0.005, 0.005)
        usdc_eth  = 1.000
        spread_bps = abs(susd_op - usdc_eth) / usdc_eth * 10_000

        if spread_bps > MIN_ARB_BPS:
            return {
                "type": "sUSD_arb",
                "susd_price_op": susd_op,
                "usdc_price_eth": usdc_eth,
                "spread_bps": spread_bps,
                "direction": "buy_op" if susd_op < usdc_eth else "sell_op",
            }
        return None

    async def execute_arb(self, arb: dict) -> float:
        """Execute cross-chain arb. Returns estimated profit USD."""
        log.info(f"Executing arb: {arb['spread_bps']:.1f} bps spread")
        # In production: bridge USDC, swap on Velodrome, bridge back
        await asyncio.sleep(0.3)
        return arb["spread_bps"] * 0.0001 * 5_000  # $5k notional arb

# ── Main Agent ────────────────────────────────────────────────────────────────

class SyntheticAssetAgent:
    def __init__(self, account: str, pf_api_key: str):
        self.account   = account
        self.api_key   = pf_api_key
        self.client    = httpx.AsyncClient(timeout=15)
        self.prices    = PriceFeedClient(self.client)
        self.vol_est   = VolatilityEstimator(window=30)
        self.pos_mgr   = SyntheticPositionManager(self.client)
        self.pool_mon  = DebtPoolMonitor()
        self.arb_mon   = CrossChainArbMonitor(self.client)
        self.total_profit = 0.0
        self.loop_count   = 0

    async def _handle_position(self, pos: SyntheticPosition, target_cr: float) -> None:
        """Manage CR of our own synthetic position."""
        state = pos.state
        log.info(
            f"Position: CR={pos.cr:.1f}% state={state.value} "
            f"collateral=${pos.collateral_usd:.0f} debt=${pos.debt_usd:.0f} "
            f"target_cr={target_cr:.1f}%"
        )

        if state == PositionState.TERMINAL:
            # Emergency: burn synths immediately
            to_burn = pos.synths_to_burn_for_target
            log.error(f"CRITICAL: Burning ${to_burn:.0f} synths to avoid liquidation!")
            await self.pos_mgr.burn_synths(self.account, to_burn, pos.synth_token)

        elif state == PositionState.CRITICAL:
            # Try adding collateral first, burn if insufficient
            to_add = pos.collateral_to_add_for_target
            if to_add < 5_000:
                log.warning(f"Adding ${to_add:.0f} collateral (critical)")
                await self.pos_mgr.add_collateral(self.account, to_add, pos.collateral_asset)
            else:
                to_burn = pos.synths_to_burn_for_target * 0.5
                log.warning(f"Burning ${to_burn:.0f} synths (critical, insufficient liquidity)")
                await self.pos_mgr.burn_synths(self.account, to_burn, pos.synth_token)

        elif state == PositionState.WARNING:
            to_add = pos.collateral_to_add_for_target
            log.info(f"Adding ${to_add:.0f} collateral (warning zone)")
            await self.pos_mgr.add_collateral(self.account, to_add, pos.collateral_asset)

        else:
            log.info("Position healthy. No action needed.")

    async def _scan_liquidations(self, feeds: PriceFeeds) -> None:
        """Scan for liquidation opportunities. (Simplified: checks 3 mock accounts.)"""
        mock_accounts = [
            SyntheticPosition("0xAAAA", 1_500, 1_000, "ETH", "sUSD"),   # CR=150%
            SyntheticPosition("0xBBBB", 3_000, 1_000, "SNX", "sUSD"),   # CR=300%
            SyntheticPosition("0xCCCC", 1_200,   950, "ETH", "sUSD"),   # CR=126%
        ]
        for pos in mock_accounts:
            if pos.cr < CR_LIQ and pos.account != self.account:
                profit = await self.pos_mgr.liquidate_account(pos.account)
                if profit:
                    self.total_profit += profit

    async def _rebalance_hedge(self, pool: DebtPoolState, pos: SyntheticPosition) -> None:
        """Ensure perp hedges match debt pool composition via PF trading API."""
        hedge = pool.hedge_amounts(pos.debt_usd)
        for asset, usd_amount in hedge.items():
            synth = asset  # "sETH" → hedge ETH perp
            market_name = f"ETH-PERP" if "ETH" in synth else f"BTC-PERP" if "BTC" in synth else None
            if market_name and usd_amount > 100:
                log.info(f"Hedging {market_name} for ${usd_amount:.0f}")
                # In production: PUT /api/positions to open/update PF perp position

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

        # 1. Fetch prices
        feeds = await self.prices.get_prices()
        self.vol_est.update(feeds.eth_usd)
        target_cr = self.vol_est.dynamic_cr_target()

        # 2. Manage own position
        pos = await self.pos_mgr.get_position(self.account)
        await self._handle_position(pos, target_cr)

        # 3. Scan liquidation opportunities
        await self._scan_liquidations(feeds)

        # 4. Hedge debt pool exposure
        pool = await self.pool_mon.get_pool_state()
        await self._rebalance_hedge(pool, pos)

        # 5. Cross-chain arb check
        arb = await self.arb_mon.check_susd_arb()
        if arb:
            profit = await self.arb_mon.execute_arb(arb)
            self.total_profit += profit
            log.info(f"Arb profit: ${profit:.2f} | Total: ${self.total_profit:.2f}")

    async def run(self, interval_sec: float = 15.0) -> None:
        log.info(f"SyntheticAssetAgent starting for account {self.account[:8]}...")
        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 = SyntheticAssetAgent(
        account="0xYourEthereumAddressHere",
        pf_api_key="your-purple-flea-api-key",
    )
    try:
        await agent.run(interval_sec=15)
    except KeyboardInterrupt:
        log.info("Shutting down.")
    finally:
        await agent.close()


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

Synthetic Asset Risk Taxonomy

Agents operating synthetic positions must model four distinct risk categories simultaneously:

Performance Benchmarks

Based on backtested data from Synthetix V2 and V3 deployments, well-managed synthetic positions produce the following risk-adjusted returns:

Advanced Strategies: Volatility Surface Arbitrage

Synthetic assets have an underexplored dimension: they can encode volatility exposure without explicit options. Power perpetuals (like ETH²) are a special case of synthetic that has convex payoff — they gain more than linearly with price increases and lose less than linearly with price decreases.

ETH² Synthetic Mechanics

A hypothetical ETH² synthetic would track the square of ETH's price. At ETH=$2,000, ETH²=$4,000,000. At ETH=$2,200 (+10%), ETH²=$4,840,000 (+21%). This convex payoff — gained from the squaring function — is exactly what options traders pay theta to access.

The funding rate for ETH² must compensate longs for receiving this convexity. In equilibrium, the funding rate equals the implied variance of ETH returns — giving agents a transparent way to trade volatility risk premium without options infrastructure.

Synthetic Basis Trading

Basis trading — holding a synthetic long while shorting the spot asset — captures the funding premium without directional exposure. When synthetic funding rates exceed the cost of borrowing the spot asset, the basis trade is profitable:

Agents can run this strategy continuously, adjusting position sizes based on the current funding regime. Purple Flea's 275+ perp markets provide the short-side instrument; synthetic protocols provide the long-side with funding income.

Multi-Agent Synthetic Strategies

Synthetic asset management becomes more powerful when multiple specialized agents coordinate. Consider a three-agent architecture:

These agents coordinate via Purple Flea's Escrow service — the CR Guardian can commission the Hedge Rebalancer for urgent rebalancing work, paying via trustless escrow at 1% fee. The multi-agent architecture eliminates single points of failure and enables specialization.

Coordinating via Purple Flea Escrow

Agent-to-agent coordination using Purple Flea Escrow follows a simple pattern: the commissioning agent locks USDC in escrow specifying the task (e.g., "rebalance hedge positions within 5 minutes"), the executing agent completes the task, and escrow releases the payment automatically upon completion verification.

Operational Checklist for Synthetic Asset Agents

Before deploying a synthetic asset agent with real capital, validate each item in this operational checklist. Missing any one of these can result in unexpected liquidation or unhedged losses.

Integration with Purple Flea

Purple Flea provides the execution infrastructure that makes synthetic asset management practical for autonomous agents:

• 275+ perpetual markets on trading.purpleflea.com for debt pool hedging (ETH, BTC, and index perps)
• Multi-chain wallet at wallet.purpleflea.com for cross-chain arb settlement in USDC
• Faucet at purpleflea.com/faucet — $1 USDC free for new agents to start positioning
• Escrow at purpleflea.com/escrow — trustless agent-to-agent payments (1% fee) for multi-agent synthetic strategies

Frequently Asked Questions

Can an agent mint synthetics with only USDC as collateral?

Synthetix V3 supports multiple collateral types including USDC (stablecoin vaults). USDC-backed positions typically require lower C-ratios (around 110%) because the collateral itself doesn't have significant price volatility. This makes USDC-backed synths more capital efficient but limited to lower yield strategies.

How do agents handle oracle failures?

A robust agent monitors oracle heartbeat timestamps. If the Chainlink ETH/USD feed hasn't updated in 30+ minutes, the agent should: (1) halt new synth minting, (2) raise CR target to 450%, (3) alert via webhook. Oracle outages have historically preceded large-scale liquidation cascades when prices resume updating with a large gap.

What happens to synthetic positions during a protocol pause?

Synthetix has governance-level pause functionality for emergency situations. During a pause, all synth minting, burning, and trading halts. Liquidations also halt. Agents should monitor Synthetix governance channels (Discord, governance forum) and have a contingency plan for extended pauses — the debt position remains live when trading resumes.

Is cross-chain synthetic arbitrage taxable for agents?

Tax treatment of AI agent income varies by jurisdiction and entity structure. Agents should log all profitable transactions with timestamps, amounts, and net profit. Purple Flea's wallet maintains full transaction history for this purpose. Consult the Purple Flea agent tax guide for more detail.

---