agiprolabs/claude-trading-skills

# Backtrader

Backtrader is a Python event-driven backtesting framework that processes data bar-by-bar, simulating realistic execution with a built-in broker, order management, and position tracking. Unlike vectorized frameworks (vectorbt, pandas), backtrader walks through history one bar at a time, firing callbacks that let you implement complex order logic that depends on previous fills, partial executions, and conditional brackets.

## Event-Driven vs Vectorized

| Aspect | Backtrader (event-driven) | vectorbt (vectorized) |
|---|---|---|
| Execution model | Bar-by-bar callbacks | Whole-array operations |
| Speed | Slower (Python loop) | Fast (NumPy/Numba) |
| Order types | Market, limit, stop, stop-limit, bracket, OCO | Market only (native) |
| Realism | Built-in broker with commission, slippage, margin | Manual slippage modeling |
| Multi-timeframe | Native resampledata | Manual alignment |
| Best for | Complex strategies, bracket orders, portfolio | Fast parameter sweeps, simple signals |

# Birdeye API — Solana Market Data

Birdeye aggregates market data across all Solana DEXes (and 13 other chains). Prices, OHLCV candles, trade history, token metadata, security info, and wallet analytics. Primary data source for Solana token research and historical analysis.

**Note**: For real-time trading systems, use Yellowstone gRPC (see `yellowstone-grpc` skill). Birdeye is best for historical data, research, and analysis workflows.

## Quick Start

### 1. Get an API Key

Sign up at [birdeye.so](https://birdeye.so) — free tier: 30K compute units/month, 1 req/sec.

```bash
[Credential-related source omitted]

# CoinGecko API Skill

Query the CoinGecko API for comprehensive crypto market data — prices, historical
charts, exchange volumes, trending tokens, global stats, and category breakdowns.
The free tier requires no API key and supports 30 calls/min.

## When to Use This Skill

- **Macro analysis**: Global market cap, BTC dominance, total volume trends
- **Historical data**: Daily/hourly OHLCV going back years (not minutes-level)
- **Cross-exchange comparisons**: Exchange volume rankings and trust scores
- **Trending/discovery**: What tokens are trending on CoinGecko in the last 24h
- **Category analysis**: Compare DeFi vs L1 vs meme coin market caps
- **Token research**: Full metadata including links, description, community stats

# Cointegration Analysis

Cointegration testing identifies pairs of assets that share a long-run equilibrium
relationship, enabling statistical arbitrage and pairs trading strategies.

## What Is Cointegration?

Two price series are **cointegrated** when they are individually non-stationary
(random walks) but a linear combination of them is stationary (mean-reverting).
Intuitively, the prices may wander apart temporarily but are pulled back to an
equilibrium spread over time.

### Cointegration vs Correlation

# Copy Trading

Wallet evaluation, monitoring, and copy-trade strategy design for Solana DEX trading. Identify profitable wallets on-chain, evaluate whether their edge is real and replicable, monitor their activity in real time, and execute proportionally-sized trades with independent risk controls.

## What Copy Trading Means on Solana

Copy trading is the practice of monitoring one or more wallets that have demonstrated consistent profitability and replicating their trades in your own wallet. On Solana, every DEX swap is publicly visible on-chain within seconds, making it technically feasible to detect and follow any wallet's activity.

### How It Differs from TradFi Copy Trading

| Dimension | TradFi (eToro, etc.) | Solana On-Chain |
|-----------|---------------------|-----------------|
| Data source | Platform-reported P&L | Verifiable on-chain transactions |
| Latency | Minutes to hours | Seconds (websocket) to sub-second (gRPC) |

# Correlation Analysis

Cross-asset correlation analysis for diversification assessment, risk management, pairs trading signal generation, and portfolio construction.

## Why Correlation Matters

Correlation measures how assets move together. In crypto markets this is critical for:

- **Diversification**: holding correlated assets provides no diversification benefit — you are effectively holding one concentrated position
- **Risk management**: portfolio risk depends on the correlation structure, not just individual asset volatility
- **Pairs trading**: highly correlated assets that temporarily diverge create mean-reversion opportunities
- **Portfolio construction**: optimal allocation requires accurate correlation estimates
- **Crash protection**: understanding tail dependence reveals whether assets crash together

# Cost Basis Engine

Compute cost basis for crypto trades using multiple accounting methods and compare the resulting tax liability across methods. This skill handles the full complexity of on-chain activity: partial sells, token migrations, airdrops, staking rewards, LP entry/exit, and multi-hop swaps.

> **Disclaimer**: This skill provides computational tools for informational purposes only. It does not constitute tax, legal, or financial advice. Consult a qualified tax professional for your specific situation. Tax law varies by jurisdiction and changes frequently.

## Prerequisites

- Python 3.10+
- No external dependencies required (standard library only)
- Trade history as a list of dicts or CSV with columns: `date`, `action`, `token`, `quantity`, `price_usd`, `fee_usd`

## Methods Overview

# Crypto Tax Export

Export trade history and tax calculations for tax software and IRS filing. Handles Solana-specific transaction types (Jupiter swaps, LP operations, staking rewards, airdrops) and generates CSVs compatible with Koinly, CoinTracker, CoinLedger, TokenTax, TurboTax/TaxAct, and IRS Form 8949.

> **Disclaimer:** This skill provides data formatting and calculation tools only. It does not constitute tax advice. Consult a qualified tax professional for guidance on reporting cryptocurrency transactions. Tax laws vary by jurisdiction and change frequently.

## Prerequisites

- Python 3.10+
- Trade history data (from internal trade journal, on-chain history, or exchange exports)
- For on-chain reconciliation: Solana RPC or Helius API access (see `helius-api` skill)
- For cost basis: historical price data (see `birdeye-api` or `coingecko-api` skills)

## Capabilities

# Custom Crypto Indicators

## Why Standard TA Falls Short for Crypto

Traditional technical analysis was built for equities and forex — markets with
fixed supply, regulated exchanges, and institutional-dominated order flow.
Crypto markets have unique properties that demand purpose-built indicators:

- **On-chain transparency**: Every transaction is public. We can measure real
  economic activity, not just price and volume on a single exchange.
- **Supply mechanics**: Fixed or programmatic supply schedules make
  supply-side analysis (velocity, holder distribution) meaningful.
- **Derivatives dominance**: Perpetual futures funding rates and open interest
  often drive spot price, not the other way around.

# DeFiLlama API — DeFi Macro Analytics

DeFiLlama is the largest DeFi TVL aggregator. Its API is **free with no authentication** for most endpoints — covering TVL, token prices, DEX volumes, fees/revenue, stablecoins, and bridges across all chains.

## Quick Start

```python
import httpx

# No auth required for free endpoints
BASE = "https://api.llama.fi"
COINS = "https://coins.llama.fi"

# Current TVL for a protocol

# DEX Execution — Solana Swap Execution via Jupiter

Execute token swaps on Solana through Jupiter, the dominant DEX aggregator routing across Raydium, Orca, Meteora, Phoenix, Lifinity, and 20+ other venues.

## Overview

Jupiter aggregates liquidity across all major Solana DEXes to find optimal swap routes. A single swap may split across multiple pools and hop through intermediate tokens to minimize price impact. The Jupiter v6 API handles route discovery, transaction building, and fee optimization — your code handles quoting, user confirmation, signing, and submission.

**Base URL**: `https://quote-api.jup.ag/v6`

## Execution Pipeline

Every swap follows this seven-step pipeline. Never skip steps 2-3 (display and confirm).

# DEX Pool Analysis — Solana AMM Pool Mechanics & Comparison

Solana's DEX ecosystem spans multiple AMM designs: constant-product pools (Raydium V4), concentrated liquidity (Raydium CLMM, Orca Whirlpool), and bin-based liquidity (Meteora DLMM). Each pool type has distinct fee structures, capital efficiency characteristics, and risk profiles. Understanding these differences is essential for selecting the best execution venue, evaluating liquidity quality, and identifying pool-level risks.

This skill covers:
- Pool type mechanics and fee structures across Solana DEXes
- Pool health metrics (TVL, volume efficiency, fee APR, LP count)
- Pool creation patterns (PumpFun graduation, manual creation)
- Best pool selection for trade execution
- Pool age and risk assessment

**Related skills**: See `lp-math` for AMM formulas, `liquidity-analysis` for depth assessment, `impermanent-loss` for LP risk, `slippage-modeling` for execution cost.

---

# DexScreener API — Free Multi-Chain DEX Data

DexScreener provides DEX pair data across 80+ chains with **no API key required**. Prices, volume, liquidity, transaction counts, and token profiles — all free. Best for quick lookups, cross-chain comparison, and lightweight monitoring.

## Quick Start

No authentication needed. Just make requests:

```python
import httpx

# Search for a token
resp = httpx.get("https://api.dexscreener.com/latest/dex/search", params={"q": "BONK"})
pairs = resp.json()["pairs"]

# Exit Strategies

Entries are easy, exits are everything. A mediocre entry with a disciplined exit will
outperform a perfect entry with no exit plan. This skill covers systematic, rule-based
exit methods for crypto and Solana token trading.

## Why Exits Matter

- **Entries** determine _if_ you participate. **Exits** determine _how much_ you keep.
- Most traders spend 90% of effort on entries and 10% on exits — invert this.
- Without defined exits you rely on emotion, which guarantees inconsistency.
- Every trade should have **three exits defined before entry**: stop loss, take profit,
  and trailing stop.

# Feature Engineering for Trading ML

Feature engineering is the single highest-leverage activity in building ML trading
models. Model selection (XGBoost vs. neural net vs. logistic regression) matters far
less than the quality and diversity of input features. A simple model on great
features will outperform a complex model on raw prices every time.

This skill covers constructing, validating, and selecting features from market data
for use in classification (signal-classification) and regression models targeting
crypto/Solana token trading.

## Why Features Beat Models

Raw OHLCV data is non-stationary, noisy, and high-dimensional. Models trained

# Fixed Income

> **Status: STUB** — This skill provides a basic bond calculator and an overview of planned capabilities. Full implementation is awaiting community contribution.

Fixed income analysis bridges traditional bond mathematics with DeFi lending rate modeling. Bond pricing fundamentals — present value of cash flows, yield curves, duration, and convexity — translate directly to analyzing DeFi lending protocols where depositors earn variable or fixed rates on crypto assets.

On Solana, lending protocols like Marginfi, Kamino, and Solend offer variable-rate lending/borrowing. Understanding term structure and rate dynamics helps optimize yield farming strategies and compare opportunities across protocols.

This skill is informational and analytical only. It does not provide financial advice or trading recommendations.

---

## Current Capabilities

# Helius API — Enhanced Solana RPC

Helius extends standard Solana RPC with parsed transaction history, a unified Digital Asset Standard (DAS) API, webhooks, and priority fee estimation. Essential for wallet analysis, token metadata, and transaction monitoring.

## Quick Start

### 1. Get an API Key

Sign up at [dashboard.helius.dev](https://dashboard.helius.dev) — free tier available (1M credits/mo, no card required).

```bash
[Credential-related source omitted]
```

# Impermanent Loss — Calculation, Modeling & Breakeven Analysis

Impermanent loss (IL) is the cost of providing liquidity to an automated market maker (AMM) relative to simply holding the tokens. When you deposit tokens into a liquidity pool, the AMM continuously rebalances your position as prices move. This rebalancing always works against you — selling winners and buying losers — resulting in less value than if you had just held the original tokens.

## Why "Impermanent"?

IL is called "impermanent" because it only crystallizes when you withdraw. If prices return to their original ratio, IL reverts to zero. However, in practice, prices rarely return exactly, so IL is usually quite real.

## Key Insight

IL is a function of the **price ratio change**, not the absolute price. A token moving from $1 to $2 produces the same IL as a token moving from $100 to $200 — both are a 2x ratio change. Direction does not matter either: a 2x increase and a 0.5x decrease produce the same IL magnitude.

## Constant-Product IL Formula

# Jito Bundle Submission for Solana

Jito bundles allow you to submit up to 5 Solana transactions that execute **atomically** — either all land in the same slot or none do. This is the primary mechanism for MEV protection and competitive transaction execution on Solana. Approximately 85%+ of Solana validators run the Jito-modified client, making bundles the standard for reliable, front-run-resistant execution.

> **EXECUTION SKILL — SAFETY WARNING**: Submitting bundles spends real SOL on tips. Always test with `--demo` mode first. Never submit bundles with real funds without explicit confirmation. Default to simulation/dry-run in all scripts and examples.

## When to Use Bundles

| Scenario | Use Bundle? | Why |
|----------|-------------|-----|
| Swap on illiquid token | Yes | Prevents sandwich attacks |
| Multi-step arbitrage | Yes | Atomic execution prevents partial fills |
| Liquidation | Yes | Competitive — tip determines priority |
| Simple SOL transfer | No | Priority fees are cheaper and sufficient |

# Kalshi API

CFTC-regulated US event exchange. USD-denominated binary contracts settle at $1.00 (YES wins) or $0.00 (NO wins). REST + WebSocket, RSA-PSS authentication on every request.

For contract semantics and settlement rules, see the `kalshi-weather-markets` and `kalshi-crypto-index-markets` skills. For strategy, sizing, and backtesting, see `prediction-market-strategy`.

---

> **VERIFY BEFORE CODING.**
> The Kalshi API has broken backward compatibility before: the host changed (old `trading-api.kalshi.com` → dead), and the order schema changed (integer cents → dollar strings). Always smoke-test signing and order bodies against a live response before shipping.
>
> Canonical sources:
> - API reference: <https://docs.kalshi.com> (legacy mirror: <https://trading-api.readme.io>)
> - Official Python starter: <https://github.com/Kalshi/kalshi-starter-code-python>

# Kalshi Crypto & Index Range Markets

Kalshi lists daily (and for crypto, hourly) **range bracket markets** on the level of four liquid underlyings: S&P 500, Nasdaq-100, Bitcoin, and Ethereum. The math is the same partition-and-Gaussian framework as weather brackets — the variable is just price/return and σ comes from the underlying's realized or implied volatility, not a temperature model.

> Cross-references: for Kalshi API mechanics see `kalshi-api`; for the strategy, sizing, and backtesting framework see `prediction-market-strategy`; for the temperature counterpart see `kalshi-weather-markets`; for the shared bracket/overround formulas see `prediction-markets/references/brackets-and-settlement.md`.

---

## Series & Market-Type Mapping

```python
SERIES_MARKET = {
    "KXINX":       "index",   # S&P 500 index level
    "KXNASDAQ100": "index",   # Nasdaq-100 index level

# Kalshi Weather Markets — Daily Temperature High/Low

Kalshi lists daily high and low temperature options for ~20 US cities as binary contracts that settle YES ($1.00) or NO ($0.00). This skill covers the market structure, the forecast-to-probability map, exact settlement mechanics, and hard-won pitfalls. It builds on the exchange layer — for Kalshi API mechanics (host, auth, orders, order book, candlesticks) see the `kalshi-api` skill; for strategy, sizing, and backtesting see `prediction-market-strategy`.

## Contract Types

### Brackets — `B<center>`

A bracket ticker `B<center>` is a **2°F-wide, both-ends-inclusive** window.

- `B74.5` covers the **two integers {74, 75}°F**.
- YES iff the settled temperature is exactly 74 **or** 75.
- Brackets in one event are mutually exclusive and (with two open tail markets) collectively exhaustive.
- Their YES prices sum to the **overround** (fair = 1.0; > 1.0 = aggregate overpricing).

# Kelly Criterion — Optimal Bet Sizing

The Kelly criterion is the mathematically optimal bet size that maximizes long-term geometric growth of capital. Developed by John Kelly at Bell Labs in 1956, it answers a precise question: given a known edge, what fraction of your bankroll should you risk to maximize the compounding rate?

**Core insight**: Betting too small leaves growth on the table. Betting too large increases ruin risk and actually *reduces* long-term growth. Kelly finds the exact optimum between these extremes.

**Practical insight**: You should almost never use full Kelly. Estimation error in your edge means full Kelly will overbets in practice. Use fractional Kelly (0.25x to 0.5x) for real trading.

---

## The Kelly Formula

For a binary outcome (win or lose):

# Liquidity Analysis — DEX Depth Assessment for Solana Tokens

Liquidity analysis answers three critical questions before every trade: **Can I get in at a reasonable price?** **Can I get out when I need to?** and **Is this pool safe?** Without it, you risk excessive slippage, failed exits, and rug pulls.

## Why Liquidity Analysis Matters

**Position sizing**: Maximum position size is bounded by available liquidity. A $10K position in a pool with $20K TVL will move the price significantly. Rule of thumb: keep trade size under 2% of pool depth to limit slippage below 1%.

**Execution cost**: Slippage is a direct cost. On a 5 SOL buy, the difference between 0.3% and 3% slippage is real money lost on every entry and exit.

**Rug risk detection**: Thin liquidity, single pools, unlocked LP tokens, and newly created pools are warning signs. Liquidity analysis catches these before you enter.

**Exit planning**: Entry liquidity may differ from exit liquidity. If LP is unlocked and owned by one wallet, it can be pulled at any time.

# LP Math — AMM Liquidity Provision Mathematics

Automated Market Makers (AMMs) replace traditional orderbooks with liquidity pools. Instead of matching buyers and sellers, a mathematical formula determines prices based on reserve ratios. Liquidity providers (LPs) deposit both assets into a pool and earn fees from every trade.

Understanding the math behind AMMs is essential for:
- Evaluating whether providing liquidity is profitable after impermanent loss
- Estimating price impact before executing large trades
- Comparing capital efficiency across pool types (constant product vs concentrated)
- Calculating expected fee revenue for a given pool position

**Related skills**: See `impermanent-loss` for IL calculations, `yield-analysis` for LP yield modeling, `liquidity-analysis` for pool depth assessment.

---

# Market Microstructure — DEX Orderflow Analysis

## Overview

Market microstructure on Solana DEXes differs fundamentally from traditional finance.
There are no orderbooks on AMMs — every trade is a swap against a liquidity pool. Yet
trade flow analysis remains powerful: the sequence, size, and direction of swaps reveal
accumulation, distribution, whale activity, and wash trading patterns.

This skill covers:
- **Trade classification** — identifying buys vs sells from swap direction
- **Volume profiles** — time-based and size-based breakdowns
- **Buyer/seller pressure** — ratio metrics, net flow, trade count asymmetry
- **Trade size distribution** — whale detection, retail vs institutional flow

# Market Microstructure (Traditional)

Market microstructure studies how orders become trades and how trades become
prices.  Understanding these mechanics is essential for execution optimization,
market making, and detecting informed flow.  This skill covers limit order book
(LOB) theory as applied to crypto markets on centralized exchanges, and compares
LOB mechanics to the AMM-based structure of DEXes.

## Core Concepts

| Concept | What It Tells You |
|---|---|
| **Bid-ask spread** | Cost of immediacy — how much you pay to trade now vs later |
| **Price impact** | How your order moves the market price |

# Mean Reversion

Mean reversion is the statistical tendency for prices, spreads, or other financial variables to return toward a long-run average after deviating from it. A mean-reverting series overshoots its mean, then corrects back -- creating predictable oscillations that can be traded.

## When Mean Reversion Works

- **Ranging markets**: Sideways price action with clear support/resistance
- **Pairs spreads**: Spread between cointegrated assets reverts to equilibrium
- **Oversold/overbought extremes**: RSI, Bollinger Band, or z-score extremes in stationary series
- **Funding rate arbitrage**: Perpetual funding rates revert to baseline
- **Stablecoin depegs**: Classic mean-reversion opportunity (peg = known mean)
- **Post-dump recovery**: Brief mean-reversion windows after initial PumpFun dumps

## When Mean Reversion Fails

# MEV Analysis for Solana DEX Trading

Maximal Extractable Value (MEV) is the profit that validators and searchers can extract by reordering, inserting, or censoring transactions within a block. On Solana DEXes, MEV primarily manifests as sandwich attacks against swaps, cross-DEX arbitrage, and liquidation extraction. This skill covers detection, estimation, and protection strategies.

## What Is MEV on Solana?

MEV occurs when someone with transaction ordering power profits at other traders' expense. On Solana, the MEV supply chain works as follows:

1. **You submit a swap** through an RPC endpoint
2. **Searchers observe** your transaction (via RPC forwarding, block engine access, or leader TPU sniffing)
3. **Searcher constructs a profitable bundle** (e.g., sandwich your swap)
4. **Bundle submitted to Jito block engine** with a tip to the validator
5. **Validator includes the bundle** in the block, earning the tip
6. **You receive worse execution**; the searcher profits the difference

# OHLCV Processing — Market Data Preparation

Clean, consistent OHLCV data is the foundation of every trading analysis. Garbage in, garbage out — a single anomalous candle can trigger false signals, corrupt indicator calculations, and produce misleading backtest results. This skill covers the full data preparation pipeline: validation, cleaning, resampling, normalization, and multi-source merging.

**Why this matters**: Crypto OHLCV data is messier than traditional markets. 24/7 trading means no official close, DEX aggregators disagree on prices, low-liquidity tokens produce impossible candles, and API outages create gaps. Every analysis workflow should start with this pipeline.

## Quick Start

### 1. Install Dependencies

```bash
uv pip install pandas numpy httpx
```

# Options Pricing

> **Status: STUB** — This skill provides a basic Black-Scholes implementation and an overview of planned capabilities. Full implementation is awaiting community contribution.

Options pricing is the quantitative foundation of derivatives trading. For crypto markets, options on BTC and ETH trade actively on Deribit, Lyra, and Aevo, while Solana options are emerging on platforms like Zeta Markets and PsyOptions. Understanding pricing models, implied volatility surfaces, and Greeks is essential for hedging, volatility trading, and constructing structured products.

This skill is informational and analytical only. It does not provide financial advice or trading recommendations.

---

## Current Capabilities

This stub includes a working Black-Scholes calculator with Greeks computation and a basic implied volatility solver. See `scripts/black_scholes.py` for the implementation.

# pandas-ta — Technical Analysis for Crypto Markets

pandas-ta is a Python library that extends pandas DataFrames with 130+ technical analysis indicators accessible via `df.ta`. It covers trend, momentum, volatility, volume, and overlap indicator categories — all callable with a single method on any OHLCV DataFrame.

## Installation

```bash
uv pip install pandas-ta pandas httpx
```

## Quick Start

```python
import pandas as pd

# Polymarket API

Polymarket is a **prediction market on Polygon mainnet**. Every market is a pair of YES/NO **ERC-1155** tokens issued by the Conditional Token Framework (CTF), collateralized 1:1 in USDC. Off-chain CLOB matching, on-chain settlement, **zero taker fees**. Prices are in [0.00, 1.00] USDC; YES + NO ≈ 1.0 per market.

---

> **Before you write any API code — read the live docs first.**
>
> - Docs: https://docs.polymarket.com
> - Official Python SDK: https://github.com/Polymarket/py-clob-client
>
> Polymarket endpoints and auth flows have changed without notice. Prefer the official `py-clob-client` SDK over hand-rolled HTTP; it handles EIP-712 derivation, API credential management, and order signing. Only hand-roll when the SDK doesn't expose what you need.

---

# Portfolio Analytics

Compute portfolio-level performance metrics from equity curves and trade logs. Covers return metrics, risk metrics, risk-adjusted ratios, drawdown analysis, rolling windows, benchmark comparison, trade-level statistics, and automated HTML report generation via quantstats.

## When to Use This Skill

- After backtesting a strategy (e.g., from `vectorbt` or `strategy-framework`)
- Comparing multiple strategies or parameter sets side-by-side
- Generating investor-ready performance reports
- Evaluating live trading performance against benchmarks
- Assessing risk-adjusted returns for portfolio allocation decisions

## Prerequisites

# Position Sizing

Position sizing is the single most important risk management decision in trading. Your entry signal determines direction; your position size determines survival. A mediocre strategy with proper sizing will outperform a great strategy with reckless sizing over any meaningful time horizon.

**Core principle**: Size determines survival, not entries. Two traders with the same signals but different sizing will have wildly different outcomes. The one who sizes conservatively survives drawdowns and compounds capital; the one who oversizes blows up.

## Methods Covered

| Method | Best For | Key Input |
|--------|----------|-----------|
| Fixed Fractional | General trading, most recommended | Account risk % |
| Volatility-Adjusted | Volatile markets, multi-asset | ATR or realized vol |
| Kelly Criterion | Quantified edge with track record | Win rate + payoff ratio |
| Liquidity-Constrained | Low-liquidity Solana tokens | Pool depth |

# Prediction-Market Trading Doctrine

Hard-won operational knowledge from a live Kalshi campaign (Aug–Sep 2026:
crypto/commodity maker ladders, regime tilts, tennis dust vacuum — all
falsified honestly, infrastructure open-sourced). Reference implementation: https://github.com/agiprolabs/kalshi-stack.
Complements `prediction-market-strategy` (edge selection/sizing) — this skill
covers the OPERATIONAL side: validating, executing, and killing strategies
against a live venue without losing more than the lesson costs.

## The prime directive

Every strategy decision is evidence-gated: backtest → paper → live micro-probe
→ ratchet. Each stage has a PRE-DECLARED kill condition with correctly
calibrated probability math, written down BEFORE the data arrives. When a

# Prediction Market Strategy

Binary prediction markets price contracts as probabilities. This skill covers the *strategy, sizing, and validation* layer that applies across all venues and market types. API mechanics live in `kalshi-api` / `polymarket-api`; contract semantics and settlement live in `kalshi-weather-markets` / `kalshi-crypto-index-markets`. This is the strategy/sizing/validation layer that applies across all of them.

## Core Thesis

**Price = implied probability.** A contract priced at $0.18 claims an 18% chance of resolving YES. Brackets in a series sum to just above $1.00 — the overround is the house margin (roughly 5–8% for weather markets on Kalshi).

**Takers systematically lose; makers systematically win.** Across 300k+ Kalshi contracts, the average pre-fee return is ≈ −20%, concentrated in takers (market-order users) and in longshot buyers. Makers (resting limit orders) earn positive returns. On Polymarket (588M+ trades), the top ~1% of accounts capture ~76.5% of profit, predominantly by resting limit orders. This is the foundational result.

**Favorite–longshot bias is the durable mechanism.** Cheap longshots are systematically overpriced: a $0.05 contract historically wins ~2%; sub-$0.10 contracts lose ~60% of stake to buyers. Favorites are fairly- to slightly-underpriced. The repeatable expression is **selling the overpriced longshot tail, maker-side** — resting NO bids on brackets priced ~$0.05–$0.20, diversified across many events to survive the rare hit. This is structural/behavioral, not a forecasting edge.

**Forecast skill ≠ trading edge.** A good weather or event forecast is largely redundant with the market price at decision time. Markets aggregate information efficiently enough that even a measurably better model produces near-zero net edge after fees unless it finds systematic mispricings (which are behavioral, not informational). The exception is official-label ML in lightly-traded markets — but that is bounded by fill-rate and capacity, not forecast accuracy.

# PumpFun Mechanics — Bonding Curves, Graduation & Instruction Parsing

PumpFun is the dominant Solana token launchpad. Understanding its bonding curve math, graduation process, and instruction formats is essential for analyzing new token launches, building trading strategies around graduation events, and parsing on-chain PumpFun activity.

## Bonding Curve Math

PumpFun uses a **virtual constant-product (CPMM)** bonding curve:

```
k = virtualSolReserves × virtualTokenReserves
```

### Initial Parameters

# Raptor — Self-Hosted Solana DEX Aggregator

Raptor is a self-hosted Rust binary that aggregates swap quotes across 25+ Solana DEXes. Unlike Jupiter, Raptor runs on your own infrastructure with **no rate limits**, **no API key**, and **no dependency on external API availability**. Free during public beta.

- **Program ID (Mainnet)**: `RaptorD5ojtsqDDtJeRsunPLg6GvLYNnwKJWxYE4m87`
- **GitHub**: [solanatracker/raptor-binary](https://github.com/solanatracker/raptor-binary)
- **Docs**: [docs.solanatracker.io/raptor/overview](https://docs.solanatracker.io/raptor/overview)

## Quick Start

```bash
# Clone the binary repo (includes required signature file)
git clone https://github.com/solanatracker/raptor-binary
cd raptor-binary

# Regime Detection

Identify the current market regime so you can pick the right strategy, size positions correctly, and avoid deploying trend-following logic in a ranging market (or vice versa).

## Why Regime Detection Matters

Every strategy has a "home regime." A momentum strategy prints money in a clean uptrend but bleeds in a choppy range. A mean-reversion grid thrives in low-volatility consolidation but gets steamrolled by a trending breakout. Regime detection tells you **which playbook to use right now**.

Key benefits:
- **Strategy selection**: Route signals to the right strategy for the current environment
- **Position sizing**: Reduce exposure in hostile regimes, increase in favorable ones
- **Stop adaptation**: Wider stops in high-vol regimes, tighter in low-vol trends
- **Drawdown control**: Sit out "danger zone" regimes (high vol + no trend)

# Regulatory Reporting

> **STATUS: STUB** — This skill outlines planned capabilities for crypto tax and regulatory reporting. All generated output must be reviewed by a qualified tax professional before filing. Nothing in this skill constitutes tax or legal advice.

## Overview

Track and generate required regulatory reports for cryptocurrency trading activity. Covers U.S. federal forms (IRS Form 8949, Schedule D), FinCEN foreign account reporting (FBAR), state-specific crypto obligations, large-transaction flagging, and deadline tracking.

Crypto tax reporting is complex and evolving. Rules change frequently, cost-basis methods vary by jurisdiction, and DeFi activities (swaps, LP positions, airdrops, staking rewards) have ambiguous treatment under current guidance. This skill provides a structured framework for organizing trade data into the formats regulators expect — but a tax professional must validate every filing.

## Disclaimer

> **WARNING**: This skill is for informational and educational purposes only. It does NOT constitute tax, legal, or financial advice. Cryptocurrency tax law is complex, jurisdiction-specific, and rapidly evolving. You MUST consult a qualified tax professional (CPA, EA, or tax attorney with crypto expertise) before relying on any output from this skill for actual tax filings. Errors in tax reporting can result in penalties, interest, and legal consequences. The authors accept no liability for any use of this material.

# Risk Management

Portfolio-level risk controls for crypto and Solana trading. This skill provides frameworks for drawdown management, exposure limits, circuit breakers, and crypto-specific risk considerations.

## Risk Management Hierarchy

Every decision must respect this priority order:

1. **Survival** — Never risk account ruin. No single trade, day, or week should threaten your ability to continue trading.
2. **Capital preservation** — Protect what you have. Losses compound geometrically; recovery requires outsized gains.
3. **Growth** — Only after survival and preservation are secured, pursue returns.

Violating this hierarchy (chasing growth at the expense of survival) is the primary cause of account blowups.

# RL Execution Optimization

Reinforcement learning (RL) for trade execution teaches an agent to split and
time large orders so that total market impact is minimized. Instead of following
a fixed schedule (TWAP, VWAP), an RL agent observes real-time market state and
adapts its trading rate on the fly.

## Why Execution Optimization Matters

Every trade has a cost beyond the quoted spread:

| Cost Component | Cause | Typical Magnitude |
|---|---|---|
| Spread cost | Crossing the bid-ask | 5-50 bps on DEXs |

# Sentiment Analysis

Extract and quantify market sentiment from social media, news feeds, and on-chain
data to identify crowd positioning and potential contrarian opportunities.

## When to Use This Skill

- Gauge crowd sentiment before entering or exiting a position
- Detect euphoria/panic extremes that precede reversals
- Monitor social mention velocity for early trend detection
- Track influencer activity around specific tokens
- Build composite sentiment scores for systematic strategies

## Core Concepts

# ShredStream — Pre-Execution Solana Data

ShredStream gives you transaction data **before the validator executes the block** — typically 100-500ms earlier than standard Yellowstone gRPC. You see transaction *intent*, not confirmed results.

This is the fastest path to Solana data for time-critical trading strategies.

## How It Works

Solana validators produce blocks by serializing transactions into **shreds** (~1,228 bytes each, sized for UDP MTU). Shreds propagate through Turbine (Solana's fanout protocol, 2-3 hops). ShredStream bypasses Turbine by receiving shreds **directly from leader validators** via Jito's Block Engine.

```
Leader Validator
     │
     ├── Turbine (standard, 2-3 hops, 200-500ms)

# Signal Classification

Predict whether an asset's price will move up or down over a forward horizon using supervised machine learning classifiers. This skill covers the full pipeline: label creation, model training, walk-forward validation, feature importance analysis, and threshold optimization for trading applications.

## Why Tree-Based Models Dominate Trading ML

XGBoost and LightGBM are the workhorses of quantitative trading ML for good reason:

- **Non-linear relationships**: Financial features interact in complex, non-linear ways that trees capture naturally
- **Robust to feature scale**: No need to normalize or standardize inputs — trees split on rank order
- **Built-in feature importance**: Understand which features drive predictions without separate analysis
- **Fast training and inference**: Train on thousands of samples in seconds, predict in microseconds
- **Handle missing values**: Native support for NaN without imputation hacks
- **Regularization built in**: max_depth, min_child_weight, subsample all prevent overfitting

# Slippage Modeling

Estimate execution costs, model slippage curves from AMM mechanics and empirical quotes, and determine optimal trade sizes that keep costs within acceptable thresholds.

## What Is Slippage?

Slippage is the difference between the **expected price** at the time you decide to trade and the **actual execution price** you receive. On decentralized exchanges, slippage is deterministic and measurable — unlike CEX slippage, which depends on hidden order book dynamics.

**Example**: You expect to buy a token at 0.001 SOL. Your trade executes at 0.00105 SOL. That 5% difference is slippage — it directly reduces your profit and increases your break-even threshold.

## Sources of Slippage

### 1. AMM Price Impact (Primary Source)

# Solana RPC — Direct Blockchain Interaction

The Solana JSON-RPC API provides direct read/write access to the blockchain. Use it for account state queries, token balance lookups, transaction building and submission, and program account enumeration. This is the low-level foundation when higher-level APIs (Birdeye, Helius, SolanaTracker) don't have the data you need.

## Quick Start

```python
import httpx

RPC = os.getenv("SOLANA_RPC_URL", "https://api.mainnet-beta.solana.com")

def rpc_call(method: str, params: list = None) -> dict:
    resp = httpx.post(RPC, json={
        "jsonrpc": "2.0", "id": 1,

# Solana Transaction Building

This skill covers how to construct, simulate, and inspect Solana transactions programmatically. It addresses the full anatomy of a Solana transaction — from raw instruction encoding to versioned transaction formats, compute budget management, priority fees, and address lookup tables.

**Safety**: This skill is for transaction *construction* and *analysis* only. Scripts in this skill NEVER sign or submit real transactions. Always simulate before sending. Never auto-sign.

## Transaction Anatomy

A Solana transaction consists of:

1. **Signatures**: One or more Ed25519 signatures (64 bytes each)
2. **Message**: The serializable payload containing:
   - **Header**: Counts of required signers, read-only signers, read-only non-signers
   - **Account keys**: Array of all pubkeys referenced by instructions

# SolanaTracker API — Token Data, Analytics & Raptor DEX Aggregator

SolanaTracker provides comprehensive Solana token data with unique features: **1-second OHLCV resolution**, **wallet PnL tracking**, **risk scoring**, **bundler/sniper detection**, and a **self-hosted DEX aggregator (Raptor)** supporting 25+ DEXes with no rate limits.

## Quick Start

```python
import httpx

[Credential-related source omitted]
BASE = "https://data.solanatracker.io"
[Credential-related source omitted]

# Token info with risk score, pools, holders

# Strategy Framework

A standardized system for defining, documenting, testing, and managing trading strategies. This skill provides templates and tools that enforce discipline, enable reproducibility, and make strategies testable.

## Why a Strategy Framework Matters

Trading without a written strategy framework leads to:
- **Inconsistency**: ad-hoc decisions driven by emotion rather than rules
- **Untestability**: vague ideas that cannot be backtested or evaluated
- **Scope creep**: strategies that drift without version-controlled definitions
- **Unmanaged risk**: missing stop losses, position limits, or drawdown halts

A strategy framework forces you to:
1. State a falsifiable hypothesis about a market inefficiency

# Sybil Detection — Coordinated Wallet & Fake Activity Analysis

Sybil attacks in Solana token markets involve a single entity operating many wallets to create the illusion of organic activity. This skill covers detecting coordinated wallet clusters, wash trading, bundled transactions, and fake holder inflation — critical for evaluating whether a token's metrics reflect real demand or manufactured signals.

## Why Sybil Detection Matters

Token markets on Solana are rife with manufactured signals:

- **Inflated holder counts**: 500 "holders" that are really 10 entities with 50 wallets each
- **Fake volume**: Wash trading between self-controlled wallets to simulate demand
- **Artificial social proof**: Many wallets holding small amounts to appear broadly distributed
- **Rug preparation**: Creator distributes supply across many wallets, then sells coordinated
- **Bundled launches**: PumpFun tokens where creator buys via Jito bundle in first slot

# ta-lib — C-Optimized Technical Analysis

TA-Lib (Technical Analysis Library) is a C library with a Python wrapper providing 150+ technical analysis functions and 61 candlestick pattern recognition functions. It is the industry standard for performance-critical indicator computation, used in production trading systems where pandas-ta or pure-Python alternatives are too slow.

## What TA-Lib Is

TA-Lib was originally written in C for financial market data analysis. The Python wrapper (`TA-Lib` on PyPI, imported as `talib`) provides:

- **150+ indicator functions** across overlap, momentum, volume, volatility, cycle, and math categories
- **61 candlestick pattern recognition functions** — the most comprehensive pattern library available
- **C-speed computation** — 10-100x faster than pure-Python equivalents on large datasets
- **Two APIs**: a function API (pass arrays directly) and an abstract API (pass dict of arrays)
- **NumPy native** — all inputs and outputs are NumPy arrays

# Tax Liability Tracking

Real-time tax liability analysis purpose-built for active Solana traders. Track proportional cost basis across partial sells, classify realized vs unrealized gains, project quarterly tax obligations, and surface tax-aware signals that feed back into trading decisions.

## Why This Matters

Active crypto traders generate hundreds of taxable events per year. Without real-time tracking:

- You do not know your actual after-tax P&L until year-end
- Partial sells (the "house money" play) create cost basis confusion
- Short-term vs long-term classification shifts your effective tax rate by 15-20%
- Tax-loss harvesting windows close without you noticing
- Quarterly estimated payments become guesswork

# Tax-Loss Harvesting

Identify, score, and plan tax-loss harvesting (TLH) opportunities across a crypto portfolio. This skill covers unrealized-loss ranking, net-benefit calculation, wash sale compliance, annual loss carryforward tracking, and year-end "use it or lose it" strategies.

> **Disclaimer:** This skill provides informational analysis only. It is NOT tax advice. Tax rules vary by jurisdiction and change frequently. Consult a qualified tax professional before making any tax-related trading decisions.

## How Tax-Loss Harvesting Works

Tax-loss harvesting is the practice of intentionally realizing investment losses to offset realized capital gains, thereby reducing your current-year tax liability.

### Core Mechanism

1. **Identify** positions with unrealized losses in your portfolio.
2. **Sell** those positions to realize the loss.

# Token Economics

Tokenomics — the study of token supply dynamics, distribution, and value accrual — is one of the most important factors in crypto asset analysis. Supply changes directly affect price: new tokens entering circulation create selling pressure, while burns and locks reduce it. Understanding these dynamics lets you estimate dilution risk, identify overvalued or undervalued tokens, and anticipate price-moving unlock events.

## Why Tokenomics Matters

Price is a function of demand **and** supply. In crypto, supply is programmable and constantly changing:

- A token inflating at 50%/year needs 50% demand growth just to maintain price
- A large unlock releasing 10% of circulating supply in one day often causes 5-20% drawdowns
- Tokens with >80% of supply locked have extreme dilution risk ahead
- Protocols that burn fees can become net deflationary, creating structural price support

## Key Supply Concepts