Data Flow

Overview

Aquarius processes data through three distinct pipelines: on-chain state ingestion, off-chain intelligence computation, and cross-chain risk propagation. Each pipeline is designed for deterministic execution, bounded latency, and graceful degradation.

On-Chain Data Flow

The primary data pipeline ingests blockchain state and transforms it into actionable risk intelligence.

Step-by-Step

Off-Chain Intelligence Flow

The off-chain pipeline handles computation that does not require direct blockchain interaction.

┌─────────────────────────────────────┐
│  1. Data Normalization              │
│     Raw events → Canonical types    │
├─────────────────────────────────────┤
│  2. Risk Metric Computation         │
│     HF projection, risk velocity,   │
│     liquidation probability          │
├─────────────────────────────────────┤
│  3. Severity Score Assignment       │
│     0-100 composite → severity enum │
├─────────────────────────────────────┤
│  4. Structured Event Emission       │
│     Risk signal broadcast via Router │
├─────────────────────────────────────┤
│  5. Execution Queue Population      │
│     Mitigation actions queued for   │
│     CRE dispatch                    │
└─────────────────────────────────────┘

CRE Workflow Pipeline

The CRE (Chainlink Runtime Environment) workflow is the orchestration layer that ties intelligence to execution. It runs as a shared domain function callable from both CLI and API:

// Simplified CRE workflow pipeline
const result: CREWorkflowResult = {
  protocolStatus: "stable" | "watch" | "high-risk",
  riskScore: {
    composite: number,
    level: RiskSeverity,
    dimensions: { utilization, liquidations, oracleHealth },
  },
  agentDecision: {
    decision: "OK" | "ESCALATE" | "OBSERVE_ONLY",
    confidence: number,
    actionsRequested: string[],
    blackSwanDetected: boolean,
  },
  llmReasoning: {
    action: string,
    confidence: number,
    reason: string,
  } | null,
  latencies: Record<string, number>,
};

The deterministic layers (risk computation, agent decision) always run first. The optional LLM reasoning layer runs asynchronously and never blocks the deterministic path.

Cross-Chain Flow (CCIP)

Aquarius includes a cross-chain risk propagation layer built on Chainlink CCIP.

Current Capabilities

• Risk broadcast — When risk is detected on one chain, a structured risk event is broadcast to registered chains via the CCIPCoordinator contract
• Observe-only mode — Cross-chain signals are currently informational; they do not trigger automatic mitigation on the receiving chain
• Chain registration — Chains must be explicitly registered before they can receive cross-chain risk broadcasts

Future Capabilities

• Multi-chain liquidation monitoring with correlated risk detection
• Cross-chain mitigation execution (e.g., rebalance collateral from Arbitrum to Ethereum)
• Aggregated risk scoring across positions on multiple chains

Event Router Architecture

The Event Router is the central nervous system of the data flow. It provides:

• Non-blocking dispatch — All handlers execute in the microtask queue, preventing any single handler from blocking the event loop
• Wildcard subscriptions — Handlers can subscribe to all events via the "*" channel
• Event statistics — The router tracks total event count and last event timestamp for observability
• Deterministic ordering — Events are processed in the order they are dispatched

const router = new EventRouter();
 
router.on("risk:evaluated", (event) => {
  // Handle risk signal
});
 
router.onAny((event) => {
  // Audit log all events
});
 
router.dispatch({
  type: "risk:evaluated",
  payload: riskSignal,
});
 
router.getStats();
// → { eventCount: 1, lastEventTimestamp: 1708444800000 }