feat: extend get_market_incident_status to Aave V3

Mirror the Compound V3 flow: iterate UiPoolDataProviderV3 reserves,
derive per-reserve utilization from totalScaledVariableDebt ×
variableBorrowIndex / (availableLiquidity + variableDebt), and flag on
isPaused / isFrozen / !isActive / utilization ≥ 0.95.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: szhygulin

src/index.ts

@@ -1148,7 +1148,7 @@ async function main() {
     "get_market_incident_status",
     {
       description:
-        "Return an 'is anything on fire' snapshot across every registered market for a protocol + chain. For Compound V3, returns per-market pause flags, utilization, totalSupply, totalBorrow, and a `flagged` bit that's true when any pause is active or utilization ≥ 95% (borrowers trapped). Top-level `incident: true` if any market is flagged. Use this when you suspect a governance pause, a utilization cliff, or a multi-market contagion from a shared collateral exploit — it collapses what would otherwise take one get_compound_market_info call per market.",
+        "Return an 'is anything on fire' snapshot across every registered market for a protocol + chain. For Compound V3, returns per-market pause flags, utilization, totalSupply, totalBorrow. For Aave V3, returns per-reserve isActive/isFrozen/isPaused, utilization, totalSupplied, totalBorrowed. Each entry has a `flagged` bit: Compound flags on any pause or utilization ≥ 95% (borrowers trapped); Aave flags on paused/frozen/inactive or utilization ≥ 95%. Top-level `incident: true` if any market/reserve is flagged. Use when you suspect a governance pause, a utilization cliff, or multi-market contagion from a shared-collateral exploit — collapses what would otherwise take one get_compound_market_info call per market.",
       inputSchema: getMarketIncidentStatusInput.shape,
     },
     handler(getMarketIncidentStatus)

src/modules/incidents/index.ts

@@ -3,6 +3,7 @@ import { getClient } from "../../data/rpc.js";
 import { CONTRACTS } from "../../config/contracts.js";
 import { cometAbi } from "../../abis/compound-comet.js";
 import { erc20Abi } from "../../abis/erc20.js";
+import { aaveUiPoolDataProviderAbi } from "../../abis/aave-ui-pool-data-provider.js";
 import { readCometPausedActions, type CometPausedAction } from "../compound/index.js";
 import { round } from "../../data/format.js";
 import type { SupportedChain } from "../../types/index.js";
@@ -31,7 +32,21 @@ export interface CompoundMarketIncidentEntry {
   flagged: boolean;
 }
 
-export interface MarketIncidentStatus {
+export interface AaveReserveIncidentEntry {
+  chain: SupportedChain;
+  symbol: string;
+  underlyingAsset: `0x${string}`;
+  isActive: boolean;
+  isFrozen: boolean;
+  isPaused: boolean;
+  utilization: number;
+  totalSupplied: string;
+  totalBorrowed: string;
+  /** True when any reserve is paused/frozen/inactive OR utilization ≥ 0.95. */
+  flagged: boolean;
+}
+
+export interface CompoundMarketIncidentStatus {
   protocol: "compound-v3";
   chain: SupportedChain;
   /** Block number at which reads were performed. Useful for incident reports. */
@@ -41,18 +56,42 @@ export interface MarketIncidentStatus {
   markets: CompoundMarketIncidentEntry[];
 }
 
+export interface AaveMarketIncidentStatus {
+  protocol: "aave-v3";
+  chain: SupportedChain;
+  blockNumber: string;
+  incident: boolean;
+  markets: AaveReserveIncidentEntry[];
+}
+
+export type MarketIncidentStatus =
+  | CompoundMarketIncidentStatus
+  | AaveMarketIncidentStatus;
+
 const HIGH_UTILIZATION_FLAG = 0.95;
+const RAY = 10n ** 27n;
+function rayMul(a: bigint, b: bigint): bigint {
+  return (a * b + RAY / 2n) / RAY;
+}
 
 export async function getMarketIncidentStatus(
   args: GetMarketIncidentStatusArgs
 ): Promise<MarketIncidentStatus> {
   const chain = args.chain as SupportedChain;
-  if (args.protocol !== "compound-v3") {
-    throw new Error(
-      `get_market_incident_status currently supports protocol="compound-v3" only. Requested ${args.protocol}.`
-    );
+  if (args.protocol === "compound-v3") {
+    return getCompoundIncidentStatus(chain);
+  }
+  if (args.protocol === "aave-v3") {
+    return getAaveIncidentStatus(chain);
   }
+  throw new Error(
+    `get_market_incident_status supports protocol="compound-v3" or "aave-v3". Requested ${args.protocol}.`
+  );
+}
 
+async function getCompoundIncidentStatus(
+  chain: SupportedChain
+): Promise<CompoundMarketIncidentStatus> {
   const registry = (CONTRACTS as Record<string, Record<string, Record<string, string>>>)[
     chain
   ]?.compound;
@@ -122,3 +161,70 @@ export async function getMarketIncidentStatus(
     markets: entries,
   };
 }
+
+interface AaveReserveRaw {
+  underlyingAsset: `0x${string}`;
+  symbol: string;
+  decimals: bigint;
+  isActive: boolean;
+  isFrozen: boolean;
+  isPaused: boolean;
+  variableBorrowIndex: bigint;
+  availableLiquidity: bigint;
+  totalScaledVariableDebt: bigint;
+}
+
+async function getAaveIncidentStatus(
+  chain: SupportedChain
+): Promise<AaveMarketIncidentStatus> {
+  const aave = (CONTRACTS as Record<string, Record<string, Record<string, string>>>)[
+    chain
+  ]?.aave;
+  if (!aave) {
+    throw new Error(`Aave V3 is not registered on ${chain}.`);
+  }
+  const provider = aave.poolAddressProvider as `0x${string}`;
+  const uiProvider = aave.uiPoolDataProvider as `0x${string}`;
+
+  const client = getClient(chain);
+  const blockNumber = await client.getBlockNumber();
+
+  const reservesResult = await client.readContract({
+    address: uiProvider,
+    abi: aaveUiPoolDataProviderAbi,
+    functionName: "getReservesData",
+    args: [provider],
+  });
+  const [reserves] = reservesResult as unknown as [AaveReserveRaw[], unknown];
+
+  const entries: AaveReserveIncidentEntry[] = reserves.map((r) => {
+    const decimals = Number(r.decimals);
+    const variableDebt = rayMul(r.totalScaledVariableDebt, r.variableBorrowIndex);
+    const totalSupplied = r.availableLiquidity + variableDebt;
+    const utilFraction =
+      totalSupplied === 0n ? 0 : Number(variableDebt) / Number(totalSupplied);
+    const flagged =
+      r.isPaused || r.isFrozen || !r.isActive || utilFraction >= HIGH_UTILIZATION_FLAG;
+
+    return {
+      chain,
+      symbol: r.symbol,
+      underlyingAsset: r.underlyingAsset,
+      isActive: r.isActive,
+      isFrozen: r.isFrozen,
+      isPaused: r.isPaused,
+      utilization: round(utilFraction, 6),
+      totalSupplied: formatUnits(totalSupplied, decimals),
+      totalBorrowed: formatUnits(variableDebt, decimals),
+      flagged,
+    };
+  });
+
+  return {
+    protocol: "aave-v3",
+    chain,
+    blockNumber: blockNumber.toString(),
+    incident: entries.some((e) => e.flagged),
+    markets: entries,
+  };
+}

src/modules/incidents/schemas.ts

@@ -5,9 +5,9 @@ const chainEnum = z.enum(SUPPORTED_CHAINS as unknown as [string, ...string[]]);
 
 export const getMarketIncidentStatusInput = z.object({
   protocol: z
-    .enum(["compound-v3"])
+    .enum(["compound-v3", "aave-v3"])
     .describe(
-      "Lending protocol to scan. Currently only compound-v3 is supported. Aave V3 pauses are per-reserve; Morpho Blue has no core-protocol pause."
+      "Lending protocol to scan. compound-v3 flags per-Comet pause + utilization. aave-v3 flags per-reserve isPaused/isFrozen/!isActive + utilization. Morpho Blue has no core-protocol pause and is not supported."
     ),
   chain: chainEnum
     .default("ethereum")

test/market-incident-status.test.ts

@@ -123,7 +123,99 @@ describe("get_market_incident_status (compound-v3)", () => {
     expect(cusdt.flagged).toBe(false);
   });
 
-  it("refuses protocols other than compound-v3", async () => {
+  it("flags a paused Aave reserve and a high-utilization reserve", async () => {
+    // Three reserves: WETH (paused, low utilization), USDC (clean, 99% utilization),
+    // DAI (clean, normal utilization). Expect incident=true with two flagged entries.
+    const reserves = [
+      {
+        underlyingAsset: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        name: "Wrapped Ether",
+        symbol: "WETH",
+        decimals: 18n,
+        isActive: true,
+        isFrozen: false,
+        isPaused: true, // flagged: paused
+        variableBorrowIndex: 10n ** 27n,
+        availableLiquidity: 1000n * 10n ** 18n,
+        totalScaledVariableDebt: 100n * 10n ** 18n,
+      },
+      {
+        underlyingAsset: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        name: "USD Coin",
+        symbol: "USDC",
+        decimals: 6n,
+        isActive: true,
+        isFrozen: false,
+        isPaused: false,
+        variableBorrowIndex: 10n ** 27n,
+        // 1 unit liquid, 99 units borrowed → 99% util → flagged.
+        availableLiquidity: 1_000_000n,
+        totalScaledVariableDebt: 99_000_000n,
+      },
+      {
+        underlyingAsset: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+        name: "Dai Stablecoin",
+        symbol: "DAI",
+        decimals: 18n,
+        isActive: true,
+        isFrozen: false,
+        isPaused: false,
+        variableBorrowIndex: 10n ** 27n,
+        availableLiquidity: 500n * 10n ** 18n,
+        totalScaledVariableDebt: 500n * 10n ** 18n, // 50% util, not flagged
+      },
+    ];
+
+    const mockClient = {
+      getBlockNumber: vi.fn(async () => 19_800_000n),
+      readContract: vi.fn(
+        async ({ functionName }: { functionName: string }) => {
+          if (functionName === "getReservesData") {
+            return [
+              reserves,
+              {
+                marketReferenceCurrencyUnit: 10n ** 8n,
+                marketReferenceCurrencyPriceInUsd: 10n ** 8n,
+                networkBaseTokenPriceInUsd: 0n,
+                networkBaseTokenPriceDecimals: 8,
+              },
+            ];
+          }
+          throw new Error(`unexpected readContract ${functionName}`);
+        }
+      ),
+    };
+
+    vi.doMock("../src/data/rpc.js", () => ({
+      getClient: () => mockClient,
+      resetClients: () => {},
+    }));
+
+    const { getMarketIncidentStatus } = await import(
+      "../src/modules/incidents/index.js"
+    );
+    const result = await getMarketIncidentStatus({
+      protocol: "aave-v3",
+      chain: "ethereum",
+    });
+
+    expect(result.protocol).toBe("aave-v3");
+    expect(result.incident).toBe(true);
+    expect(result.markets).toHaveLength(3);
+
+    const weth = result.markets.find((m) => m.symbol === "WETH")!;
+    expect(weth.isPaused).toBe(true);
+    expect(weth.flagged).toBe(true);
+
+    const usdc = result.markets.find((m) => m.symbol === "USDC")!;
+    expect(usdc.utilization).toBeGreaterThanOrEqual(0.95);
+    expect(usdc.flagged).toBe(true);
+
+    const dai = result.markets.find((m) => m.symbol === "DAI")!;
+    expect(dai.flagged).toBe(false);
+  });
+
+  it("refuses unsupported protocols", async () => {
     vi.doMock("../src/data/rpc.js", () => ({
       getClient: () => ({ getBlockNumber: async () => 0n, multicall: async () => [] }),
       resetClients: () => {},
@@ -133,9 +225,9 @@ describe("get_market_incident_status (compound-v3)", () => {
     );
     await expect(
       getMarketIncidentStatus({
-        protocol: "aave-v3" as unknown as "compound-v3",
+        protocol: "morpho-blue" as unknown as "compound-v3",
         chain: "ethereum",
       })
-    ).rejects.toThrow(/compound-v3/);
+    ).rejects.toThrow(/compound-v3|aave-v3/);
   });
 });