القائمة
Crypto-native indicators including NVT ratio, exchange flow, funding rate signals, holder momentum, and smart money flow
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
استنادا إلى تصنيف SOC المهني
| name | custom-indicators |
| description | Crypto-native indicators including NVT ratio, exchange flow, funding rate signals, holder momentum, and smart money flow |
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:
This skill covers nine crypto-native indicators. Each section includes the formula, interpretation guide, data sources, and a working code snippet.
| File | Description |
|---|---|
references/indicator_formulas.md | Full formulas, parameter tables, signal ranges for all 9 indicators |
references/signal_interpretation.md | Composite scoring, divergence detection, false signal filtering |
scripts/compute_crypto_indicators.py | Computes all 9 indicators from free APIs or demo data |
scripts/holder_momentum.py | Holder count tracking with momentum signals |
Network Value to Transactions — the crypto equivalent of a P/E ratio.
NVT = Market Cap / Daily On-Chain Transaction Volume (USD)
def nvt_ratio(market_cap: float, daily_tx_volume_usd: float) -> float:
"""Compute NVT ratio.
Args:
market_cap: Current market capitalization in USD.
daily_tx_volume_usd: 24h on-chain transaction volume in USD.
Returns:
NVT ratio value.
"""
if daily_tx_volume_usd <= 0:
return float("inf")
return market_cap / daily_tx_volume_usd
Smoothing: Apply a 14-day or 28-day moving average to NVT (called NVT Signal) to reduce noise from daily volume spikes.
Market Value to Realized Value — compares the current market cap to the aggregate cost basis of all holders.
MVRV = Market Cap / Realized Cap
Realized Cap = Sum of (each UTXO * price when it last moved)
def mvrv_ratio(market_cap: float, realized_cap: float) -> float:
"""Compute MVRV ratio.
Args:
market_cap: Current market capitalization in USD.
realized_cap: Realized capitalization (aggregate cost basis).
Returns:
MVRV ratio value.
"""
if realized_cap <= 0:
return float("inf")
return market_cap / realized_cap
For tokens without UTXO-based realized cap, estimate using average purchase price from DEX trade history multiplied by circulating supply.
Net exchange deposits minus withdrawals — signals selling or accumulation intent.
Exchange Netflow = Deposits to Exchanges - Withdrawals from Exchanges
def exchange_netflow(
deposits_usd: float, withdrawals_usd: float
) -> tuple[float, str]:
"""Compute exchange netflow and interpret.
Returns:
Tuple of (netflow_value, signal_label).
"""
netflow = deposits_usd - withdrawals_usd
if netflow > 0:
signal = "bearish"
elif netflow < 0:
signal = "bullish"
else:
signal = "neutral"
return netflow, signal
Normalize by market cap for cross-token comparison:
Netflow Ratio = Netflow / Market Cap.
Perpetual futures contracts use funding rates to anchor price to spot.
Funding Rate = (Perp Mark Price - Spot Price) / Spot Price
(paid every 8 hours on most exchanges)
def funding_rate_signal(
rates: list[float], weights: list[float] | None = None
) -> tuple[float, str]:
"""Volume-weighted average funding rate with signal.
Args:
rates: Funding rates from multiple exchanges.
weights: Optional volume weights per exchange.
"""
import numpy as np
if weights is None:
weights = [1.0 / len(rates)] * len(rates)
vw_rate = float(np.average(rates, weights=weights))
if vw_rate > 0.0005:
signal = "bearish"
elif vw_rate < -0.0005:
signal = "bullish"
else:
signal = "neutral"
return vw_rate, signal
Tracks the rate of change in total open interest across derivatives exchanges.
OI Momentum = (OI_today - OI_n_days_ago) / OI_n_days_ago * 100
def oi_momentum(
oi_series: list[float], lookback: int = 7
) -> float:
"""Compute open interest momentum as percentage change.
Args:
oi_series: Daily open interest values (newest last).
lookback: Number of days for momentum calculation.
"""
if len(oi_series) < lookback + 1:
return 0.0
old = oi_series[-(lookback + 1)]
new = oi_series[-1]
if old <= 0:
return 0.0
return (new - old) / old * 100.0
Tracks the net change in unique token holders over time.
Holder Momentum = (Holders_today - Holders_n_days_ago) / Holders_n_days_ago
Holder Acceleration = Holder Momentum_today - Holder Momentum_yesterday
def holder_momentum(
holder_counts: list[int], lookback: int = 7
) -> tuple[float, float]:
"""Compute holder momentum and acceleration.
Returns:
Tuple of (momentum_pct, acceleration).
"""
if len(holder_counts) < lookback + 2:
return 0.0, 0.0
old = holder_counts[-(lookback + 1)]
new = holder_counts[-1]
prev_old = holder_counts[-(lookback + 2)]
prev_new = holder_counts[-2]
mom = (new - old) / old if old > 0 else 0.0
prev_mom = (prev_new - prev_old) / prev_old if prev_old > 0 else 0.0
accel = mom - prev_mom
return mom, accel
See scripts/holder_momentum.py for a full tracking implementation.
A composite metric combining order book depth, bid-ask spread, and DEX pool depth to estimate how easily a position can be entered/exited.
Liquidity Score = w1 * Depth Score + w2 * Spread Score + w3 * Pool Score
Where:
min(1, total_bids_within_2pct / target_position_size)max(0, 1 - spread_bps / 100)min(1, pool_tvl / (target_position_size * 10))w1=0.4, w2=0.3, w3=0.3def liquidity_score(
depth_usd: float,
spread_bps: float,
pool_tvl: float,
position_size: float,
weights: tuple[float, float, float] = (0.4, 0.3, 0.3),
) -> float:
"""Composite liquidity score from 0 (illiquid) to 1 (highly liquid)."""
depth_s = min(1.0, depth_usd / position_size) if position_size > 0 else 0
spread_s = max(0.0, 1.0 - spread_bps / 100.0)
pool_s = min(1.0, pool_tvl / (position_size * 10)) if position_size > 0 else 0
return weights[0] * depth_s + weights[1] * spread_s + weights[2] * pool_s
Net buying pressure from wallets identified as "smart money" (historically profitable, large balances, early entry patterns).
Smart Money Flow = Sum(smart_wallet_buys_usd) - Sum(smart_wallet_sells_usd)
SMF Ratio = Smart Money Flow / Total Volume
def smart_money_flow(
smart_buys_usd: float,
smart_sells_usd: float,
total_volume_usd: float,
) -> tuple[float, float, str]:
"""Compute smart money flow and ratio.
Returns:
Tuple of (net_flow, smf_ratio, signal).
"""
net = smart_buys_usd - smart_sells_usd
ratio = net / total_volume_usd if total_volume_usd > 0 else 0.0
if ratio > 0.1:
signal = "bullish"
elif ratio < -0.1:
signal = "bearish"
else:
signal = "neutral"
return net, ratio, signal
Measures how frequently a token changes hands relative to its supply.
Token Velocity = Daily Trading Volume (tokens) / Circulating Supply
def token_velocity(
daily_volume_tokens: float, circulating_supply: float
) -> tuple[float, str]:
"""Compute token velocity.
Returns:
Tuple of (velocity, interpretation).
"""
if circulating_supply <= 0:
return 0.0, "unknown"
vel = daily_volume_tokens / circulating_supply
if vel > 0.3:
interp = "high_speculation"
elif vel > 0.1:
interp = "moderate"
elif vel > 0.05:
interp = "low"
else:
interp = "very_low_strong_holders"
return vel, interp
No single indicator is reliable in isolation. See
references/signal_interpretation.md for guidance on:
uv pip install httpx pandas numpy
All indicators and analysis provided by this skill are for informational and educational purposes only. They do not constitute financial advice. Always conduct your own research before making any investment decisions.
Kalshi exchange mechanics — RSA-PSS auth, order schema, YES/NO orderbook convention, WebSocket, and endpoint surface. Market-type-agnostic shared layer for all Kalshi skills.
Kalshi daily and hourly range markets on crypto prices (BTC, ETH) and equity indices (S&P 500, Nasdaq-100) — bracket structure, Gaussian P(YES) modeling on price/vol, close-offset decision timing, longshot-sell edge with honest evidence bounds
Daily temperature high/low bracket and threshold contracts on Kalshi — contract structure, forecast→P(YES) map, settlement rules, cross-venue divergences, and weather-specific pitfalls
Polymarket exchange mechanics — on-chain Polygon CTF, Gamma/CLOB/Data APIs, EIP-712 auth, identifier model, WebSocket, settlement, and geo/KYC constraint
Venue- and market-type-agnostic strategy, sizing, and backtesting layer for binary prediction markets (Kalshi, Polymarket, ForecastEx). Covers the durable edge thesis, fee-aware selection, fractional-Kelly sizing, and leak-free validation methodology.
Portfolio-level risk controls, drawdown management, exposure limits, and circuit breakers for crypto trading