Ship pre-execution security in one function call.

import { aegis } from "@/lib/aegis-sdk";

const result = await aegis.analyze({
  transaction: await tx.toJSON(),
  sender: account.address,
  network: "testnet",
});

if (result.status === "approved") {
  await signAndExecuteTransaction({ transaction: tx });
}

"use client";

import { useState } from "react";
import { useCurrentAccount, useDAppKit } from "@mysten/dapp-kit-react";
import { Transaction } from "@mysten/sui/transactions";
import { aegis } from "@/lib/aegis-sdk";

export function SendButton() {
  const account = useCurrentAccount();
  const dAppKit = useDAppKit();
  const [needsExtension, setNeedsExtension] = useState(false);

  async function send() {
    if (!account) return;

    // 1. Build the transaction exactly as you would today.
    const tx = new Transaction();
    tx.setSender(account.address);
    const [coin] = tx.splitCoins(tx.gas, [tx.pure.u64(50_000_000n)]);
    tx.transferObjects([coin], tx.pure.address(RECIPIENT));

    const payload = await tx.toJSON();

    // 2. Hand it to AEGIS. The extension popup opens; this awaits the user.
    const result = await aegis.analyze({
      transaction: payload,
      sender: account.address,
      network: "testnet",
      label: "Send 0.05 SUI",
    });

    if (result.status === "not_installed") {
      setNeedsExtension(true);
      return;
    }
    if (result.status !== "approved") return; // rejected or cancelled

    // 3. Sign the exact payload AEGIS analyzed — never a rebuilt one.
    await dAppKit.signAndExecuteTransaction({
      transaction: Transaction.from(payload),
    });
  }

  return <button onClick={send}>Send</button>;
}

const result = await aegis.analyze({ transaction, sender, network });

switch (result.status) {
  case "approved":
    await signAndExecuteTransaction({ transaction: tx });
    break;

  case "rejected":
    toast("AEGIS flagged this transaction and you rejected it.");
    break;

  case "cancelled":
    // Popup closed without deciding — usually a no-op.
    break;

  case "not_installed":
    showInstallPrompt();
    break;

  case "error":
    toast.error(result.error!.message);
    break;
}

interface AgentAnalysis {
  explanation: string;
  riskScore: number;                          // 0–100
  riskFlags: string[];
  recommendation: "approve" | "caution" | "reject";
  operations: string[];
  protocols: {
    packageId: string;
    name: string;
    category: string;
    audited: boolean;
    risk: string;
  }[];
  simulation: {
    status: string;                           // "simulated" | "estimated" | …
    balanceChanges: { coinType: string; amount: string }[];
    objectChanges: string[];
    gasUsed: { computationCost: string; storageCost: string };
    events: string[];
  } | null;
  similarPatterns?: {
    description: string;
    category: string;
    riskLevel: string;
    similarity: number;                       // 0–1
  }[];
}

import { useEffect, useState } from "react";
import { aegis } from "@/lib/aegis-sdk";

function useAegis() {
  const [version, setVersion] = useState<string | null>(null);
  const [checked, setChecked] = useState(false);

  useEffect(() => {
    let cancelled = false;
    aegis.detect().then((provider) => {
      if (cancelled) return;
      setVersion(provider?.version ?? null);
      setChecked(true);
    });
    return () => { cancelled = true; };
  }, []);

  return { installed: version !== null, version, checked };
}

// Without the SDK — the raw injected provider.
if (window.aegis?.isAegis) {
  const { status, analysis } = await window.aegis.analyze({
    transaction: await tx.toJSON(),
    sender: address,
    network: "testnet",
  });
}

// Injected at document_start, and announced for late listeners:
window.addEventListener("aegis#initialized", (e) => {
  console.log("AEGIS ready", e.detail); // { name, rdns, version }
});

POST http://localhost:3001/analyze-stream
Content-Type: application/json

{ "rawPtb": "<tx.toJSON() string>", "walletAddress": "0x…" }

--- response: text/event-stream ---
data: {"type":"tool_start","tool":"parse_ptb","label":"Decoding PTB"}
data: {"type":"tool_end","tool":"parse_ptb","summary":"4 commands, 2 packages"}
data: {"type":"thought","text":"Checking the target against …","source":"gemini"}
data: {"type":"result","data":{ … AgentAnalysis … }}
data: {"type":"error","message":"…"}