← Back to list
💰

market-microstructure Checked

DEX orderflow analysis, trade classification, buyer/seller pressure, and microstructure signals f…
💰 Finance & Trading skills By agiprolabs Version v1.0.0 Added 2026-09-20 Updated 2026-09-20 Source ↗
8.5Overall rating
2Views
8Downloads
366Stars

Installation

🤖 Install via AI

Copy the prompt below and send it to your AI assistant (e.g. Claude Code) — it will follow the instructions and install automatically.

Install the "market-microstructure" skill by following the instructions at https://skill123.me/install/market-microstructure.
⌨️ Command line install

Run in your terminal — downloads and installs to ~/.claude/skills/.

curl -fsSL https://skill123.me/install/market-microstructure.sh | bash
📦 Download ZIP

Download the zip and extract it into your skills directory (e.g. ~/.claude/skills/), then restart your session.

⬇ Download v1.0.0 · 24 KB
📊 Static rating
8.5/10
Trigger
6.5
Structure
8.7
Workflow
8.4
Content
9.0
Engineering
10.0
Security
9.5

Six-dimension rubric with reviewer rationale.

View scorecard ↓
🛡 Dynamic test
—

Not live-tested yet — this skill is rated on static analysis only.

About this skill

DEX orderflow analysis, trade classification, buyer/seller pressure, and microstructure signals for Solana tokens

Market Microstructure — DEX Orderflow Analysis

Documentation

DEX orderflow analysis, trade classification, buyer/seller pressure, and microstructure signals for Solana tokens

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
  • **Flow momentum signals** — acceleration, volume spikes, composite scores
  • **Token velocity** — turnover rate as a sentiment proxy
  • **Wash trading detection** — spotting fake volume and bot patterns

Why Microstructure Matters on DEXes

On CEXes, microstructure means orderbook depth, bid-ask spread, and queue position.

On AMMs, liquidity sits in pool curves — there is no spread or queue. But the **trade

tape** (the chronological list of swaps) contains rich signal:

1. **Who is trading?** — Whale wallets vs retail, smart money vs bots

2. **How are they trading?** — Large single swaps vs DCA-style splits

3. **When are they trading?** — Volume clustering around events or time zones

4. **What direction?** — Net buy vs sell pressure over sliding windows

These signals feed into entry/exit timing, position sizing, and token quality scoring.

Trade Classification

### Buy vs Sell Identification

On Solana DEXes, every swap has an input token and output token:

| Swap Direction | Classification | Meaning |

|----------------|---------------|---------|

| SOL → Token | **Buy** | Trader spending SOL to acquire token |

| USDC → Token | **Buy** | Trader spending stables to acquire token |

| Token → SOL | **Sell** | Trader converting token back to SOL |

| Token → USDC | **Sell** | Trader converting token to stables |

| Token A → Token B | Context-dependent | Classify based on which token you're analyzing |

### From API Data Sources

**Birdeye Trade History** (/defi/txs/token):

  • Returns side field: "buy" or "sell"
  • Includes from (input token) and to (output token) amounts

**DexScreener Pair Trades:**

  • Returns type field indicating swap direction relative to the pair

**Helius Parsed Transactions:**

  • Parse swap instructions to extract input/output mints and amounts
  • Classify based on which mint matches your target token

See references/trade_classification.md for detailed classification logic and size buckets.

Volume Profiles

### Time-Based Profiles

Aggregate trade volume into fixed time buckets to identify patterns:

View full documentation

# Hourly volume profile
hourly_volume = {}
for trade in trades:
    hour = trade["timestamp"] // 3600 * 3600
    hourly_volume.setdefault(hour, {"buy_vol": 0, "sell_vol": 0})
    if trade["side"] == "buy":
        hourly_volume[hour]["buy_vol"] += trade["volume_usd"]
    else:
        hourly_volume[hour]["sell_vol"] += trade["volume_usd"]

Key metrics from time profiles:

  • **Peak hours** — when is the token most actively traded?
  • **Volume trend** — is volume increasing, decreasing, or stable?
  • **Volume anomalies** — spikes exceeding 3x the rolling average

### Size-Based Profiles

Classify trades into size buckets to separate whale activity from retail:

| Bucket | SOL Range | Typical Actor |

|--------|-----------|---------------|

| Micro | < 0.1 SOL | Dust / test trades |

| Small | 0.1 – 1 SOL | Retail traders |

| Medium | 1 – 10 SOL | Active traders |

| Large | 10 – 50 SOL | Serious positions |

| Whale | 50+ SOL | Whales / institutions |

Buyer/Seller Pressure Metrics

### Core Ratios


def compute_pressure(trades: list[dict], period_seconds: int = 3600) -> dict:
    """Compute buy/sell pressure metrics over a time period."""
    buy_vol = sum(t["volume_usd"] for t in trades if t["side"] == "buy")
    sell_vol = sum(t["volume_usd"] for t in trades if t["side"] == "sell")
    total_vol = buy_vol + sell_vol

    buy_trades = sum(1 for t in trades if t["side"] == "buy")
    sell_trades = sum(1 for t in trades if t["side"] == "sell")
    total_trades = buy_trades + sell_trades

    return {
        "buy_sell_ratio": buy_vol / sell_vol if sell_vol > 0 else float("inf"),
        "buy_volume_pct": buy_vol / total_vol if total_vol > 0 else 0.5,
        "net_flow_usd": buy_vol - sell_vol,
        "trade_count_ratio": buy_trades / total_trades if total_trades > 0 else 0.5,
    }

### Signal Interpretation

| Metric | Bullish | Neutral | Bearish |

|--------|---------|---------|---------|

| Buy Volume % | > 60% | 40–60% | < 40% |

| Net Flow | Positive, increasing | Near zero | Negative, increasing |

| Trade Count Ratio | > 0.55 | 0.45–0.55 | < 0.45 |

| Large Trade Ratio | High buy-side | Balanced | High sell-side |

See references/flow_signals.md for the full signal catalog and composite scoring.

Trade Size Distribution

Analyzing the distribution of trade sizes reveals market structure:


import statistics

def analyze_trade_sizes(trades: list[dict]) -> dict:
    """Analyze trade size distribution."""
    sizes = [t["volume_usd"] for t in trades]
    if not sizes:
        return {}

    return {
        "mean": statistics.mean(sizes),
        "median": statistics.median(sizes),
        "stdev": statistics.stdev(sizes) if len(sizes) > 1 else 0,
        "skew_indicator": statistics.mean(sizes) / statistics.median(sizes),
        "max_trade": max(sizes),
        "whale_pct": sum(s for s in sizes if s > 5000) / sum(sizes),
    }

**Interpreting skew:** A skew_indicator (mean/median) well above 1.0 indicates a

fat-tailed distribution — a few large trades dominate. This is normal for tokens with

whale interest but can also signal manipulation.

Momentum Signals from Trade Flow

### Volume Acceleration

Compare current period volume to the previous period:


acceleration = current_volume / previous_volume if previous_volume > 0 else 0
  • **acceleration > 2.0** — volume surge, potential breakout or dump
  • **acceleration 0.8–1.2** — stable activity
  • **acceleration < 0.5** — dying interest

### Buy Pressure Acceleration

Track how the buy ratio changes over time:


current_buy_ratio = current_buy_vol / current_total_vol
previous_buy_ratio = prev_buy_vol / prev_total_vol
buy_momentum = current_buy_ratio - previous_buy_ratio

Positive buy_momentum with increasing volume is a strong accumulation signal.

Token Velocity

Token velocity measures how frequently tokens change hands:


velocity = daily_volume / circulating_supply

| Velocity | Interpretation |

|----------|---------------|

| < 0.01 | Low activity, illiquid, or strong holders |

| 0.01–0.05 | Normal trading activity |

| 0.05–0.20 | Active trading, possible speculation |

| > 0.20 | Very high turnover, potential wash trading |

High velocity combined with low unique trader count is a wash trading red flag.

Wash Trading Detection

Wash trading inflates volume to make a token appear more active than it truly is.

Key detection signals:

1. **Low unique trader ratio** — unique_wallets / trade_count < 0.3

2. **Volume/TVL anomaly** — daily_volume / tvl > 10 (volume vastly exceeds liquidity)

3. **Uniform trade sizes** — low entropy in trade size distribution

4. **Self-trading** — same wallet on both sides within short windows

5. **Funded-together clusters** — multiple wallets funded from the same source

See references/wash_trading.md for detailed detection methods and scoring.

Data Sources

### Birdeye API

Primary source for trade history on Solana tokens:

  • GET /defi/txs/token — recent trades for a token
  • GET /defi/ohlcv — candle data with volume
  • GET /defi/price/volume — aggregated volume data

Requires API key. See the birdeye-api skill for endpoint details.

### D

Score breakdown

Trigger
6.5
Description states What (orderflow, trade classification, pressure, microstructure signals) and domain (Solana tokens) with solid keyword coverage; no Use-when or boundary; no trigger variants.
Structure
8.7
309-line SKILL.md with three well-scoped references and two scripts, correctly classified and annotated; minor overlap between SKILL.md classification tables and trade_classification.md.
Workflow
8.4
Good task design: classification decision table, size-bucket taxonomy, ratio formulas with zero-division guards, composite score with explicit component weights and interpretation bands, wash-trading risk scoring; scripts have demo mode and graceful ImportError handling; verification limited to demo output.
Content
9.0
Concise, table- and code-driven; every metric has a formula and interpretation.
Engineering
10.0
Frontmatter valid; shebangs, dependencies, env vars documented; all referenced paths exist.
Security
9.5
6.0 manifest — network destinations: public-api.birdeye.so and api.dexscreener.com (both official public market-data APIs, declared in script headers, demo fallback when no key); keys via env only; no file writes, no credentials, no persistence. Capabilities match declared scope. Minor: no not-financial-advice disclaimer for trading-signal content.
Well-organized DEX microstructure skill: trade classification rules for AMM swaps, time/size volume profiles with whale buckets, buy/sell pressure metrics, composite flow-momentum scoring with documented component weights, and a dedicated wash-trading detection reference. Scripts fetch from official Birdeye/DexScreener APIs with demo fallback. Deductions: description lacks When/When-Not; no financial disclaimer despite signal-generating content; some classification detail duplicated between SKILL.md and references.