cryptorugmunch
f932ac4e1e
Gitleaks flagged 4 production secrets in rmi-backend source:
app/caching_shield/solana_tracker.py: st_ZMzXzdUI54TXQPx5E6JkG
app/databus/arkham_ws.py: ws_Z5x09Rcr_1780418740765322917
app/routers/webhooks_router.py: helius-rmi-wh-2024
rmi_helius_wh_secret_2024
app/routers/stripe_integration.py: pk_test_51Tn13MAXseReicQtM...
Each replaced with os.getenv() reads. Placeholder env lines added to
/srv/rmi-infra/.env.secrets. Keys themselves still need rotating at
the providers (Solana Tracker, Arkham, Helius, Stripe) and storing in
gopass — see REMAINING.md.
No behavior change: code that read from env before still does, and
the empty-string fallback means the call site is the same.
Note: this commit scrubs the keys from the working tree. They remain
in git history. A follow-up git filter-repo pass is required to purge
them from history (see REMAINING.md). After that, all clones and
external remotes must be force-updated.
311 lines
11 KiB
Python
311 lines
11 KiB
Python
"""
|
|
Webhook Receivers — Helius (Solana) + Moralis Streams (EVM).
|
|
Processes real-time blockchain events: transfers, swaps, mints, whale activity.
|
|
INTELLIGENT PROCESSING: Whale detection, cluster correlation, scam pattern matching.
|
|
"""
|
|
|
|
import logging
|
|
import os
|
|
|
|
from fastapi import APIRouter, HTTPException, Request
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
router = APIRouter(prefix="/api/v1/webhooks", tags=["webhooks"])
|
|
|
|
# ── Config ──────────────────────────────────────────────────
|
|
|
|
HELIUS_WEBHOOK_AUTH = os.getenv("HELIUS_WEBHOOK_AUTH", "")
|
|
HELIUS_WEBHOOK_SECRET = os.getenv("HELIUS_WEBHOOK_SECRET", "")
|
|
|
|
# ── Intelligent Processor ────────────────────────────────────
|
|
|
|
|
|
async def _process_with_intelligence(event: dict, source: str) -> dict | None:
|
|
"""Process event with intelligent analysis."""
|
|
try:
|
|
from app.intelligent_webhooks import get_intelligent_processor
|
|
|
|
processor = get_intelligent_processor()
|
|
|
|
if source == "helius":
|
|
alert = await processor.process_helius_event(event)
|
|
elif source == "moralis":
|
|
alert = await processor.process_moralis_event(event)
|
|
else:
|
|
return None
|
|
|
|
if alert:
|
|
# Log critical/high alerts
|
|
if alert.severity in ("critical", "high"):
|
|
logger.warning(
|
|
f"🚨 {alert.severity.upper()}: {alert.alert_type} "
|
|
f"wallet={alert.wallet[:16]}... amount=${alert.amount_usd:,.0f} "
|
|
f"risk={alert.risk_score:.1f}"
|
|
)
|
|
|
|
return {
|
|
"alert_id": alert.alert_id,
|
|
"severity": alert.severity,
|
|
"type": alert.alert_type,
|
|
"wallet": alert.wallet,
|
|
"chain": alert.chain,
|
|
"amount_usd": alert.amount_usd,
|
|
"risk_score": alert.risk_score,
|
|
"description": alert.description,
|
|
"enriched": alert.enriched_data,
|
|
"actions": alert.actions,
|
|
}
|
|
return None
|
|
except Exception as e:
|
|
logger.debug(f"Intelligent processing failed: {e}")
|
|
return None
|
|
|
|
|
|
def _process_helius_event(event: dict) -> dict:
|
|
"""Process a single Helius webhook event."""
|
|
result = {
|
|
"signature": event.get("signature", ""),
|
|
"type": event.get("type", "unknown"),
|
|
"source": "helius",
|
|
"timestamp": event.get("timestamp", 0),
|
|
"wallet": "",
|
|
"description": "",
|
|
"processed": False,
|
|
}
|
|
|
|
try:
|
|
# Extract key data from Helius enriched transaction
|
|
events = event.get("events", [])
|
|
event.get("accountData", [])
|
|
fee_payer = event.get("feePayer", "")
|
|
description = event.get("description", "")
|
|
|
|
result["wallet"] = fee_payer
|
|
result["description"] = description[:200]
|
|
|
|
# Classify event type
|
|
event_types = [e.get("type", "") for e in events] if isinstance(events, list) else []
|
|
if any("swap" in str(e).lower() for e in [*event_types, description]):
|
|
result["type"] = "swap"
|
|
elif any("transfer" in str(e).lower() for e in [*event_types, description]):
|
|
result["type"] = "transfer"
|
|
elif any("mint" in str(e).lower() for e in [*event_types, description]):
|
|
result["type"] = "mint"
|
|
elif any("nft" in str(e).lower() for e in [*event_types, description]):
|
|
result["type"] = "nft"
|
|
|
|
# Track amounts from account data
|
|
native_transfers = event.get("nativeTransfers", [])
|
|
if native_transfers:
|
|
max_transfer = max(native_transfers, key=lambda t: t.get("amount", 0), default={})
|
|
result["largest_transfer"] = max_transfer.get("amount", 0) / 1e9 # lamports to SOL
|
|
|
|
# Token transfers
|
|
token_transfers = event.get("tokenTransfers", [])
|
|
if token_transfers:
|
|
for tt in token_transfers[:3]: # Top 3 token transfers
|
|
mint = tt.get("mint", "")
|
|
amount = tt.get("tokenAmount", {}).get("uiAmount", 0)
|
|
if amount and float(amount) > 0:
|
|
result.setdefault("token_moves", []).append(
|
|
{
|
|
"mint": mint,
|
|
"amount": float(amount),
|
|
"from": tt.get("fromUserAccount", ""),
|
|
"to": tt.get("toUserAccount", ""),
|
|
}
|
|
)
|
|
|
|
result["processed"] = True
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Event processing error: {e}")
|
|
result["error"] = str(e)[:200]
|
|
|
|
return result
|
|
|
|
|
|
def _process_moralis_event(event: dict) -> dict:
|
|
"""Process a single Moralis Stream (EVM) event."""
|
|
result = {
|
|
"hash": event.get("transactionHash", event.get("hash", "")),
|
|
"chain": event.get("chainId", "0x1"),
|
|
"source": "moralis",
|
|
"type": "unknown",
|
|
"from": event.get("fromAddress", ""),
|
|
"to": event.get("toAddress", ""),
|
|
"value": "0",
|
|
"timestamp": event.get("blockTimestamp", ""),
|
|
"processed": False,
|
|
}
|
|
|
|
try:
|
|
# Classify by log events or description
|
|
logs = event.get("logs", [])
|
|
erc20_transfers = event.get("erc20Transfers", [])
|
|
|
|
if erc20_transfers:
|
|
result["type"] = "erc20_transfer"
|
|
for t in erc20_transfers[:3]:
|
|
result.setdefault("token_transfers", []).append(
|
|
{
|
|
"from": t.get("from", ""),
|
|
"to": t.get("to", ""),
|
|
"value": t.get("value", "0"),
|
|
"symbol": t.get("symbol", ""),
|
|
"token": t.get("address", ""),
|
|
}
|
|
)
|
|
elif logs:
|
|
# Check for swap events (Uniswap, etc.)
|
|
result["type"] = "contract_interaction"
|
|
else:
|
|
native_value = event.get("value", "0")
|
|
if native_value and float(native_value) > 0:
|
|
result["type"] = "native_transfer"
|
|
result["value"] = str(float(native_value) / 1e18)
|
|
|
|
# Whale detection — flag transfers > 10 ETH equivalent
|
|
try:
|
|
val = float(event.get("value", "0")) / 1e18 if event.get("value") else 0
|
|
if val > 10:
|
|
result["whale_alert"] = True
|
|
result["whale_value_eth"] = val
|
|
except (ValueError, TypeError):
|
|
pass
|
|
|
|
result["processed"] = True
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Moralis event processing error: {e}")
|
|
result["error"] = str(e)[:200]
|
|
|
|
return result
|
|
|
|
|
|
# ── Endpoints ───────────────────────────────────────────────
|
|
|
|
|
|
@router.post("/helius")
|
|
async def helius_webhook(request: Request):
|
|
"""Receive Helius webhook events (Solana transfers, swaps, mints).
|
|
INTELLIGENT: Whale detection, cluster correlation, scam pattern matching."""
|
|
try:
|
|
body = await request.json()
|
|
except Exception:
|
|
raise HTTPException(status_code=400, detail="Invalid JSON")
|
|
|
|
# Helius can send single events or arrays
|
|
events = body if isinstance(body, list) else [body]
|
|
processed = []
|
|
alerts = []
|
|
|
|
for event in events:
|
|
# Basic processing
|
|
result = _process_helius_event(event)
|
|
processed.append(result)
|
|
|
|
# Intelligent processing
|
|
alert = await _process_with_intelligence(event, "helius")
|
|
if alert:
|
|
alerts.append(alert)
|
|
|
|
# Store in cache for retrieval
|
|
try:
|
|
from app.chain_cache import get_chain_cache
|
|
|
|
cache = get_chain_cache()
|
|
await cache.set("helius_events", processed, "latest", ttl=3600)
|
|
if alerts:
|
|
await cache.set("helius_alerts", alerts, "latest", ttl=3600)
|
|
except Exception:
|
|
pass
|
|
|
|
return {
|
|
"status": "ok",
|
|
"events_processed": len(processed),
|
|
"alerts_generated": len(alerts),
|
|
"critical_alerts": len([a for a in alerts if a.get("severity") == "critical"]),
|
|
}
|
|
|
|
|
|
@router.post("/moralis")
|
|
async def moralis_webhook(request: Request):
|
|
"""Receive Moralis Stream events (EVM whale tracking, token transfers).
|
|
INTELLIGENT: Whale detection, cluster correlation, scam pattern matching."""
|
|
try:
|
|
body = await request.json()
|
|
except Exception:
|
|
raise HTTPException(status_code=400, detail="Invalid JSON")
|
|
|
|
# Moralis streams send arrays of confirmed/tx events
|
|
confirmed = body.get("confirmed", body.get("logs", []))
|
|
if isinstance(body, list):
|
|
confirmed = body
|
|
|
|
processed = []
|
|
alerts = []
|
|
for event in confirmed if isinstance(confirmed, list) else [confirmed]:
|
|
# Basic processing
|
|
result = _process_moralis_event(event)
|
|
processed.append(result)
|
|
|
|
# Intelligent processing
|
|
alert = await _process_with_intelligence(event, "moralis")
|
|
if alert:
|
|
alerts.append(alert)
|
|
|
|
# Cache latest events
|
|
try:
|
|
from app.chain_cache import get_chain_cache
|
|
|
|
cache = get_chain_cache()
|
|
await cache.set("moralis_events", processed, "latest", ttl=3600)
|
|
if alerts:
|
|
await cache.set("moralis_alerts", alerts, "latest", ttl=3600)
|
|
except Exception:
|
|
pass
|
|
|
|
return {
|
|
"status": "ok",
|
|
"events_processed": len(processed),
|
|
"alerts_generated": len(alerts),
|
|
"critical_alerts": len([a for a in alerts if a.get("severity") == "critical"]),
|
|
}
|
|
|
|
|
|
@router.get("/events")
|
|
async def get_recent_events(source: str | None = None):
|
|
"""Get recent webhook events from cache."""
|
|
try:
|
|
from app.chain_cache import get_chain_cache
|
|
|
|
cache = get_chain_cache()
|
|
|
|
events = []
|
|
helius = await cache.get("helius_events", "latest")
|
|
if helius:
|
|
events.extend(helius if source != "moralis" else [])
|
|
|
|
moralis = await cache.get("moralis_events", "latest")
|
|
if moralis:
|
|
events.extend(moralis if source != "helius" else [])
|
|
|
|
return {"total": len(events), "events": events[:50]}
|
|
except Exception:
|
|
return {"total": 0, "events": []}
|
|
|
|
|
|
@router.get("/health")
|
|
async def webhooks_health():
|
|
"""Webhook health check."""
|
|
return {
|
|
"status": "ok",
|
|
"service": "webhook-receiver",
|
|
"endpoints": {
|
|
"helius": "/api/v1/webhooks/helius",
|
|
"moralis": "/api/v1/webhooks/moralis",
|
|
"events": "/api/v1/webhooks/events",
|
|
},
|
|
}
|