Add AI-powered RPC health monitoring and adaptive response system

Dockerfile

@@ -0,0 +1,17 @@
+# Base image
+FROM node:18-alpine
+
+# Set working directory
+WORKDIR /app
+
+# Copy files
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+
+# Expose port
+EXPOSE 3000
+
+# Start app
+CMD ["npm", "start"]

ReadMe.md

@@ -1 +1,56 @@
-See [PiRC1: Pi Ecosystem Token Design](./PiRC1/ReadMe.md)
+See [PiRC1: Pi Ecosystem Token Design](./PiRC1/ReadMe.md)
+
+
+🚀 PiRC AI Oracle – Health Monitoring Engine
+
+Overview
+
+PiRC AI Oracle is an intelligent monitoring system for Pi Testnet RPC nodes.
+It analyzes network health and automatically determines risk levels and system actions.
+
+Features
+
+- 🔍 Real-time RPC health monitoring ("getHealth")
+- 🧠 AI-based risk analysis engine
+- ⚡ Automated decision system (failover, throttling)
+- 🌐 REST API integration
+
+Architecture
+
+Pi RPC → AI Oracle → Risk Engine → Action Engine → API
+
+API Endpoint
+
+GET /api/health-check
+
+Example Response
+
+{
+  "health": {
+    "status": "degraded",
+    "txCount": 1200,
+    "ledger": 9500
+  },
+  "analysis": {
+    "risk": "HIGH",
+    "score": 80,
+    "insight": "⚠️ Network anomaly detected"
+  },
+  "action": {
+    "action": "SWITCH_RPC",
+    "message": "Switching to backup node..."
+  }
+}
+
+Installation
+
+npm install
+npm start
+
+Vision
+
+To build a self-adaptive AI-powered monitoring layer for decentralized infrastructure.
+
+---
+
+🔥 Built for Pi Network ecosystem developers

engine/actionEngine.js

@@ -0,0 +1,40 @@
+import { sendTelegramAlert } from "../alerts/telegramAlert.js";
+import { switchRPC } from "../services/rpcManager.js";
+import { triggerProtection } from "../blockchain/contractTrigger.js";
+
+export async function takeAction(analysis) {
+  //  HIGH RISK
+  if (analysis.risk === "HIGH") {
+    // kirim alert
+    await sendTelegramAlert(
+      ` *Pi Network Alert*\nRisk: HIGH\nScore: ${analysis.score}\n${analysis.insight}`
+    );
+
+    // switch RPC
+    const newRpc = switchRPC();
+
+    // trigger protection (optional)
+    await triggerProtection("PAUSE");
+
+    return {
+      action: "EMERGENCY_MODE",
+      rpc: newRpc,
+      protection: "ENABLED",
+      message: "High risk detected: RPC switched & protection activated"
+    };
+  }
+
+  //  MEDIUM RISK
+  if (analysis.risk === "MEDIUM") {
+    return {
+      action: "THROTTLE",
+      message: "Reducing request rate..."
+    };
+  }
+
+  //  SAFE
+  return {
+    action: "NORMAL",
+    message: "All systems stable"
+  };
+}

k8s/deployment.yaml

@@ -0,0 +1,19 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: pirc-ai-oracle
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: pirc-ai-oracle
+  template:
+    metadata:
+      labels:
+        app: pirc-ai-oracle
+    spec:
+      containers:
+        - name: pirc-ai-oracle
+          image: pirc-ai-oracle:latest
+          ports:
+            - containerPort: 3000

k8s/service.yaml

@@ -0,0 +1,12 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: pirc-service
+spec:
+  type: NodePort
+  selector:
+    app: pirc-ai-oracle
+  ports:
+    - port: 80
+      targetPort: 3000
+      nodePort: 30007

oracle/aiOracle.js

@@ -0,0 +1,28 @@
+export function analyzeHealth(health) {
+  let riskScore = 0;
+  let status = "SAFE";
+
+  if (health.status !== "healthy") riskScore += 40;
+  if (health.txCount > 1000) riskScore += 30;
+  if (health.ledger < 10000) riskScore += 20;
+
+  if (riskScore > 70) status = "HIGH";
+  else if (riskScore > 40) status = "MEDIUM";
+
+  return {
+    risk: status,
+    score: riskScore,
+    insight: generateInsight(status)
+  };
+}
+
+function generateInsight(status) {
+  switch (status) {
+    case "HIGH":
+      return "⚠️ Network anomaly detected";
+    case "MEDIUM":
+      return "⚡ Moderate load detected";
+    default:
+      return "✅ Network stable";
+  }
+}

package.json

@@ -0,0 +1,14 @@
+{
+  "name": "pirc-ai-oracle",
+  "version": "1.0.0",
+  "description": "AI-powered health monitoring for Pi Testnet RPC",
+  "main": "src/app.js",
+  "type": "module",
+  "scripts": {
+    "start": "node src/app.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "node-fetch": "^3.3.2"
+  }
+}

routes/healthRoute.js

@@ -0,0 +1,22 @@
+import express from "express";
+import { getPiHealth } from "../services/piHealth.js";
+import { analyzeHealth } from "../oracle/aiOracle.js";
+import { takeAction } from "../engine/actionEngine.js";
+
+const router = express.Router();
+
+router.get("/health-check", async (req, res) => {
+  try {
+    const health = await getPiHealth();
+    const analysis = analyzeHealth(health);
+    const action = takeAction(analysis);
+
+    res.json({ health, analysis, action });
+  } catch (err) {
+    res.status(500).json({
+      error: "Failed to fetch health"
+    });
+  }
+});
+
+export default router;

services/piHealth.js

@@ -0,0 +1,20 @@
+import fetch from "node-fetch";
+import { getCurrentRPC } from "./rpcManager.js";
+
+export async function getPiHealth() {
+  const rpc = getCurrentRPC();
+
+  const res = await fetch(rpc, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "getHealth"
+    })
+  });
+
+  return res.json();
+}

src/alerts/telegramAlert.js

@@ -0,0 +1,22 @@
+import fetch from "node-fetch";
+
+const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
+const CHAT_ID = process.env.TELEGRAM_CHAT_ID;
+
+export async function sendTelegramAlert(message) {
+  if (!BOT_TOKEN || !CHAT_ID) return;
+
+  const url = `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`;
+
+  await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      chat_id: CHAT_ID,
+      text: message,
+      parse_mode: "Markdown"
+    })
+  });
+}

src/app.js

@@ -0,0 +1,38 @@
+import express from "express";
+import { getPiHealth } from "./services/piHealth.js";
+import { analyzeHealth } from "./oracle/aiOracle.js";
+import { takeAction } from "./engine/actionEngine.js";
+
+//  import metrics
+import metricsRoute, { updateMetrics } from "./routes/metrics.js";
+
+const app = express();
+
+app.use(express.json());
+
+//  register endpoint metrics
+app.use("/metrics", metricsRoute);
+
+//  endpoint utama
+app.get("/health-check", async (req, res) => {
+  try {
+    const health = await getPiHealth();
+    const analysis = analyzeHealth(health);
+    const action = await takeAction(analysis);
+
+    //  update metrics DI SINI (bukan di luar)
+    updateMetrics({ health, analysis, action });
+
+    res.json({
+      health,
+      analysis,
+      action
+    });
+  } catch (err) {
+    res.status(500).json({
+      error: "Failed to fetch health"
+    });
+  }
+});
+
+export default app;

src/blockchain/contractTrigger.js

@@ -0,0 +1,10 @@
+import { triggerProtection } from "../blockchain/contractTrigger.js";
+
+if (analysis.risk === "HIGH") {
+  await triggerProtection("PAUSE");
+
+  return {
+    action: "PAUSE_NETWORK",
+    message: "Smart contract paused"
+  };
+}

src/blockchain/oracleBridge.js

@@ -0,0 +1,9 @@
+export async function sendToBlockchain(data) {
+  console.log("📡 Sending AI result to blockchain...");
+
+  // pseudo-call
+  return {
+    txHash: "0xORACLE123",
+    data
+  };
+}

src/blockchain/piContract.js

@@ -0,0 +1,8 @@
+export async function pauseNetwork() {
+  console.log("⛔ Pausing network via smart contract...");
+
+  return {
+    txHash: "0xPAUSE",
+    status: "success"
+  };
+}

src/config/rpcList.js

@@ -0,0 +1,5 @@
+export const RPC_ENDPOINTS = [
+  "https://rpc.testnet.minepi.com",
+  "https://rpc-backup1.minepi.com",
+  "https://rpc-backup2.minepi.com"
+];

src/ml/anomalyModel.js

@@ -0,0 +1,23 @@
+import * as tf from "@tensorflow/tfjs";
+
+let model;
+
+export async function loadModel() {
+  model = tf.sequential();
+  model.add(tf.layers.dense({ units: 8, inputShape: [2], activation: "relu" }));
+  model.add(tf.layers.dense({ units: 1, activation: "sigmoid" }));
+
+  model.compile({
+    optimizer: "adam",
+    loss: "binaryCrossentropy"
+  });
+}
+
+export function predictAnomaly(txCount, ledger) {
+  if (!model) return 0;
+
+  const input = tf.tensor2d([[txCount, ledger]]);
+  const output = model.predict(input);
+
+  return output.dataSync()[0];
+}

src/routes/metrics.js

@@ -0,0 +1,15 @@
+import express from "express";
+
+const router = express.Router();
+
+let latestData = {};
+
+export function updateMetrics(data) {
+  latestData = data;
+}
+
+router.get("/metrics", (req, res) => {
+  res.json(latestData);
+});
+
+export default router;

src/server.js

@@ -0,0 +1,7 @@
+import app from "./app.js";
+
+const PORT = process.env.PORT || 3000;
+
+app.listen(PORT, () => {
+  console.log(`🚀 PiRC AI Oracle running on port ${PORT}`);
+});

src/services/rpcManager.js

@@ -0,0 +1,12 @@
+import { RPC_ENDPOINTS } from "../config/rpcList.js";
+
+let currentIndex = 0;
+
+export function getCurrentRPC() {
+  return RPC_ENDPOINTS[currentIndex];
+}
+
+export function switchRPC() {
+  currentIndex = (currentIndex + 1) % RPC_ENDPOINTS.length;
+  return getCurrentRPC();
+}