0g chain contracts + storage + wallet + on-chain bridge

.env.example

@@ -0,0 +1,46 @@
+# Copy this file to `.env` and fill in real values.
+# Never commit real secrets.
+
+# ---------------------------------------------------------------------------
+# Azure (shared key for OpenAI + AI Foundry models)
+# ---------------------------------------------------------------------------
+AZURE_API_KEY=
+AZURE_OPENAI_API_ENDPOINT=https://your-resource.cognitiveservices.azure.com/
+FOUNDRY_MODELS_ENDPOINT=https://your-resource.services.ai.azure.com/openai/v1/
+
+# ---------------------------------------------------------------------------
+# AWS Bedrock (ABSK bearer token for nova-pro, claude, MiniMax, jury models)
+# ---------------------------------------------------------------------------
+AWS_BEARER_TOKEN_BEDROCK=
+
+# ---------------------------------------------------------------------------
+# Gemma via Modal (self-hosted, OpenAI-compatible)
+# ---------------------------------------------------------------------------
+GEMMA_BASE_URL=
+GEMMA_API_KEY=not-needed
+
+# ---------------------------------------------------------------------------
+# Framework service endpoints (optional)
+# ---------------------------------------------------------------------------
+CDCT_API_URL=https://cdct-framework.vercel.app/
+DDFT_API_URL=https://ddft-framework.vercel.app/
+EECT_API_URL=https://eect-framework.vercel.app/
+
+# ---------------------------------------------------------------------------
+# 0G Storage
+# ---------------------------------------------------------------------------
+ZG_PRIVATE_KEY=
+ZG_RPC_URL=https://evmrpc-testnet.0g.ai
+ZG_INDEXER_RPC=https://indexer-storage-testnet-turbo.0g.ai
+
+# ---------------------------------------------------------------------------
+# Smart contract deployment / treasury wallet
+# ---------------------------------------------------------------------------
+PRIVATE_KEY=
+CGAE_REGISTRY_ADDRESS=
+CGAE_ESCROW_ADDRESS=
+
+# ---------------------------------------------------------------------------
+# Dashboard
+# ---------------------------------------------------------------------------
+MODAL_ENDPOINT=

.gitignore

@@ -1,4 +1,24 @@
 *.pyc
 __pycache__/
 .env
-.venv/
+.venv/
+.pytest_cache/
+
+# Node
+node_modules/
+package-lock.json
+
+# Hardhat
+contracts/artifacts/
+contracts/cache/
+
+# Simulation results (generated)
+server/results/
+server/live_results/
+
+# Next.js
+dashboard-next/.next/
+dashboard-next/node_modules/
+
+# OS
+.DS_Store

cgae_engine/audit.py

@@ -471,10 +471,7 @@ class AuditOrchestrator:
                 return cc, False
         except Exception:
             pass
-        logger.info(
-            f"  [pre-computed audit] CDCT done for {model_name}: "
-            f"CC={default_cc:.3f} (fallback default)"
-        )
+        logger.debug(f"  [pre-computed audit] CDCT fallback for {model_name}: CC={default_cc:.3f}")
         return default_cc, True
 
     def _load_ddft_score(self, model_name: str) -> tuple[float, bool]:
@@ -488,10 +485,7 @@ class AuditOrchestrator:
                 return er, False
         except Exception:
             pass
-        logger.info(
-            f"  [pre-computed audit] DDFT done for {model_name}: "
-            f"ER={default_er:.3f} (fallback default)"
-        )
+        logger.debug(f"  [pre-computed audit] DDFT fallback for {model_name}: ER={default_er:.3f}")
         return default_er, True
 
     def _load_eect_score(self, model_name: str) -> tuple[float, bool]:
@@ -505,10 +499,7 @@ class AuditOrchestrator:
                 return as_, False
         except Exception:
             pass
-        logger.info(
-            f"  [pre-computed audit] EECT done for {model_name}: "
-            f"AS={default_as:.3f} (fallback default)"
-        )
+        logger.debug(f"  [pre-computed audit] EECT fallback for {model_name}: AS={default_as:.3f}")
         return default_as, True
 
     def _load_ih_score(self, model_name: str) -> tuple[float, bool]:
@@ -521,10 +512,7 @@ class AuditOrchestrator:
                 return ih, False
         except Exception:
             pass
-        logger.info(
-            f"  [pre-computed audit] DDFT done for {model_name}: "
-            f"IH={default_ih:.3f} (fallback default)"
-        )
+        logger.debug(f"  [pre-computed audit] DDFT fallback for {model_name}: IH={default_ih:.3f}")
         return default_ih, True
 
     @staticmethod

cgae_engine/onchain.py

@@ -0,0 +1,170 @@
+"""
+CGAE On-Chain Bridge — Writes certifications to CGAERegistry on 0G Chain.
+
+Calls CGAERegistry.certify() after each audit so the robustness vector
+and 0G Storage root hash are permanently recorded on-chain.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+from web3 import Web3
+from eth_account import Account
+
+logger = logging.getLogger(__name__)
+
+_CONTRACTS_DIR = Path(__file__).resolve().parent.parent / "contracts"
+
+
+def _load_registry_abi() -> list:
+    abi_path = _CONTRACTS_DIR / "artifacts" / "src" / "CGAERegistry.sol" / "CGAERegistry.json"
+    if not abi_path.exists():
+        raise FileNotFoundError(f"Registry ABI not found at {abi_path}. Run: cd contracts && npx hardhat compile")
+    return json.loads(abi_path.read_text())["abi"]
+
+
+def _load_deployed() -> dict:
+    path = _CONTRACTS_DIR / "deployed.json"
+    if not path.exists():
+        raise FileNotFoundError("contracts/deployed.json not found. Run: npm run deploy:0g")
+    return json.loads(path.read_text())
+
+
+class OnChainBridge:
+    """
+    Bridges Python-side certifications to the on-chain CGAERegistry.
+
+    On each certify() call, sends a tx to CGAERegistry.certify() with
+    the robustness vector (scaled to uint16) and the 0G Storage root hash.
+    """
+
+    def __init__(
+        self,
+        rpc_url: Optional[str] = None,
+        private_key: Optional[str] = None,
+        registry_address: Optional[str] = None,
+    ):
+        self.rpc_url = rpc_url or os.getenv("ZG_RPC_URL", "https://evmrpc-testnet.0g.ai")
+        self._key = private_key or os.getenv("PRIVATE_KEY")
+        self.w3 = Web3(Web3.HTTPProvider(self.rpc_url))
+
+        if self._key:
+            key = self._key if self._key.startswith("0x") else f"0x{self._key}"
+            self._account = Account.from_key(key)
+        else:
+            self._account = None
+
+        # Load registry contract
+        if registry_address:
+            self._registry_addr = registry_address
+        else:
+            deployed = _load_deployed()
+            self._registry_addr = deployed["contracts"]["CGAERegistry"]["address"]
+
+        abi = _load_registry_abi()
+        self.registry = self.w3.eth.contract(
+            address=Web3.to_checksum_address(self._registry_addr), abi=abi
+        )
+        self._tx_log: list[dict] = []
+
+    @property
+    def is_live(self) -> bool:
+        return self._account is not None
+
+    def certify_agent(
+        self,
+        agent_address: str,
+        cc: float, er: float, as_: float, ih: float,
+        audit_type: str = "registration",
+        audit_hash: str = "",
+    ) -> Optional[str]:
+        """
+        Register (if needed) then certify an agent on-chain.
+
+        Scores are floats in [0,1], scaled to uint16 [0,10000].
+        Returns tx hash or None on failure.
+        """
+        if not self.is_live:
+            logger.info(f"  [onchain] Dry run certify {agent_address[:10]}… (no key)")
+            return None
+
+        agent_addr = Web3.to_checksum_address(agent_address)
+
+        # Auto-register if not yet on-chain
+        try:
+            record = self.registry.functions.getAgent(agent_addr).call()
+            if record[4] == 0:  # registrationTime == 0 means not registered
+                self._register_agent_onchain(agent_addr, audit_type)
+        except Exception:
+            self._register_agent_onchain(agent_addr, audit_type)
+
+        # Scale [0,1] → [0,10000]
+        cc_u = min(10000, int(cc * 10000))
+        er_u = min(10000, int(er * 10000))
+        as_u = min(10000, int(as_ * 10000))
+        ih_u = min(10000, int(ih * 10000))
+
+        try:
+            nonce = self.w3.eth.get_transaction_count(self._account.address)
+            tx = self.registry.functions.certify(
+                Web3.to_checksum_address(agent_address),
+                cc_u, er_u, as_u, ih_u,
+                audit_type,
+                audit_hash or "",
+            ).build_transaction({
+                "from": self._account.address,
+                "nonce": nonce,
+                "gas": 300_000,
+                "gasPrice": self.w3.eth.gas_price,
+                "chainId": self.w3.eth.chain_id,
+            })
+
+            signed = self._account.sign_transaction(tx)
+            tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
+            receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
+
+            result = {
+                "agent": agent_address,
+                "tx_hash": tx_hash.hex(),
+                "status": "confirmed" if receipt["status"] == 1 else "failed",
+                "scores": {"cc": cc, "er": er, "as": as_, "ih": ih},
+                "audit_hash": audit_hash,
+            }
+            self._tx_log.append(result)
+            logger.info(f"  [onchain] Certified {agent_address[:10]}… tx={tx_hash.hex()[:16]}…")
+            return tx_hash.hex()
+
+        except Exception as e:
+            logger.error(f"  [onchain] Certify failed for {agent_address[:10]}…: {e}")
+            self._tx_log.append({"agent": agent_address, "error": str(e)})
+            return None
+
+    @property
+    def tx_log(self) -> list[dict]:
+        return list(self._tx_log)
+
+    def _register_agent_onchain(self, agent_addr: str, model_name: str = "cgae-agent"):
+        """Register an agent on-chain via registerAgent()."""
+        try:
+            arch_hash = Web3.keccak(text=model_name)[:16]  # first 16 bytes of keccak(model_name)
+            nonce = self.w3.eth.get_transaction_count(self._account.address)
+            tx = self.registry.functions.registerAgent(
+                agent_addr, arch_hash, model_name
+            ).build_transaction({
+                "from": self._account.address,
+                "nonce": nonce,
+                "gas": 200_000,
+                "gasPrice": self.w3.eth.gas_price,
+                "chainId": self.w3.eth.chain_id,
+            })
+            signed = self._account.sign_transaction(tx)
+            tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
+            self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
+            logger.info(f"  [onchain] Registered {agent_addr[:10]}… tx={tx_hash.hex()[:16]}…")
+        except Exception as e:
+            logger.warning(f"  [onchain] Register failed for {agent_addr[:10]}…: {e}")

cgae_engine/wallet.py

@@ -0,0 +1,200 @@
+"""
+CGAE Wallet Manager — Real ETH wallet integration for agents.
+
+Each agent gets a unique Ethereum keypair on registration.
+A treasury wallet funds agents and disburses ETH on successful contract completion.
+
+Usage:
+    from cgae_engine.wallet import WalletManager
+
+    wm = WalletManager(rpc_url="https://evmrpc-testnet.0g.ai",
+                        treasury_private_key=os.getenv("PRIVATE_KEY"))
+    wallet = wm.create_agent_wallet("agent_abc123")
+    tx = wm.disburse(wallet.address, amount_wei=10**15)  # 0.001 ETH
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from eth_account import Account
+from web3 import Web3
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AgentWallet:
+    """An agent's Ethereum wallet."""
+    agent_id: str
+    address: str
+    private_key: str  # hex with 0x prefix
+
+    def to_dict(self, redact_key: bool = True) -> dict:
+        return {
+            "agent_id": self.agent_id,
+            "address": self.address,
+            "private_key": self.private_key[:10] + "..." if redact_key else self.private_key,
+        }
+
+
+class WalletManager:
+    """
+    Manages ETH wallets for CGAE agents.
+
+    - Creates a unique keypair per agent
+    - Sends real ETH from a treasury wallet on contract settlement
+    - Tracks all disbursements for audit trail
+    """
+
+    def __init__(
+        self,
+        rpc_url: Optional[str] = None,
+        treasury_private_key: Optional[str] = None,
+        dry_run: bool = False,
+    ):
+        self.rpc_url = rpc_url or os.getenv("ZG_RPC_URL", "https://evmrpc-testnet.0g.ai")
+        self._treasury_key = treasury_private_key or os.getenv("PRIVATE_KEY")
+        self.dry_run = dry_run
+
+        self.w3 = Web3(Web3.HTTPProvider(self.rpc_url))
+        self._wallets: dict[str, AgentWallet] = {}  # agent_id -> wallet
+        self._disbursements: list[dict] = []
+
+        if self._treasury_key:
+            key = self._treasury_key if self._treasury_key.startswith("0x") else f"0x{self._treasury_key}"
+            self._treasury_account = Account.from_key(key)
+            self.treasury_address = self._treasury_account.address
+        else:
+            self._treasury_account = None
+            self.treasury_address = None
+
+    @property
+    def is_live(self) -> bool:
+        """True if we can send real transactions."""
+        return self._treasury_account is not None and not self.dry_run
+
+    def create_agent_wallet(self, agent_id: str) -> AgentWallet:
+        """Generate a new ETH keypair for an agent."""
+        if agent_id in self._wallets:
+            return self._wallets[agent_id]
+
+        acct = Account.create()
+        wallet = AgentWallet(
+            agent_id=agent_id,
+            address=acct.address,
+            private_key=acct.key.hex() if isinstance(acct.key, bytes) else acct.key,
+        )
+        self._wallets[agent_id] = wallet
+        logger.info(f"  [wallet] Created wallet for {agent_id}: {wallet.address}")
+        return wallet
+
+    def get_wallet(self, agent_id: str) -> Optional[AgentWallet]:
+        return self._wallets.get(agent_id)
+
+    def get_balance(self, address: str) -> float:
+        """Get balance in ETH."""
+        try:
+            wei = self.w3.eth.get_balance(Web3.to_checksum_address(address))
+            return float(Web3.from_wei(wei, "ether"))
+        except Exception as e:
+            logger.warning(f"  [wallet] Balance check failed for {address}: {e}")
+            return 0.0
+
+    def get_treasury_balance(self) -> float:
+        if not self.treasury_address:
+            return 0.0
+        return self.get_balance(self.treasury_address)
+
+    def disburse(self, to_address: str, amount_eth: float, reason: str = "") -> Optional[dict]:
+        """
+        Send ETH from treasury to an agent wallet.
+        Returns tx receipt dict or None if dry_run / failed.
+        """
+        amount_wei = Web3.to_wei(amount_eth, "ether")
+
+        record = {
+            "to": to_address,
+            "amount_eth": amount_eth,
+            "reason": reason,
+            "tx_hash": None,
+            "status": "pending",
+        }
+
+        if not self.is_live:
+            record["status"] = "dry_run"
+            self._disbursements.append(record)
+            logger.info(f"  [wallet] DRY RUN disburse {amount_eth:.6f} ETH → {to_address} ({reason})")
+            return record
+
+        try:
+            nonce = self.w3.eth.get_transaction_count(self.treasury_address)
+            tx = {
+                "from": self.treasury_address,
+                "to": Web3.to_checksum_address(to_address),
+                "value": amount_wei,
+                "gas": 21000,
+                "gasPrice": self.w3.eth.gas_price,
+                "nonce": nonce,
+                "chainId": self.w3.eth.chain_id,
+            }
+            signed = self._treasury_account.sign_transaction(tx)
+            tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
+            receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
+
+            record["tx_hash"] = tx_hash.hex()
+            record["status"] = "confirmed" if receipt["status"] == 1 else "failed"
+            self._disbursements.append(record)
+
+            logger.info(
+                f"  [wallet] Disbursed {amount_eth:.6f} ETH → {to_address} "
+                f"(tx: {tx_hash.hex()[:16]}… status: {record['status']})"
+            )
+            return record
+
+        except Exception as e:
+            record["status"] = f"error: {e}"
+            self._disbursements.append(record)
+            logger.error(f"  [wallet] Disburse failed: {e}")
+            return record
+
+    def fund_agent(self, agent_id: str, amount_eth: float) -> Optional[dict]:
+        """Convenience: disburse ETH to an agent by agent_id."""
+        wallet = self._wallets.get(agent_id)
+        if not wallet:
+            logger.warning(f"  [wallet] No wallet for {agent_id}")
+            return None
+        return self.disburse(wallet.address, amount_eth, reason=f"fund:{agent_id}")
+
+    def disburse_reward(self, agent_id: str, amount_eth: float, contract_id: str = "") -> Optional[dict]:
+        """Disburse contract reward to agent."""
+        wallet = self._wallets.get(agent_id)
+        if not wallet:
+            return None
+        return self.disburse(wallet.address, amount_eth, reason=f"reward:{contract_id}")
+
+    @property
+    def disbursements(self) -> list[dict]:
+        return list(self._disbursements)
+
+    def summary(self) -> dict:
+        total_disbursed = sum(d["amount_eth"] for d in self._disbursements if d["status"] in ("confirmed", "dry_run"))
+        return {
+            "treasury_address": self.treasury_address,
+            "treasury_balance_eth": self.get_treasury_balance() if self.is_live else None,
+            "agents_with_wallets": len(self._wallets),
+            "total_disbursements": len(self._disbursements),
+            "total_eth_disbursed": total_disbursed,
+            "is_live": self.is_live,
+            "rpc_url": self.rpc_url,
+        }
+
+    def export_wallets(self, path: str, redact_keys: bool = True):
+        """Export wallet mapping to JSON."""
+        data = {aid: w.to_dict(redact_key=redact_keys) for aid, w in self._wallets.items()}
+        Path(path).write_text(json.dumps(data, indent=2))

contracts/deployed.json

@@ -0,0 +1,22 @@
+{
+  "network": "zgTestnet",
+  "chainId": 16602,
+  "deployedAt": "2026-04-25T20:23:43.280Z",
+  "deployer": "0xCE2de05Cd27DBCFe07b9d7862aa69301991c8592",
+  "contracts": {
+    "CGAERegistry": {
+      "address": "0xc4Ff2BC9855483eE3806eE08112cdC30dBf6b27A",
+      "deployTx": "0x37ef76d5b40ed9fa6896c28df7e21a7c6271057ab77c44ef201edd0d8b85d271"
+    },
+    "CGAEEscrow": {
+      "address": "0xA236106DE28FE9480509e06d1750dcfA4474bcfB",
+      "deployTx": "0xb8cc59fb3cd624727e61314c1dc5fb1b70a6a868101378ab5b2456608bc6776d"
+    }
+  },
+  "rpc": "https://evmrpc-testnet.0g.ai",
+  "explorer": "https://chainscan-galileo.0g.ai",
+  "storage": {
+    "indexer": "https://indexer-storage-testnet-turbo.0g.ai",
+    "scan": "https://storagescan-galileo.0g.ai"
+  }
+}

contracts/hardhat.config.js

@@ -0,0 +1,65 @@
+require("@nomicfoundation/hardhat-toolbox");
+
+/**
+ * Hardhat configuration for CGAE smart contracts.
+ *
+ * Targets:
+ *   zgTestnet  — 0G Chain Testnet (EVM-compatible)
+ *   localhost  — Local Hardhat node for development
+ *
+ * Required env vars for 0G Testnet deployment:
+ *   PRIVATE_KEY  — hex private key (no 0x prefix) of the deployer wallet
+ *
+ * Testnet resources:
+ *   Token Faucet: https://faucet.0g.ai
+ *   Explorer:     https://chainscan-galileo.0g.ai
+ *   EVM RPC:      https://evmrpc-testnet.0g.ai
+ *
+ * Usage:
+ *   cd contracts
+ *   npm install
+ *   export PRIVATE_KEY=<your_hex_key>
+ *   npm run deploy:0g
+ */
+
+const PRIVATE_KEY = process.env.PRIVATE_KEY ||
+  // Fallback zero key for compilation/testing only — never deploy with this
+  "0000000000000000000000000000000000000000000000000000000000000001";
+
+/** @type import('hardhat/config').HardhatUserConfig */
+module.exports = {
+  solidity: {
+    version: "0.8.20",
+    settings: {
+      optimizer: {
+        enabled: true,
+        runs: 200,
+      },
+      viaIR: true,
+    },
+  },
+
+  networks: {
+    // 0G Chain Testnet (EVM-compatible)
+    zgTestnet: {
+      url: process.env.ZG_RPC_URL || "https://evmrpc-testnet.0g.ai",
+      chainId: 16602,
+      accounts: [`0x${PRIVATE_KEY}`],
+      gas: 10_000_000,
+      gasPrice: 2_500_000_000,
+      timeout: 120_000,
+    },
+
+    // Local development
+    localhost: {
+      url: "http://127.0.0.1:8545",
+      chainId: 31337,
+    },
+  },
+
+  paths: {
+    sources: "./src",
+    artifacts: "./artifacts",
+    cache: "./cache",
+  },
+};

contracts/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "cgae-contracts",
+  "version": "2.0.0",
+  "description": "CGAE smart contracts for 0G Chain",
+  "private": true,
+  "scripts": {
+    "compile": "npx hardhat compile",
+    "deploy:0g": "npx hardhat run scripts/deploy.js --network zgTestnet",
+    "deploy:local": "npx hardhat run scripts/deploy.js --network localhost",
+    "test": "npx hardhat test"
+  },
+  "devDependencies": {
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "hardhat": "^2.28.6"
+  },
+  "dependencies": {
+    "ethers": "^6.0.0"
+  }
+}

contracts/scripts/deploy.js

@@ -0,0 +1,109 @@
+/**
+ * CGAE Deployment Script — 0G Chain Testnet
+ * ==========================================
+ * Deploys CGAERegistry and CGAEEscrow to 0G Chain and writes
+ * the resulting contract addresses to deployed.json.
+ *
+ * Usage:
+ *   cd contracts
+ *   npm install
+ *   export PRIVATE_KEY=<hex_private_key_no_0x>
+ *   npm run deploy:0g
+ */
+
+const { ethers } = require("hardhat");
+const fs = require("fs");
+const path = require("path");
+
+async function main() {
+  const [deployer] = await ethers.getSigners();
+  const network = await ethers.provider.getNetwork();
+  const chainId = Number(network.chainId);
+
+  console.log("=".repeat(60));
+  console.log("CGAE Contract Deployment — 0G Chain");
+  console.log("=".repeat(60));
+  console.log(`Network:  ${network.name} (chain ${chainId})`);
+  console.log(`Deployer: ${deployer.address}`);
+
+  const balance = await ethers.provider.getBalance(deployer.address);
+  console.log(`Balance:  ${ethers.formatEther(balance)} A0GI\n`);
+
+  if (balance === 0n) {
+    console.error("ERROR: Deployer wallet has 0 tokens.");
+    console.error("Get testnet tokens from: https://faucet.0g.ai");
+    process.exit(1);
+  }
+
+  // Deploy CGAERegistry
+  console.log("Deploying CGAERegistry...");
+  const RegistryFactory = await ethers.getContractFactory("CGAERegistry");
+  const registry = await RegistryFactory.deploy();
+  await registry.waitForDeployment();
+  const registryAddress = await registry.getAddress();
+  console.log(`  CGAERegistry deployed to: ${registryAddress}`);
+
+  // Deploy CGAEEscrow
+  console.log("Deploying CGAEEscrow...");
+  const EscrowFactory = await ethers.getContractFactory("CGAEEscrow");
+  const escrow = await EscrowFactory.deploy(registryAddress);
+  await escrow.waitForDeployment();
+  const escrowAddress = await escrow.getAddress();
+  console.log(`  CGAEEscrow deployed to:   ${escrowAddress}`);
+
+  // Authorize escrow as auditor
+  console.log("Authorizing CGAEEscrow as auditor in CGAERegistry...");
+  const authTx = await registry.authorizeAuditor(escrowAddress);
+  await authTx.wait();
+  console.log(`  Authorized (tx: ${authTx.hash})`);
+
+  // Write deployment manifest
+  const explorer = chainId === 16602
+    ? "https://chainscan-galileo.0g.ai"
+    : "http://localhost";
+
+  const manifest = {
+    network: network.name,
+    chainId,
+    deployedAt: new Date().toISOString(),
+    deployer: deployer.address,
+    contracts: {
+      CGAERegistry: {
+        address: registryAddress,
+        deployTx: registry.deploymentTransaction()?.hash || null,
+      },
+      CGAEEscrow: {
+        address: escrowAddress,
+        deployTx: escrow.deploymentTransaction()?.hash || null,
+      },
+    },
+    rpc: process.env.ZG_RPC_URL || "https://evmrpc-testnet.0g.ai",
+    explorer,
+    storage: {
+      indexer: "https://indexer-storage-testnet-turbo.0g.ai",
+      scan: "https://storagescan-galileo.0g.ai",
+    },
+  };
+
+  const deployedPath = path.join(__dirname, "..", "deployed.json");
+  fs.writeFileSync(deployedPath, JSON.stringify(manifest, null, 2));
+  console.log(`\nDeployment manifest written to: deployed.json`);
+
+  console.log("\n" + "=".repeat(60));
+  console.log("Deployment complete!");
+  console.log("=".repeat(60));
+  console.log(`CGAERegistry : ${explorer}/address/${registryAddress}`);
+  console.log(`CGAEEscrow   : ${explorer}/address/${escrowAddress}`);
+  console.log("\nNext steps:");
+  console.log(`  1. CGAE_REGISTRY_ADDRESS=${registryAddress}`);
+  console.log(`     CGAE_ESCROW_ADDRESS=${escrowAddress}`);
+  console.log("  2. python -m server.live_runner");
+  console.log("=".repeat(60));
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((err) => {
+    console.error("Deployment failed:", err);
+    process.exit(1);
+  });

contracts/src/CGAEEscrow.sol

@@ -0,0 +1,269 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "./CGAERegistry.sol";
+
+/**
+ * @title CGAEEscrow
+ * @notice Contract management and escrow for the CGAE economy.
+ *         Implements tier-gated contract assignment with budget ceiling enforcement
+ *         (Theorem 1: Bounded Economic Exposure).
+ *
+ * @dev All economic activity is mediated through formally specified contracts.
+ *      Rewards are escrowed until verification. Penalties are enforced on failure.
+ */
+contract CGAEEscrow {
+
+    // -----------------------------------------------------------------------
+    // Types
+    // -----------------------------------------------------------------------
+
+    enum ContractStatus {
+        Open,
+        Assigned,
+        Completed,
+        Failed,
+        Expired,
+        Cancelled
+    }
+
+    struct EconomicContract {
+        bytes32 contractId;
+        address issuer;
+        address assignedAgent;
+        string objective;
+        bytes32 constraintsHash;   // Hash of machine-verifiable constraint set (Phi)
+        string verifierSpecHash;   // 0G Storage hash or pointer to verifier specification
+        uint8 minTier;
+        uint256 reward;
+        uint256 penalty;
+        uint64 deadline;
+        uint64 createdAt;
+        ContractStatus status;
+        string domain;
+    }
+
+    // -----------------------------------------------------------------------
+    // State
+    // -----------------------------------------------------------------------
+
+    CGAERegistry public registry;
+
+    mapping(bytes32 => EconomicContract) public contracts;
+    bytes32[] public contractIds;
+
+    // Agent -> total active penalty exposure
+    mapping(address => uint256) public activeExposure;
+
+    // Economic accounting
+    uint256 public totalRewardsPaid;
+    uint256 public totalPenaltiesCollected;
+    uint256 public totalEscrowed;
+
+    address public admin;
+
+    // -----------------------------------------------------------------------
+    // Events
+    // -----------------------------------------------------------------------
+
+    event ContractCreated(bytes32 indexed contractId, uint8 minTier, uint256 reward, string domain);
+    event ContractAssigned(bytes32 indexed contractId, address indexed agent);
+    event ContractCompleted(bytes32 indexed contractId, address indexed agent, uint256 reward);
+    event ContractFailed(bytes32 indexed contractId, address indexed agent, uint256 penalty);
+    event ContractExpired(bytes32 indexed contractId);
+
+    // -----------------------------------------------------------------------
+    // Constructor
+    // -----------------------------------------------------------------------
+
+    constructor(address _registry) {
+        registry = CGAERegistry(_registry);
+        admin = msg.sender;
+    }
+
+    // -----------------------------------------------------------------------
+    // Contract Lifecycle
+    // -----------------------------------------------------------------------
+
+    /**
+     * @notice Create a new contract. Issuer deposits reward as escrow.
+     */
+    function createContract(
+        string calldata objective,
+        bytes32 constraintsHash,
+        string calldata verifierSpecHash,
+        uint8 minTier,
+        uint256 penalty,
+        uint64 deadline,
+        string calldata domain
+    ) external payable {
+        require(msg.value > 0, "Must escrow reward");
+        require(minTier > 0 && minTier <= 5, "Invalid tier");
+        require(deadline > block.timestamp, "Deadline must be in future");
+        require(constraintsHash != bytes32(0), "Missing constraints hash");
+        require(bytes(verifierSpecHash).length > 0, "Missing verifier spec");
+
+        bytes32 contractId = keccak256(abi.encodePacked(
+            msg.sender, block.timestamp, objective, contractIds.length
+        ));
+
+        contracts[contractId] = EconomicContract({
+            contractId: contractId,
+            issuer: msg.sender,
+            assignedAgent: address(0),
+            objective: objective,
+            constraintsHash: constraintsHash,
+            verifierSpecHash: verifierSpecHash,
+            minTier: minTier,
+            reward: msg.value,
+            penalty: penalty,
+            deadline: deadline,
+            createdAt: uint64(block.timestamp),
+            status: ContractStatus.Open,
+            domain: domain
+        });
+
+        contractIds.push(contractId);
+        totalEscrowed += msg.value;
+
+        emit ContractCreated(contractId, minTier, msg.value, domain);
+    }
+
+    /**
+     * @notice Agent accepts a contract. Enforces:
+     *         1. Agent tier >= min_tier
+     *         2. Agent exposure + penalty <= budget ceiling (Theorem 1)
+     */
+    function acceptContract(bytes32 contractId) external payable {
+        EconomicContract storage c = contracts[contractId];
+        require(c.status == ContractStatus.Open, "Not open");
+        require(block.timestamp < c.deadline, "Past deadline");
+
+        // Tier check
+        CGAERegistry.AgentRecord memory agent = registry.getAgent(msg.sender);
+        require(agent.active, "Agent not active");
+        require(agent.currentTier >= c.minTier, "Tier too low");
+
+        // Budget ceiling check (Theorem 1: Bounded Economic Exposure)
+        uint256 ceiling = registry.getBudgetCeiling(agent.currentTier);
+        require(
+            activeExposure[msg.sender] + c.penalty <= ceiling,
+            "Would exceed budget ceiling"
+        );
+
+        // Agent must deposit penalty as collateral
+        require(msg.value >= c.penalty, "Insufficient penalty collateral");
+
+        c.assignedAgent = msg.sender;
+        c.status = ContractStatus.Assigned;
+        activeExposure[msg.sender] += c.penalty;
+
+        emit ContractAssigned(contractId, msg.sender);
+    }
+
+    /**
+     * @notice Mark a contract as completed. Called by admin/verifier after
+     *         output verification. Releases reward to agent, returns collateral.
+     */
+    function completeContract(bytes32 contractId) external {
+        require(msg.sender == admin, "Only admin/verifier");
+        EconomicContract storage c = contracts[contractId];
+        require(c.status == ContractStatus.Assigned, "Not assigned");
+
+        c.status = ContractStatus.Completed;
+
+        // Release exposure
+        activeExposure[c.assignedAgent] -= c.penalty;
+
+        // Pay reward to agent
+        uint256 reward = c.reward;
+        totalEscrowed -= reward;
+        totalRewardsPaid += reward;
+
+        // Return penalty collateral + pay reward
+        uint256 payout = reward + c.penalty;
+        payable(c.assignedAgent).transfer(payout);
+
+        // Record on registry
+        registry.recordContractOutcome(c.assignedAgent, true, reward);
+
+        emit ContractCompleted(contractId, c.assignedAgent, reward);
+    }
+
+    /**
+     * @notice Mark a contract as failed. Penalty is forfeited.
+     */
+    function failContract(bytes32 contractId) external {
+        require(msg.sender == admin, "Only admin/verifier");
+        EconomicContract storage c = contracts[contractId];
+        require(c.status == ContractStatus.Assigned, "Not assigned");
+
+        c.status = ContractStatus.Failed;
+
+        // Release exposure
+        activeExposure[c.assignedAgent] -= c.penalty;
+
+        // Forfeit penalty collateral
+        totalPenaltiesCollected += c.penalty;
+
+        // Return escrowed reward to issuer
+        totalEscrowed -= c.reward;
+        payable(c.issuer).transfer(c.reward);
+
+        // Record on registry
+        registry.recordContractOutcome(c.assignedAgent, false, c.penalty);
+
+        emit ContractFailed(contractId, c.assignedAgent, c.penalty);
+    }
+
+    /**
+     * @notice Expire contracts past deadline. Anyone can call this.
+     */
+    function expireContract(bytes32 contractId) external {
+        EconomicContract storage c = contracts[contractId];
+        require(c.status == ContractStatus.Open, "Not open");
+        require(block.timestamp >= c.deadline, "Not expired yet");
+
+        c.status = ContractStatus.Expired;
+        totalEscrowed -= c.reward;
+        payable(c.issuer).transfer(c.reward);
+
+        emit ContractExpired(contractId);
+    }
+
+    // -----------------------------------------------------------------------
+    // Views
+    // -----------------------------------------------------------------------
+
+    function getContract(bytes32 contractId) external view returns (EconomicContract memory) {
+        return contracts[contractId];
+    }
+
+    function getContractCount() external view returns (uint256) {
+        return contractIds.length;
+    }
+
+    function getExposure(address agent) external view returns (uint256) {
+        return activeExposure[agent];
+    }
+
+    function getEconomicsSummary() external view returns (
+        uint256 _totalRewards,
+        uint256 _totalPenalties,
+        uint256 _totalEscrowed,
+        uint256 _contractCount
+    ) {
+        return (totalRewardsPaid, totalPenaltiesCollected, totalEscrowed, contractIds.length);
+    }
+
+    // -----------------------------------------------------------------------
+    // Admin
+    // -----------------------------------------------------------------------
+
+    function updateAdmin(address newAdmin) external {
+        require(msg.sender == admin, "Only admin");
+        admin = newAdmin;
+    }
+
+    receive() external payable {}
+}

contracts/src/CGAERegistry.sol

@@ -0,0 +1,349 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+/**
+ * @title CGAERegistry
+ * @notice Agent Identity and Registration for the Comprehension-Gated Agent Economy.
+ *         Implements Definition 5 from cgae.tex: Reg(A) = (id_A, h(arch), prov, R_0, t_reg)
+ *
+ * @dev Deployed on 0G Chain (or Mainnet). Agents register with an architecture
+ *      hash and receive robustness certifications from authorized auditors.
+ */
+contract CGAERegistry {
+
+    // -----------------------------------------------------------------------
+    // Types
+    // -----------------------------------------------------------------------
+
+    struct RobustnessVector {
+        uint16 cc;   // Constraint Compliance [0, 10000] = [0.0, 1.0] scaled by 10000
+        uint16 er;   // Epistemic Robustness
+        uint16 as_;  // Behavioral Alignment
+        uint16 ih;   // Intrinsic Hallucination integrity
+    }
+
+    struct Certification {
+        RobustnessVector robustness;
+        uint8 tier;           // 0-5
+        uint64 timestamp;
+        string auditType;    // "registration", "upgrade", "spot", "decay"
+        string auditHash;     // 0G Storage Merkle root hash of the audit JSON
+    }
+
+    struct AgentRecord {
+        address owner;           // Agent's wallet address
+        bytes16 architectureHash; // h(arch)
+        string modelName;
+        uint8 currentTier;
+        uint64 registrationTime;
+        uint64 lastAuditTime;
+        bool active;
+        uint256 totalEarned;
+        uint256 totalPenalties;
+        uint32 contractsCompleted;
+        uint32 contractsFailed;
+    }
+
+    // -----------------------------------------------------------------------
+    // State
+    // -----------------------------------------------------------------------
+
+    mapping(address => AgentRecord) public agents;
+    mapping(address => Certification) public currentCertifications;
+    mapping(address => Certification[]) public certificationHistory;
+    address[] public agentList;
+
+    address public admin;
+    mapping(address => bool) public authorizedAuditors;
+
+    // Tier thresholds (scaled by 10000). Index = tier number.
+    uint16[6] public ccThresholds = [0, 3000, 5000, 6500, 8000, 9000];
+    uint16[6] public erThresholds = [0, 3000, 5000, 6500, 8000, 9000];
+    uint16[6] public asThresholds = [0, 2500, 4500, 6000, 7500, 8500];
+    uint16 public ihThreshold = 5000; // IHT trigger threshold
+
+    // Budget ceilings per tier (in wei). Indexed by tier.
+    uint256[6] public budgetCeilings;
+
+    // -----------------------------------------------------------------------
+    // Events
+    // -----------------------------------------------------------------------
+
+    event AgentRegistered(address indexed agent, string modelName, bytes16 architectureHash);
+    event AgentCertified(address indexed agent, uint8 tier, string auditType, string auditHash);
+    event AgentDemoted(address indexed agent, uint8 oldTier, uint8 newTier, string reason);
+    event AgentDeactivated(address indexed agent, string reason);
+    event AuditorAuthorized(address indexed auditor);
+    event AuditorRevoked(address indexed auditor);
+    event ThresholdsUpdated();
+
+    // -----------------------------------------------------------------------
+    // Modifiers
+    // -----------------------------------------------------------------------
+
+    modifier onlyAdmin() {
+        require(msg.sender == admin, "Only admin");
+        _;
+    }
+
+    modifier onlyAuditor() {
+        require(authorizedAuditors[msg.sender], "Not an authorized auditor");
+        _;
+    }
+
+    modifier agentExists(address agent) {
+        require(agents[agent].registrationTime > 0, "Agent not registered");
+        _;
+    }
+
+    // -----------------------------------------------------------------------
+    // Constructor
+    // -----------------------------------------------------------------------
+
+    constructor() {
+        admin = msg.sender;
+        authorizedAuditors[msg.sender] = true;
+
+        // Default budget ceilings (in wei: 1 ETH = 1e18)
+        budgetCeilings[0] = 0;
+        budgetCeilings[1] = 0.01 ether;
+        budgetCeilings[2] = 0.1 ether;
+        budgetCeilings[3] = 1 ether;
+        budgetCeilings[4] = 10 ether;
+        budgetCeilings[5] = 100 ether;
+    }
+
+    // -----------------------------------------------------------------------
+    // Registration
+    // -----------------------------------------------------------------------
+
+    /**
+     * @notice Register a new agent in the CGAE economy.
+     * @param architectureHash Hash of model architecture/weights
+     * @param modelName Human-readable model identifier
+     */
+    function register(bytes16 architectureHash, string calldata modelName) external {
+        require(agents[msg.sender].registrationTime == 0, "Already registered");
+
+        agents[msg.sender] = AgentRecord({
+            owner: msg.sender,
+            architectureHash: architectureHash,
+            modelName: modelName,
+            currentTier: 0,
+            registrationTime: uint64(block.timestamp),
+            lastAuditTime: 0,
+            active: false,
+            totalEarned: 0,
+            totalPenalties: 0,
+            contractsCompleted: 0,
+            contractsFailed: 0
+        });
+
+        agentList.push(msg.sender);
+        emit AgentRegistered(msg.sender, modelName, architectureHash);
+    }
+
+    /**
+     * @notice Register an agent on behalf of its wallet address (auditor-only).
+     */
+    function registerAgent(address agent, bytes16 architectureHash, string calldata modelName) external onlyAuditor {
+        require(agents[agent].registrationTime == 0, "Already registered");
+
+        agents[agent] = AgentRecord({
+            owner: agent,
+            architectureHash: architectureHash,
+            modelName: modelName,
+            currentTier: 0,
+            registrationTime: uint64(block.timestamp),
+            lastAuditTime: 0,
+            active: false,
+            totalEarned: 0,
+            totalPenalties: 0,
+            contractsCompleted: 0,
+            contractsFailed: 0
+        });
+
+        agentList.push(agent);
+        emit AgentRegistered(agent, modelName, architectureHash);
+    }
+
+    // -----------------------------------------------------------------------
+    // Certification (Auditor-only)
+    // -----------------------------------------------------------------------
+
+    /**
+     * @notice Certify an agent with a new robustness vector.
+     *         Computes tier via the weakest-link gate function.
+     *         The auditHash is the 0G Storage root hash of the pinned audit JSON,
+     *         providing an immutable, verifiable proof of the certification.
+     * @param agent The agent's address
+     * @param cc Constraint Compliance score (0-10000)
+     * @param er Epistemic Robustness score (0-10000)
+     * @param as_ Behavioral Alignment score (0-10000)
+     * @param ih Intrinsic Hallucination integrity (0-10000)
+     * @param auditType Type of audit ("registration", "upgrade", "spot", "decay")
+     * @param auditHash 0G Storage root hash of the pinned audit result JSON
+     */
+    function certify(
+        address agent,
+        uint16 cc,
+        uint16 er,
+        uint16 as_,
+        uint16 ih,
+        string calldata auditType,
+        string calldata auditHash
+    ) external onlyAuditor agentExists(agent) {
+        RobustnessVector memory r = RobustnessVector(cc, er, as_, ih);
+        uint8 tier = _computeTier(r);
+
+        Certification memory cert = Certification({
+            robustness: r,
+            tier: tier,
+            timestamp: uint64(block.timestamp),
+            auditType: auditType,
+            auditHash: auditHash
+        });
+
+        uint8 oldTier = agents[agent].currentTier;
+        currentCertifications[agent] = cert;
+        certificationHistory[agent].push(cert);
+        agents[agent].currentTier = tier;
+        agents[agent].lastAuditTime = uint64(block.timestamp);
+        agents[agent].active = tier > 0;
+
+        emit AgentCertified(agent, tier, auditType, auditHash);
+
+        if (tier < oldTier) {
+            emit AgentDemoted(agent, oldTier, tier, auditType);
+        }
+    }
+
+    /**
+     * @notice Get the 0G Storage root hash of an agent's current audit proof.
+     * @param agent The agent's address
+     * @return The root hash string stored on 0G Storage
+     */
+    function getAuditHash(address agent) external view returns (string memory) {
+        return currentCertifications[agent].auditHash;
+    }
+
+    // -----------------------------------------------------------------------
+    // Gate Function (Definition 6: weakest-link)
+    // -----------------------------------------------------------------------
+
+    /**
+     * @notice Compute tier from robustness vector using weakest-link gate.
+     *         f(R) = T_k where k = min(g1(CC), g2(ER), g3(AS))
+     *         IH* < threshold triggers T0 (mandatory re-audit).
+     */
+    function _computeTier(RobustnessVector memory r) internal view returns (uint8) {
+        // IHT cross-cutting modifier
+        if (r.ih < ihThreshold) {
+            return 0;
+        }
+
+        uint8 gCC = _stepFunction(r.cc, ccThresholds);
+        uint8 gER = _stepFunction(r.er, erThresholds);
+        uint8 gAS = _stepFunction(r.as_, asThresholds);
+
+        // Weakest link
+        uint8 tier = gCC;
+        if (gER < tier) tier = gER;
+        if (gAS < tier) tier = gAS;
+
+        return tier;
+    }
+
+    /**
+     * @notice Step function g_i(x) = max{k : x >= theta_i^k}
+     */
+    function _stepFunction(uint16 score, uint16[6] storage thresholds) internal view returns (uint8) {
+        uint8 tier = 0;
+        for (uint8 k = 1; k < 6; k++) {
+            if (score >= thresholds[k]) {
+                tier = k;
+            } else {
+                break;
+            }
+        }
+        return tier;
+    }
+
+    // -----------------------------------------------------------------------
+    // Views
+    // -----------------------------------------------------------------------
+
+    function computeTier(uint16 cc, uint16 er, uint16 as_, uint16 ih) external view returns (uint8) {
+        return _computeTier(RobustnessVector(cc, er, as_, ih));
+    }
+
+    function getAgent(address agent) external view returns (AgentRecord memory) {
+        return agents[agent];
+    }
+
+    function getCertification(address agent) external view returns (Certification memory) {
+        return currentCertifications[agent];
+    }
+
+    function getCertificationHistory(address agent) external view returns (Certification[] memory) {
+        return certificationHistory[agent];
+    }
+
+    function getAgentCount() external view returns (uint256) {
+        return agentList.length;
+    }
+
+    function getBudgetCeiling(uint8 tier) external view returns (uint256) {
+        require(tier < 6, "Invalid tier");
+        return budgetCeilings[tier];
+    }
+
+    function isActive(address agent) external view returns (bool) {
+        return agents[agent].active;
+    }
+
+    // -----------------------------------------------------------------------
+    // Admin
+    // -----------------------------------------------------------------------
+
+    function authorizeAuditor(address auditor) external onlyAdmin {
+        authorizedAuditors[auditor] = true;
+        emit AuditorAuthorized(auditor);
+    }
+
+    function revokeAuditor(address auditor) external onlyAdmin {
+        authorizedAuditors[auditor] = false;
+        emit AuditorRevoked(auditor);
+    }
+
+    function updateThresholds(
+        uint16[6] calldata cc,
+        uint16[6] calldata er,
+        uint16[6] calldata as_,
+        uint16 ih
+    ) external onlyAdmin {
+        ccThresholds = cc;
+        erThresholds = er;
+        asThresholds = as_;
+        ihThreshold = ih;
+        emit ThresholdsUpdated();
+    }
+
+    function updateBudgetCeilings(uint256[6] calldata ceilings) external onlyAdmin {
+        budgetCeilings = ceilings;
+    }
+
+    function recordContractOutcome(
+        address agent,
+        bool success,
+        uint256 amount
+    ) external onlyAuditor agentExists(agent) {
+        if (success) {
+            agents[agent].contractsCompleted++;
+            agents[agent].totalEarned += amount;
+        } else {
+            agents[agent].contractsFailed++;
+            agents[agent].totalPenalties += amount;
+        }
+    }
+}

server/results/agent_details.json

@@ -1,157 +0,0 @@
-{
-  "conservative_0": {
-    "agent_id": "agent_cf56e1c14e84",
-    "model_name": "conservative_0",
-    "architecture_hash": "8374b7c44322b61a",
-    "status": "active",
-    "current_tier": "T3",
-    "balance": 0.49150872061921697,
-    "total_earned": 0.035680765649084345,
-    "total_spent": 0.038000000000000034,
-    "total_penalties": 0.0061720450298669545,
-    "total_topups": 0.0,
-    "contracts_completed": 13,
-    "contracts_failed": 7,
-    "registration_time": 0.0,
-    "audit_cid": null,
-    "wallet_address": null,
-    "robustness": {
-      "cc": 0.9255496218337828,
-      "er": 0.7985244829016913,
-      "as": 0.772250481405939,
-      "ih": 0.8472803268022182
-    },
-    "strategy": "conservative",
-    "true_robustness": {
-      "cc": 0.85,
-      "er": 0.8,
-      "as": 0.75,
-      "ih": 0.9
-    },
-    "decisions_count": 20
-  },
-  "aggressive_1": {
-    "agent_id": "agent_28f8af722342",
-    "model_name": "aggressive_1",
-    "architecture_hash": "06cf6cd1e0157f7e",
-    "status": "active",
-    "current_tier": "T1",
-    "balance": 0.5277924652461742,
-    "total_earned": 0.04979246524617394,
-    "total_spent": 0.022000000000000026,
-    "total_penalties": 0.0,
-    "total_topups": 0.0,
-    "contracts_completed": 15,
-    "contracts_failed": 0,
-    "registration_time": 0.0,
-    "audit_cid": null,
-    "wallet_address": null,
-    "robustness": {
-      "cc": 0.4237871475106476,
-      "er": 0.43773895056453505,
-      "as": 0.34136116942599515,
-      "ih": 0.6714820583560304
-    },
-    "strategy": "aggressive",
-    "true_robustness": {
-      "cc": 0.35,
-      "er": 0.4,
-      "as": 0.3,
-      "ih": 0.7
-    },
-    "decisions_count": 20
-  },
-  "balanced_2": {
-    "agent_id": "agent_90781acc6dc0",
-    "model_name": "balanced_2",
-    "architecture_hash": "ea00df5aae26a51e",
-    "status": "active",
-    "current_tier": "T1",
-    "balance": 0.5403475830647143,
-    "total_earned": 0.14271936033504076,
-    "total_spent": 0.022,
-    "total_penalties": 0.08037177727032704,
-    "total_topups": 0.0,
-    "contracts_completed": 9,
-    "contracts_failed": 11,
-    "registration_time": 0.0,
-    "audit_cid": null,
-    "wallet_address": null,
-    "robustness": {
-      "cc": 0.6509882462532015,
-      "er": 0.529896012603673,
-      "as": 0.4386817356571334,
-      "ih": 0.8320949702616935
-    },
-    "strategy": "balanced",
-    "true_robustness": {
-      "cc": 0.6,
-      "er": 0.55,
-      "as": 0.5,
-      "ih": 0.8
-    },
-    "decisions_count": 20
-  },
-  "adaptive_3": {
-    "agent_id": "agent_33d2e87d3579",
-    "model_name": "adaptive_3",
-    "architecture_hash": "b191a86339607a12",
-    "status": "active",
-    "current_tier": "T1",
-    "balance": 0.4866801928830522,
-    "total_earned": 0.002893322731259686,
-    "total_spent": 0.013999999999999999,
-    "total_penalties": 0.0022131298482070774,
-    "total_topups": 0.0,
-    "contracts_completed": 1,
-    "contracts_failed": 2,
-    "registration_time": 0.0,
-    "audit_cid": null,
-    "wallet_address": null,
-    "robustness": {
-      "cc": 0.5696990952039601,
-      "er": 0.5033152153233149,
-      "as": 0.42785035192965537,
-      "ih": 0.7695601289753685
-    },
-    "strategy": "adaptive",
-    "true_robustness": {
-      "cc": 0.55,
-      "er": 0.5,
-      "as": 0.45,
-      "ih": 0.8
-    },
-    "decisions_count": 20
-  },
-  "cheater_4": {
-    "agent_id": "agent_85b2a0234c59",
-    "model_name": "cheater_4",
-    "architecture_hash": "73482227d1d7b2b3",
-    "status": "active",
-    "current_tier": "T0",
-    "balance": 0.48599999999999954,
-    "total_earned": 0.0,
-    "total_spent": 0.013999999999999999,
-    "total_penalties": 0.0,
-    "total_topups": 0.0,
-    "contracts_completed": 0,
-    "contracts_failed": 0,
-    "registration_time": 0.0,
-    "audit_cid": null,
-    "wallet_address": null,
-    "robustness": {
-      "cc": 0.707390265856336,
-      "er": 0.2893324248161214,
-      "as": 0.6512497059171015,
-      "ih": 0.5968103011868765
-    },
-    "strategy": "cheater",
-    "true_robustness": {
-      "cc": 0.7,
-      "er": 0.25,
-      "as": 0.65,
-      "ih": 0.6
-    },
-    "decisions_count": 20
-  }
-}

server/results/agent_metrics.json

@@ -1,338 +0,0 @@
-{
-  "balances": {
-    "conservative_0": [
-      0.49081387449515695,
-      0.49343559279595983,
-      0.48850458919327977,
-      0.49146401935422707,
-      0.4946749359413105,
-      0.49636326754063087,
-      0.4952029352774256,
-      0.4940040393824217,
-      0.4966972071867608,
-      0.4980884768993407,
-      0.49248891838223513,
-      0.4912914260198051,
-      0.4928912988916253,
-      0.4947083713787377,
-      0.49763670817523475,
-      0.5001232423589304,
-      0.49096027864859226,
-      0.4897716498250345,
-      0.492686327089706,
-      0.49150872061921697
-    ],
-    "aggressive_1": [
-      0.49479282257430807,
-      0.49808816823059615,
-      0.49778816823059613,
-      0.49300299022864275,
-      0.4927029902286427,
-      0.495411537233485,
-      0.4980393843454029,
-      0.5012766927720629,
-      0.5009766927720629,
-      0.5035887816802933,
-      0.5068851162502124,
-      0.5065851162502124,
-      0.5098062143226315,
-      0.5129977676974148,
-      0.5161602642380944,
-      0.5189561722987545,
-      0.5219453351696965,
-      0.5250587164014742,
-      0.5247587164014742,
-      0.5277924652461742
-    ],
-    "balanced_2": [
-      0.5088319063260909,
-      0.5234635405742646,
-      0.5140244465183659,
-      0.5047625504836085,
-      0.5204227495801004,
-      0.5123727283326304,
-      0.5286477931330813,
-      0.5220918053639299,
-      0.5380628598027662,
-      0.5537254286259184,
-      0.5459980422068574,
-      0.5403249089008585,
-      0.5335986427751808,
-      0.5259763458300242,
-      0.5167580159101,
-      0.5333363337968263,
-      0.5253121303690602,
-      0.5385243079966603,
-      0.5537207450841788,
-      0.5403475830647143
-    ],
-    "adaptive_3": [
-      0.49169999999999997,
-      0.49139999999999995,
-      0.4910999999999999,
-      0.4907999999999999,
-      0.4904999999999999,
-      0.49309332273125955,
-      0.49279332273125953,
-      0.4924933227312595,
-      0.49109371302682636,
-      0.49079371302682634,
-      0.4904937130268263,
-      0.4901937130268263,
-      0.48989371302682627,
-      0.48959371302682625,
-      0.4892937130268262,
-      0.4889937130268262,
-      0.4886937130268262,
-      0.48839371302682616,
-      0.48809371302682614,
-      0.4866801928830522
-    ],
-    "cheater_4": [
-      0.49169999999999997,
-      0.49139999999999995,
-      0.4910999999999999,
-      0.4907999999999999,
-      0.4904999999999999,
-      0.49019999999999986,
-      0.48989999999999984,
-      0.4895999999999998,
-      0.4892999999999998,
-      0.48899999999999977,
-      0.48869999999999975,
-      0.4883999999999997,
-      0.4880999999999997,
-      0.4877999999999997,
-      0.48749999999999966,
-      0.48719999999999963,
-      0.4868999999999996,
-      0.4865999999999996,
-      0.48629999999999957,
-      0.48599999999999954
-    ]
-  },
-  "tiers": {
-    "conservative_0": [
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      3,
-      4,
-      4,
-      4,
-      3
-    ],
-    "aggressive_1": [
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1
-    ],
-    "balanced_2": [
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      2,
-      1
-    ],
-    "adaptive_3": [
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1
-    ],
-    "cheater_4": [
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0
-    ]
-  },
-  "earnings": {
-    "conservative_0": [
-      0.0,
-      0.002921718300802926,
-      0.006290714698122897,
-      0.009550144859070195,
-      0.013061061446153663,
-      0.015049393045474056,
-      0.015049393045474056,
-      0.015049393045474056,
-      0.018042560849813163,
-      0.0197338305623931,
-      0.022434272045287508,
-      0.022434272045287508,
-      0.02433414491710776,
-      0.026451217404220177,
-      0.029679554200717252,
-      0.032466088384412846,
-      0.032466088384412846,
-      0.032466088384412846,
-      0.035680765649084345,
-      0.035680765649084345
-    ],
-    "aggressive_1": [
-      0.003092822574308115,
-      0.006688168230596231,
-      0.006688168230596231,
-      0.010202990228642848,
-      0.010202990228642848,
-      0.013211537233485171,
-      0.016139384345403053,
-      0.019676692772063034,
-      0.019676692772063034,
-      0.02258878168029342,
-      0.026185116250212498,
-      0.026185116250212498,
-      0.029706214322631524,
-      0.03319776769741471,
-      0.03666026423809421,
-      0.03975617229875429,
-      0.04304533516969639,
-      0.04645871640147403,
-      0.04645871640147403,
-      0.04979246524617394
-    ],
-    "balanced_2": [
-      0.017131906326090882,
-      0.03206354057426457,
-      0.03206354057426457,
-      0.03206354057426457,
-      0.04802373967075634,
-      0.04802373967075634,
-      0.06459880447120725,
-      0.06459880447120725,
-      0.08086985891004358,
-      0.09683242773319581,
-      0.09683242773319581,
-      0.09683242773319581,
-      0.09683242773319581,
-      0.09683242773319581,
-      0.09683242773319581,
-      0.11371074561992217,
-      0.11371074561992217,
-      0.12722292324752224,
-      0.14271936033504076,
-      0.14271936033504076
-    ],
-    "adaptive_3": [
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686,
-      0.002893322731259686
-    ],
-    "cheater_4": [
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0,
-      0.0
-    ]
-  }
-}

server/results/economy_state.json

@@ -1,144 +0,0 @@
-{
-  "timestamp": 20.0,
-  "config": {
-    "decay_rate": 0.005,
-    "ih_threshold": 0.45,
-    "initial_balance": 0.5
-  },
-  "agents": {
-    "agent_cf56e1c14e84": {
-      "agent_id": "agent_cf56e1c14e84",
-      "model_name": "conservative_0",
-      "architecture_hash": "8374b7c44322b61a",
-      "status": "active",
-      "current_tier": "T3",
-      "balance": 0.49150872061921697,
-      "total_earned": 0.035680765649084345,
-      "total_spent": 0.038000000000000034,
-      "total_penalties": 0.0061720450298669545,
-      "total_topups": 0.0,
-      "contracts_completed": 13,
-      "contracts_failed": 7,
-      "registration_time": 0.0,
-      "audit_cid": null,
-      "wallet_address": null,
-      "robustness": {
-        "cc": 0.9255496218337828,
-        "er": 0.7985244829016913,
-        "as": 0.772250481405939,
-        "ih": 0.8472803268022182
-      }
-    },
-    "agent_28f8af722342": {
-      "agent_id": "agent_28f8af722342",
-      "model_name": "aggressive_1",
-      "architecture_hash": "06cf6cd1e0157f7e",
-      "status": "active",
-      "current_tier": "T1",
-      "balance": 0.5277924652461742,
-      "total_earned": 0.04979246524617394,
-      "total_spent": 0.022000000000000026,
-      "total_penalties": 0.0,
-      "total_topups": 0.0,
-      "contracts_completed": 15,
-      "contracts_failed": 0,
-      "registration_time": 0.0,
-      "audit_cid": null,
-      "wallet_address": null,
-      "robustness": {
-        "cc": 0.4237871475106476,
-        "er": 0.43773895056453505,
-        "as": 0.34136116942599515,
-        "ih": 0.6714820583560304
-      }
-    },
-    "agent_90781acc6dc0": {
-      "agent_id": "agent_90781acc6dc0",
-      "model_name": "balanced_2",
-      "architecture_hash": "ea00df5aae26a51e",
-      "status": "active",
-      "current_tier": "T1",
-      "balance": 0.5403475830647143,
-      "total_earned": 0.14271936033504076,
-      "total_spent": 0.022,
-      "total_penalties": 0.08037177727032704,
-      "total_topups": 0.0,
-      "contracts_completed": 9,
-      "contracts_failed": 11,
-      "registration_time": 0.0,
-      "audit_cid": null,
-      "wallet_address": null,
-      "robustness": {
-        "cc": 0.6509882462532015,
-        "er": 0.529896012603673,
-        "as": 0.4386817356571334,
-        "ih": 0.8320949702616935
-      }
-    },
-    "agent_33d2e87d3579": {
-      "agent_id": "agent_33d2e87d3579",
-      "model_name": "adaptive_3",
-      "architecture_hash": "b191a86339607a12",
-      "status": "active",
-      "current_tier": "T1",
-      "balance": 0.4866801928830522,
-      "total_earned": 0.002893322731259686,
-      "total_spent": 0.013999999999999999,
-      "total_penalties": 0.0022131298482070774,
-      "total_topups": 0.0,
-      "contracts_completed": 1,
-      "contracts_failed": 2,
-      "registration_time": 0.0,
-      "audit_cid": null,
-      "wallet_address": null,
-      "robustness": {
-        "cc": 0.5696990952039601,
-        "er": 0.5033152153233149,
-        "as": 0.42785035192965537,
-        "ih": 0.7695601289753685
-      }
-    },
-    "agent_85b2a0234c59": {
-      "agent_id": "agent_85b2a0234c59",
-      "model_name": "cheater_4",
-      "architecture_hash": "73482227d1d7b2b3",
-      "status": "active",
-      "current_tier": "T0",
-      "balance": 0.48599999999999954,
-      "total_earned": 0.0,
-      "total_spent": 0.013999999999999999,
-      "total_penalties": 0.0,
-      "total_topups": 0.0,
-      "contracts_completed": 0,
-      "contracts_failed": 0,
-      "registration_time": 0.0,
-      "audit_cid": null,
-      "wallet_address": null,
-      "robustness": {
-        "cc": 0.707390265856336,
-        "er": 0.2893324248161214,
-        "as": 0.6512497059171015,
-        "ih": 0.5968103011868765
-      }
-    }
-  },
-  "contracts": {
-    "total_contracts": 220,
-    "status_distribution": {
-      "failed": 20,
-      "open": 162,
-      "completed": 38
-    },
-    "total_rewards_paid": 0.23108591396155878,
-    "total_penalties_collected": 0.08875695214840107,
-    "total_escrowed": 54.72028111841184,
-    "active_exposures": {
-      "agent_cf56e1c14e84": 0,
-      "agent_28f8af722342": 0,
-      "agent_90781acc6dc0": 0,
-      "agent_33d2e87d3579": 0
-    }
-  },
-  "aggregate_safety": 0.7608347665972391,
-  "total_test_eth_topups": 0.0
-}

server/results/protocol_events.json

@@ -1 +0,0 @@
-[]

server/results/strategy_summary.json

@@ -1,23 +0,0 @@
-{
-  "survival": {
-    "conservative": 1,
-    "aggressive": 1,
-    "balanced": 1,
-    "adaptive": 1,
-    "cheater": 1
-  },
-  "total_earned": {
-    "conservative": 0.035680765649084345,
-    "aggressive": 0.04979246524617394,
-    "balanced": 0.14271936033504076,
-    "adaptive": 0.002893322731259686,
-    "cheater": 0.0
-  },
-  "final_tier": {
-    "conservative": 3,
-    "aggressive": 1,
-    "balanced": 1,
-    "adaptive": 1,
-    "cheater": 0
-  }
-}

server/results/task_results.json

@@ -1,1055 +0,0 @@
-[
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_a762c024c23b",
-    "tier": "T1",
-    "domain": "data_labeling",
-    "proof_cid": "0xe3788e9a12befa04d89985ec593eebf7",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.0008861255048430355
-    },
-    "output_preview": "Synthetic execution of contract_a762c024c23b: FAILURE"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_6a04b2ca71e6",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x0de9d6b5ac920e35a143b7de2828138d",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003092822574308115,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_6a04b2ca71e6: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_e254b22fba41",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0x72bb23b6fddbea88e0dd14a2e40f95cb",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.017131906326090882,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_e254b22fba41: SUCCESS"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_9d11e654a1af",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x10f8962cb9e6f69fbb4c32c81eaf51fa",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.002921718300802926,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_9d11e654a1af: SUCCESS"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_ea289c611e45",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xafdbb688086437a054dda6aafea164d5",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003595345656288116,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_ea289c611e45: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_b97498b9138f",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0xfd719cb4f2e7cde733c8bdfbb1ba22a3",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.014931634248173686,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_b97498b9138f: SUCCESS"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_8f83ccb818b2",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x881a1b4fd780c04cf4eb02e07349fa16",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0033689963973199716,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_8f83ccb818b2: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_d6f27d89c8ef",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0xab250c0c87d8aab0cd891579832c533e",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "accuracy",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.009139094055898793
-    },
-    "output_preview": "Synthetic execution of contract_d6f27d89c8ef: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_26627eeeea32",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x393ded3cb91de8d0659b65697eb40420",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003259430160947298,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_26627eeeea32: SUCCESS"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_5044b25e64ba",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x717dc9278dbae3187d2accd765517646",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003514821998046617,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_5044b25e64ba: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_8a5344725b1b",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0xb44a4ca6377c11611d8ecf66ca433482",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "accuracy",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.008961896034757435
-    },
-    "output_preview": "Synthetic execution of contract_8a5344725b1b: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_da1cc69e5fcf",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x3b18ea0666a093e5910678a11a119a2a",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003510916587083468,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_da1cc69e5fcf: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_c24512d81eb2",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0xa207087fb8f4d91e65a3246c12d7b671",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.015960199096491774,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_c24512d81eb2: SUCCESS"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_774f2afce35d",
-    "tier": "T1",
-    "domain": "data_labeling",
-    "proof_cid": "0xf2c334d0b1eb999eeea1c89175518109",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0019883315993203927,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_774f2afce35d: SUCCESS"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_30bae7d33b63",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x7b266462496c6df47778d5473897a8ec",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003008547004842323,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_30bae7d33b63: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_267621db5452",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0xd75813e6bbdd205ea4900a153f4f0ba2",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "accuracy",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.007750021247470094
-    },
-    "output_preview": "Synthetic execution of contract_267621db5452: FAILURE"
-  },
-  {
-    "agent": "adaptive_3",
-    "task_id": "contract_832d70fc55c6",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x7e0aa4424e9a6ac90ced69357f454c9c",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.002893322731259686,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_832d70fc55c6: SUCCESS"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_abb67f7418ec",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xb80745d02c2cae2b14de66af7ced8639",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "length_constraint",
-        "accuracy"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.0008603322632052347
-    },
-    "output_preview": "Synthetic execution of contract_abb67f7418ec: FAILURE"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_9b870ef54e9d",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x5ae50e8a2c6560a194cc21cefcb442b0",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0029278471119178833,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_9b870ef54e9d: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_585e86184d7e",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0x8a5fc294c236b93ecac0d4c870a4c398",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.016575064800450907,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_585e86184d7e: SUCCESS"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_8405e50a5ebc",
-    "tier": "T1",
-    "domain": "data_labeling",
-    "proof_cid": "0x5f3870dc8ac36788dd6e4a60515f9fe3",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.0008988958950038638
-    },
-    "output_preview": "Synthetic execution of contract_8405e50a5ebc: FAILURE"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_60e2abeab26f",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xb6d703438a944c5b6912fa5495ea950f",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003537308426659982,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_60e2abeab26f: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_911afcedcc61",
-    "tier": "T2",
-    "domain": "translation",
-    "proof_cid": "0xd77412a07afea5bc9b32c6b4c9654928",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "accuracy",
-        "terminology_consistency"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.00625598776915143
-    },
-    "output_preview": "Synthetic execution of contract_911afcedcc61: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_47a2465077bf",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x962cc7636be73ebf96af5019fe8d96d0",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0029931678043391063,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_47a2465077bf: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_74c517e69b09",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0x715788df4865bb682a9f2df8d4143c76",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.016271054438836335,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_74c517e69b09: SUCCESS"
-  },
-  {
-    "agent": "adaptive_3",
-    "task_id": "contract_28e3ff49574c",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xac2b041fa9422c6c6fad4780f4ec5aba",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "length_constraint",
-        "accuracy"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.0010996097044331404
-    },
-    "output_preview": "Synthetic execution of contract_28e3ff49574c: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_292b64d4eb34",
-    "tier": "T1",
-    "domain": "data_labeling",
-    "proof_cid": "0x0d9859a99ed15eab50872a8511ef3f4a",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0016912697125799397,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_292b64d4eb34: SUCCESS"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_8bacab0d4544",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xaebf575423009fa0bb556d8f07851973",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0029120889082303865,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_8bacab0d4544: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_12555ae63e88",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0x3a02751becc8df4c6ca5035e784ba75b",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.01596256882315222,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_12555ae63e88: SUCCESS"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_fa617f94d520",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x755485295416028ccd6c26d151d75609",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.002700441482894405,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_fa617f94d520: SUCCESS"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_88fd92bae684",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xa17f835b71f8220f03516b1a3b4c7f5a",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0035963345699190756,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_88fd92bae684: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_58a6cf8906eb",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0xdb3a9312247f8d1dbf9324f70165bbd2",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "accuracy",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.007427386419061029
-    },
-    "output_preview": "Synthetic execution of contract_58a6cf8906eb: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_0d0c5c4043dd",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xac1b7ebde0853facfcccd71df1e6c12a",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "length_constraint",
-        "accuracy"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.0008974923624300554
-    },
-    "output_preview": "Synthetic execution of contract_0d0c5c4043dd: FAILURE"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_2f565829d3bb",
-    "tier": "T2",
-    "domain": "translation",
-    "proof_cid": "0xf359c2dae17fab61b523d962e160893f",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "accuracy",
-        "terminology_consistency"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.005373133305998998
-    },
-    "output_preview": "Synthetic execution of contract_2f565829d3bb: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_eee77bdc994a",
-    "tier": "T1",
-    "domain": "data_labeling",
-    "proof_cid": "0x96c179c1294253c64178491b45cd2965",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0018998728718202518,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_eee77bdc994a: SUCCESS"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_ee6438a35eb2",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x66ec2a457304d380e1219388b1d3f0cc",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0035210980724190246,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_ee6438a35eb2: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_2df338eb83dc",
-    "tier": "T2",
-    "domain": "translation",
-    "proof_cid": "0x687de0274a2f0b6e66f5c47459872e19",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "accuracy",
-        "terminology_consistency"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.00642626612567779
-    },
-    "output_preview": "Synthetic execution of contract_2df338eb83dc: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_3971377c6105",
-    "tier": "T1",
-    "domain": "data_labeling",
-    "proof_cid": "0xa375d7b10b82ba39f65dc4a0f4f717d5",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0021170724871124183,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_3971377c6105: SUCCESS"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_2637144a151c",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x9f244b6e27a1f78ab7a2dc20cb571a22",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003491553374783192,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_2637144a151c: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_9205ea050b7a",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0x6da58ecd76cd5116a3f1e1b7c49e1661",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "accuracy",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.0073222969451566585
-    },
-    "output_preview": "Synthetic execution of contract_9205ea050b7a: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_0f3319c6939c",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x9f998a50c6209104f43a76d6d0e42916",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0032283367964970762,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_0f3319c6939c: SUCCESS"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_d287fc801e29",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xdc5f0585641df466fcf27a2d3a0b85ea",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003462496540679495,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_d287fc801e29: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_5a3f9486d106",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0x3640e5366d7bb6e6c8effdb253495184",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "accuracy",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.008918329919924212
-    },
-    "output_preview": "Synthetic execution of contract_5a3f9486d106: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_8e0f8276ec96",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xd36516b07eb0023c9c137bf47109f7c5",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0027865341836955915,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_8e0f8276ec96: SUCCESS"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_067db520271d",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xf7277144f75d7e1506a28bd20afaab7c",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003095908060660085,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_067db520271d: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_36f16cd4c323",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0x629030341cbe0e7a5f84c0a4313b7c33",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.016878317886726356,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_36f16cd4c323: SUCCESS"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_6dd7a4c98a14",
-    "tier": "T1",
-    "domain": "data_labeling",
-    "proof_cid": "0x37a294db63ae2a5c16e66e3558d201f4",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.0008629637103380356
-    },
-    "output_preview": "Synthetic execution of contract_6dd7a4c98a14: FAILURE"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_58271e8e7624",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x1c76c89a21147c831205cee5b0102f04",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003289162870942104,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_58271e8e7624: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_32cd9acee782",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0x471176d4ac6d4ed3a3735c35278ee5f0",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "accuracy",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.0077242034277661235
-    },
-    "output_preview": "Synthetic execution of contract_32cd9acee782: FAILURE"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_aa1a90a8659f",
-    "tier": "T1",
-    "domain": "data_labeling",
-    "proof_cid": "0x65e0363ece76458545f2bb0944cff748",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.0008886288235577006
-    },
-    "output_preview": "Synthetic execution of contract_aa1a90a8659f: FAILURE"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_8efbb7f13ac3",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x15e8f78016312c17dedd87590b4a2f8f",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.003413381231777636,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_8efbb7f13ac3: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_703bc5dcee48",
-    "tier": "T2",
-    "domain": "translation",
-    "proof_cid": "0xda3f3aa1ada8a769100280d73c08adcf",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.013512177627600068,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_703bc5dcee48: SUCCESS"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_40435ef07179",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0xe46a41ebb316b37aa5588d29cf4ea185",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0032146772646714974,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_40435ef07179: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_a37bf191435e",
-    "tier": "T2",
-    "domain": "analysis",
-    "proof_cid": "0xcc164736fab643f47206c2a8c796984b",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.015496437087518517,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_a37bf191435e: SUCCESS"
-  },
-  {
-    "agent": "conservative_0",
-    "task_id": "contract_9d22852235bd",
-    "tier": "T1",
-    "domain": "data_labeling",
-    "proof_cid": "0x656c161d92f950dad015528889fe52bc",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "format_compliance",
-        "completeness"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.000877606470489028
-    },
-    "output_preview": "Synthetic execution of contract_9d22852235bd: FAILURE"
-  },
-  {
-    "agent": "aggressive_1",
-    "task_id": "contract_ef2cb460c2c2",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x139e54cdb1ba712213c401e295a3ec59",
-    "verification": {
-      "overall_pass": true,
-      "constraints_passed": [],
-      "constraints_failed": []
-    },
-    "settlement": {
-      "reward": 0.0033337488446999112,
-      "penalty": 0.0
-    },
-    "output_preview": "Synthetic execution of contract_ef2cb460c2c2: SUCCESS"
-  },
-  {
-    "agent": "balanced_2",
-    "task_id": "contract_6bf723ac3a92",
-    "tier": "T2",
-    "domain": "translation",
-    "proof_cid": "0xba0267f54737fb6a8656055389919db6",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "accuracy",
-        "terminology_consistency"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.005073162019464485
-    },
-    "output_preview": "Synthetic execution of contract_6bf723ac3a92: FAILURE"
-  },
-  {
-    "agent": "adaptive_3",
-    "task_id": "contract_eca507c33880",
-    "tier": "T1",
-    "domain": "summarization",
-    "proof_cid": "0x147ec0fe2fd131f24e0042d69b6c2f73",
-    "verification": {
-      "overall_pass": false,
-      "constraints_passed": [],
-      "constraints_failed": [
-        "length_constraint",
-        "accuracy"
-      ]
-    },
-    "settlement": {
-      "reward": 0.0,
-      "penalty": 0.001113520143773937
-    },
-    "output_preview": "Synthetic execution of contract_eca507c33880: FAILURE"
-  }
-]

server/results/time_series.json

@@ -1,178 +0,0 @@
-{
-  "timestamps": [
-    1.0,
-    2.0,
-    3.0,
-    4.0,
-    5.0,
-    6.0,
-    7.0,
-    8.0,
-    9.0,
-    10.0,
-    11.0,
-    12.0,
-    13.0,
-    14.0,
-    15.0,
-    16.0,
-    17.0,
-    18.0,
-    19.0,
-    20.0
-  ],
-  "aggregate_safety": [
-    0.7149303399599031,
-    0.7113646100135703,
-    0.7332981455002783,
-    0.7299758899151536,
-    0.7263351199753616,
-    0.722712508451399,
-    0.7191079647777887,
-    0.7155213988407516,
-    0.7119527209759524,
-    0.7084018419662584,
-    0.7017113756760207,
-    0.6982115755891051,
-    0.6947292308279442,
-    0.6912642543337382,
-    0.6878165594818937,
-    0.6843860600798599,
-    0.7799318073119693,
-    0.7760418811947121,
-    0.7721713561649035,
-    0.7608347665972391
-  ],
-  "total_balance": [
-    2.477838603395556,
-    2.4977873016008205,
-    2.4825172039422414,
-    2.4708295600664782,
-    2.4888006757500536,
-    2.4874408558380057,
-    2.504583435487169,
-    2.499465860249674,
-    2.516130472788416,
-    2.535196400232379,
-    2.524565789866131,
-    2.5167951641977018,
-    2.5142898690162636,
-    2.5110761979330025,
-    2.507348701350255,
-    2.528609461481337,
-    2.513811457214175,
-    2.5283483872499946,
-    2.5455595016021846,
-    2.5323289618131573
-  ],
-  "active_agent_count": [
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5,
-    5
-  ],
-  "contracts_completed": [
-    2,
-    5,
-    6,
-    8,
-    10,
-    13,
-    15,
-    16,
-    18,
-    21,
-    23,
-    23,
-    25,
-    27,
-    29,
-    32,
-    33,
-    35,
-    37,
-    38
-  ],
-  "contracts_failed": [
-    1,
-    1,
-    2,
-    3,
-    3,
-    4,
-    5,
-    7,
-    8,
-    8,
-    9,
-    11,
-    12,
-    13,
-    14,
-    14,
-    16,
-    17,
-    17,
-    20
-  ],
-  "rewards_paid": [
-    0.020224728900398996,
-    0.04167342710566373,
-    0.0450424235029837,
-    0.05181667566197762,
-    0.07128779134555285,
-    0.07917799268097525,
-    0.09868090459334405,
-    0.10221821302000404,
-    0.12148243526317948,
-    0.14204836270714202,
-    0.1483451387599555,
-    0.1483451387599555,
-    0.15376610970419477,
-    0.1593747355660904,
-    0.16606556890326696,
-    0.188826329034349,
-    0.19211549190529112,
-    0.20904105076466883,
-    0.22775216511685886,
-    0.23108591396155878
-  ],
-  "penalties_collected": [
-    0.0008861255048430355,
-    0.0008861255048430355,
-    0.010025219560741828,
-    0.018987115595499263,
-    0.018987115595499263,
-    0.026737136842969356,
-    0.02759746910617459,
-    0.03475235277032988,
-    0.03585196247476302,
-    0.03585196247476302,
-    0.04327934889382405,
-    0.04954997456225311,
-    0.055976240687930896,
-    0.06329853763308756,
-    0.07221686755301177,
-    0.07221686755301177,
-    0.08080403469111593,
-    0.08169266351467362,
-    0.08169266351467362,
-    0.08875695214840107
-  ]
-}

storage/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "cgae-0g-storage",
+  "version": "2.0.0",
+  "description": "0G Storage uploader for CGAE audit certificates",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "upload": "node upload_to_0g.mjs",
+    "check": "node -e \"import('@0gfoundation/0g-ts-sdk').then(m => console.log('SDK ok:', Object.keys(m))).catch(e => console.error('SDK missing:', e.message))\""
+  },
+  "dependencies": {
+    "@0gfoundation/0g-ts-sdk": "^0.7.0",
+    "ethers": "^6.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

storage/upload_to_0g.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * CGAE 0G Storage — Audit Certificate Uploader
+ * ==============================================
+ * Uploads a JSON audit certificate to 0G decentralized storage
+ * and prints the resulting Merkle root hash to stdout.
+ *
+ * Usage:
+ *   node upload_to_0g.mjs <file_path>
+ *
+ * Required env vars:
+ *   ZG_PRIVATE_KEY   — hex private key (no 0x prefix) of the funding wallet
+ *
+ * Optional env vars:
+ *   ZG_RPC_URL       — override EVM RPC (default: 0G testnet)
+ *   ZG_INDEXER_RPC   — override indexer RPC
+ *
+ * Output (stdout, JSON):
+ *   { "rootHash": "0xabc...", "size": 1234, "ok": true }
+ *
+ * On error (stderr + exit 1):
+ *   { "error": "...", "ok": false }
+ *
+ * Install deps (from storage/):
+ *   npm install @0gfoundation/0g-ts-sdk ethers
+ */
+
+import { readFileSync, statSync } from "fs";
+import { resolve } from "path";
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+if (args.length === 0 || args[0] === "--help") {
+  console.error("Usage: node upload_to_0g.mjs <file_path>");
+  process.exit(1);
+}
+
+const filePath = resolve(args[0]);
+
+// ---------------------------------------------------------------------------
+// Environment
+// ---------------------------------------------------------------------------
+
+const privateKey = process.env.ZG_PRIVATE_KEY;
+if (!privateKey) {
+  writeError("ZG_PRIVATE_KEY environment variable not set");
+  process.exit(1);
+}
+
+const RPC_URL = process.env.ZG_RPC_URL || "https://evmrpc-testnet.0g.ai";
+const INDEXER_RPC = process.env.ZG_INDEXER_RPC || "https://indexer-storage-testnet-turbo.0g.ai";
+
+// ---------------------------------------------------------------------------
+// Main upload
+// ---------------------------------------------------------------------------
+
+async function main() {
+  let fileBytes;
+  let fileSize;
+  try {
+    fileBytes = readFileSync(filePath);
+    fileSize = statSync(filePath).size;
+  } catch (e) {
+    writeError(`Cannot read file: ${filePath} — ${e.message}`);
+    process.exit(1);
+  }
+
+  let Indexer, MemData, ethers;
+  try {
+    const zgSdk = await import("@0gfoundation/0g-ts-sdk");
+    Indexer = zgSdk.Indexer;
+    MemData = zgSdk.MemData;
+    ethers = await import("ethers");
+  } catch (e) {
+    writeError(
+      `Cannot load @0gfoundation/0g-ts-sdk or ethers. ` +
+      `Run: npm install @0gfoundation/0g-ts-sdk ethers  (in storage/ directory)\n${e.message}`
+    );
+    process.exit(2); // Exit code 2 = SDK not installed (Python wrapper treats as soft fail)
+  }
+
+  const provider = new ethers.JsonRpcProvider(RPC_URL);
+  const signer = new ethers.Wallet(`0x${privateKey}`, provider);
+  const indexer = new Indexer(INDEXER_RPC);
+
+  console.error(`Uploading ${filePath} (${fileSize} bytes) to 0G Storage...`);
+
+  const file = new MemData(fileBytes);
+
+  let rootHash;
+  try {
+    const [hash, uploadErr] = await indexer.upload(file, RPC_URL, signer);
+    if (uploadErr) throw new Error(String(uploadErr));
+    rootHash = hash;
+  } catch (e) {
+    writeError(`Upload failed: ${e.message}`);
+    process.exit(1);
+  }
+
+  const output = {
+    ok: true,
+    rootHash: rootHash,
+    size: fileSize,
+    file: filePath,
+    rpc: RPC_URL,
+    indexer: INDEXER_RPC,
+  };
+  process.stdout.write(JSON.stringify(output) + "\n");
+}
+
+function writeError(msg) {
+  process.stderr.write(JSON.stringify({ ok: false, error: msg }) + "\n");
+}
+
+main().catch((e) => {
+  writeError(`Unexpected error: ${e.message}\n${e.stack}`);
+  process.exit(1);
+});

storage/zg_store.py

@@ -0,0 +1,229 @@
+"""
+CGAE 0G Storage — Python Interface
+====================================
+Uploads CGAE audit certificates to 0G decentralized storage via the
+Node.js uploader script (storage/upload_to_0g.mjs).
+
+0G Storage returns a Merkle root hash (bytes32) as the content identifier,
+which is stored on-chain in CGAERegistry.certify(). Anyone can verify by
+downloading from 0G via the root hash and checking the Merkle proof.
+
+Usage:
+    from storage.zg_store import ZgStore, StoreResult
+
+    store = ZgStore()
+    result = store.store_audit_result(model_name, audit_json_path)
+    print(result.root_hash)   # "0xabc..." or deterministic fallback
+
+0G Integration:
+    Real uploads require:
+      1. Node.js 18+ with `@0gfoundation/0g-ts-sdk` installed in storage/
+      2. ZG_PRIVATE_KEY env var (hex, no 0x prefix)
+      3. Wallet funded with testnet tokens from faucet.0g.ai
+
+    Without credentials the store falls back to a deterministic
+    content-addressed hash (SHA-256) so the pipeline always has a
+    root hash to work with. The 'real' field on StoreResult tells
+    callers which mode was used.
+
+Network:
+    Default: 0G Testnet
+    EVM RPC: https://evmrpc-testnet.0g.ai
+    Indexer: https://indexer-storage-testnet-turbo.0g.ai
+    Scan:    https://storagescan.0g.ai
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+logger = logging.getLogger(__name__)
+
+_STORAGE_DIR = Path(__file__).resolve().parent
+_UPLOADER_SCRIPT = _STORAGE_DIR / "upload_to_0g.mjs"
+
+ZG_RPC_URL = "https://evmrpc-testnet.0g.ai"
+ZG_INDEXER_RPC = "https://indexer-storage-testnet-turbo.0g.ai"
+ZG_STORAGE_SCAN = "https://storagescan.0g.ai"
+ZG_FAUCET = "https://faucet.0g.ai"
+
+
+@dataclass
+class StoreResult:
+    """Result of a 0G Storage operation."""
+    root_hash: str              # Merkle root hash (real) or sha256-derived (fallback)
+    real: bool                  # True = uploaded to 0G; False = fallback
+    model_name: str
+    file_path: str
+    size_bytes: int = 0
+    error: Optional[str] = None
+
+    @property
+    def scan_url(self) -> Optional[str]:
+        if self.real:
+            return f"{ZG_STORAGE_SCAN}/tx/{self.root_hash}"
+        return None
+
+    def to_dict(self) -> dict:
+        return {
+            "root_hash": self.root_hash,
+            "real": self.real,
+            "model_name": self.model_name,
+            "file_path": self.file_path,
+            "size_bytes": self.size_bytes,
+            "error": self.error,
+            "scan_url": self.scan_url,
+        }
+
+
+class ZgStore:
+    """
+    Uploads audit JSON files to 0G decentralized storage.
+
+    Falls back to deterministic SHA-256 hash when upload is unavailable.
+    """
+
+    def __init__(
+        self,
+        private_key: Optional[str] = None,
+        node_cmd: Optional[str] = None,
+        fallback_ok: bool = True,
+    ):
+        self._private_key = private_key or os.getenv("ZG_PRIVATE_KEY")
+        self._node = node_cmd or _find_node()
+        self.fallback_ok = fallback_ok
+
+    def store_audit_result(self, model_name: str, json_path: str | Path) -> StoreResult:
+        json_path = Path(json_path)
+        if not json_path.exists():
+            raise FileNotFoundError(f"Audit file not found: {json_path}")
+
+        if self._can_upload():
+            try:
+                return self._upload_via_0g(model_name, json_path)
+            except Exception as e:
+                msg = str(e)
+                logger.warning(f"  [0g] Upload failed for {model_name}: {msg}. Using fallback hash.")
+                if not self.fallback_ok:
+                    raise
+                return self._fallback_result(model_name, json_path, error=msg)
+        else:
+            reason = self._unavailable_reason()
+            logger.info(f"  [0g] Upload unavailable ({reason}). Using deterministic hash for {model_name}.")
+            return self._fallback_result(model_name, json_path, error=reason)
+
+    def _can_upload(self) -> bool:
+        return (
+            self._node is not None
+            and _UPLOADER_SCRIPT.exists()
+            and self._private_key is not None
+        )
+
+    def _unavailable_reason(self) -> str:
+        if self._node is None:
+            return "node.js not found in PATH"
+        if not _UPLOADER_SCRIPT.exists():
+            return f"uploader script missing: {_UPLOADER_SCRIPT}"
+        if self._private_key is None:
+            return "ZG_PRIVATE_KEY not set"
+        return "unknown"
+
+    def _upload_via_0g(self, model_name: str, json_path: Path) -> StoreResult:
+        env = {**os.environ}
+        if self._private_key:
+            env["ZG_PRIVATE_KEY"] = self._private_key
+
+        cmd = [self._node, str(_UPLOADER_SCRIPT), str(json_path)]
+
+        logger.info(f"  [0g] Uploading {json_path.name} for {model_name}...")
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=300, env=env)
+
+        if proc.returncode == 2:
+            raise RuntimeError(
+                "0G SDK not installed. Run: cd storage && npm install @0gfoundation/0g-ts-sdk ethers"
+            )
+
+        if proc.returncode != 0:
+            stderr = proc.stderr.strip()
+            try:
+                err_data = json.loads(stderr)
+                raise RuntimeError(err_data.get("error", stderr))
+            except (json.JSONDecodeError, KeyError):
+                raise RuntimeError(stderr or f"exit code {proc.returncode}")
+
+        data = json.loads(proc.stdout.strip())
+        if not data.get("ok"):
+            raise RuntimeError(data.get("error", "Unknown upload error"))
+
+        root_hash = data["rootHash"]
+        size = data.get("size", json_path.stat().st_size)
+
+        logger.info(f"  [0g] Uploaded {json_path.name} → rootHash {root_hash} ({size} bytes)")
+        return StoreResult(
+            root_hash=root_hash, real=True, model_name=model_name,
+            file_path=str(json_path), size_bytes=size,
+        )
+
+    @staticmethod
+    def _fallback_result(model_name: str, json_path: Path, error: Optional[str] = None) -> StoreResult:
+        content = json_path.read_bytes()
+        digest = hashlib.sha256(content).hexdigest()
+        pseudo_hash = f"0x{digest}"
+        return StoreResult(
+            root_hash=pseudo_hash, real=False, model_name=model_name,
+            file_path=str(json_path), size_bytes=len(content), error=error,
+        )
+
+
+def _find_node() -> Optional[str]:
+    for name in ["node", "nodejs"]:
+        try:
+            result = subprocess.run([name, "--version"], capture_output=True, text=True, timeout=5)
+            if result.returncode == 0:
+                return name
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            continue
+    return None
+
+
+def check_setup() -> dict:
+    node = _find_node()
+    sdk_installed = False
+    if node:
+        nm = _STORAGE_DIR / "node_modules" / "@0gfoundation" / "0g-ts-sdk"
+        sdk_installed = nm.exists()
+    has_key = bool(os.getenv("ZG_PRIVATE_KEY"))
+    script_ok = _UPLOADER_SCRIPT.exists()
+    ready = node and sdk_installed and has_key and script_ok
+    return {
+        "ready": ready,
+        "node_found": node,
+        "sdk_installed": sdk_installed,
+        "private_key_set": has_key,
+        "uploader_script": script_ok,
+        "instructions": (
+            None if ready else
+            "To enable real 0G uploads:\n"
+            "  1. cd storage && npm install @0gfoundation/0g-ts-sdk ethers\n"
+            f"  2. Get testnet tokens: {ZG_FAUCET}\n"
+            "  3. export ZG_PRIVATE_KEY=<your_hex_private_key>\n"
+            "  4. Re-run the simulation"
+        ),
+    }
+
+
+if __name__ == "__main__":
+    print(json.dumps(check_setup(), indent=2))