@chaoschain/sdk 0.2.2 → 0.2.4

package/dist/{index.mjs → index.cjs}

@@ -1,13 +1,41 @@
-import { ethers } from 'ethers';
-import * as fs3 from 'fs';
-import fs3__default from 'fs';
-import * as path3 from 'path';
-import path3__default from 'path';
-import * as crypto2 from 'crypto';
-import { createHash } from 'crypto';
-import axios2 from 'axios';
-import * as http from 'http';
-import * as jose from 'jose';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ethers = require('ethers');
+var fs3 = require('fs');
+var path3 = require('path');
+var crypto2 = require('crypto');
+var axios2 = require('axios');
+var http = require('http');
+var jose = require('jose');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
+var axios2__default = /*#__PURE__*/_interopDefault(axios2);
+var http__namespace = /*#__PURE__*/_interopNamespace(http);
+var jose__namespace = /*#__PURE__*/_interopNamespace(jose);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -37,7 +65,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
   mod
 ));
 
@@ -10285,27 +10313,27 @@ var WalletManager = class _WalletManager {
    */
   initializeWallet(config) {
     if (config.privateKey) {
-      return new ethers.Wallet(config.privateKey);
+      return new ethers.ethers.Wallet(config.privateKey);
     }
     if (config.mnemonic) {
-      return ethers.Wallet.fromPhrase(config.mnemonic);
+      return ethers.ethers.Wallet.fromPhrase(config.mnemonic);
     }
     if (config.walletFile) {
       return this.loadFromFile(config.walletFile);
     }
-    return ethers.Wallet.createRandom();
+    return ethers.ethers.Wallet.createRandom();
   }
   /**
    * Load wallet from encrypted file
    */
   loadFromFile(filePath) {
     try {
-      const walletData = fs3.readFileSync(filePath, "utf8");
+      const walletData = fs3__namespace.readFileSync(filePath, "utf8");
       const data = JSON.parse(walletData);
       if (data.encrypted) {
         throw new Error("Encrypted wallets require password (not yet implemented)");
       }
-      return new ethers.Wallet(data.privateKey);
+      return new ethers.ethers.Wallet(data.privateKey);
     } catch (error) {
       throw new Error(`Failed to load wallet from file: ${error.message}`);
     }
@@ -10314,13 +10342,13 @@ var WalletManager = class _WalletManager {
    * Save wallet to encrypted file
    */
   async saveToFile(filePath, password) {
-    const directory = path3.dirname(filePath);
-    if (!fs3.existsSync(directory)) {
-      fs3.mkdirSync(directory, { recursive: true });
+    const directory = path3__namespace.dirname(filePath);
+    if (!fs3__namespace.existsSync(directory)) {
+      fs3__namespace.mkdirSync(directory, { recursive: true });
     }
     if (password) {
       const encrypted = await this.wallet.encrypt(password);
-      fs3.writeFileSync(filePath, encrypted, "utf8");
+      fs3__namespace.writeFileSync(filePath, encrypted, "utf8");
     } else {
       const data = {
         address: this.wallet.address,
@@ -10328,7 +10356,7 @@ var WalletManager = class _WalletManager {
         mnemonic: "mnemonic" in this.wallet ? this.wallet.mnemonic?.phrase : void 0,
         encrypted: false
       };
-      fs3.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+      fs3__namespace.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
     }
   }
   /**
@@ -10396,7 +10424,7 @@ var WalletManager = class _WalletManager {
    * Generate a new random wallet
    */
   static createRandom() {
-    const wallet = ethers.Wallet.createRandom();
+    const wallet = ethers.ethers.Wallet.createRandom();
     return new _WalletManager({ privateKey: wallet.privateKey });
   }
   /**
@@ -10415,14 +10443,14 @@ var WalletManager = class _WalletManager {
    * Generate new mnemonic
    */
   static generateMnemonic() {
-    return ethers.Wallet.createRandom().mnemonic?.phrase || "";
+    return ethers.ethers.Wallet.createRandom().mnemonic?.phrase || "";
   }
   /**
    * Validate mnemonic
    */
   static isValidMnemonic(mnemonic) {
     try {
-      ethers.Wallet.fromPhrase(mnemonic);
+      ethers.ethers.Wallet.fromPhrase(mnemonic);
       return true;
     } catch {
       return false;
@@ -10433,7 +10461,7 @@ var WalletManager = class _WalletManager {
    */
   static isValidPrivateKey(privateKey) {
     try {
-      new ethers.Wallet(privateKey);
+      new ethers.ethers.Wallet(privateKey);
       return true;
     } catch {
       return false;
@@ -10443,7 +10471,7 @@ var WalletManager = class _WalletManager {
    * Derive child wallet from HD path
    */
   static deriveChild(mnemonic, path4) {
-    const hdNode = ethers.HDNodeWallet.fromPhrase(mnemonic, void 0, path4);
+    const hdNode = ethers.ethers.HDNodeWallet.fromPhrase(mnemonic, void 0, path4);
     return new _WalletManager({ privateKey: hdNode.privateKey });
   }
 };
@@ -11313,13 +11341,13 @@ var ChaosAgent = class {
   _agentId = null;
   constructor(addresses, signer, _provider) {
     this.signer = signer;
-    this.identityContract = new ethers.Contract(addresses.identity, IDENTITY_REGISTRY_ABI, signer);
-    this.reputationContract = new ethers.Contract(
+    this.identityContract = new ethers.ethers.Contract(addresses.identity, IDENTITY_REGISTRY_ABI, signer);
+    this.reputationContract = new ethers.ethers.Contract(
       addresses.reputation,
       REPUTATION_REGISTRY_ABI,
       signer
     );
-    this.validationContract = new ethers.Contract(
+    this.validationContract = new ethers.ethers.Contract(
       addresses.validation,
       VALIDATION_REGISTRY_ABI,
       signer
@@ -11521,23 +11549,23 @@ var ChaosAgent = class {
       const chainId = network.chainId;
       const identityAddress = await this.identityContract.getAddress();
       const signerAddress = await this.signer.getAddress();
-      const feedbackAuthData = ethers.solidityPackedKeccak256(
+      const feedbackAuthData = ethers.ethers.solidityPackedKeccak256(
         ["uint256", "address", "uint64", "uint256", "uint256", "address", "address"],
         [agentId, clientAddress, indexLimit, expiry, chainId, identityAddress, signerAddress]
       );
-      const signature = await this.signer.signMessage(ethers.getBytes(feedbackAuthData));
-      const signatureBytes = ethers.getBytes(signature);
-      const structBytes = ethers.concat([
-        ethers.toBeHex(agentId, 32),
-        ethers.zeroPadValue(clientAddress, 32),
-        ethers.concat([ethers.toBeHex(indexLimit, 8), ethers.zeroPadValue("0x", 24)]),
+      const signature = await this.signer.signMessage(ethers.ethers.getBytes(feedbackAuthData));
+      const signatureBytes = ethers.ethers.getBytes(signature);
+      const structBytes = ethers.ethers.concat([
+        ethers.ethers.toBeHex(agentId, 32),
+        ethers.ethers.zeroPadValue(clientAddress, 32),
+        ethers.ethers.concat([ethers.ethers.toBeHex(indexLimit, 8), ethers.ethers.zeroPadValue("0x", 24)]),
         // uint64 padded
-        ethers.toBeHex(expiry, 32),
-        ethers.toBeHex(chainId, 32),
-        ethers.zeroPadValue(identityAddress, 32),
-        ethers.zeroPadValue(signerAddress, 32)
+        ethers.ethers.toBeHex(expiry, 32),
+        ethers.ethers.toBeHex(chainId, 32),
+        ethers.ethers.zeroPadValue(identityAddress, 32),
+        ethers.ethers.zeroPadValue(signerAddress, 32)
       ]);
-      const feedbackAuth = ethers.hexlify(ethers.concat([structBytes, signatureBytes]));
+      const feedbackAuth = ethers.ethers.hexlify(ethers.ethers.concat([structBytes, signatureBytes]));
       console.log(`\u2705 Generated feedback authorization for agent #${agentId}`);
       return feedbackAuth;
     } catch (e) {
@@ -11562,7 +11590,7 @@ var ChaosAgent = class {
     const rawValue = typeof feedbackData?.value === "bigint" || typeof feedbackData?.value === "number" ? feedbackData.value : rating;
     const value = typeof rawValue === "bigint" ? rawValue : BigInt(Math.round(rawValue * Math.pow(10, valueDecimals)));
     const feedbackContent = typeof feedbackData?.content === "string" ? feedbackData.content : feedbackUri;
-    const feedbackHash = typeof feedbackData?.feedbackHash === "string" ? feedbackData.feedbackHash.startsWith("0x") ? feedbackData.feedbackHash : ethers.id(feedbackData.feedbackHash) : ethers.keccak256(ethers.toUtf8Bytes(feedbackContent));
+    const feedbackHash = typeof feedbackData?.feedbackHash === "string" ? feedbackData.feedbackHash.startsWith("0x") ? feedbackData.feedbackHash : ethers.ethers.id(feedbackData.feedbackHash) : ethers.ethers.keccak256(ethers.ethers.toUtf8Bytes(feedbackContent));
     const tx = await this.reputationContract.giveFeedback(
       agentId,
       value,
@@ -11704,7 +11732,7 @@ var ChaosAgent = class {
    * @param requestHash Hash of the request content (bytes32)
    */
   async requestValidation(validatorAddress, agentId, requestUri, requestHash) {
-    const hashBytes = requestHash.startsWith("0x") ? requestHash : ethers.id(requestHash);
+    const hashBytes = requestHash.startsWith("0x") ? requestHash : ethers.ethers.id(requestHash);
     const tx = await this.validationContract.validationRequest(
       validatorAddress,
       agentId,
@@ -11722,13 +11750,13 @@ var ChaosAgent = class {
    * @param responseHash Hash of the response content (bytes32)
    * @param tag Optional tag for categorization (bytes32)
    */
-  async respondToValidation(requestHash, response, responseUri, responseHash, tag = ethers.ZeroHash) {
+  async respondToValidation(requestHash, response, responseUri, responseHash, tag = ethers.ethers.ZeroHash) {
     if (response < 0 || response > 100) {
       throw new Error("Response must be between 0 and 100");
     }
-    const reqHashBytes = requestHash.startsWith("0x") ? requestHash : ethers.id(requestHash);
-    const resHashBytes = responseHash.startsWith("0x") ? responseHash : ethers.id(responseHash);
-    const tagBytes = tag.startsWith("0x") ? tag : ethers.ZeroHash;
+    const reqHashBytes = requestHash.startsWith("0x") ? requestHash : ethers.ethers.id(requestHash);
+    const resHashBytes = responseHash.startsWith("0x") ? responseHash : ethers.ethers.id(responseHash);
+    const tagBytes = tag.startsWith("0x") ? tag : ethers.ethers.ZeroHash;
     const tx = await this.validationContract.validationResponse(
       reqHashBytes,
       response,
@@ -11744,7 +11772,7 @@ var ChaosAgent = class {
    * @param requestHash Hash of the validation request (bytes32)
    */
   async getValidationStatus(requestHash) {
-    const hashBytes = requestHash.startsWith("0x") ? requestHash : ethers.id(requestHash);
+    const hashBytes = requestHash.startsWith("0x") ? requestHash : ethers.ethers.id(requestHash);
     const result = await this.validationContract.getValidationStatus(hashBytes);
     return {
       validatorAddress: result.validatorAddress,
@@ -11761,8 +11789,8 @@ var ChaosAgent = class {
    * @param validatorAddresses Array of validator addresses (empty for all)
    * @param tag Tag filter (ZeroHash for no filter)
    */
-  async getValidationSummary(agentId, validatorAddresses = [], tag = ethers.ZeroHash) {
-    const tagBytes = tag.startsWith("0x") ? tag : ethers.ZeroHash;
+  async getValidationSummary(agentId, validatorAddresses = [], tag = ethers.ethers.ZeroHash) {
+    const tagBytes = tag.startsWith("0x") ? tag : ethers.ethers.ZeroHash;
     const result = await this.validationContract.getSummary(agentId, validatorAddresses, tagBytes);
     return {
       count: result.count,
@@ -11793,25 +11821,25 @@ var ChaosAgent = class {
   // Cache Implementation
   // ============================================================================
   getCachedFilePath() {
-    return path3__default.join(process.cwd(), "chaoschain_agent_ids.json");
+    return path3__namespace.default.join(process.cwd(), "chaoschain_agent_ids.json");
   }
   loadAgentIdFromCache(chainId, wallet) {
     const cacheFile = this.getCachedFilePath();
-    if (!fs3__default.existsSync(cacheFile)) return null;
-    const cacheData = fs3__default.readFileSync(cacheFile, "utf-8");
+    if (!fs3__namespace.default.existsSync(cacheFile)) return null;
+    const cacheData = fs3__namespace.default.readFileSync(cacheFile, "utf-8");
     const cache = JSON.parse(cacheData);
     return cache[chainId]?.[wallet]?.agentId || null;
   }
   saveAgentIdTocache(chainId, wallet, agentId, domain) {
     const cacheFile = this.getCachedFilePath();
-    const cache = fs3__default.existsSync(cacheFile) ? JSON.parse(fs3__default.readFileSync(cacheFile, "utf-8")) : {};
+    const cache = fs3__namespace.default.existsSync(cacheFile) ? JSON.parse(fs3__namespace.default.readFileSync(cacheFile, "utf-8")) : {};
     cache[String(chainId)] = cache[String(chainId)] ?? {};
     cache[String(chainId)][wallet.toLowerCase()] = {
       agentId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       domain
     };
-    fs3__default.writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
+    fs3__namespace.default.writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
   }
   // ============================================================================
   // Event Listening
@@ -12009,10 +12037,10 @@ var X402PaymentManager = class {
    */
   getTreasuryAddress(network) {
     const treasuries = {
-      "base-sepolia": "0x8004AA63c570c570eBF15376c0dB199918BFe9Fb",
-      "ethereum-sepolia": "0x8004a6090Cd10A7288092483047B097295Fb8847",
-      "optimism-sepolia": "0x8004a6090Cd10A7288092483047B097295Fb8847",
-      "linea-sepolia": "0x8004aa7C931bCE1233973a0C6A667f73F66282e7"
+      "base-sepolia": "0x20E7B2A2c8969725b88Dd3EF3a11Bc3353C83F70",
+      "ethereum-sepolia": "0x20E7B2A2c8969725b88Dd3EF3a11Bc3353C83F70",
+      "optimism-sepolia": "0x20E7B2A2c8969725b88Dd3EF3a11Bc3353C83F70",
+      "linea-sepolia": "0x20E7B2A2c8969725b88Dd3EF3a11Bc3353C83F70"
     };
     return treasuries[network] || treasuries["base-sepolia"];
   }
@@ -12040,7 +12068,7 @@ var X402PaymentManager = class {
    * Returns 32-byte hex string (0x-prefixed)
    */
   generateNonce() {
-    return ethers.hexlify(ethers.randomBytes(32));
+    return ethers.ethers.hexlify(ethers.ethers.randomBytes(32));
   }
   /**
    * Sign EIP-3009 Transfer Authorization
@@ -12253,8 +12281,8 @@ var X402PaymentManager = class {
    * Execute native token (ETH) payment
    */
   async executeNativePayment(recipientAddress, amount, protocolFee) {
-    const amountWei = ethers.parseEther(amount.toString());
-    const feeWei = ethers.parseEther(protocolFee.toString());
+    const amountWei = ethers.ethers.parseEther(amount.toString());
+    const feeWei = ethers.ethers.parseEther(protocolFee.toString());
     const mainTx = await this.wallet.sendTransaction({
       to: recipientAddress,
       value: amountWei
@@ -12293,8 +12321,8 @@ var X402PaymentManager = class {
     if (!usdcAddress) {
       throw new PaymentError(`USDC not supported on ${this.network}`);
     }
-    const totalAmountWei = ethers.parseUnits(amount.toString(), 6);
-    const feeWei = ethers.parseUnits(protocolFee.toString(), 6);
+    const totalAmountWei = ethers.ethers.parseUnits(amount.toString(), 6);
+    const feeWei = ethers.ethers.parseUnits(protocolFee.toString(), 6);
     console.log(`\u{1F4B3} Preparing EIP-3009 payment authorization...`);
     console.log(`   Total: ${amount} USDC`);
     console.log(`   Fee: ${protocolFee} USDC`);
@@ -12389,7 +12417,7 @@ var X402PaymentManager = class {
       scheme: "exact",
       // x402 scheme for exact payment amount
       network: this.network,
-      maxAmountRequired: ethers.parseUnits(amount.toString(), currency === "USDC" ? 6 : 18).toString(),
+      maxAmountRequired: ethers.ethers.parseUnits(amount.toString(), currency === "USDC" ? 6 : 18).toString(),
       resource,
       description: serviceDescription,
       mimeType: "application/json",
@@ -12437,7 +12465,7 @@ var X402PaymentManager = class {
       status: paymentProof.status
     };
     const receiptJson = JSON.stringify(receiptData);
-    const receiptHash = crypto2.createHash("sha256").update(receiptJson).digest("hex");
+    const receiptHash = crypto2__namespace.createHash("sha256").update(receiptJson).digest("hex");
     return {
       receipt_type: "x402_payment",
       receipt_hash: receiptHash,
@@ -12481,7 +12509,7 @@ var PaymentManager = class {
     this.wallet = wallet;
     this.credentials = credentials;
     if (credentials.stripe_secret_key) {
-      this.stripeAxiosInstance = axios2.create({
+      this.stripeAxiosInstance = axios2__default.default.create({
         baseURL: "https://api.stripe.com/v1",
         headers: {
           Authorization: `Bearer ${credentials.stripe_secret_key}`,
@@ -12503,7 +12531,7 @@ var PaymentManager = class {
       const auth = Buffer.from(
         `${this.credentials.paypal_client_id}:${this.credentials.paypal_client_secret}`
       ).toString("base64");
-      const response = await axios2.post(
+      const response = await axios2__default.default.post(
         "https://api-m.sandbox.paypal.com/v1/oauth2/token",
         "grant_type=client_credentials",
         {
@@ -12770,7 +12798,7 @@ var X402Server = class {
       console.warn("\u26A0\uFE0F  Server already running");
       return;
     }
-    this.server = http.createServer((req, res) => {
+    this.server = http__namespace.createServer((req, res) => {
       this.handleRequest(req, res).catch((error) => {
         console.error("\u274C Request handler error:", error);
         res.writeHead(500, { "Content-Type": "application/json" });
@@ -12973,17 +13001,17 @@ var GoogleAP2Integration = class {
    * Generate or load RSA keypair for production JWT signing
    */
   getOrGenerateRsaKeypair() {
-    const keyDir = path3.join(process.cwd(), "keys");
-    const privateKeyPath = path3.join(keyDir, `${this.agentName}_ap2_private.pem`);
-    const publicKeyPath = path3.join(keyDir, `${this.agentName}_ap2_public.pem`);
-    if (!fs3.existsSync(keyDir)) {
-      fs3.mkdirSync(keyDir, { recursive: true });
+    const keyDir = path3__namespace.join(process.cwd(), "keys");
+    const privateKeyPath = path3__namespace.join(keyDir, `${this.agentName}_ap2_private.pem`);
+    const publicKeyPath = path3__namespace.join(keyDir, `${this.agentName}_ap2_public.pem`);
+    if (!fs3__namespace.existsSync(keyDir)) {
+      fs3__namespace.mkdirSync(keyDir, { recursive: true });
     }
-    if (fs3.existsSync(privateKeyPath) && fs3.existsSync(publicKeyPath)) {
+    if (fs3__namespace.existsSync(privateKeyPath) && fs3__namespace.existsSync(publicKeyPath)) {
       try {
-        const privateKeyPem = fs3.readFileSync(privateKeyPath, "utf-8");
-        const publicKeyPem = fs3.readFileSync(publicKeyPath, "utf-8");
-        const privateKey2 = crypto2.createPrivateKey(privateKeyPem);
+        const privateKeyPem = fs3__namespace.readFileSync(privateKeyPath, "utf-8");
+        const publicKeyPem = fs3__namespace.readFileSync(publicKeyPath, "utf-8");
+        const privateKey2 = crypto2__namespace.createPrivateKey(privateKeyPem);
         console.log(`\u{1F511} Loaded existing RSA keypair for ${this.agentName}`);
         return { privateKey: privateKey2, publicKey: publicKeyPem };
       } catch (e) {
@@ -12991,7 +13019,7 @@ var GoogleAP2Integration = class {
       }
     }
     console.log(`\u{1F511} Generating new RSA keypair for ${this.agentName}`);
-    const { privateKey, publicKey } = crypto2.generateKeyPairSync("rsa", {
+    const { privateKey, publicKey } = crypto2__namespace.generateKeyPairSync("rsa", {
       modulusLength: 2048,
       publicKeyEncoding: {
         type: "spki",
@@ -13003,14 +13031,14 @@ var GoogleAP2Integration = class {
       }
     });
     try {
-      fs3.writeFileSync(privateKeyPath, privateKey);
-      fs3.writeFileSync(publicKeyPath, publicKey);
+      fs3__namespace.writeFileSync(privateKeyPath, privateKey);
+      fs3__namespace.writeFileSync(publicKeyPath, publicKey);
       console.log(`\u{1F4BE} RSA keypair saved to ${keyDir}`);
     } catch (e) {
       console.warn(`\u26A0\uFE0F  Failed to save keys: ${e}`);
     }
     return {
-      privateKey: crypto2.createPrivateKey(privateKey),
+      privateKey: crypto2__namespace.createPrivateKey(privateKey),
       publicKey
     };
   }
@@ -13119,7 +13147,7 @@ var GoogleAP2Integration = class {
    */
   async createMerchantJwt(cartContents) {
     const cartJson = JSON.stringify(cartContents);
-    const cartHash = crypto2.createHash("sha256").update(cartJson).digest("hex");
+    const cartHash = crypto2__namespace.createHash("sha256").update(cartJson).digest("hex");
     const now = Math.floor(Date.now() / 1e3);
     const payload = {
       iss: `did:chaoschain:${this.agentName}`,
@@ -13138,7 +13166,7 @@ var GoogleAP2Integration = class {
       // Cart integrity hash
       merchant_name: cartContents.merchant_name
     };
-    const jwt = await new jose.SignJWT(payload).setProtectedHeader({
+    const jwt = await new jose__namespace.SignJWT(payload).setProtectedHeader({
       alg: "RS256",
       kid: `did:chaoschain:${this.agentName}#key-1`
     }).sign(this.privateKey);
@@ -13149,8 +13177,8 @@ var GoogleAP2Integration = class {
    */
   async verifyJwtToken(token) {
     try {
-      const publicKey = crypto2.createPublicKey(this.publicKey);
-      const { payload } = await jose.jwtVerify(token, publicKey, {
+      const publicKey = crypto2__namespace.createPublicKey(this.publicKey);
+      const { payload } = await jose__namespace.jwtVerify(token, publicKey, {
         algorithms: ["RS256"],
         audience: "chaoschain:payment_processor"
       });
@@ -13404,7 +13432,7 @@ var A2AX402Extension = class {
       agent_payee: this.agentName
     };
     const proofJson = JSON.stringify(proofData);
-    const proofHash = crypto2.createHash("sha256").update(proofJson).digest("hex");
+    const proofHash = crypto2__namespace.createHash("sha256").update(proofJson).digest("hex");
     return {
       proof_type: "a2a_x402_payment",
       proof_hash: proofHash,
@@ -13542,10 +13570,10 @@ var ProcessIntegrity = class {
   generateCodeHash(func) {
     try {
       const sourceCode = func.toString();
-      return createHash("sha256").update(sourceCode).digest("hex");
+      return crypto2.createHash("sha256").update(sourceCode).digest("hex");
     } catch {
       const funcInfo = `${func.name}`;
-      return createHash("sha256").update(funcInfo).digest("hex");
+      return crypto2.createHash("sha256").update(funcInfo).digest("hex");
     }
   }
   /**
@@ -13621,7 +13649,7 @@ var ProcessIntegrity = class {
       execution_time: executionTime.toISOString(),
       agent_name: this.agentName
     };
-    const executionHash = createHash("sha256").update(JSON.stringify(executionData)).digest("hex");
+    const executionHash = crypto2.createHash("sha256").update(JSON.stringify(executionData)).digest("hex");
     const proof = {
       proofId,
       functionName,
@@ -13745,7 +13773,7 @@ var LocalIPFSStorage = class {
       const buffer = typeof data === "string" ? Buffer.from(data) : data;
       const form = new import_form_data.default();
       form.append("file", buffer, { contentType: mime });
-      const response = await axios2.post(`${this.apiUrl}/api/v0/add`, form, {
+      const response = await axios2__default.default.post(`${this.apiUrl}/api/v0/add`, form, {
         headers: form.getHeaders(),
         maxBodyLength: Infinity
       });
@@ -13768,7 +13796,7 @@ var LocalIPFSStorage = class {
   }
   async get(cid) {
     try {
-      const response = await axios2.post(`${this.apiUrl}/api/v0/cat`, null, {
+      const response = await axios2__default.default.post(`${this.apiUrl}/api/v0/cat`, null, {
         params: { arg: cid },
         responseType: "arraybuffer"
       });
@@ -13779,7 +13807,7 @@ var LocalIPFSStorage = class {
   }
   async pin(cid) {
     try {
-      await axios2.post(`${this.apiUrl}/api/v0/pin/add`, null, {
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/pin/add`, null, {
         params: { arg: cid }
       });
       console.log(`\u{1F4CC} Pinned to local IPFS: ${cid}`);
@@ -13789,7 +13817,7 @@ var LocalIPFSStorage = class {
   }
   async unpin(cid) {
     try {
-      await axios2.post(`${this.apiUrl}/api/v0/pin/rm`, null, {
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/pin/rm`, null, {
         params: { arg: cid }
       });
       console.log(`\u{1F4CC} Unpinned from local IPFS: ${cid}`);
@@ -13814,7 +13842,7 @@ var PinataStorage = class {
         contentType: mime,
         filename: `file_${Date.now()}`
       });
-      const response = await axios2.post("https://api.pinata.cloud/pinning/pinFileToIPFS", form, {
+      const response = await axios2__default.default.post("https://api.pinata.cloud/pinning/pinFileToIPFS", form, {
         headers: {
           ...form.getHeaders(),
           Authorization: `Bearer ${this.jwtToken}`
@@ -13835,7 +13863,7 @@ var PinataStorage = class {
   }
   async get(cid) {
     try {
-      const response = await axios2.get(`${this.gatewayUrl}/ipfs/${cid}`, {
+      const response = await axios2__default.default.get(`${this.gatewayUrl}/ipfs/${cid}`, {
         responseType: "arraybuffer"
       });
       return Buffer.from(response.data);
@@ -13845,7 +13873,7 @@ var PinataStorage = class {
   }
   async pin(cid) {
     try {
-      await axios2.post(
+      await axios2__default.default.post(
         "https://api.pinata.cloud/pinning/pinByHash",
         { hashToPin: cid },
         {
@@ -13862,7 +13890,7 @@ var PinataStorage = class {
   }
   async unpin(cid) {
     try {
-      await axios2.delete(`https://api.pinata.cloud/pinning/unpin/${cid}`, {
+      await axios2__default.default.delete(`https://api.pinata.cloud/pinning/unpin/${cid}`, {
         headers: {
           Authorization: `Bearer ${this.jwtToken}`
         }
@@ -13898,7 +13926,7 @@ var IrysStorage = class {
   }
   async get(cid) {
     try {
-      const response = await axios2.get(`https://arweave.net/${cid}`, {
+      const response = await axios2__default.default.get(`https://arweave.net/${cid}`, {
         responseType: "arraybuffer"
       });
       return Buffer.from(response.data);
@@ -14555,7 +14583,21 @@ var GatewayClient = class {
   auth;
   retryConfig;
   constructor(config) {
-    this.gatewayUrl = config.gatewayUrl.replace(/\/$/, "");
+    const rawBaseUrl = config.baseUrl ?? config.gatewayUrl ?? "https://gateway.chaoscha.in";
+    let parsed;
+    try {
+      parsed = new URL(rawBaseUrl);
+    } catch {
+      throw new Error(
+        `Invalid gateway baseUrl "${rawBaseUrl}". Provide a valid absolute URL, e.g. https://gateway.chaoscha.in`
+      );
+    }
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new Error(
+        `Invalid gateway baseUrl protocol "${parsed.protocol}". Only http/https are supported.`
+      );
+    }
+    this.gatewayUrl = parsed.toString().replace(/\/$/, "");
     this.timeout = this._resolveTimeout(
       config.timeoutMs,
       config.timeoutSeconds,
@@ -14696,7 +14738,7 @@ var GatewayClient = class {
     let attempt = 0;
     while (true) {
       try {
-        const response = await axios2({
+        const response = await axios2__default.default({
           method,
           url,
           data,
@@ -14980,6 +15022,68 @@ var GatewayClient = class {
     const workflow = await this.closeEpoch(studioAddress, epoch, signerAddress);
     return this.waitForCompletion(workflow.workflowId, options);
   }
+  // ===========================================================================
+  // Read API — Studio Work Discovery
+  // ===========================================================================
+  /**
+   * Fetch pending (unfinalized) work for a studio from the gateway.
+   *
+   * @param studioAddress - 0x-prefixed studio contract address
+   * @param options - Optional limit/offset for pagination
+   * @returns Typed pending work response
+   */
+  async getPendingWork(studioAddress, options) {
+    const limit = options?.limit ?? 20;
+    const offset = options?.offset ?? 0;
+    const url = `${this.gatewayUrl}/v1/studio/${studioAddress}/work?status=pending&limit=${limit}&offset=${offset}`;
+    try {
+      const response = await axios2__default.default.get(url, {
+        timeout: this.timeout,
+        headers: this._buildHeaders()
+      });
+      return response.data;
+    } catch (error) {
+      const axiosErr = error;
+      if (axiosErr.code === "ECONNREFUSED" || axiosErr.code === "ENOTFOUND" || !axiosErr.response) {
+        throw new GatewayConnectionError(
+          `ChaosChain gateway unreachable at ${this.gatewayUrl}. Check GATEWAY_URL.`
+        );
+      }
+      if (axiosErr.response) {
+        throw new GatewayError(
+          `Gateway returned ${axiosErr.response.status}: ${JSON.stringify(axiosErr.response.data)}`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Fetch full evidence graph for a work submission.
+   * Endpoint: GET /v1/work/{hash}/evidence
+   */
+  async getWorkEvidence(workHash) {
+    const url = `${this.gatewayUrl}/v1/work/${workHash}/evidence`;
+    try {
+      const response = await axios2__default.default.get(url, {
+        timeout: this.timeout,
+        headers: this._buildHeaders()
+      });
+      return response.data;
+    } catch (error) {
+      const axiosErr = error;
+      if (axiosErr.code === "ECONNREFUSED" || axiosErr.code === "ENOTFOUND" || !axiosErr.response) {
+        throw new GatewayConnectionError(
+          `ChaosChain gateway unreachable at ${this.gatewayUrl}. Check GATEWAY_URL.`
+        );
+      }
+      if (axiosErr.response) {
+        throw new GatewayError(
+          `Gateway returned ${axiosErr.response.status}: ${JSON.stringify(axiosErr.response.data)}`
+        );
+      }
+      throw error;
+    }
+  }
 };
 var StudioClient = class {
   provider;
@@ -15006,7 +15110,7 @@ var StudioClient = class {
     if (!chaosCoreAddress) {
       throw new ContractError(`ChaosCore contract address not found for network: ${this.network}.`);
     }
-    const chaosCore = new ethers.Contract(chaosCoreAddress, CHAOS_CORE_ABI, this.signer);
+    const chaosCore = new ethers.ethers.Contract(chaosCoreAddress, CHAOS_CORE_ABI, this.signer);
     const tx = await chaosCore.createStudio(name, logicModuleAddress);
     const receipt = await tx.wait();
     const event = receipt.logs.find((log) => {
@@ -15040,11 +15144,11 @@ var StudioClient = class {
    * @param stakeAmount - Amount to stake in wei (default: 0.0001 ETH)
    */
   async registerWithStudio(studioAddress, agentId, role, stakeAmount) {
-    const stake = stakeAmount ?? ethers.parseEther("0.0001");
+    const stake = stakeAmount ?? ethers.ethers.parseEther("0.0001");
     if (stake === 0n) {
       throw new ContractError("Stake amount must be > 0 (contract requirement)");
     }
-    const studio = new ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
+    const studio = new ethers.ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
     const tx = await studio.registerAgent(agentId, role, {
       value: stake
     });
@@ -15067,7 +15171,7 @@ var StudioClient = class {
    */
   async submitWork(studioAddress, dataHash, threadRoot, evidenceRoot, feedbackAuth = "0x") {
     console.warn("submitWork() is deprecated. Use Gateway for production.");
-    const studio = new ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
+    const studio = new ethers.ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
     const tx = await studio.submitWork(dataHash, threadRoot, evidenceRoot, feedbackAuth);
     const receipt = await tx.wait();
     return receipt.hash;
@@ -15096,7 +15200,7 @@ var StudioClient = class {
         `Participants (${participants.length}) and weights (${contributionWeights.length}) must have same length`
       );
     }
-    const studio = new ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
+    const studio = new ethers.ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
     const tx = await studio.submitWorkMultiAgent(
       dataHash,
       threadRoot,
@@ -15123,7 +15227,7 @@ var StudioClient = class {
    * @returns Transaction hash
    */
   async commitScore(studioAddress, dataHash, commitment) {
-    const studio = new ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
+    const studio = new ethers.ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
     const tx = await studio.commitScore(dataHash, commitment);
     const receipt = await tx.wait();
     return receipt.hash;
@@ -15141,7 +15245,7 @@ var StudioClient = class {
    * @returns Transaction hash
    */
   async revealScore(studioAddress, dataHash, scoreVector, salt) {
-    const studio = new ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
+    const studio = new ethers.ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
     const tx = await studio.revealScore(dataHash, scoreVector, salt);
     const receipt = await tx.wait();
     return receipt.hash;
@@ -15163,7 +15267,7 @@ var StudioClient = class {
    * @returns Transaction hash
    */
   async submitScoreVector(studioAddress, dataHash, scores) {
-    const studio = new ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
+    const studio = new ethers.ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
     const scoreVector = this.encodeScoreVector(scores);
     const tx = await studio.submitScoreVector(dataHash, scoreVector);
     const receipt = await tx.wait();
@@ -15192,7 +15296,7 @@ var StudioClient = class {
    * @returns Transaction hash
    */
   async submitScoreVectorForWorker(studioAddress, dataHash, workerAddress, scores) {
-    const studio = new ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
+    const studio = new ethers.ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
     const scoreVector = this.encodeScoreVector(scores);
     const tx = await studio.submitScoreVectorForWorker(dataHash, workerAddress, scoreVector);
     const receipt = await tx.wait();
@@ -15219,7 +15323,7 @@ var StudioClient = class {
         `RewardsDistributor contract address not found for network: ${this.network}.`
       );
     }
-    const distributor = new ethers.Contract(
+    const distributor = new ethers.ethers.Contract(
       rewardsDistributorAddress,
       REWARDS_DISTRIBUTOR_ABI,
       this.signer
@@ -15239,7 +15343,7 @@ var StudioClient = class {
    * @returns Pending reward amount in wei
    */
   async getPendingRewards(studioAddress, account) {
-    const studio = new ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.provider);
+    const studio = new ethers.ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.provider);
     return studio.getWithdrawableBalance(account);
   }
   /**
@@ -15249,7 +15353,7 @@ var StudioClient = class {
    * @returns Transaction hash
    */
   async withdrawRewards(studioAddress) {
-    const studio = new ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
+    const studio = new ethers.ethers.Contract(studioAddress, STUDIO_PROXY_ABI, this.signer);
     const tx = await studio.withdrawRewards();
     const receipt = await tx.wait();
     return receipt.hash;
@@ -15266,9 +15370,9 @@ var StudioClient = class {
    * @returns bytes32 commitment hash
    */
   computeScoreCommitment(scores, salt, dataHash) {
-    const abiCoder = new ethers.AbiCoder();
+    const abiCoder = new ethers.ethers.AbiCoder();
     const encoded = abiCoder.encode(["uint8[]", "bytes32", "bytes32"], [scores, salt, dataHash]);
-    return ethers.keccak256(encoded);
+    return ethers.ethers.keccak256(encoded);
   }
   /**
    * Encode score vector for revealScore.
@@ -15277,7 +15381,7 @@ var StudioClient = class {
    * @returns ABI-encoded bytes
    */
   encodeScoreVector(scores) {
-    const abiCoder = new ethers.AbiCoder();
+    const abiCoder = new ethers.ethers.AbiCoder();
     return abiCoder.encode(["uint8[]"], [scores]);
   }
   /**
@@ -15286,13 +15390,12 @@ var StudioClient = class {
    * @returns bytes32 random salt
    */
   generateSalt() {
-    return ethers.hexlify(ethers.randomBytes(32));
+    return ethers.ethers.hexlify(ethers.ethers.randomBytes(32));
   }
 };
 
 // src/ChaosChainSDK.ts
 var ChaosChainSDK = class _ChaosChainSDK {
-  static warnedGatewayMissing = false;
   static warnedStudioClientProduction = false;
   // Core components
   walletManager;
@@ -15371,7 +15474,7 @@ var ChaosChainSDK = class _ChaosChainSDK {
       );
     }
     try {
-      this.provider = new ethers.JsonRpcProvider(rpcUrl);
+      this.provider = new ethers.ethers.JsonRpcProvider(rpcUrl);
     } catch (error) {
       throw new ConfigurationError(
         `Failed to initialize provider for network "${String(config.network)}".`,
@@ -15470,23 +15573,16 @@ var ChaosChainSDK = class _ChaosChainSDK {
         this.computeProvider
       );
     }
-    if (config.gatewayConfig || config.gatewayUrl) {
-      const gatewayConfig = config.gatewayConfig || { gatewayUrl: config.gatewayUrl };
-      this.gateway = new GatewayClient(gatewayConfig);
-      console.log(`\u{1F310} Gateway client initialized: ${gatewayConfig.gatewayUrl}`);
-    }
+    const gatewayConfig = config.gatewayConfig ?? (config.gatewayUrl ? { gatewayUrl: config.gatewayUrl } : {});
+    this.gateway = new GatewayClient(gatewayConfig);
+    const gatewayBaseUrl = gatewayConfig.baseUrl ?? gatewayConfig.gatewayUrl ?? "https://gateway.chaoscha.in";
+    console.log(`\u{1F310} Gateway client initialized: ${gatewayBaseUrl}`);
     this.studio = new StudioClient({
       provider: this.provider,
       signer: this.walletManager.getWallet(),
       network: typeof config.network === "string" ? config.network : config.network
     });
     const isLocalNetwork = String(config.network) === "local" /* LOCAL */ || String(config.network) === "local";
-    if (!this.gateway && !isLocalNetwork && !_ChaosChainSDK.warnedGatewayMissing) {
-      console.warn(
-        "\u26A0\uFE0F Gateway is not configured. For production workflows, use gatewayConfig to enable Gateway orchestration."
-      );
-      _ChaosChainSDK.warnedGatewayMissing = true;
-    }
     if (process.env.NODE_ENV === "production" && !isLocalNetwork && !_ChaosChainSDK.warnedStudioClientProduction) {
       console.warn(
         "\u26A0\uFE0F StudioClient is intended for low-level or testing use. In production, prefer Gateway workflows."
@@ -15589,19 +15685,19 @@ var ChaosChainSDK = class _ChaosChainSDK {
    * Get agent reputation score (ERC-8004 v1.0)
    */
   async getReputationScore(agentId) {
-    const summary = await this.chaosAgent.getSummary(agentId, [], ethers.ZeroHash, ethers.ZeroHash);
+    const summary = await this.chaosAgent.getSummary(agentId, [], ethers.ethers.ZeroHash, ethers.ethers.ZeroHash);
     return summary.averageScore;
   }
   /**
    * Read all feedback for an agent
    */
-  async readAllFeedback(agentId, clientAddresses = [], tag1 = ethers.ZeroHash, tag2 = ethers.ZeroHash, includeRevoked = false) {
+  async readAllFeedback(agentId, clientAddresses = [], tag1 = ethers.ethers.ZeroHash, tag2 = ethers.ethers.ZeroHash, includeRevoked = false) {
     return this.chaosAgent.readAllFeedback(agentId, clientAddresses, tag1, tag2, includeRevoked);
   }
   /**
    * Get feedback summary statistics
    */
-  async getFeedbackSummary(agentId, clientAddresses = [], tag1 = ethers.ZeroHash, tag2 = ethers.ZeroHash) {
+  async getFeedbackSummary(agentId, clientAddresses = [], tag1 = ethers.ethers.ZeroHash, tag2 = ethers.ethers.ZeroHash) {
     return this.chaosAgent.getSummary(agentId, clientAddresses, tag1, tag2);
   }
   /**
@@ -15640,7 +15736,7 @@ var ChaosChainSDK = class _ChaosChainSDK {
   /**
    * Get validation summary for an agent
    */
-  async getValidationSummary(agentId, validatorAddresses = [], tag = ethers.ZeroHash) {
+  async getValidationSummary(agentId, validatorAddresses = [], tag = ethers.ethers.ZeroHash) {
     return this.chaosAgent.getValidationSummary(agentId, validatorAddresses, tag);
   }
   /**
@@ -15727,7 +15823,7 @@ var ChaosChainSDK = class _ChaosChainSDK {
    */
   async getETHBalance() {
     const balance = await this.provider.getBalance(this.getAddress());
-    return ethers.formatEther(balance);
+    return ethers.ethers.formatEther(balance);
   }
   /**
    * Get USDC balance (if USDC contract exists on network)
@@ -15911,7 +16007,7 @@ var ChaosChainSDK = class _ChaosChainSDK {
    * Get SDK version
    */
   getVersion() {
-    return "0.1.3";
+    return "0.2.4";
   }
   /**
    * Get SDK capabilities summary
@@ -16090,7 +16186,7 @@ var IPFSLocalStorage = class {
       const formData = new FormData();
       const blob = new Blob([buffer], { type: options?.mime || "application/octet-stream" });
       formData.append("file", blob);
-      const response = await axios2.post(`${this.apiUrl}/api/v0/add`, formData, {
+      const response = await axios2__default.default.post(`${this.apiUrl}/api/v0/add`, formData, {
         headers: {
           "Content-Type": "multipart/form-data"
         },
@@ -16115,7 +16211,7 @@ var IPFSLocalStorage = class {
    */
   async download(cid) {
     try {
-      const response = await axios2.get(`${this.gatewayUrl}/ipfs/${cid}`, {
+      const response = await axios2__default.default.get(`${this.gatewayUrl}/ipfs/${cid}`, {
         responseType: "arraybuffer"
       });
       return Buffer.from(response.data);
@@ -16128,7 +16224,7 @@ var IPFSLocalStorage = class {
    */
   async pin(cid) {
     try {
-      await axios2.post(`${this.apiUrl}/api/v0/pin/add`, null, {
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/pin/add`, null, {
         params: { arg: cid }
       });
     } catch (error) {
@@ -16140,7 +16236,7 @@ var IPFSLocalStorage = class {
    */
   async unpin(cid) {
     try {
-      await axios2.post(`${this.apiUrl}/api/v0/pin/rm`, null, {
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/pin/rm`, null, {
         params: { arg: cid }
       });
     } catch (error) {
@@ -16152,7 +16248,7 @@ var IPFSLocalStorage = class {
    */
   async isAvailable() {
     try {
-      await axios2.post(`${this.apiUrl}/api/v0/version`);
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/version`);
       return true;
     } catch {
       return false;
@@ -16163,7 +16259,7 @@ var IPFSLocalStorage = class {
    */
   async getVersion() {
     try {
-      const response = await axios2.post(`${this.apiUrl}/api/v0/version`);
+      const response = await axios2__default.default.post(`${this.apiUrl}/api/v0/version`);
       return response.data.Version;
     } catch (error) {
       throw new Error(`Failed to get IPFS version: ${error.message}`);
@@ -16342,8 +16438,372 @@ var StudioManager = class {
   }
 };
 
+// src/evidence.ts
+function rangeFit(value, min, target, max) {
+  if (value <= min || value >= max) return 0;
+  if (value === target) return 1;
+  if (value < target) {
+    return Math.max(0, Math.min(1, (value - min) / (target - min)));
+  }
+  return Math.max(0, Math.min(1, (max - value) / (max - target)));
+}
+function resolveScoring(policy, mandate) {
+  if (!policy) return void 0;
+  if (!mandate?.overrides) return policy.scoring;
+  const base = policy.scoring;
+  const ov = mandate.overrides;
+  return {
+    initiative: ov.initiative ?? base.initiative,
+    collaboration: ov.collaboration ?? base.collaboration,
+    reasoning: ov.reasoning ?? base.reasoning,
+    compliance: ov.compliance ?? base.compliance,
+    efficiency: ov.efficiency ?? base.efficiency
+  };
+}
+function computeObserved(evidence) {
+  const totalNodes = evidence.length;
+  const byId = /* @__PURE__ */ new Map();
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const e of evidence) {
+    byId.set(e.arweave_tx_id, e);
+    childrenOf.set(e.arweave_tx_id, []);
+  }
+  let edgeCount = 0;
+  let rootCount = 0;
+  let artifactCount = 0;
+  for (const e of evidence) {
+    edgeCount += e.parent_ids.length;
+    if (e.parent_ids.length === 0) rootCount++;
+    if (e.artifact_ids.length > 0) artifactCount++;
+    for (const pid of e.parent_ids) {
+      const c = childrenOf.get(pid);
+      if (c) c.push(e.arweave_tx_id);
+    }
+  }
+  const rootOrigins = /* @__PURE__ */ new Map();
+  function getRootOrigins(id) {
+    if (rootOrigins.has(id)) return rootOrigins.get(id);
+    const node = byId.get(id);
+    if (!node || node.parent_ids.length === 0) {
+      const s = /* @__PURE__ */ new Set([id]);
+      rootOrigins.set(id, s);
+      return s;
+    }
+    const origins = /* @__PURE__ */ new Set();
+    for (const pid of node.parent_ids) {
+      for (const r of getRootOrigins(pid)) origins.add(r);
+    }
+    rootOrigins.set(id, origins);
+    return origins;
+  }
+  for (const e of evidence) getRootOrigins(e.arweave_tx_id);
+  let integrationNodeCount = 0;
+  for (const e of evidence) {
+    if (e.parent_ids.length < 2) continue;
+    const parentRootSets = e.parent_ids.filter((pid) => byId.has(pid)).map((pid) => rootOrigins.get(pid));
+    const uniqueRoots = /* @__PURE__ */ new Set();
+    for (const s of parentRootSets) {
+      for (const r of s) uniqueRoots.add(r);
+    }
+    if (uniqueRoots.size >= 2) integrationNodeCount++;
+  }
+  let terminalCount = 0;
+  for (const [, children] of childrenOf) {
+    if (children.length === 0) terminalCount++;
+  }
+  const uniqueAuthors = new Set(evidence.map((e) => e.author)).size;
+  const timestamps = evidence.map((e) => e.timestamp).filter((t) => t > 0);
+  const durationMs = timestamps.length >= 2 ? Math.max(...timestamps) - Math.min(...timestamps) : void 0;
+  const maxDepth = computeDepth(evidence);
+  return {
+    totalNodes,
+    rootCount,
+    edgeCount,
+    maxDepth,
+    artifactCount,
+    terminalCount,
+    integrationNodeCount,
+    uniqueAuthors,
+    durationMs
+  };
+}
+function computeComplianceSignal(evidence, _observed, scoring, mandate) {
+  const compliance = scoring.compliance;
+  const allArtifacts = /* @__PURE__ */ new Set();
+  for (const e of evidence) {
+    for (const a of e.artifact_ids) allArtifacts.add(a);
+  }
+  const testPatterns = ["test", "spec", ".test.", ".spec.", "__test__", "__spec__"];
+  const testsPresent = [...allArtifacts].some((a) => {
+    const lower = a.toLowerCase();
+    return testPatterns.some((p) => lower.includes(p));
+  });
+  const requiredArtifacts = [
+    ...compliance.requiredArtifacts ?? [],
+    ...mandate?.constraints?.requiredArtifacts ?? []
+  ];
+  const present = [];
+  const missing = [];
+  for (const req of requiredArtifacts) {
+    const found = [...allArtifacts].some((a) => a.toLowerCase().includes(req.toLowerCase()));
+    if (found) present.push(req);
+    else missing.push(req);
+  }
+  const forbiddenPatterns = [
+    ...compliance.forbiddenPatterns ?? [],
+    ...mandate?.constraints?.forbiddenPatterns ?? []
+  ];
+  const violations = [];
+  for (const pattern of forbiddenPatterns) {
+    const lower = pattern.toLowerCase();
+    if ([...allArtifacts].some((a) => a.toLowerCase().includes(lower))) {
+      violations.push(`forbidden pattern found: ${pattern}`);
+    }
+  }
+  if (mandate?.constraints?.mustPassTests && !testsPresent) {
+    violations.push("mandate requires tests but none detected");
+  }
+  const w = compliance.weights;
+  const totalWeight = (w.testsPresent ?? 0) + (w.requiredArtifactsPresent ?? 0) + (w.noPolicyViolations ?? 0);
+  if (totalWeight === 0) {
+    return { signal: testsPresent ? 1 : 0, testsPresent, violations, present, missing };
+  }
+  const testsScore = testsPresent ? 1 : 0;
+  const artifactScore = requiredArtifacts.length > 0 ? present.length / requiredArtifacts.length : 1;
+  const violationScore = violations.length === 0 ? 1 : 0;
+  const signal = Math.max(0, Math.min(
+    1,
+    (w.testsPresent * testsScore + w.requiredArtifactsPresent * artifactScore + w.noPolicyViolations * violationScore) / totalWeight
+  ));
+  return { signal, testsPresent, violations, present, missing };
+}
+function computeEfficiencySignal(observed, scoring, mandate) {
+  const eff = scoring.efficiency;
+  const w = eff.weights;
+  let totalWeight = 0;
+  let weightedSum = 0;
+  if (eff.durationRatio && w.durationRatio && observed.durationMs !== void 0) {
+    const latencyBudget = mandate?.constraints?.latencyBudgetMs;
+    if (latencyBudget && latencyBudget > 0) {
+      const ratio = observed.durationMs / latencyBudget;
+      weightedSum += w.durationRatio * rangeFit(ratio, eff.durationRatio.min, eff.durationRatio.target, eff.durationRatio.max);
+      totalWeight += w.durationRatio;
+    }
+  }
+  if (eff.artifactCountRatio && w.artifactCountRatio && observed.totalNodes > 0) {
+    const ratio = observed.artifactCount / observed.totalNodes;
+    weightedSum += w.artifactCountRatio * rangeFit(ratio, eff.artifactCountRatio.min, eff.artifactCountRatio.target, eff.artifactCountRatio.max);
+    totalWeight += w.artifactCountRatio;
+  }
+  if (totalWeight === 0) return void 0;
+  return Math.max(0, Math.min(1, weightedSum / totalWeight));
+}
+function extractAgencySignals(evidence, context) {
+  const totalNodes = evidence.length;
+  if (totalNodes === 0) {
+    return {
+      initiativeSignal: 0,
+      collaborationSignal: 0,
+      reasoningSignal: 0,
+      observed: {
+        totalNodes: 0,
+        rootCount: 0,
+        edgeCount: 0,
+        maxDepth: 0,
+        artifactCount: 0,
+        terminalCount: 0,
+        integrationNodeCount: 0
+      }
+    };
+  }
+  const observed = computeObserved(evidence);
+  const rootRatio = observed.rootCount / totalNodes;
+  const edgeDensity = observed.edgeCount / Math.max(totalNodes - 1, 1);
+  const integrationRatio = observed.integrationNodeCount / totalNodes;
+  const depthRatio = observed.maxDepth / totalNodes;
+  const scoring = resolveScoring(context?.studioPolicy, context?.workMandate);
+  let initiativeSignal;
+  let collaborationSignal;
+  let reasoningSignal;
+  let complianceSignal;
+  let efficiencySignal;
+  const observedBlock = {
+    totalNodes,
+    rootCount: observed.rootCount,
+    edgeCount: observed.edgeCount,
+    maxDepth: observed.maxDepth,
+    artifactCount: observed.artifactCount,
+    terminalCount: observed.terminalCount,
+    integrationNodeCount: observed.integrationNodeCount,
+    uniqueAuthors: observed.uniqueAuthors,
+    durationMs: observed.durationMs
+  };
+  if (!scoring) {
+    const SOFT_CAP = 0.9;
+    initiativeSignal = Math.max(0, Math.min(SOFT_CAP, rootRatio));
+    collaborationSignal = Math.max(0, Math.min(SOFT_CAP, edgeDensity));
+    reasoningSignal = Math.max(0, Math.min(SOFT_CAP, depthRatio));
+  } else {
+    const ir = scoring.initiative.rootRatio;
+    const initiativeBase = rangeFit(rootRatio, ir.min, ir.target, ir.max);
+    const cw = scoring.collaboration.weights;
+    const ed = scoring.collaboration.edgeDensity;
+    const intR = scoring.collaboration.integrationRatio;
+    const collabWeightSum = (cw.edgeDensity || 0) + (cw.integrationRatio || 0);
+    if (collabWeightSum > 0) {
+      collaborationSignal = (cw.edgeDensity * rangeFit(edgeDensity, ed.min, ed.target, ed.max) + cw.integrationRatio * rangeFit(integrationRatio, intR.min, intR.target, intR.max)) / collabWeightSum;
+    } else {
+      collaborationSignal = 0;
+    }
+    collaborationSignal = Math.max(0, Math.min(1, collaborationSignal));
+    const dr = scoring.reasoning.depthRatio;
+    const reasoningBase = rangeFit(depthRatio, dr.min, dr.target, dr.max);
+    const fragmentationPenalty = rootRatio > ir.max ? (rootRatio - ir.max) * 0.5 : 0;
+    const overcomplexityPenalty = depthRatio > dr.max ? (depthRatio - dr.max) * 0.5 : 0;
+    initiativeSignal = Math.max(0, Math.min(1, initiativeBase - fragmentationPenalty));
+    reasoningSignal = Math.max(0, Math.min(1, reasoningBase - overcomplexityPenalty));
+    observedBlock.fragmentationPenalty = fragmentationPenalty;
+    observedBlock.overcomplexityPenalty = overcomplexityPenalty;
+    const compResult = computeComplianceSignal(evidence, observed, scoring, context?.workMandate);
+    complianceSignal = compResult.signal;
+    observedBlock.testsPresent = compResult.testsPresent;
+    observedBlock.policyViolations = compResult.violations;
+    observedBlock.requiredArtifactsPresent = compResult.present;
+    observedBlock.missingArtifacts = compResult.missing;
+    efficiencySignal = computeEfficiencySignal(observed, scoring, context?.workMandate);
+  }
+  return {
+    initiativeSignal,
+    collaborationSignal,
+    reasoningSignal,
+    complianceSignal,
+    efficiencySignal,
+    observed: observedBlock
+  };
+}
+function computeDepth(evidence) {
+  if (evidence.length === 0) return 0;
+  const byId = /* @__PURE__ */ new Map();
+  for (const e of evidence) byId.set(e.arweave_tx_id, e);
+  const memo = /* @__PURE__ */ new Map();
+  function dfs(id) {
+    if (memo.has(id)) return memo.get(id);
+    const node = byId.get(id);
+    if (!node || node.parent_ids.length === 0) {
+      memo.set(id, 1);
+      return 1;
+    }
+    let maxParent = 0;
+    for (const pid of node.parent_ids) {
+      maxParent = Math.max(maxParent, dfs(pid));
+    }
+    const depth = maxParent + 1;
+    memo.set(id, depth);
+    return depth;
+  }
+  let maxDepth = 0;
+  for (const e of evidence) {
+    maxDepth = Math.max(maxDepth, dfs(e.arweave_tx_id));
+  }
+  return maxDepth;
+}
+function normalizeInput(value) {
+  const v = value > 1 ? value / 100 : value;
+  return Math.max(0, Math.min(1, v));
+}
+var CLAMP_100 = (v) => Math.max(0, Math.min(100, Math.round(v)));
+function resolveDimension(override, signal) {
+  if (override !== void 0) return normalizeInput(override);
+  return signal ?? 0;
+}
+function composeScoreVector(signals, assessment) {
+  if (assessment.complianceScore === void 0 || assessment.complianceScore === null) {
+    throw new Error("complianceScore is required for production scoring");
+  }
+  if (assessment.efficiencyScore === void 0 || assessment.efficiencyScore === null) {
+    throw new Error("efficiencyScore is required for production scoring");
+  }
+  return [
+    CLAMP_100(resolveDimension(assessment.initiativeScore, signals.initiativeSignal) * 100),
+    CLAMP_100(resolveDimension(assessment.collaborationScore, signals.collaborationSignal) * 100),
+    CLAMP_100(resolveDimension(assessment.reasoningScore, signals.reasoningSignal) * 100),
+    CLAMP_100(normalizeInput(assessment.complianceScore) * 100),
+    CLAMP_100(normalizeInput(assessment.efficiencyScore) * 100)
+  ];
+}
+function composeScoreVectorWithDefaults(signals, assessment) {
+  return [
+    CLAMP_100(resolveDimension(assessment?.initiativeScore, signals.initiativeSignal) * 100),
+    CLAMP_100(resolveDimension(assessment?.collaborationScore, signals.collaborationSignal) * 100),
+    CLAMP_100(resolveDimension(assessment?.reasoningScore, signals.reasoningSignal) * 100),
+    CLAMP_100(resolveDimension(assessment?.complianceScore, signals.complianceSignal) * 100),
+    CLAMP_100(resolveDimension(assessment?.efficiencyScore, signals.efficiencySignal) * 100)
+  ];
+}
+function derivePoAScores(evidence, options) {
+  if (evidence.length === 0) {
+    return [
+      0,
+      0,
+      0,
+      CLAMP_100(options?.compliance !== void 0 ? normalizeInput(options.compliance) * 100 : 0),
+      CLAMP_100(options?.efficiency !== void 0 ? normalizeInput(options.efficiency) * 100 : 0)
+    ];
+  }
+  const signals = extractAgencySignals(evidence);
+  return composeScoreVectorWithDefaults(signals, {
+    complianceScore: options?.compliance,
+    efficiencyScore: options?.efficiency
+  });
+}
+function validateEvidenceGraph(evidence) {
+  const ids = new Set(evidence.map((e) => e.arweave_tx_id));
+  for (const e of evidence) {
+    for (const pid of e.parent_ids) {
+      if (!ids.has(pid)) return false;
+    }
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const e of evidence) {
+    if (!inDegree.has(e.arweave_tx_id)) inDegree.set(e.arweave_tx_id, 0);
+    if (!children.has(e.arweave_tx_id)) children.set(e.arweave_tx_id, []);
+  }
+  for (const e of evidence) {
+    for (const pid of e.parent_ids) {
+      inDegree.set(e.arweave_tx_id, (inDegree.get(e.arweave_tx_id) ?? 0) + 1);
+      const c = children.get(pid) ?? [];
+      c.push(e.arweave_tx_id);
+      children.set(pid, c);
+    }
+  }
+  const queue = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0) queue.push(id);
+  }
+  let visited = 0;
+  while (queue.length > 0) {
+    const node = queue.shift();
+    visited++;
+    for (const child of children.get(node) ?? []) {
+      const newDeg = (inDegree.get(child) ?? 1) - 1;
+      inDegree.set(child, newDeg);
+      if (newDeg === 0) queue.push(child);
+    }
+  }
+  return visited === evidence.length;
+}
+function verifyWorkEvidence(evidence, context) {
+  const valid = validateEvidenceGraph(evidence);
+  if (!valid) {
+    return { valid: false };
+  }
+  const signals = extractAgencySignals(evidence, context);
+  return { valid: true, signals };
+}
+
 // src/index.ts
-var SDK_VERSION = "0.2.0";
+var SDK_VERSION = "0.2.4";
 var ERC8004_VERSION = "1.0";
 var X402_VERSION = "1.0";
 var src_default = ChaosChainSDK;
@@ -16369,6 +16829,65 @@ mime-types/index.js:
    *)
 */
 
-export { A2AX402Extension, AgentRegistrationError, AgentRole, AutoStorageManager, CHAOS_CORE_ABI, ChaosAgent, ChaosChainSDK, ChaosChainSDKError, ConfigurationError, ContractError, ERC8004_VERSION, GatewayClient, GatewayConnectionError, GatewayError, GatewayTimeoutError, GoogleAP2Integration, IDENTITY_REGISTRY_ABI, IPFSLocalStorage, PinataStorage as IPFSPinataStorage, IntegrityVerificationError, IrysStorage, IrysStorage as IrysStorageProvider, LocalIPFSStorage, MandateManager, NetworkConfig, PaymentError, PaymentManager, PaymentMethod, PinataStorage, REPUTATION_REGISTRY_ABI, REWARDS_DISTRIBUTOR_ABI, ValidationError as SDKValidationError, SDK_VERSION, STUDIO_FACTORY_ABI, STUDIO_PROXY_ABI, StorageError, StudioClient, StudioManager, VALIDATION_REGISTRY_ABI, ValidationStatus, WalletManager, WorkflowFailedError, WorkflowState, WorkflowType, X402PaymentManager, X402Server, X402_VERSION, ZeroGStorage, src_default as default, getContractAddresses2 as getContractAddresses, getNetworkInfo, initChaosChainSDK };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map
+exports.A2AX402Extension = A2AX402Extension;
+exports.AgentRegistrationError = AgentRegistrationError;
+exports.AgentRole = AgentRole;
+exports.AutoStorageManager = AutoStorageManager;
+exports.CHAOS_CORE_ABI = CHAOS_CORE_ABI;
+exports.ChaosAgent = ChaosAgent;
+exports.ChaosChainSDK = ChaosChainSDK;
+exports.ChaosChainSDKError = ChaosChainSDKError;
+exports.ConfigurationError = ConfigurationError;
+exports.ContractError = ContractError;
+exports.ERC8004_VERSION = ERC8004_VERSION;
+exports.GatewayClient = GatewayClient;
+exports.GatewayConnectionError = GatewayConnectionError;
+exports.GatewayError = GatewayError;
+exports.GatewayTimeoutError = GatewayTimeoutError;
+exports.GoogleAP2Integration = GoogleAP2Integration;
+exports.IDENTITY_REGISTRY_ABI = IDENTITY_REGISTRY_ABI;
+exports.IPFSLocalStorage = IPFSLocalStorage;
+exports.IPFSPinataStorage = PinataStorage;
+exports.IntegrityVerificationError = IntegrityVerificationError;
+exports.IrysStorage = IrysStorage;
+exports.IrysStorageProvider = IrysStorage;
+exports.LocalIPFSStorage = LocalIPFSStorage;
+exports.MandateManager = MandateManager;
+exports.NetworkConfig = NetworkConfig;
+exports.PaymentError = PaymentError;
+exports.PaymentManager = PaymentManager;
+exports.PaymentMethod = PaymentMethod;
+exports.PinataStorage = PinataStorage;
+exports.REPUTATION_REGISTRY_ABI = REPUTATION_REGISTRY_ABI;
+exports.REWARDS_DISTRIBUTOR_ABI = REWARDS_DISTRIBUTOR_ABI;
+exports.SDKValidationError = ValidationError;
+exports.SDK_VERSION = SDK_VERSION;
+exports.STUDIO_FACTORY_ABI = STUDIO_FACTORY_ABI;
+exports.STUDIO_PROXY_ABI = STUDIO_PROXY_ABI;
+exports.StorageError = StorageError;
+exports.StudioClient = StudioClient;
+exports.StudioManager = StudioManager;
+exports.VALIDATION_REGISTRY_ABI = VALIDATION_REGISTRY_ABI;
+exports.ValidationStatus = ValidationStatus;
+exports.WalletManager = WalletManager;
+exports.WorkflowFailedError = WorkflowFailedError;
+exports.WorkflowState = WorkflowState;
+exports.WorkflowType = WorkflowType;
+exports.X402PaymentManager = X402PaymentManager;
+exports.X402Server = X402Server;
+exports.X402_VERSION = X402_VERSION;
+exports.ZeroGStorage = ZeroGStorage;
+exports.composeScoreVector = composeScoreVector;
+exports.composeScoreVectorWithDefaults = composeScoreVectorWithDefaults;
+exports.computeDepth = computeDepth;
+exports.default = src_default;
+exports.derivePoAScores = derivePoAScores;
+exports.extractAgencySignals = extractAgencySignals;
+exports.getContractAddresses = getContractAddresses2;
+exports.getNetworkInfo = getNetworkInfo;
+exports.initChaosChainSDK = initChaosChainSDK;
+exports.rangeFit = rangeFit;
+exports.validateEvidenceGraph = validateEvidenceGraph;
+exports.verifyWorkEvidence = verifyWorkEvidence;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map