640 lines
24 KiB
Python
640 lines
24 KiB
Python
"""
|
|
Exit Scam Forecaster (Rug Pull Predictor)
|
|
==========================================
|
|
Predictive model identifying tokens at high risk of rug pull.
|
|
Multi-signal analysis combining liquidity patterns, holder behavior,
|
|
deployer history, and social signals for early warning.
|
|
|
|
The model evaluates 6 risk dimensions, each weighted by predictive power,
|
|
to produce a single 0-100 rug score with explainable per-signal breakdown.
|
|
|
|
TOOL : rug_pull_predictor
|
|
TIER : premium / intelligence
|
|
PRICE : $0.10 (100000 atoms)
|
|
TRIAL : 1 free check
|
|
|
|
Signals Analyzed:
|
|
- LIQUIDITY: LP lock status, liquidity depth vs market cap, sudden changes
|
|
- HOLDER_CONCENTRATION: Top-10 concentration, single-entity cluster ratio
|
|
- DEPLOYER: Previous project history, rug count, anonymous deployer
|
|
- LAUNCH_PATTERN: Bundled distribution, sniper activity, presale structure
|
|
- TRADING_BEHAVIOR: Seller concentration, wash trading, suspicious transfers
|
|
- SOCIAL_SIGNALS: Low engagement, anonymous team, no community presence
|
|
|
|
Data Sources (all free):
|
|
- DexScreener — token pairs, liquidity, price
|
|
- Solscan (public) — SPL token holder data
|
|
- Etherscan/BscScan (public free) — EVM token info
|
|
- Birdeye public — basic token metrics
|
|
- GoPlus (free) — token security info (if available)
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import logging
|
|
import re
|
|
import time
|
|
from dataclasses import dataclass, field
|
|
from datetime import UTC, datetime
|
|
from enum import Enum
|
|
from typing import Any
|
|
|
|
import httpx
|
|
|
|
__all__ = ["RiskLevel", "RugPullAnalysis", "SignalResult", "analyze", "predict_rug_pull"]
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# ── Constants ────────────────────────────────────────────────────
|
|
|
|
FREE_APIS = {
|
|
"dexscreener": "https://api.dexscreener.com/latest/dex",
|
|
"birdeye_public": "https://public-api.birdeye.so",
|
|
"goplus": "https://api.gopluslabs.io/api/v1",
|
|
}
|
|
|
|
EVM_ADDR_RE = re.compile(r"^0x[a-fA-F0-9]{40}$")
|
|
SOLANA_ADDR_RE = re.compile(r"^[1-9A-HJ-NP-Za-km-z]{32,44}$")
|
|
|
|
# Default risk thresholds
|
|
DEFAULT_WEIGHTS = {
|
|
"liquidity": 0.25,
|
|
"holder_concentration": 0.20,
|
|
"deployer": 0.15,
|
|
"launch_pattern": 0.18,
|
|
"trading_behavior": 0.12,
|
|
"social_signals": 0.10,
|
|
}
|
|
|
|
CHAIN_MAP: dict[str, str] = {
|
|
"solana": "solana",
|
|
"ethereum": "ethereum",
|
|
"bsc": "bsc",
|
|
"polygon": "polygon",
|
|
"arbitrum": "arbitrum",
|
|
"optimism": "optimism",
|
|
"base": "base",
|
|
"avalanche": "avalanche",
|
|
}
|
|
|
|
# ── Data Models ──────────────────────────────────────────────────
|
|
|
|
|
|
class RiskLevel(Enum):
|
|
SAFE = "safe"
|
|
LOW = "low"
|
|
MEDIUM = "medium"
|
|
HIGH = "high"
|
|
CRITICAL = "critical"
|
|
|
|
|
|
@dataclass
|
|
class SignalResult:
|
|
"""Individual signal analysis result."""
|
|
|
|
signal: str
|
|
score: float # 0 (safe) - 100 (risky)
|
|
weight: float
|
|
findings: list[str] = field(default_factory=list)
|
|
details: dict[str, Any] = field(default_factory=dict)
|
|
|
|
@property
|
|
def weighted_score(self) -> float:
|
|
return self.score * self.weight
|
|
|
|
@property
|
|
def level(self) -> RiskLevel:
|
|
if self.score < 20:
|
|
return RiskLevel.SAFE
|
|
elif self.score < 40:
|
|
return RiskLevel.LOW
|
|
elif self.score < 60:
|
|
return RiskLevel.MEDIUM
|
|
elif self.score < 80:
|
|
return RiskLevel.HIGH
|
|
return RiskLevel.CRITICAL
|
|
|
|
|
|
@dataclass
|
|
class RugPullAnalysis:
|
|
"""Complete rug pull risk analysis result."""
|
|
|
|
token_address: str
|
|
chain: str
|
|
token_symbol: str
|
|
token_name: str
|
|
|
|
overall_score: float # 0 (safe) - 100 (critical risk)
|
|
overall_level: RiskLevel
|
|
signals: list[SignalResult] = field(default_factory=list)
|
|
summary: str = ""
|
|
recommendations: list[str] = field(default_factory=list)
|
|
analysis_timestamp: str = ""
|
|
|
|
def to_dict(self) -> dict[str, Any]:
|
|
return {
|
|
"token_address": self.token_address,
|
|
"chain": self.chain,
|
|
"token_symbol": self.token_symbol,
|
|
"token_name": self.token_name,
|
|
"rug_score": round(self.overall_score, 1),
|
|
"risk_level": self.overall_level.value,
|
|
"signals": [
|
|
{
|
|
"name": s.signal,
|
|
"score": round(s.score, 1),
|
|
"level": s.level.value,
|
|
"findings": s.findings,
|
|
}
|
|
for s in self.signals
|
|
],
|
|
"summary": self.summary,
|
|
"recommendations": self.recommendations,
|
|
"analyzed_at": self.analysis_timestamp,
|
|
}
|
|
|
|
|
|
# ── Helpers ──────────────────────────────────────────────────────
|
|
|
|
|
|
def is_valid_address(addr: str) -> bool:
|
|
addr = addr.strip()
|
|
return bool(EVM_ADDR_RE.match(addr) or SOLANA_ADDR_RE.match(addr))
|
|
|
|
|
|
def _normalize_chain(chain: str) -> str:
|
|
chain = chain.strip().lower()
|
|
return CHAIN_MAP.get(chain, chain)
|
|
|
|
|
|
def _level_from_score(score: float) -> RiskLevel:
|
|
if score < 20:
|
|
return RiskLevel.SAFE
|
|
elif score < 40:
|
|
return RiskLevel.LOW
|
|
elif score < 60:
|
|
return RiskLevel.MEDIUM
|
|
elif score < 80:
|
|
return RiskLevel.HIGH
|
|
return RiskLevel.CRITICAL
|
|
|
|
|
|
# ── Signal Analyzers ────────────────────────────────────────────
|
|
|
|
|
|
async def _analyze_liquidity(client: httpx.AsyncClient, token_address: str, chain: str) -> SignalResult:
|
|
"""Analyze liquidity risk: depth, lock status, sudden changes."""
|
|
signal = SignalResult(
|
|
signal="liquidity",
|
|
score=0.0,
|
|
weight=DEFAULT_WEIGHTS["liquidity"],
|
|
findings=[],
|
|
)
|
|
|
|
try:
|
|
# Try DexScreener for pair data
|
|
url = f"{FREE_APIS['dexscreener']}/search?q={token_address}"
|
|
resp = await client.get(url, timeout=10)
|
|
if resp.status_code == 200:
|
|
data = resp.json()
|
|
pairs = data.get("pairs", [])
|
|
if pairs:
|
|
pair = pairs[0]
|
|
liquidity_usd = float(pair.get("liquidity", {}).get("usd", 0) or 0)
|
|
fdv = float(pair.get("fdv", 0) or 0)
|
|
volume_24h = float(pair.get("volume", {}).get("h24", 0) or 0)
|
|
|
|
signal.details["liquidity_usd"] = liquidity_usd
|
|
signal.details["fdv"] = fdv
|
|
signal.details["volume_24h"] = volume_24h
|
|
|
|
# Score: low liquidity = higher risk
|
|
if liquidity_usd < 1000:
|
|
signal.score += 40
|
|
signal.findings.append("Extremely low liquidity (<$1K)")
|
|
elif liquidity_usd < 10000:
|
|
signal.score += 25
|
|
signal.findings.append("Low liquidity (<$10K)")
|
|
elif liquidity_usd < 100000:
|
|
signal.score += 15
|
|
else:
|
|
signal.score += 5
|
|
|
|
# Score: low liquidity-to-FDV ratio = manipulation risk
|
|
if fdv > 0 and liquidity_usd > 0:
|
|
liq_ratio = liquidity_usd / fdv
|
|
if liq_ratio < 0.01:
|
|
signal.score += 20
|
|
signal.findings.append("Critical: Liquidity-to-FDV ratio <1% - easy to dump")
|
|
elif liq_ratio < 0.05:
|
|
signal.score += 10
|
|
signal.findings.append("Low liquidity-to-FDV ratio")
|
|
|
|
# Score: zero volume or very low = suspicious
|
|
if volume_24h < 100:
|
|
signal.score += 15
|
|
signal.findings.append("Near-zero 24h trading volume")
|
|
except Exception as e:
|
|
logger.warning("Liquidity analysis failed: %s", e)
|
|
signal.findings.append("Liquidity data unavailable - scoring conservative")
|
|
|
|
signal.score = min(signal.score, 100)
|
|
return signal
|
|
|
|
|
|
async def _analyze_holder_concentration(client: httpx.AsyncClient, token_address: str, chain: str) -> SignalResult:
|
|
"""Analyze token holder distribution for concentration risk."""
|
|
signal = SignalResult(
|
|
signal="holder_concentration",
|
|
score=0.0,
|
|
weight=DEFAULT_WEIGHTS["holder_concentration"],
|
|
findings=[],
|
|
)
|
|
|
|
if chain == "solana":
|
|
try:
|
|
# Try Birdeye public API for holder info
|
|
resp = await client.get(
|
|
f"{FREE_APIS['birdeye_public']}/public/token/token_owner?address={token_address}",
|
|
headers={"accept": "application/json"},
|
|
timeout=10,
|
|
)
|
|
if resp.status_code == 200:
|
|
data = resp.json()
|
|
holders = data.get("data", {}).get("tokenOwner", []) or data.get("data", {}).get("list", []) or []
|
|
if holders:
|
|
total_supply_analyzed = sum(float(h.get("uiAmount", 0) or 0) for h in holders)
|
|
top10 = sorted(holders, key=lambda h: float(h.get("uiAmount", 0) or 0), reverse=True)[:10]
|
|
top10_pct = (
|
|
sum(float(h.get("uiAmount", 0) or 0) for h in top10) / total_supply_analyzed
|
|
if total_supply_analyzed > 0
|
|
else 0
|
|
)
|
|
|
|
signal.details["top_10_concentration_pct"] = round(top10_pct * 100, 1)
|
|
|
|
if top10_pct > 0.8:
|
|
signal.score += 45
|
|
signal.findings.append(
|
|
f"Top 10 holders control {top10_pct * 100:.0f}% of supply - extreme concentration"
|
|
)
|
|
elif top10_pct > 0.5:
|
|
signal.score += 30
|
|
signal.findings.append(f"Top 10 holders control {top10_pct * 100:.0f}% - high concentration")
|
|
elif top10_pct > 0.3:
|
|
signal.score += 15
|
|
else:
|
|
signal.score += 5
|
|
except Exception as e:
|
|
logger.warning("Holder concentration analysis failed: %s", e)
|
|
signal.findings.append("Holder data unavailable")
|
|
|
|
# Conservative scoring if we lack data
|
|
if not signal.findings:
|
|
signal.score = 30 # moderate default
|
|
signal.findings.append("Limited holder data - scored conservatively")
|
|
|
|
signal.score = min(signal.score, 100)
|
|
return signal
|
|
|
|
|
|
async def _analyze_deployer(client: httpx.AsyncClient, deployer: str | None, chain: str) -> SignalResult:
|
|
"""Analyze deployer risk based on available data."""
|
|
signal = SignalResult(
|
|
signal="deployer",
|
|
score=0.0,
|
|
weight=DEFAULT_WEIGHTS["deployer"],
|
|
findings=[],
|
|
)
|
|
|
|
if not deployer:
|
|
signal.score = 50
|
|
signal.findings.append("Deployer address unknown - cannot verify history")
|
|
signal.score = min(signal.score, 100)
|
|
return signal
|
|
|
|
try:
|
|
if chain == "solana":
|
|
# Try to check if deployer has multiple tokens
|
|
resp = await client.get(
|
|
f"{FREE_APIS['birdeye_public']}/public/token/list?creator={deployer}",
|
|
headers={"accept": "application/json"},
|
|
timeout=10,
|
|
)
|
|
if resp.status_code == 200:
|
|
data = resp.json()
|
|
tokens_deployed = data.get("data", {}).get("items", [])
|
|
token_count = len(tokens_deployed)
|
|
|
|
signal.details["deployer_token_count"] = token_count
|
|
|
|
if token_count > 20:
|
|
signal.score += 40
|
|
signal.findings.append(f"Serial deployer: {token_count} tokens created - potential rug factory")
|
|
elif token_count > 10:
|
|
signal.score += 25
|
|
signal.findings.append(f"Active deployer: {token_count} tokens created")
|
|
elif token_count > 5:
|
|
signal.score += 10
|
|
else:
|
|
signal.score += 5
|
|
else:
|
|
# EVM - check if deployer is a known contract factory
|
|
signal.score += 10
|
|
signal.findings.append("EVM deployer - limited public history available")
|
|
except Exception as e:
|
|
logger.warning("Deployer analysis failed: %s", e)
|
|
signal.findings.append("Deployer data unavailable")
|
|
|
|
signal.score = min(signal.score, 100)
|
|
return signal
|
|
|
|
|
|
async def _analyze_launch_pattern(client: httpx.AsyncClient, token_address: str, chain: str) -> SignalResult:
|
|
"""Analyze launch pattern for manipulation signs."""
|
|
signal = SignalResult(
|
|
signal="launch_pattern",
|
|
score=20.0, # Start at moderate risk as baseline
|
|
weight=DEFAULT_WEIGHTS["launch_pattern"],
|
|
findings=[],
|
|
)
|
|
|
|
try:
|
|
# Use DexScreener for trading data
|
|
url = f"{FREE_APIS['dexscreener']}/search?q={token_address}"
|
|
resp = await client.get(url, timeout=10)
|
|
if resp.status_code == 200:
|
|
data = resp.json()
|
|
pairs = data.get("pairs", [])
|
|
if pairs:
|
|
pair = pairs[0]
|
|
pair_age_hours = None
|
|
if pair.get("pairCreatedAt"):
|
|
created = pair["pairCreatedAt"] / 1000 # ms to s
|
|
pair_age_hours = (time.time() - created) / 3600
|
|
signal.details["age_hours"] = round(pair_age_hours, 1)
|
|
|
|
txns = pair.get("txns", {})
|
|
buys_h24 = int(txns.get("h24", {}).get("buys", 0))
|
|
sells_h24 = int(txns.get("h24", {}).get("sells", 0))
|
|
|
|
signal.details["buys_24h"] = buys_h24
|
|
signal.details["sells_24h"] = sells_h24
|
|
|
|
# Very young pair = higher risk
|
|
if pair_age_hours is not None:
|
|
if pair_age_hours < 1:
|
|
signal.score += 25
|
|
signal.findings.append(f"Pair is {pair_age_hours:.1f}h old - extremely young, high risk")
|
|
elif pair_age_hours < 24:
|
|
signal.score += 15
|
|
signal.findings.append(f"Pair is {pair_age_hours:.1f}h old - recent launch")
|
|
|
|
# Abnormal buy/sell ratio
|
|
total_txns = buys_h24 + sells_h24
|
|
if total_txns > 0:
|
|
sell_ratio = sells_h24 / total_txns
|
|
if sell_ratio > 0.8:
|
|
signal.score += 20
|
|
signal.findings.append(f"Sell ratio {sell_ratio * 100:.0f}% - heavy selling pressure")
|
|
elif sell_ratio > 0.6:
|
|
signal.score += 10
|
|
elif sell_ratio < 0.1 and buys_h24 > 50:
|
|
signal.score += 15
|
|
signal.findings.append("Abnormally low sell ratio - possible bot wash trading")
|
|
except Exception as e:
|
|
logger.warning("Launch pattern analysis failed: %s", e)
|
|
signal.findings.append("Launch data partially available")
|
|
|
|
signal.score = min(signal.score, 100)
|
|
return signal
|
|
|
|
|
|
async def _analyze_trading_behavior(client: httpx.AsyncClient, token_address: str, chain: str) -> SignalResult:
|
|
"""Analyze trading behavior for manipulation signs."""
|
|
signal = SignalResult(
|
|
signal="trading_behavior",
|
|
score=10.0,
|
|
weight=DEFAULT_WEIGHTS["trading_behavior"],
|
|
findings=[],
|
|
)
|
|
|
|
try:
|
|
url = f"{FREE_APIS['dexscreener']}/search?q={token_address}"
|
|
resp = await client.get(url, timeout=10)
|
|
if resp.status_code == 200:
|
|
data = resp.json()
|
|
pairs = data.get("pairs", [])
|
|
if pairs:
|
|
pair = pairs[0]
|
|
liquidity_usd = float(pair.get("liquidity", {}).get("usd", 0) or 0)
|
|
volume_24h = float(pair.get("volume", {}).get("h24", 0) or 0)
|
|
|
|
# Suspicious volume-to-liquidity ratio (wash trading indicator)
|
|
if liquidity_usd > 0 and volume_24h > 0:
|
|
vol_liq_ratio = volume_24h / liquidity_usd
|
|
if vol_liq_ratio > 20:
|
|
signal.score += 25
|
|
signal.findings.append(
|
|
f"Volume/liquidity ratio of {vol_liq_ratio:.0f}x - possible wash trading"
|
|
)
|
|
elif vol_liq_ratio > 10:
|
|
signal.score += 10
|
|
elif liquidity_usd == 0 and volume_24h > 0:
|
|
signal.score += 20
|
|
signal.findings.append("Volume with zero liquidity - suspicious")
|
|
|
|
# Price change indicators
|
|
price_change_h24 = pair.get("priceChange", {}).get("h24", 0)
|
|
if isinstance(price_change_h24, int | float):
|
|
if price_change_h24 < -50:
|
|
signal.score += 20
|
|
signal.findings.append(f"Price dropped {abs(price_change_h24):.0f}% in 24h")
|
|
elif price_change_h24 > 500:
|
|
signal.score += 10
|
|
signal.findings.append(f"Price surged {price_change_h24:.0f}% in 24h - potential pump")
|
|
except Exception as e:
|
|
logger.warning("Trading behavior analysis failed: %s", e)
|
|
|
|
signal.score = min(signal.score, 100)
|
|
return signal
|
|
|
|
|
|
async def _analyze_social_signals(token_address: str, chain: str) -> SignalResult:
|
|
"""Analyze social signals (placeholder - relies on chain metadata)."""
|
|
signal = SignalResult(
|
|
signal="social_signals",
|
|
score=20.0, # Default conservative
|
|
weight=DEFAULT_WEIGHTS["social_signals"],
|
|
findings=["Social signal analysis limited with free data sources"],
|
|
)
|
|
|
|
# Conservative scoring: no social data = moderate risk
|
|
signal.score = 30
|
|
return signal
|
|
|
|
|
|
# ── Main Analysis ───────────────────────────────────────────────
|
|
|
|
|
|
async def predict_rug_pull(
|
|
token_address: str,
|
|
chain: str = "solana",
|
|
deployer: str | None = None,
|
|
weights: dict[str, float] | None = None,
|
|
) -> RugPullAnalysis:
|
|
"""
|
|
Predict rug pull risk for a given token.
|
|
|
|
Args:
|
|
token_address: The token contract/mint address
|
|
chain: Blockchain (solana, ethereum, bsc, etc.)
|
|
deployer: Optional deployer/creator address for history check
|
|
weights: Optional custom signal weights (must sum to 1.0)
|
|
|
|
Returns:
|
|
RugPullAnalysis with overall score and per-signal breakdown
|
|
"""
|
|
if not is_valid_address(token_address):
|
|
raise ValueError(f"Invalid token address: {token_address}")
|
|
|
|
chain = _normalize_chain(chain)
|
|
effective_weights = weights or DEFAULT_WEIGHTS
|
|
|
|
# Validate weights
|
|
if abs(sum(effective_weights.values()) - 1.0) > 0.01:
|
|
raise ValueError("Signal weights must sum to 1.0")
|
|
|
|
token_symbol = ""
|
|
token_name = ""
|
|
|
|
# Run all signal analyzers in parallel (single client for efficiency)
|
|
async with httpx.AsyncClient(timeout=30.0) as client:
|
|
# Quick metadata fetch for display
|
|
try:
|
|
search_resp = await client.get(f"{FREE_APIS['dexscreener']}/search?q={token_address}", timeout=10)
|
|
if search_resp.status_code == 200:
|
|
pairs = search_resp.json().get("pairs", [])
|
|
if pairs:
|
|
token_symbol = pairs[0].get("baseToken", {}).get("symbol", "")
|
|
token_name = pairs[0].get("baseToken", {}).get("name", "")
|
|
except Exception:
|
|
pass
|
|
results = await asyncio.gather(
|
|
_analyze_liquidity(client, token_address, chain),
|
|
_analyze_holder_concentration(client, token_address, chain),
|
|
_analyze_deployer(client, deployer, chain),
|
|
_analyze_launch_pattern(client, token_address, chain),
|
|
_analyze_trading_behavior(client, token_address, chain),
|
|
_analyze_social_signals(token_address, chain),
|
|
return_exceptions=True,
|
|
)
|
|
|
|
signals: list[SignalResult] = []
|
|
for r in results:
|
|
if isinstance(r, SignalResult):
|
|
signals.append(r)
|
|
elif isinstance(r, Exception):
|
|
logger.warning("Signal analysis exception: %s", r)
|
|
signals.append(
|
|
SignalResult(
|
|
signal="unknown",
|
|
score=50.0,
|
|
weight=0.05,
|
|
findings=[f"Analysis error: {r}"],
|
|
)
|
|
)
|
|
|
|
# Calculate weighted overall score using ternary
|
|
total_weight = sum(s.weight for s in signals)
|
|
overall_score = sum(s.score * s.weight for s in signals) / total_weight if total_weight > 0 else 50.0
|
|
|
|
overall_score = min(max(overall_score, 0), 100)
|
|
overall_level = _level_from_score(overall_score)
|
|
|
|
# Generate summary
|
|
if overall_score >= 70:
|
|
summary = (
|
|
f"CRITICAL RISK: This token shows strong rug pull indicators "
|
|
f"(score: {overall_score:.0f}/100). Multiple red flags detected "
|
|
f"across {sum(1 for s in signals if s.score > 50)} risk dimensions."
|
|
)
|
|
elif overall_score >= 50:
|
|
summary = (
|
|
f"HIGH RISK: This token has concerning signals "
|
|
f"(score: {overall_score:.0f}/100). Proceed with extreme caution."
|
|
)
|
|
elif overall_score >= 30:
|
|
summary = (
|
|
f"MODERATE RISK: Some concerning patterns detected "
|
|
f"(score: {overall_score:.0f}/100). Standard due diligence recommended."
|
|
)
|
|
else:
|
|
summary = (
|
|
f"LOW RISK: No major rug pull indicators detected "
|
|
f"(score: {overall_score:.0f}/100). Continue standard safety checks."
|
|
)
|
|
|
|
# Generate recommendations
|
|
recommendations = []
|
|
if overall_score >= 50:
|
|
recommendations.append("AVOID trading this token - high rug pull probability")
|
|
if any(s.score > 60 for s in signals if s.signal == "liquidity"):
|
|
recommendations.append("Liquidity is critically low or manipulable")
|
|
if any(s.score > 50 for s in signals if s.signal == "holder_concentration"):
|
|
recommendations.append("Top holders control excessive supply - potential dump risk")
|
|
if any(s.score > 50 for s in signals if s.signal == "deployer"):
|
|
recommendations.append("Deployer has concerning history - check their other projects")
|
|
if recommendations:
|
|
recommendations.append("Always verify with RugShield or SENTINEL deep scan before trading")
|
|
|
|
return RugPullAnalysis(
|
|
token_address=token_address,
|
|
chain=chain,
|
|
token_symbol=token_symbol or "UNKNOWN",
|
|
token_name=token_name or "Unknown Token",
|
|
overall_score=overall_score,
|
|
overall_level=overall_level,
|
|
signals=signals,
|
|
summary=summary,
|
|
recommendations=recommendations or ["No specific concerns detected"],
|
|
analysis_timestamp=datetime.now(UTC).isoformat(),
|
|
)
|
|
|
|
|
|
# ── Synchronous Wrapper ─────────────────────────────────────────
|
|
|
|
|
|
def analyze(token_address: str, chain: str = "solana", **kwargs: Any) -> dict[str, Any]:
|
|
"""
|
|
Synchronous entry point for rug pull prediction.
|
|
|
|
Args:
|
|
token_address: Token contract/mint address
|
|
chain: Blockchain name
|
|
**kwargs: Additional options (deployer, weights)
|
|
|
|
Returns:
|
|
Dict with full analysis results
|
|
"""
|
|
result = asyncio.run(predict_rug_pull(token_address, chain, **kwargs))
|
|
return result.to_dict()
|
|
|
|
|
|
# ── CLI Entry Point ─────────────────────────────────────────────
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
|
|
logging.basicConfig(level=logging.INFO)
|
|
|
|
if len(sys.argv) < 2:
|
|
print("Usage: python3 rug_pull_predictor.py <TOKEN_ADDRESS> [chain] [deployer]")
|
|
sys.exit(1)
|
|
|
|
addr = sys.argv[1]
|
|
chain = sys.argv[2] if len(sys.argv) > 2 else "solana"
|
|
deployer = sys.argv[3] if len(sys.argv) > 3 else None
|
|
|
|
result = analyze(addr, chain, deployer=deployer)
|
|
print(json.dumps(result, indent=2))
|