@chaoschain/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3549 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ethers = require('ethers');
+var fs2 = require('fs');
+var path2 = require('path');
+var axios2 = require('axios');
+var http = require('http');
+var crypto = require('crypto');
+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 fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var axios2__default = /*#__PURE__*/_interopDefault(axios2);
+var http__namespace = /*#__PURE__*/_interopNamespace(http);
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+var jose__namespace = /*#__PURE__*/_interopNamespace(jose);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var WalletManager = class _WalletManager {
+  wallet;
+  provider;
+  constructor(config, provider) {
+    this.wallet = this.initializeWallet(config);
+    this.provider = provider;
+    if (provider) {
+      this.wallet = this.wallet.connect(provider);
+    }
+  }
+  /**
+   * Initialize wallet from various sources
+   */
+  initializeWallet(config) {
+    if (config.privateKey) {
+      return new ethers.ethers.Wallet(config.privateKey);
+    }
+    if (config.mnemonic) {
+      return ethers.ethers.Wallet.fromPhrase(config.mnemonic);
+    }
+    if (config.walletFile) {
+      return this.loadFromFile(config.walletFile);
+    }
+    return ethers.ethers.Wallet.createRandom();
+  }
+  /**
+   * Load wallet from encrypted file
+   */
+  loadFromFile(filePath) {
+    try {
+      const walletData = fs2__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.ethers.Wallet(data.privateKey);
+    } catch (error) {
+      throw new Error(`Failed to load wallet from file: ${error.message}`);
+    }
+  }
+  /**
+   * Save wallet to encrypted file
+   */
+  async saveToFile(filePath, password) {
+    const directory = path2__namespace.dirname(filePath);
+    if (!fs2__namespace.existsSync(directory)) {
+      fs2__namespace.mkdirSync(directory, { recursive: true });
+    }
+    if (password) {
+      const encrypted = await this.wallet.encrypt(password);
+      fs2__namespace.writeFileSync(filePath, encrypted, "utf8");
+    } else {
+      const data = {
+        address: this.wallet.address,
+        privateKey: this.wallet.privateKey,
+        mnemonic: this.wallet.mnemonic?.phrase,
+        encrypted: false
+      };
+      fs2__namespace.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+    }
+  }
+  /**
+   * Get wallet instance
+   */
+  getWallet() {
+    return this.wallet;
+  }
+  /**
+   * Get wallet address
+   */
+  getAddress() {
+    return this.wallet.address;
+  }
+  /**
+   * Get private key (use with caution)
+   */
+  getPrivateKey() {
+    return this.wallet.privateKey;
+  }
+  /**
+   * Get mnemonic phrase (if available)
+   */
+  getMnemonic() {
+    return this.wallet.mnemonic?.phrase;
+  }
+  /**
+   * Sign a message
+   */
+  async signMessage(message) {
+    return this.wallet.signMessage(message);
+  }
+  /**
+   * Sign typed data (EIP-712)
+   */
+  async signTypedData(domain, types, value) {
+    return this.wallet.signTypedData(domain, types, value);
+  }
+  /**
+   * Get balance
+   */
+  async getBalance() {
+    if (!this.provider) {
+      throw new Error("Provider not set");
+    }
+    return this.provider.getBalance(this.wallet.address);
+  }
+  /**
+   * Get nonce
+   */
+  async getNonce() {
+    if (!this.provider) {
+      throw new Error("Provider not set");
+    }
+    return this.provider.getTransactionCount(this.wallet.address);
+  }
+  /**
+   * Connect to a new provider
+   */
+  connect(provider) {
+    this.provider = provider;
+    this.wallet = this.wallet.connect(provider);
+  }
+  /**
+   * Generate a new random wallet
+   */
+  static createRandom() {
+    const wallet = ethers.ethers.Wallet.createRandom();
+    return new _WalletManager({ privateKey: wallet.privateKey });
+  }
+  /**
+   * Create from mnemonic
+   */
+  static fromMnemonic(mnemonic, provider) {
+    return new _WalletManager({ mnemonic }, provider);
+  }
+  /**
+   * Create from private key
+   */
+  static fromPrivateKey(privateKey, provider) {
+    return new _WalletManager({ privateKey }, provider);
+  }
+  /**
+   * Generate new mnemonic
+   */
+  static generateMnemonic() {
+    return ethers.ethers.Wallet.createRandom().mnemonic?.phrase || "";
+  }
+  /**
+   * Validate mnemonic
+   */
+  static isValidMnemonic(mnemonic) {
+    try {
+      ethers.ethers.Wallet.fromPhrase(mnemonic);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Validate private key
+   */
+  static isValidPrivateKey(privateKey) {
+    try {
+      new ethers.ethers.Wallet(privateKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Derive child wallet from HD path
+   */
+  static deriveChild(mnemonic, path3) {
+    const hdNode = ethers.ethers.HDNodeWallet.fromPhrase(mnemonic, void 0, path3);
+    return new _WalletManager({ privateKey: hdNode.privateKey });
+  }
+};
+
+// src/utils/contracts.ts
+var IDENTITY_REGISTRY_ABI = [
+  {
+    inputs: [
+      { name: "tokenURI_", type: "string" },
+      {
+        name: "metadata",
+        type: "tuple[]",
+        components: [
+          { name: "key", type: "string" },
+          { name: "value", type: "bytes" }
+        ]
+      }
+    ],
+    name: "register",
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "tokenURI_", type: "string" }],
+    name: "register",
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "register",
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // ERC-721 Standard Functions
+  {
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    name: "ownerOf",
+    outputs: [{ name: "owner", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "owner", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "balance", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    name: "tokenURI",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    name: "transferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    name: "setApprovalForAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    name: "getApproved",
+    outputs: [{ name: "operator", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    name: "isApprovedForAll",
+    outputs: [{ name: "approved", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Metadata Functions
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "key", type: "string" },
+      { name: "value", type: "bytes" }
+    ],
+    name: "setMetadata",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "key", type: "string" }
+    ],
+    name: "getMetadata",
+    outputs: [{ name: "value", type: "bytes" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Additional Functions
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "newUri", type: "string" }
+    ],
+    name: "setAgentUri",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalAgents",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Events
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "agentId", type: "uint256" },
+      { indexed: false, name: "tokenURI", type: "string" },
+      { indexed: true, name: "owner", type: "address" }
+    ],
+    name: "Registered",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "agentId", type: "uint256" },
+      { indexed: true, name: "indexedKey", type: "string" },
+      { indexed: false, name: "key", type: "string" },
+      { indexed: false, name: "value", type: "bytes" }
+    ],
+    name: "MetadataSet",
+    type: "event"
+  },
+  // ERC-721 Standard Events
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: true, name: "tokenId", type: "uint256" }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: true, name: "approved", type: "address" },
+      { indexed: true, name: "tokenId", type: "uint256" }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: true, name: "operator", type: "address" },
+      { indexed: false, name: "approved", type: "bool" }
+    ],
+    name: "ApprovalForAll",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "agentId", type: "uint256" },
+      { indexed: false, name: "newUri", type: "string" },
+      { indexed: true, name: "updatedBy", type: "address" }
+    ],
+    name: "UriUpdated",
+    type: "event"
+  }
+];
+var REPUTATION_REGISTRY_ABI = [
+  // Core Functions
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "score", type: "uint8" },
+      { name: "tag1", type: "bytes32" },
+      { name: "tag2", type: "bytes32" },
+      { name: "feedbackUri", type: "string" },
+      { name: "feedbackHash", type: "bytes32" },
+      { name: "feedbackAuth", type: "bytes" }
+    ],
+    name: "giveFeedback",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "feedbackIndex", type: "uint64" }
+    ],
+    name: "revokeFeedback",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddress", type: "address" },
+      { name: "feedbackIndex", type: "uint64" },
+      { name: "responseUri", type: "string" },
+      { name: "responseHash", type: "bytes32" }
+    ],
+    name: "appendResponse",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // Read Functions
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddresses", type: "address[]" },
+      { name: "tag1", type: "bytes32" },
+      { name: "tag2", type: "bytes32" }
+    ],
+    name: "getSummary",
+    outputs: [
+      { name: "count", type: "uint64" },
+      { name: "averageScore", type: "uint8" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddress", type: "address" },
+      { name: "index", type: "uint64" }
+    ],
+    name: "readFeedback",
+    outputs: [
+      { name: "score", type: "uint8" },
+      { name: "tag1", type: "bytes32" },
+      { name: "tag2", type: "bytes32" },
+      { name: "isRevoked", type: "bool" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddresses", type: "address[]" },
+      { name: "tag1", type: "bytes32" },
+      { name: "tag2", type: "bytes32" },
+      { name: "includeRevoked", type: "bool" }
+    ],
+    name: "readAllFeedback",
+    outputs: [
+      { name: "clients", type: "address[]" },
+      { name: "scores", type: "uint8[]" },
+      { name: "tag1s", type: "bytes32[]" },
+      { name: "tag2s", type: "bytes32[]" },
+      { name: "revokedStatuses", type: "bool[]" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "agentId", type: "uint256" }],
+    name: "getClients",
+    outputs: [{ name: "clientList", type: "address[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddress", type: "address" }
+    ],
+    name: "getLastIndex",
+    outputs: [{ name: "lastIndex", type: "uint64" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getIdentityRegistry",
+    outputs: [{ name: "registry", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Events
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "agentId", type: "uint256" },
+      { indexed: true, name: "clientAddress", type: "address" },
+      { indexed: false, name: "score", type: "uint8" },
+      { indexed: true, name: "tag1", type: "bytes32" },
+      { indexed: false, name: "tag2", type: "bytes32" },
+      { indexed: false, name: "feedbackUri", type: "string" },
+      { indexed: false, name: "feedbackHash", type: "bytes32" }
+    ],
+    name: "NewFeedback",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "agentId", type: "uint256" },
+      { indexed: true, name: "clientAddress", type: "address" },
+      { indexed: false, name: "feedbackIndex", type: "uint64" },
+      { indexed: true, name: "responder", type: "address" },
+      { indexed: false, name: "responseUri", type: "string" },
+      { indexed: false, name: "responseHash", type: "bytes32" }
+    ],
+    name: "ResponseAppended",
+    type: "event"
+  }
+];
+var VALIDATION_REGISTRY_ABI = [
+  // Core Functions
+  {
+    inputs: [
+      { name: "validatorAddress", type: "address" },
+      { name: "agentId", type: "uint256" },
+      { name: "requestUri", type: "string" },
+      { name: "requestHash", type: "bytes32" }
+    ],
+    name: "validationRequest",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "requestHash", type: "bytes32" },
+      { name: "response", type: "uint8" },
+      { name: "responseUri", type: "string" },
+      { name: "responseHash", type: "bytes32" },
+      { name: "tag", type: "bytes32" }
+    ],
+    name: "validationResponse",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // Read Functions
+  {
+    inputs: [{ name: "requestHash", type: "bytes32" }],
+    name: "getValidationStatus",
+    outputs: [
+      { name: "validatorAddress", type: "address" },
+      { name: "agentId", type: "uint256" },
+      { name: "response", type: "uint8" },
+      { name: "responseHash", type: "bytes32" },
+      { name: "tag", type: "bytes32" },
+      { name: "lastUpdate", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "validatorAddresses", type: "address[]" },
+      { name: "tag", type: "bytes32" }
+    ],
+    name: "getSummary",
+    outputs: [
+      { name: "count", type: "uint64" },
+      { name: "avgResponse", type: "uint8" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "agentId", type: "uint256" }],
+    name: "getAgentValidations",
+    outputs: [{ name: "requestHashes", type: "bytes32[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "validatorAddress", type: "address" }],
+    name: "getValidatorRequests",
+    outputs: [{ name: "requestHashes", type: "bytes32[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getIdentityRegistry",
+    outputs: [{ name: "registry", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Events
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "validatorAddress", type: "address" },
+      { indexed: true, name: "agentId", type: "uint256" },
+      { indexed: false, name: "requestUri", type: "string" },
+      { indexed: true, name: "requestHash", type: "bytes32" }
+    ],
+    name: "ValidationRequest",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "validatorAddress", type: "address" },
+      { indexed: true, name: "agentId", type: "uint256" },
+      { indexed: true, name: "requestHash", type: "bytes32" },
+      { indexed: false, name: "response", type: "uint8" },
+      { indexed: false, name: "responseUri", type: "string" },
+      { indexed: false, name: "responseHash", type: "bytes32" },
+      { indexed: false, name: "tag", type: "bytes32" }
+    ],
+    name: "ValidationResponse",
+    type: "event"
+  }
+];
+
+// src/ChaosAgent.ts
+var ChaosAgent = class {
+  identityContract;
+  reputationContract;
+  validationContract;
+  signer;
+  constructor(addresses, signer, _provider) {
+    this.signer = signer;
+    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.ethers.Contract(
+      addresses.validation,
+      VALIDATION_REGISTRY_ABI,
+      signer
+    );
+  }
+  // ============================================================================
+  // Identity Registry Methods
+  // ============================================================================
+  /**
+   * Register a new agent identity (ERC-8004)
+   */
+  async registerIdentity(metadata) {
+    const uri = metadata ? `data:application/json,${JSON.stringify(metadata)}` : "";
+    const tx = await this.identityContract.registerAgent(uri);
+    const receipt = await tx.wait();
+    const event = receipt.logs.map((log) => {
+      try {
+        return this.identityContract.interface.parseLog({
+          topics: [...log.topics],
+          data: log.data
+        });
+      } catch {
+        return null;
+      }
+    }).find((e) => e?.name === "AgentRegistered");
+    if (!event) {
+      throw new Error("AgentRegistered event not found");
+    }
+    return {
+      agentId: event.args.agentId,
+      txHash: receipt.hash,
+      owner: event.args.owner
+    };
+  }
+  /**
+   * Get agent metadata
+   */
+  async getAgentMetadata(agentId) {
+    try {
+      const uri = await this.identityContract.getAgentURI(agentId);
+      if (!uri) {
+        return null;
+      }
+      if (uri.startsWith("data:application/json,")) {
+        const json = uri.substring("data:application/json,".length);
+        return JSON.parse(decodeURIComponent(json));
+      }
+      if (uri.startsWith("ipfs://")) {
+        const cid = uri.substring(7);
+        const response = await fetch(`https://ipfs.io/ipfs/${cid}`);
+        return response.json();
+      }
+      if (uri.startsWith("https://") || uri.startsWith("http://")) {
+        const response = await fetch(uri);
+        return response.json();
+      }
+      return null;
+    } catch (error) {
+      console.error("Failed to get agent metadata:", error);
+      return null;
+    }
+  }
+  /**
+   * Set agent URI
+   */
+  async setAgentUri(agentId, uri) {
+    const tx = await this.identityContract.setAgentURI(agentId, uri);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  /**
+   * Update agent metadata
+   */
+  async updateAgentMetadata(agentId, metadata) {
+    const uri = `data:application/json,${JSON.stringify(metadata)}`;
+    return this.setAgentUri(agentId, uri);
+  }
+  /**
+   * Check if agent exists
+   */
+  async agentExists(agentId) {
+    return this.identityContract.agentExists(agentId);
+  }
+  /**
+   * Get agent owner
+   */
+  async getAgentOwner(agentId) {
+    return this.identityContract.ownerOf(agentId);
+  }
+  /**
+   * Get total number of agents
+   */
+  async getTotalAgents() {
+    return this.identityContract.totalAgents();
+  }
+  /**
+   * Transfer agent ownership
+   */
+  async transferAgent(agentId, to) {
+    const from = await this.signer.getAddress();
+    const tx = await this.identityContract.transferFrom(from, to, agentId);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  // ============================================================================
+  // Reputation Registry Methods
+  // ============================================================================
+  /**
+   * Generate EIP-191 signed feedback authorization (ERC-8004 v1.0)
+   * 
+   * This signature allows a client to submit feedback to an agent's reputation.
+   * The agent owner signs to authorize the client to give feedback up to a certain index.
+   * 
+   * @param agentId Target agent ID receiving feedback
+   * @param clientAddress Address of the client giving feedback
+   * @param indexLimit Maximum feedback index this authorization permits
+   * @param expiry Unix timestamp when authorization expires
+   * @returns Signed feedbackAuth bytes for use in giveFeedback()
+   */
+  async generateFeedbackAuthorization(agentId, clientAddress, indexLimit, expiry) {
+    try {
+      const network = await this.signer.provider.getNetwork();
+      const chainId = network.chainId;
+      const identityAddress = await this.identityContract.getAddress();
+      const signerAddress = await this.signer.getAddress();
+      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.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.ethers.toBeHex(expiry, 32),
+        ethers.ethers.toBeHex(chainId, 32),
+        ethers.ethers.zeroPadValue(identityAddress, 32),
+        ethers.ethers.zeroPadValue(signerAddress, 32)
+      ]);
+      const feedbackAuth = ethers.ethers.hexlify(ethers.ethers.concat([structBytes, signatureBytes]));
+      console.log(`\u2705 Generated feedback authorization for agent #${agentId}`);
+      return feedbackAuth;
+    } catch (e) {
+      throw new Error(`Failed to generate feedback authorization: ${e.message}`);
+    }
+  }
+  /**
+   * Give feedback to an agent
+   */
+  async giveFeedback(params) {
+    const { agentId, rating, feedbackUri } = params;
+    if (rating < 0 || rating > 100) {
+      throw new Error("Rating must be between 0 and 100");
+    }
+    const tx = await this.reputationContract.giveFeedback(agentId, rating, feedbackUri);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  /**
+   * Revoke feedback
+   */
+  async revokeFeedback(feedbackId) {
+    const tx = await this.reputationContract.revokeFeedback(feedbackId);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  /**
+   * Append response to feedback
+   */
+  async appendResponse(feedbackId, responseUri) {
+    const tx = await this.reputationContract.appendResponse(feedbackId, responseUri);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  /**
+   * Get feedback details
+   */
+  async getFeedback(feedbackId) {
+    const feedback = await this.reputationContract.getFeedback(feedbackId);
+    return {
+      feedbackId: feedback.feedbackId,
+      fromAgent: feedback.fromAgent,
+      toAgent: feedback.toAgent,
+      rating: feedback.rating,
+      feedbackUri: feedback.feedbackURI,
+      timestamp: Number(feedback.timestamp),
+      revoked: feedback.revoked
+    };
+  }
+  /**
+   * Get agent feedback IDs
+   */
+  async getAgentFeedback(agentId, offset = 0, limit = 10) {
+    return this.reputationContract.getAgentFeedback(agentId, offset, limit);
+  }
+  /**
+   * Get agent reputation stats
+   */
+  async getAgentStats(agentId) {
+    return this.reputationContract.getAgentStats(agentId);
+  }
+  // ============================================================================
+  // Validation Registry Methods
+  // ============================================================================
+  /**
+   * Request validation from another agent
+   */
+  async requestValidation(params) {
+    const { validatorAgentId, requestUri, requestHash } = params;
+    const hashBytes = ethers.ethers.id(requestHash);
+    const tx = await this.validationContract.requestValidation(
+      validatorAgentId,
+      requestUri,
+      hashBytes
+    );
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  /**
+   * Respond to validation request
+   */
+  async respondToValidation(requestId, approved, responseUri) {
+    const tx = await this.validationContract.respondToValidation(
+      requestId,
+      approved,
+      responseUri
+    );
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  /**
+   * Get validation request details
+   */
+  async getValidationRequest(requestId) {
+    const request = await this.validationContract.getValidationRequest(requestId);
+    return {
+      requestId: request.requestId,
+      requester: request.requester,
+      validator: request.validator,
+      requestUri: request.requestURI,
+      requestHash: request.requestHash,
+      status: request.status,
+      responseUri: request.responseURI,
+      timestamp: Number(request.timestamp)
+    };
+  }
+  /**
+   * Get agent validation requests
+   */
+  async getAgentValidationRequests(agentId, asValidator = false, offset = 0, limit = 10) {
+    return this.validationContract.getAgentValidationRequests(
+      agentId,
+      asValidator,
+      offset,
+      limit
+    );
+  }
+  /**
+   * Get validation statistics for an agent
+   */
+  async getValidationStats(agentId) {
+    return this.validationContract.getValidationStats(agentId);
+  }
+  // ============================================================================
+  // Event Listening
+  // ============================================================================
+  /**
+   * Listen for AgentRegistered events
+   */
+  onAgentRegistered(callback) {
+    this.identityContract.on("AgentRegistered", callback);
+  }
+  /**
+   * Listen for FeedbackGiven events
+   */
+  onFeedbackGiven(callback) {
+    this.reputationContract.on("FeedbackGiven", callback);
+  }
+  /**
+   * Listen for ValidationRequested events
+   */
+  onValidationRequested(callback) {
+    this.validationContract.on("ValidationRequested", callback);
+  }
+  /**
+   * Listen for ValidationResponded events
+   */
+  onValidationResponded(callback) {
+    this.validationContract.on("ValidationResponded", callback);
+  }
+  /**
+   * Remove all event listeners
+   */
+  removeAllListeners() {
+    this.identityContract.removeAllListeners();
+    this.reputationContract.removeAllListeners();
+    this.validationContract.removeAllListeners();
+  }
+};
+
+// src/exceptions.ts
+var ChaosChainSDKError = class _ChaosChainSDKError extends Error {
+  details;
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "ChaosChainSDKError";
+    this.details = details;
+    Object.setPrototypeOf(this, _ChaosChainSDKError.prototype);
+  }
+  toString() {
+    if (Object.keys(this.details).length > 0) {
+      return `${this.message} | Details: ${JSON.stringify(this.details)}`;
+    }
+    return this.message;
+  }
+};
+var AgentRegistrationError = class _AgentRegistrationError extends ChaosChainSDKError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "AgentRegistrationError";
+    Object.setPrototypeOf(this, _AgentRegistrationError.prototype);
+  }
+};
+var PaymentError2 = class _PaymentError extends ChaosChainSDKError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "PaymentError";
+    Object.setPrototypeOf(this, _PaymentError.prototype);
+  }
+};
+var StorageError = class _StorageError extends ChaosChainSDKError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "StorageError";
+    Object.setPrototypeOf(this, _StorageError.prototype);
+  }
+};
+var IntegrityVerificationError = class _IntegrityVerificationError extends ChaosChainSDKError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "IntegrityVerificationError";
+    Object.setPrototypeOf(this, _IntegrityVerificationError.prototype);
+  }
+};
+var ContractError = class _ContractError extends ChaosChainSDKError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "ContractError";
+    Object.setPrototypeOf(this, _ContractError.prototype);
+  }
+};
+var ConfigurationError = class _ConfigurationError extends ChaosChainSDKError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "ConfigurationError";
+    Object.setPrototypeOf(this, _ConfigurationError.prototype);
+  }
+};
+
+// src/X402PaymentManager.ts
+var X402PaymentManager = class {
+  wallet;
+  provider;
+  network;
+  treasuryAddress;
+  protocolFeePercentage;
+  usdcAddresses;
+  constructor(wallet, network) {
+    this.wallet = wallet;
+    this.network = network;
+    this.protocolFeePercentage = 0.025;
+    this.treasuryAddress = this.getTreasuryAddress(network);
+    this.usdcAddresses = {
+      "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+      "ethereum-sepolia": "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+      "optimism-sepolia": "0x5fd84259d66Cd46123540766Be93DFE6D43130D7",
+      "linea-sepolia": "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+    };
+    this.provider = wallet.provider;
+    console.log(`\u2705 X402 Payment Manager initialized on ${network}`);
+    console.log(`\u{1F4B0} Treasury: ${this.treasuryAddress}`);
+    console.log(`\u{1F4CA} Protocol Fee: ${this.protocolFeePercentage * 100}%`);
+  }
+  /**
+   * Get ChaosChain treasury address for network
+   */
+  getTreasuryAddress(network) {
+    const treasuries = {
+      "base-sepolia": "0x8004AA63c570c570eBF15376c0dB199918BFe9Fb",
+      "ethereum-sepolia": "0x8004a6090Cd10A7288092483047B097295Fb8847",
+      "optimism-sepolia": "0x8004a6090Cd10A7288092483047B097295Fb8847",
+      "linea-sepolia": "0x8004aa7C931bCE1233973a0C6A667f73F66282e7"
+    };
+    return treasuries[network] || treasuries["base-sepolia"];
+  }
+  /**
+   * Create x402 payment request
+   */
+  createPaymentRequest(fromAgent, toAgent, amount, currency = "USDC", serviceDescription = "AI Agent Service") {
+    const paymentId = `x402_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 9)}`;
+    const protocolFee = amount * this.protocolFeePercentage;
+    const request = {
+      payment_id: paymentId,
+      from_agent: fromAgent,
+      to_agent: toAgent,
+      amount,
+      currency,
+      service_description: serviceDescription,
+      network: this.network,
+      protocol_fee: protocolFee,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    console.log(`\u{1F4C4} Created x402 payment request: ${paymentId}`);
+    console.log(`   From: ${fromAgent} \u2192 To: ${toAgent}`);
+    console.log(`   Amount: ${amount} ${currency} + ${protocolFee.toFixed(4)} ${currency} fee`);
+    return request;
+  }
+  /**
+   * Execute x402 payment on-chain
+   */
+  async executePayment(paymentRequest, recipientAddress) {
+    console.log(`\u{1F4B8} Executing x402 payment: ${paymentRequest.payment_id}`);
+    console.log(`   Network: ${this.network}`);
+    console.log(`   Recipient: ${recipientAddress}`);
+    const currency = paymentRequest.currency.toUpperCase();
+    const amount = paymentRequest.amount;
+    const protocolFee = paymentRequest.protocol_fee;
+    let mainTxHash;
+    let feeTxHash;
+    let chainId;
+    try {
+      const networkInfo = await this.provider.getNetwork();
+      chainId = Number(networkInfo.chainId);
+      if (currency === "ETH" || currency === "NATIVE") {
+        const { mainTx, feeTx } = await this.executeNativePayment(recipientAddress, amount, protocolFee);
+        mainTxHash = mainTx;
+        feeTxHash = feeTx;
+      } else if (currency === "USDC") {
+        const { mainTx, feeTx } = await this.executeUsdcPayment(recipientAddress, amount, protocolFee);
+        mainTxHash = mainTx;
+        feeTxHash = feeTx;
+      } else {
+        throw new PaymentError2(`Unsupported currency: ${currency}`);
+      }
+      const receipt = await this.provider.getTransactionReceipt(mainTxHash);
+      const proof = {
+        payment_id: paymentRequest.payment_id,
+        transaction_hash: mainTxHash,
+        main_transaction_hash: mainTxHash,
+        fee_transaction_hash: feeTxHash,
+        from_address: this.wallet.address,
+        to_address: recipientAddress,
+        treasury_address: this.treasuryAddress,
+        amount,
+        currency,
+        protocol_fee: protocolFee,
+        network: this.network,
+        chain_id: chainId,
+        block_number: receipt?.blockNumber,
+        timestamp: /* @__PURE__ */ new Date(),
+        status: receipt?.status === 1 ? "confirmed" : "failed",
+        confirmations: 1
+      };
+      console.log(`\u2705 x402 payment executed successfully`);
+      console.log(`   Main TX: ${mainTxHash}`);
+      if (feeTxHash) {
+        console.log(`   Fee TX: ${feeTxHash}`);
+      }
+      return proof;
+    } catch (e) {
+      throw new PaymentError2(`x402 payment failed: ${e.message}`, { payment_id: paymentRequest.payment_id });
+    }
+  }
+  /**
+   * Execute native token (ETH) payment
+   */
+  async executeNativePayment(recipientAddress, amount, protocolFee) {
+    const amountWei = ethers.ethers.parseEther(amount.toString());
+    const feeWei = ethers.ethers.parseEther(protocolFee.toString());
+    const mainTx = await this.wallet.sendTransaction({
+      to: recipientAddress,
+      value: amountWei
+    });
+    await mainTx.wait();
+    let feeTxHash;
+    if (protocolFee > 0) {
+      const feeTx = await this.wallet.sendTransaction({
+        to: this.treasuryAddress,
+        value: feeWei
+      });
+      await feeTx.wait();
+      feeTxHash = feeTx.hash;
+    }
+    return {
+      mainTx: mainTx.hash,
+      feeTx: feeTxHash
+    };
+  }
+  /**
+   * Execute USDC payment
+   */
+  async executeUsdcPayment(recipientAddress, amount, protocolFee) {
+    const usdcAddress = this.usdcAddresses[this.network];
+    if (!usdcAddress) {
+      throw new PaymentError2(`USDC not supported on ${this.network}`);
+    }
+    const amountUsdc = ethers.ethers.parseUnits(amount.toString(), 6);
+    const feeUsdc = ethers.ethers.parseUnits(protocolFee.toString(), 6);
+    const erc20Abi = ["function transfer(address to, uint256 amount) returns (bool)"];
+    const usdcContract = new ethers.ethers.Contract(usdcAddress, erc20Abi, this.wallet);
+    const mainTx = await usdcContract.transfer(recipientAddress, amountUsdc);
+    await mainTx.wait();
+    let feeTxHash;
+    if (protocolFee > 0) {
+      const feeTx = await usdcContract.transfer(this.treasuryAddress, feeUsdc);
+      await feeTx.wait();
+      feeTxHash = feeTx.hash;
+    }
+    return {
+      mainTx: mainTx.hash,
+      feeTx: feeTxHash
+    };
+  }
+  /**
+   * Verify x402 payment on-chain
+   */
+  async verifyPayment(paymentProof) {
+    try {
+      const receipt = await this.provider.getTransactionReceipt(paymentProof.main_transaction_hash);
+      if (!receipt) {
+        console.error(`\u274C Transaction not found: ${paymentProof.main_transaction_hash}`);
+        return false;
+      }
+      if (receipt.status !== 1) {
+        console.error(`\u274C Transaction failed: ${paymentProof.main_transaction_hash}`);
+        return false;
+      }
+      const tx = await this.provider.getTransaction(paymentProof.main_transaction_hash);
+      if (tx?.to?.toLowerCase() !== paymentProof.to_address.toLowerCase()) {
+        console.error(`\u274C Recipient mismatch`);
+        return false;
+      }
+      console.log(`\u2705 Payment verified on-chain: ${paymentProof.main_transaction_hash}`);
+      return true;
+    } catch (e) {
+      console.error(`\u274C Payment verification failed: ${e}`);
+      return false;
+    }
+  }
+  /**
+   * Create payment requirements for receiving payments
+   */
+  createPaymentRequirements(amount, currency = "USDC", serviceDescription = "AI Agent Service", expiryMinutes = 30) {
+    const expiryTime = new Date(Date.now() + expiryMinutes * 60 * 1e3);
+    return {
+      amount,
+      currency,
+      service_description: serviceDescription,
+      settlement_address: this.wallet.address,
+      network: this.network,
+      protocol_version: "x402-v1.0",
+      expires_at: expiryTime.toISOString(),
+      payment_endpoint: `x402://pay/${this.wallet.address}`
+    };
+  }
+  /**
+   * Get payment history (from on-chain events)
+   */
+  async getPaymentHistory(limit = 10) {
+    console.log(`\u{1F4CA} Payment history: querying last ${limit} payments...`);
+    return [];
+  }
+  /**
+   * Create cryptographic receipt for payment
+   */
+  createPaymentReceipt(paymentProof) {
+    const receiptData = {
+      payment_id: paymentProof.payment_id,
+      transaction_hash: paymentProof.main_transaction_hash,
+      from_address: paymentProof.from_address,
+      to_address: paymentProof.to_address,
+      amount: paymentProof.amount,
+      currency: paymentProof.currency,
+      protocol_fee: paymentProof.protocol_fee,
+      network: paymentProof.network,
+      chain_id: paymentProof.chain_id,
+      timestamp: paymentProof.timestamp.toISOString(),
+      status: paymentProof.status
+    };
+    const crypto2 = __require("crypto");
+    const receiptJson = JSON.stringify(receiptData);
+    const receiptHash = crypto2.createHash("sha256").update(receiptJson).digest("hex");
+    return {
+      receipt_type: "x402_payment",
+      receipt_hash: receiptHash,
+      receipt_data: receiptData,
+      verification_url: `https://explorer.base.org/tx/${paymentProof.main_transaction_hash}`,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get payment statistics
+   */
+  getPaymentStats() {
+    return {
+      network: this.network,
+      wallet_address: this.wallet.address,
+      treasury_address: this.treasuryAddress,
+      protocol_fee_percentage: this.protocolFeePercentage * 100,
+      supported_currencies: ["ETH", "USDC"],
+      features: {
+        instant_settlement: true,
+        on_chain_verification: true,
+        protocol_fees: true,
+        multi_currency: true,
+        payment_receipts: true
+      }
+    };
+  }
+};
+var PaymentManager = class {
+  agentName;
+  network;
+  wallet;
+  credentials;
+  stripeAxiosInstance;
+  paypalAccessToken;
+  constructor(agentName, network, wallet, credentials = {}) {
+    this.agentName = agentName;
+    this.network = network;
+    this.wallet = wallet;
+    this.credentials = credentials;
+    if (credentials.stripe_secret_key) {
+      this.stripeAxiosInstance = axios2__default.default.create({
+        baseURL: "https://api.stripe.com/v1",
+        headers: {
+          Authorization: `Bearer ${credentials.stripe_secret_key}`,
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+      console.log("\u2705 Stripe integration enabled");
+    }
+    if (credentials.paypal_client_id && credentials.paypal_client_secret) {
+      this.initializePayPal().catch(console.error);
+    }
+    console.log(`\u{1F4B3} Payment Manager initialized for ${agentName}`);
+  }
+  /**
+   * Initialize PayPal OAuth access token
+   */
+  async initializePayPal() {
+    try {
+      const auth = Buffer.from(
+        `${this.credentials.paypal_client_id}:${this.credentials.paypal_client_secret}`
+      ).toString("base64");
+      const response = await axios2__default.default.post(
+        "https://api-m.sandbox.paypal.com/v1/oauth2/token",
+        "grant_type=client_credentials",
+        {
+          headers: {
+            Authorization: `Basic ${auth}`,
+            "Content-Type": "application/x-www-form-urlencoded"
+          }
+        }
+      );
+      this.paypalAccessToken = response.data.access_token;
+      console.log("\u2705 PayPal integration enabled");
+    } catch (e) {
+      console.error("\u274C Failed to initialize PayPal:", e);
+    }
+  }
+  /**
+   * Execute traditional payment (cards, wallets, etc.)
+   */
+  executeTraditionalPayment(paymentMethod, amount, currency, paymentData_unused) {
+    console.log(`\u{1F4B3} Processing ${paymentMethod} payment: $${amount} ${currency}`);
+    switch (paymentMethod) {
+      case "basic-card" /* BASIC_CARD */:
+        return this.processBasicCard(amount, currency, paymentData);
+      case "https://google.com/pay" /* GOOGLE_PAY */:
+        return this.processGooglePay(amount, currency, paymentData);
+      case "https://apple.com/apple-pay" /* APPLE_PAY */:
+        return this.processApplePay(amount, currency, paymentData);
+      case "https://paypal.com" /* PAYPAL */:
+        return this.processPayPal(amount, currency, paymentData);
+      case "https://a2a.org/x402" /* A2A_X402 */:
+        return this.processA2AX402(amount, currency, paymentData);
+      default:
+        throw new PaymentError(`Unsupported payment method: ${paymentMethod}`);
+    }
+  }
+  /**
+   * Process Basic Card payment (Visa, Mastercard, Amex, etc.) via Stripe
+   */
+  processBasicCard(amount, currency, paymentData_unused) {
+    console.log("\u{1F4B3} Processing Basic Card via Stripe...");
+    if (!this.stripeAxiosInstance) {
+      console.warn("\u26A0\uFE0F  Stripe not configured, simulating payment");
+      return this.simulateTraditionalPayment("basic-card" /* BASIC_CARD */, amount, currency);
+    }
+    try {
+      return this.simulateTraditionalPayment("basic-card" /* BASIC_CARD */, amount, currency);
+    } catch (e) {
+      throw new PaymentError(`Basic card payment failed: ${e}`);
+    }
+  }
+  /**
+   * Process Google Pay payment
+   */
+  processGooglePay(amount, currency, paymentData_unused) {
+    console.log("\u{1F176}  Processing Google Pay...");
+    if (!this.credentials.google_pay_merchant_id) {
+      console.warn("\u26A0\uFE0F  Google Pay not configured, simulating payment");
+      return this.simulateTraditionalPayment("https://google.com/pay" /* GOOGLE_PAY */, amount, currency);
+    }
+    return this.simulateTraditionalPayment("https://google.com/pay" /* GOOGLE_PAY */, amount, currency);
+  }
+  /**
+   * Process Apple Pay payment
+   */
+  processApplePay(amount, currency, paymentData_unused) {
+    console.log("\u{1F34E} Processing Apple Pay...");
+    if (!this.credentials.apple_pay_merchant_id) {
+      console.warn("\u26A0\uFE0F  Apple Pay not configured, simulating payment");
+      return this.simulateTraditionalPayment("https://apple.com/apple-pay" /* APPLE_PAY */, amount, currency);
+    }
+    return this.simulateTraditionalPayment("https://apple.com/apple-pay" /* APPLE_PAY */, amount, currency);
+  }
+  /**
+   * Process PayPal payment
+   */
+  processPayPal(amount, currency, paymentData_unused) {
+    console.log("\u{1F499} Processing PayPal...");
+    if (!this.paypalAccessToken) {
+      console.warn("\u26A0\uFE0F  PayPal not configured, simulating payment");
+      return this.simulateTraditionalPayment("https://paypal.com" /* PAYPAL */, amount, currency);
+    }
+    try {
+      return this.simulateTraditionalPayment("https://paypal.com" /* PAYPAL */, amount, currency);
+    } catch (e) {
+      throw new PaymentError(`PayPal payment failed: ${e}`);
+    }
+  }
+  /**
+   * Process A2A-x402 crypto payment
+   */
+  processA2AX402(amount, currency, paymentData_unused) {
+    console.log("\u{1F517} Processing A2A-x402 crypto payment...");
+    const paymentId = `a2a_x402_${Date.now().toString(36)}`;
+    return {
+      payment_id: paymentId,
+      transaction_id: paymentData.transaction_hash || `crypto_tx_${paymentId}`,
+      status: "pending_crypto_confirmation",
+      amount,
+      currency,
+      payment_method: "https://a2a.org/x402" /* A2A_X402 */,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      processor_response: {
+        network: this.network,
+        settlement_type: "crypto",
+        requires_blockchain_confirmation: true
+      }
+    };
+  }
+  /**
+   * Simulate traditional payment (for testing/fallback)
+   */
+  simulateTraditionalPayment(method, amount, currency) {
+    const paymentId = `sim_${method}_${Date.now().toString(36)}`;
+    const transactionId = `txn_${paymentId}`;
+    console.log(`\u{1F504} Simulating ${method} payment`);
+    return {
+      payment_id: paymentId,
+      transaction_id: transactionId,
+      status: "completed",
+      amount,
+      currency,
+      payment_method: method,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      processor_response: {
+        simulation: true,
+        authorization_code: `AUTH_${Math.random().toString(36).substring(2, 10).toUpperCase()}`,
+        network: method === "basic-card" /* BASIC_CARD */ ? "visa" : method,
+        last4: method === "basic-card" /* BASIC_CARD */ ? "4242" : void 0
+      }
+    };
+  }
+  /**
+   * Get payment method configuration status
+   */
+  getPaymentMethodsStatus() {
+    return {
+      ["basic-card" /* BASIC_CARD */]: !!this.credentials.stripe_secret_key,
+      ["https://google.com/pay" /* GOOGLE_PAY */]: !!this.credentials.google_pay_merchant_id,
+      ["https://apple.com/apple-pay" /* APPLE_PAY */]: !!this.credentials.apple_pay_merchant_id,
+      ["https://paypal.com" /* PAYPAL */]: !!this.paypalAccessToken,
+      ["https://a2a.org/x402" /* A2A_X402 */]: true
+      // Always available via wallet
+    };
+  }
+  /**
+   * Get supported payment methods
+   */
+  getSupportedPaymentMethods() {
+    const status = this.getPaymentMethodsStatus();
+    return Object.entries(status).filter(([_, enabled]) => enabled).map(([method, _]) => method);
+  }
+  /**
+   * Validate payment method credentials
+   */
+  async validateCredentials() {
+    const results = {};
+    if (this.credentials.stripe_secret_key) {
+      try {
+        await this.stripeAxiosInstance.get("/balance");
+        results.stripe = true;
+      } catch (e) {
+        results.stripe = false;
+      }
+    }
+    if (this.credentials.paypal_client_id) {
+      results.paypal = !!this.paypalAccessToken;
+    }
+    results.google_pay = !!this.credentials.google_pay_merchant_id;
+    results.apple_pay = !!this.credentials.apple_pay_merchant_id;
+    results.crypto = !!this.wallet;
+    return results;
+  }
+  /**
+   * Create x402 payment request (for crypto payments)
+   */
+  createX402PaymentRequest(fromAgent, toAgent, amount, currency, serviceDescription) {
+    return {
+      payment_id: `x402_${Date.now().toString(36)}`,
+      from_agent: fromAgent,
+      to_agent: toAgent,
+      amount,
+      currency,
+      service_description: serviceDescription,
+      network: this.network,
+      protocol_fee: amount * 0.025,
+      // 2.5% ChaosChain fee
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Execute x402 crypto payment (delegated to X402PaymentManager)
+   */
+  executeX402Payment(paymentRequest) {
+    const transactionHash = `0x${Math.random().toString(16).substring(2, 66)}`;
+    return {
+      payment_id: paymentRequest.payment_id,
+      transaction_hash: transactionHash,
+      status: "confirmed",
+      timestamp: /* @__PURE__ */ new Date(),
+      network: this.network,
+      from_address: this.wallet.address,
+      to_address: paymentRequest.to_agent
+    };
+  }
+  /**
+   * Get payment statistics
+   */
+  getPaymentStats() {
+    return {
+      agent_name: this.agentName,
+      network: this.network,
+      wallet_address: this.wallet.address,
+      supported_methods: this.getSupportedPaymentMethods().length,
+      payment_methods_status: this.getPaymentMethodsStatus(),
+      features: {
+        traditional_payments: true,
+        crypto_payments: true,
+        multi_currency: true,
+        instant_settlement: true
+      }
+    };
+  }
+};
+var X402Server = class {
+  paymentManager;
+  server = null;
+  endpoints = /* @__PURE__ */ new Map();
+  paymentCache = /* @__PURE__ */ new Map();
+  config;
+  constructor(paymentManager, config) {
+    this.paymentManager = paymentManager;
+    this.config = {
+      port: config.port,
+      host: config.host || "0.0.0.0",
+      defaultCurrency: config.defaultCurrency || "USDC"
+    };
+    console.log(`\u{1F512} X402 Paywall Server initialized on port ${this.config.port}`);
+  }
+  /**
+   * Register a payment-protected endpoint
+   */
+  requirePayment(amount, description, currency) {
+    return (handler) => {
+      const path3 = `/${handler.name || "endpoint"}`;
+      const endpointConfig = {
+        path: path3,
+        amount,
+        currency: currency || this.config.defaultCurrency,
+        description,
+        handler
+      };
+      this.endpoints.set(path3, endpointConfig);
+      console.log(`\u{1F4B0} Registered paywall endpoint: ${path3} (${amount} ${currency || this.config.defaultCurrency})`);
+      return handler;
+    };
+  }
+  /**
+   * Start the HTTP 402 server
+   */
+  start() {
+    if (this.server) {
+      console.warn("\u26A0\uFE0F  Server already running");
+      return;
+    }
+    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" });
+        res.end(JSON.stringify({ error: "Internal server error" }));
+      });
+    });
+    this.server.listen(this.config.port, this.config.host, () => {
+      console.log(`\u{1F680} X402 Paywall Server running at http://${this.config.host}:${this.config.port}`);
+      console.log(`\u{1F4CB} Registered endpoints: ${this.endpoints.size}`);
+      this.endpoints.forEach((config, path3) => {
+        console.log(`   - ${path3}: ${config.amount} ${config.currency} - ${config.description}`);
+      });
+    });
+  }
+  /**
+   * Stop the server
+   */
+  stop() {
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        resolve();
+        return;
+      }
+      this.server.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          console.log("\u{1F6D1} X402 Paywall Server stopped");
+          this.server = null;
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Handle incoming HTTP requests
+   */
+  async handleRequest(req, res) {
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    const path3 = url.pathname;
+    const endpointConfig = this.endpoints.get(path3);
+    if (!endpointConfig) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Endpoint not found" }));
+      return;
+    }
+    const paymentToken = req.headers["x-payment-token"];
+    const paymentTxHash = req.headers["x-payment-tx"];
+    if (!paymentToken && !paymentTxHash) {
+      this.sendPaymentRequired(res, endpointConfig);
+      return;
+    }
+    const isValidPayment = await this.verifyPayment(paymentToken || paymentTxHash, endpointConfig);
+    if (!isValidPayment) {
+      res.writeHead(402, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid or insufficient payment" }));
+      return;
+    }
+    try {
+      let requestData = {};
+      if (req.method === "POST" || req.method === "PUT") {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        await new Promise((resolve) => req.on("end", resolve));
+        const body = Buffer.concat(chunks).toString();
+        requestData = body ? JSON.parse(body) : {};
+      }
+      const result = await endpointConfig.handler(requestData);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, data: result }));
+    } catch (error) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: error.message }));
+    }
+  }
+  /**
+   * Send HTTP 402 Payment Required response
+   */
+  sendPaymentRequired(res, endpointConfig) {
+    const paymentRequirements = this.paymentManager.createPaymentRequirements(
+      endpointConfig.amount,
+      endpointConfig.currency,
+      endpointConfig.description
+    );
+    const response = {
+      error: "Payment Required",
+      payment_required: true,
+      payment_requirements: paymentRequirements,
+      instructions: {
+        step_1: "Execute payment using x402 protocol",
+        step_2: "Include payment transaction hash in X-Payment-Tx header",
+        step_3: "Retry request with payment proof"
+      }
+    };
+    res.writeHead(402, {
+      "Content-Type": "application/json",
+      "X-Payment-Required": "true",
+      "X-Payment-Amount": endpointConfig.amount.toString(),
+      "X-Payment-Currency": endpointConfig.currency,
+      "X-Payment-Address": paymentRequirements.settlement_address
+    });
+    res.end(JSON.stringify(response));
+  }
+  /**
+   * Verify payment
+   */
+  async verifyPayment(paymentIdentifier, endpointConfig) {
+    try {
+      const cachedPayment = this.paymentCache.get(paymentIdentifier);
+      if (cachedPayment) {
+        if (cachedPayment.amount >= endpointConfig.amount && cachedPayment.currency === endpointConfig.currency) {
+          console.log(`\u2705 Payment verified from cache: ${paymentIdentifier}`);
+          return true;
+        }
+      }
+      if (paymentIdentifier.startsWith("0x") && paymentIdentifier.length === 66) {
+        const mockProof = {
+          payment_id: paymentIdentifier,
+          transaction_hash: paymentIdentifier,
+          main_transaction_hash: paymentIdentifier,
+          from_address: "0x0000000000000000000000000000000000000000",
+          to_address: "0x0000000000000000000000000000000000000000",
+          treasury_address: "0x0000000000000000000000000000000000000000",
+          amount: endpointConfig.amount,
+          currency: endpointConfig.currency,
+          protocol_fee: 0,
+          network: "base-sepolia",
+          chain_id: 84532,
+          timestamp: /* @__PURE__ */ new Date(),
+          status: "confirmed",
+          confirmations: 1
+        };
+        const isValid = await this.paymentManager.verifyPayment(mockProof);
+        if (isValid) {
+          this.paymentCache.set(paymentIdentifier, mockProof);
+          console.log(`\u2705 Payment verified on-chain: ${paymentIdentifier}`);
+          return true;
+        }
+      }
+      console.error(`\u274C Payment verification failed: ${paymentIdentifier}`);
+      return false;
+    } catch (error) {
+      console.error(`\u274C Payment verification error: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * Get server statistics
+   */
+  getServerStats() {
+    return {
+      running: !!this.server,
+      port: this.config.port,
+      host: this.config.host,
+      endpoints: Array.from(this.endpoints.entries()).map(([path3, config]) => ({
+        path: path3,
+        amount: config.amount,
+        currency: config.currency,
+        description: config.description
+      })),
+      payments_cached: this.paymentCache.size,
+      default_currency: this.config.defaultCurrency
+    };
+  }
+  /**
+   * Clear payment cache
+   */
+  clearPaymentCache() {
+    this.paymentCache.clear();
+    console.log("\u{1F5D1}\uFE0F  Payment cache cleared");
+  }
+};
+var GoogleAP2Integration = class {
+  agentName;
+  privateKey;
+  publicKey;
+  merchantPrivateKey;
+  constructor(agentName, merchantPrivateKey) {
+    this.agentName = agentName;
+    this.merchantPrivateKey = merchantPrivateKey || "demo_private_key_123";
+    const keypair = this.getOrGenerateRsaKeypair();
+    this.privateKey = keypair.privateKey;
+    this.publicKey = keypair.publicKey;
+    console.log(`\u2705 Google AP2 Integration initialized for ${agentName}`);
+  }
+  /**
+   * Generate or load RSA keypair for production JWT signing
+   */
+  getOrGenerateRsaKeypair() {
+    const keyDir = path2__namespace.join(process.cwd(), "keys");
+    const privateKeyPath = path2__namespace.join(keyDir, `${this.agentName}_ap2_private.pem`);
+    const publicKeyPath = path2__namespace.join(keyDir, `${this.agentName}_ap2_public.pem`);
+    if (!fs2__namespace.existsSync(keyDir)) {
+      fs2__namespace.mkdirSync(keyDir, { recursive: true });
+    }
+    if (fs2__namespace.existsSync(privateKeyPath) && fs2__namespace.existsSync(publicKeyPath)) {
+      try {
+        const privateKeyPem = fs2__namespace.readFileSync(privateKeyPath, "utf-8");
+        const publicKeyPem = fs2__namespace.readFileSync(publicKeyPath, "utf-8");
+        const privateKey2 = crypto__namespace.createPrivateKey(privateKeyPem);
+        console.log(`\u{1F511} Loaded existing RSA keypair for ${this.agentName}`);
+        return { privateKey: privateKey2, publicKey: publicKeyPem };
+      } catch (e) {
+        console.warn(`\u26A0\uFE0F  Failed to load existing keys: ${e}`);
+      }
+    }
+    console.log(`\u{1F511} Generating new RSA keypair for ${this.agentName}`);
+    const { privateKey, publicKey } = crypto__namespace.generateKeyPairSync("rsa", {
+      modulusLength: 2048,
+      publicKeyEncoding: {
+        type: "spki",
+        format: "pem"
+      },
+      privateKeyEncoding: {
+        type: "pkcs8",
+        format: "pem"
+      }
+    });
+    try {
+      fs2__namespace.writeFileSync(privateKeyPath, privateKey);
+      fs2__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: crypto__namespace.createPrivateKey(privateKey),
+      publicKey
+    };
+  }
+  /**
+   * Create an IntentMandate using Google's official AP2 types
+   */
+  createIntentMandate(userDescription, merchants, skus, requiresRefundability = false, expiryMinutes = 60) {
+    try {
+      const expiryTime = new Date(Date.now() + expiryMinutes * 60 * 1e3);
+      const intentMandate = {
+        user_cart_confirmation_required: true,
+        natural_language_description: userDescription,
+        merchants,
+        skus,
+        requires_refundability: requiresRefundability,
+        intent_expiry: expiryTime.toISOString()
+      };
+      console.log(`\u{1F4DD} Created Google AP2 IntentMandate`);
+      console.log(`   Description: ${userDescription}`);
+      console.log(`   Expires: ${expiryTime.toISOString()}`);
+      return {
+        intent_mandate: intentMandate,
+        success: true
+      };
+    } catch (e) {
+      console.error(`\u274C Failed to create IntentMandate: ${e}`);
+      return {
+        success: false,
+        error: String(e)
+      };
+    }
+  }
+  /**
+   * Create a CartMandate using Google's official AP2 types with JWT signing
+   */
+  async createCartMandate(cartId, items, totalAmount, currency = "USD", merchantName, expiryMinutes = 15) {
+    try {
+      const expiryTime = new Date(Date.now() + expiryMinutes * 60 * 1e3);
+      const paymentItems = items.map((item) => ({
+        label: item.name,
+        amount: {
+          currency,
+          value: item.price
+        }
+      }));
+      const totalItem = {
+        label: "Total",
+        amount: {
+          currency,
+          value: totalAmount
+        }
+      };
+      const methodData = [
+        {
+          supported_methods: "basic-card",
+          data: { supportedNetworks: ["visa", "mastercard"] }
+        },
+        {
+          supported_methods: "google-pay",
+          data: { environment: "TEST" }
+        },
+        {
+          supported_methods: "crypto",
+          data: { supportedCurrencies: ["USDC", "ETH"] }
+        }
+      ];
+      const paymentRequest = {
+        method_data: methodData,
+        details: {
+          id: `payment_${cartId}`,
+          display_items: paymentItems,
+          total: totalItem
+        }
+      };
+      const cartContents = {
+        id: cartId,
+        user_cart_confirmation_required: true,
+        payment_request: paymentRequest,
+        cart_expiry: expiryTime.toISOString(),
+        merchant_name: merchantName || this.agentName
+      };
+      const jwtToken = await this.createMerchantJwt(cartContents);
+      const cartMandate = {
+        contents: cartContents,
+        merchant_authorization: jwtToken
+      };
+      console.log(`\u{1F6D2} Created Google AP2 CartMandate with JWT`);
+      console.log(`   Cart ID: ${cartId}`);
+      console.log(`   Items: ${items.length} items, Total: ${totalAmount} ${currency}`);
+      console.log(`   JWT: ${jwtToken.slice(0, 50)}...`);
+      return {
+        cart_mandate: cartMandate,
+        jwt_token: jwtToken,
+        success: true
+      };
+    } catch (e) {
+      console.error(`\u274C Failed to create CartMandate: ${e}`);
+      return {
+        success: false,
+        error: String(e)
+      };
+    }
+  }
+  /**
+   * Create a JWT token for merchant authorization as per Google's AP2 spec
+   */
+  async createMerchantJwt(cartContents) {
+    const cartJson = JSON.stringify(cartContents);
+    const cartHash = crypto__namespace.createHash("sha256").update(cartJson).digest("hex");
+    const now = Math.floor(Date.now() / 1e3);
+    const payload = {
+      iss: `did:chaoschain:${this.agentName}`,
+      // Issuer (DID format)
+      sub: cartContents.id,
+      // Subject (cart ID)
+      aud: "chaoschain:payment_processor",
+      // Audience
+      iat: now,
+      // Issued at
+      exp: now + 15 * 60,
+      // Expires (15 minutes)
+      jti: `jwt_${cartContents.id}_${now}`,
+      // JWT ID
+      cart_hash: cartHash,
+      // Cart integrity hash
+      merchant_name: cartContents.merchant_name
+    };
+    const jwt = await new jose__namespace.SignJWT(payload).setProtectedHeader({
+      alg: "RS256",
+      kid: `did:chaoschain:${this.agentName}#key-1`
+    }).sign(this.privateKey);
+    return jwt;
+  }
+  /**
+   * Verify a JWT token (for validation purposes)
+   */
+  async verifyJwtToken(token) {
+    try {
+      const publicKey = crypto__namespace.createPublicKey(this.publicKey);
+      const { payload } = await jose__namespace.jwtVerify(token, publicKey, {
+        algorithms: ["RS256"],
+        audience: "chaoschain:payment_processor"
+      });
+      console.log(`\u2705 JWT token verified successfully with RSA256`);
+      return payload;
+    } catch (e) {
+      if (e.code === "ERR_JWT_EXPIRED") {
+        console.error(`\u274C JWT token has expired`);
+      } else if (e.code === "ERR_JWT_CLAIM_VALIDATION_FAILED") {
+        console.error(`\u274C JWT token has invalid audience`);
+      } else {
+        console.error(`\u274C JWT token is invalid: ${e}`);
+      }
+      return {};
+    }
+  }
+  /**
+   * Get a summary of the Google AP2 integration capabilities
+   */
+  getIntegrationSummary() {
+    return {
+      integration_type: "Google Official AP2",
+      agent_name: this.agentName,
+      supported_features: [
+        "IntentMandate creation with Google types",
+        "CartMandate creation with JWT signing",
+        "W3C PaymentRequest API compliance",
+        "Multi-payment method support",
+        "JWT-based merchant authorization",
+        "Proper expiry handling",
+        "Cart integrity verification"
+      ],
+      cryptographic_features: [
+        "JWT signing with RS256 (production)",
+        "Cart content hashing for integrity",
+        "Timestamp-based expiry",
+        "Replay attack prevention with JTI"
+      ],
+      compliance: ["Google AP2 Protocol", "W3C Payment Request API", "JWT RFC 7519", "ISO 8601 timestamps"]
+    };
+  }
+};
+
+// src/A2AX402Extension.ts
+var A2AX402Extension = class {
+  agentName;
+  network;
+  paymentManager;
+  supportedCryptoMethods;
+  supportedNetworks;
+  w3cPaymentMethods;
+  constructor(agentName, network, paymentManager) {
+    this.agentName = agentName;
+    this.network = network;
+    this.paymentManager = paymentManager;
+    this.supportedCryptoMethods = ["usdc", "eth", "native"];
+    this.supportedNetworks = ["base-sepolia", "ethereum-sepolia", "optimism-sepolia"];
+    this.w3cPaymentMethods = this.initializeW3cPaymentMethods();
+    console.log(`\u2705 A2A-x402 Extension initialized for ${agentName} on ${network}`);
+    console.log(`\u{1F4B3} Multi-payment support: ${this.w3cPaymentMethods.length} methods available`);
+  }
+  /**
+   * Initialize W3C Payment Request API compliant payment methods
+   */
+  initializeW3cPaymentMethods() {
+    const methods = [];
+    methods.push({
+      supported_methods: "basic-card",
+      data: {
+        supportedNetworks: ["visa", "mastercard", "amex", "discover"],
+        supportedTypes: ["credit", "debit"]
+      }
+    });
+    methods.push({
+      supported_methods: "https://google.com/pay",
+      data: {
+        environment: "PRODUCTION",
+        apiVersion: 2,
+        apiVersionMinor: 0,
+        allowedPaymentMethods: [
+          {
+            type: "CARD",
+            parameters: {
+              allowedAuthMethods: ["PAN_ONLY", "CRYPTOGRAM_3DS"],
+              allowedCardNetworks: ["AMEX", "DISCOVER", "JCB", "MASTERCARD", "VISA"]
+            }
+          }
+        ]
+      }
+    });
+    methods.push({
+      supported_methods: "https://apple.com/apple-pay",
+      data: {
+        version: 3,
+        merchantIdentifier: `merchant.chaoschain.${this.agentName.toLowerCase()}`,
+        merchantCapabilities: ["supports3DS"],
+        supportedNetworks: ["visa", "masterCard", "amex", "discover"]
+      }
+    });
+    methods.push({
+      supported_methods: "https://a2a.org/x402",
+      data: {
+        supportedCryptocurrencies: this.supportedCryptoMethods,
+        supportedNetworks: this.supportedNetworks,
+        settlementAddress: "dynamic",
+        protocolVersion: "x402-v1.0"
+      }
+    });
+    methods.push({
+      supported_methods: "https://paypal.com",
+      data: {
+        environment: "sandbox",
+        intent: "capture"
+      }
+    });
+    return methods;
+  }
+  /**
+   * Create x402 payment method descriptor with W3C compliance
+   */
+  createX402PaymentMethod(settlementAddress) {
+    const w3cMethods = this.w3cPaymentMethods.map((method) => method.supported_methods);
+    return {
+      supported_methods: w3cMethods,
+      supported_networks: this.supportedNetworks,
+      payment_endpoint: `x402://${this.agentName}.chaoschain.com/pay`,
+      verification_endpoint: `https://${this.agentName}.chaoschain.com/verify`,
+      method_data: {
+        w3c_methods: this.w3cPaymentMethods.map((method) => ({
+          supportedMethods: method.supported_methods,
+          data: method.data
+        })),
+        crypto_settlement_address: settlementAddress
+      }
+    };
+  }
+  /**
+   * Create enhanced payment request with x402 crypto support
+   */
+  createEnhancedPaymentRequest(cartId, totalAmount, currency, items, settlementAddress) {
+    const x402Methods = [this.createX402PaymentMethod(settlementAddress)];
+    const paymentRequest = {
+      id: `x402_${cartId}_${Date.now().toString(36)}`,
+      total: {
+        amount: { value: totalAmount.toString(), currency },
+        label: `Payment for ${items.length} items`
+      },
+      display_items: items.map((item) => ({
+        label: item.name || item.service || "Item",
+        amount: { value: (item.price || 0).toString(), currency }
+      })),
+      x402_methods: x402Methods,
+      settlement_address: settlementAddress,
+      network: this.network,
+      expires_at: new Date(Date.now() + 30 * 60 * 1e3).toISOString()
+    };
+    console.log(`\u{1F4B3} Created x402 payment request: ${paymentRequest.id}`);
+    return paymentRequest;
+  }
+  /**
+   * Execute x402 crypto payment using the real payment manager
+   */
+  async executeX402Payment(paymentRequest, payerAgent, serviceDescription = "A2A Service") {
+    console.log(`\u{1F4B8} Executing x402 payment: ${payerAgent} \u2192 ${this.agentName}`);
+    const amount = parseFloat(paymentRequest.total.amount.value);
+    const currency = paymentRequest.total.amount.currency;
+    const pmPaymentRequest = this.paymentManager.createX402PaymentRequest(
+      payerAgent,
+      this.agentName,
+      amount,
+      currency,
+      serviceDescription
+    );
+    const paymentProof = this.paymentManager.executeX402Payment(pmPaymentRequest);
+    const response = {
+      payment_id: paymentProof.payment_id,
+      transaction_hash: paymentProof.transaction_hash,
+      network: this.network,
+      amount,
+      currency,
+      settlement_address: paymentRequest.settlement_address,
+      confirmation_blocks: 1,
+      status: "confirmed",
+      timestamp: paymentProof.timestamp.toISOString(),
+      gas_fee: void 0,
+      protocol_fee: pmPaymentRequest.protocol_fee
+    };
+    console.log(`\u2705 x402 payment confirmed: ${response.transaction_hash}`);
+    return response;
+  }
+  /**
+   * Execute traditional payment (cards, Google Pay, Apple Pay, etc.)
+   */
+  executeTraditionalPayment(paymentMethod, amount, currency, paymentData2) {
+    console.log(`\u{1F4B3} Processing ${paymentMethod} payment: $${amount} ${currency}`);
+    if (this.paymentManager) {
+      let methodEnum;
+      if (paymentMethod === "basic-card") {
+        methodEnum = "basic-card" /* BASIC_CARD */;
+      } else if (paymentMethod === "https://google.com/pay") {
+        methodEnum = "https://google.com/pay" /* GOOGLE_PAY */;
+      } else if (paymentMethod === "https://apple.com/apple-pay") {
+        methodEnum = "https://apple.com/apple-pay" /* APPLE_PAY */;
+      } else if (paymentMethod === "https://paypal.com") {
+        methodEnum = "https://paypal.com" /* PAYPAL */;
+      } else if (paymentMethod === "https://a2a.org/x402") {
+        methodEnum = "https://a2a.org/x402" /* A2A_X402 */;
+      }
+      if (methodEnum) {
+        const result = this.paymentManager.executeTraditionalPayment(methodEnum, amount, currency, paymentData2);
+        return {
+          payment_id: result.payment_id,
+          method: paymentMethod,
+          amount,
+          currency,
+          status: result.status,
+          transaction_id: result.transaction_id,
+          authorization_code: result.processor_response?.authorization_code,
+          timestamp: result.timestamp,
+          receipt_data: result.processor_response
+        };
+      }
+    }
+    const paymentId = `trad_${Date.now().toString(36)}`;
+    return {
+      payment_id: paymentId,
+      method: paymentMethod,
+      amount,
+      currency,
+      status: "failed",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      receipt_data: { error: "Unsupported payment method" }
+    };
+  }
+  /**
+   * Verify x402 payment on-chain
+   */
+  verifyX402Payment(paymentResponse) {
+    return paymentResponse.status === "confirmed" && !!paymentResponse.transaction_hash && paymentResponse.transaction_hash.length === 66;
+  }
+  /**
+   * Create cryptographic proof of x402 payment
+   */
+  createPaymentProof(paymentResponse) {
+    const proofData = {
+      payment_id: paymentResponse.payment_id,
+      transaction_hash: paymentResponse.transaction_hash,
+      network: paymentResponse.network,
+      amount: paymentResponse.amount,
+      currency: paymentResponse.currency,
+      settlement_address: paymentResponse.settlement_address,
+      timestamp: paymentResponse.timestamp,
+      agent_payer: "unknown",
+      agent_payee: this.agentName
+    };
+    const proofJson = JSON.stringify(proofData);
+    const crypto2 = __require("crypto");
+    const proofHash = crypto2.createHash("sha256").update(proofJson).digest("hex");
+    return {
+      proof_type: "a2a_x402_payment",
+      proof_hash: proofHash,
+      proof_data: proofData,
+      verification_method: "on_chain_transaction",
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get A2A-x402 extension capabilities with W3C Payment Request API compliance
+   */
+  getExtensionCapabilities() {
+    return {
+      extension_name: "a2a-x402-multi-payment",
+      version: "1.0.0",
+      w3c_payment_methods: this.w3cPaymentMethods.map((m) => m.supported_methods),
+      supported_crypto_methods: this.supportedCryptoMethods,
+      supported_networks: this.supportedNetworks,
+      features: [
+        "w3c_payment_request_api",
+        "multi_payment_methods",
+        "basic_card_support",
+        "google_pay_integration",
+        "apple_pay_integration",
+        "paypal_integration",
+        "crypto_payments",
+        "instant_settlement",
+        "on_chain_verification",
+        "protocol_fees",
+        "gas_optimization",
+        "multi_network_support"
+      ],
+      compliance: [
+        "W3C Payment Request API",
+        "A2A-x402 Specification v0.1",
+        "Google Pay API v2",
+        "Apple Pay JS API v3",
+        "PayPal Checkout API",
+        "EIP-20 Token Standard",
+        "HTTP 402 Payment Required"
+      ],
+      payment_processors: {
+        traditional: ["simulated_processor", "google_pay", "apple_pay", "paypal"],
+        crypto: ["chaoschain_x402", "base_sepolia", "ethereum"]
+      }
+    };
+  }
+};
+var ProcessIntegrity = class {
+  agentName;
+  storageManager;
+  computeProvider;
+  registeredFunctions;
+  functionHashes;
+  constructor(agentName, storageManager = null, computeProvider = null) {
+    this.agentName = agentName;
+    this.storageManager = storageManager;
+    this.computeProvider = computeProvider;
+    this.registeredFunctions = /* @__PURE__ */ new Map();
+    this.functionHashes = /* @__PURE__ */ new Map();
+    const verificationMode = !computeProvider ? "local" : "local + TEE attestation";
+    console.log(
+      `\u2705 ChaosChain Process Integrity Verifier initialized: ${agentName} (${verificationMode})`
+    );
+  }
+  /**
+   * Register a function for integrity checking.
+   */
+  registerFunction(func, functionName) {
+    const name = functionName || func.name;
+    const codeHash = this.generateCodeHash(func);
+    this.registeredFunctions.set(name, func);
+    this.functionHashes.set(name, codeHash);
+    console.log(`\u{1F4DD} Registered integrity-checked function: ${name}`);
+    console.log(`   Code hash: ${codeHash.slice(0, 16)}...`);
+    return codeHash;
+  }
+  /**
+   * Execute a registered function with integrity proof generation.
+   */
+  async executeWithProof(functionName, inputs, requireProof = true, useTee = true) {
+    if (!this.registeredFunctions.has(functionName)) {
+      const available = Array.from(this.registeredFunctions.keys());
+      throw new IntegrityVerificationError(`Function not registered: ${functionName}`, {
+        available_functions: available
+      });
+    }
+    const func = this.registeredFunctions.get(functionName);
+    const codeHash = this.functionHashes.get(functionName);
+    const executionMode = useTee && this.computeProvider ? "local + TEE" : "local";
+    console.log(`\u26A1 Executing with ChaosChain Process Integrity: ${functionName} (${executionMode})`);
+    const startTime = /* @__PURE__ */ new Date();
+    let teeAttestation = null;
+    try {
+      const result = await func(inputs);
+      const executionTime = /* @__PURE__ */ new Date();
+      if (useTee && this.computeProvider) {
+        try {
+          teeAttestation = await this.getTeeAttestation(functionName, inputs, result);
+        } catch (e) {
+          console.warn(`\u26A0\uFE0F  TEE attestation failed (continuing with local proof): ${e}`);
+        }
+      }
+      if (!requireProof) {
+        return [result, null];
+      }
+      const proof = this.generateIntegrityProof(
+        functionName,
+        codeHash,
+        inputs,
+        result,
+        startTime,
+        executionTime,
+        teeAttestation
+      );
+      if (this.storageManager) {
+        await this.storeProofOnIpfs(proof);
+      }
+      return [result, proof];
+    } catch (e) {
+      throw new IntegrityVerificationError(`Function execution failed: ${e}`, {
+        function_name: functionName,
+        inputs
+      });
+    }
+  }
+  /**
+   * Generate a hash of the function's code.
+   */
+  generateCodeHash(func) {
+    try {
+      const sourceCode = func.toString();
+      return crypto.createHash("sha256").update(sourceCode).digest("hex");
+    } catch {
+      const funcInfo = `${func.name}`;
+      return crypto.createHash("sha256").update(funcInfo).digest("hex");
+    }
+  }
+  /**
+   * Get TEE attestation from compute provider (e.g., 0G Compute).
+   */
+  async getTeeAttestation(functionName, inputs, result) {
+    if (!this.computeProvider) {
+      return null;
+    }
+    console.log(`\u{1F510} Requesting TEE attestation from compute provider...`);
+    try {
+      const taskData = {
+        function: functionName,
+        inputs,
+        model: "gpt-oss-120b",
+        // Default model for 0G Compute
+        prompt: `Execute function: ${functionName} with inputs: ${JSON.stringify(inputs)}`
+      };
+      const jobId = await this.computeProvider.submit(taskData);
+      const maxWait = 6e4;
+      const startWait = Date.now();
+      while (Date.now() - startWait < maxWait) {
+        const statusResult = await this.computeProvider.status(jobId);
+        const state = statusResult.state || "unknown";
+        if (state === "completed") {
+          const computeResult = await this.computeProvider.result(jobId);
+          if (computeResult.success) {
+            const attestationData = await this.computeProvider.attestation(jobId);
+            console.log(`\u2705 TEE attestation received: ${jobId}`);
+            console.log(`   Execution Hash: ${computeResult.execution_hash}`);
+            console.log(`   Verification: ${computeResult.verification_method.value}`);
+            return {
+              job_id: jobId,
+              provider: "0g-compute",
+              execution_hash: computeResult.execution_hash,
+              // TEE execution ID
+              verification_method: computeResult.verification_method.value,
+              model: taskData.model,
+              attestation_data: attestationData,
+              // Full attestation proof
+              proof: computeResult.proof?.toString("hex"),
+              metadata: computeResult.metadata,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            };
+          } else {
+            console.warn(`\u26A0\uFE0F  Compute result failed: ${computeResult.error}`);
+            return null;
+          }
+        } else if (state === "failed") {
+          console.warn(`\u26A0\uFE0F  TEE execution failed`);
+          return null;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+      }
+      console.warn(`\u26A0\uFE0F  TEE attestation timeout after ${maxWait}ms`);
+      return null;
+    } catch (e) {
+      console.warn(`\u26A0\uFE0F  TEE attestation error: ${e}`);
+      return null;
+    }
+  }
+  /**
+   * Generate a cryptographic integrity proof.
+   */
+  generateIntegrityProof(functionName, codeHash, inputs, result, startTime, executionTime, teeAttestation) {
+    const proofId = `proof_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+    const executionData = {
+      function_name: functionName,
+      code_hash: codeHash,
+      inputs,
+      result: this.serializeResult(result),
+      start_time: startTime.toISOString(),
+      execution_time: executionTime.toISOString(),
+      agent_name: this.agentName
+    };
+    const executionHash = crypto.createHash("sha256").update(JSON.stringify(executionData)).digest("hex");
+    const proof = {
+      proof_id: proofId,
+      function_name: functionName,
+      code_hash: codeHash,
+      execution_hash: executionHash,
+      timestamp: executionTime,
+      agent_name: this.agentName,
+      verification_status: "verified",
+      ipfs_cid: void 0,
+      // TEE fields (if available)
+      tee_attestation: teeAttestation || void 0,
+      tee_provider: teeAttestation?.provider,
+      tee_job_id: teeAttestation?.job_id,
+      tee_execution_hash: teeAttestation?.execution_hash
+    };
+    const verificationLevel = teeAttestation ? "local + TEE" : "local";
+    console.log(`\u2705 Process integrity proof generated: ${proofId} (${verificationLevel})`);
+    return proof;
+  }
+  /**
+   * Store integrity proof on IPFS for persistence.
+   */
+  async storeProofOnIpfs(proof) {
+    if (!this.storageManager) return;
+    try {
+      const proofData = {
+        type: "chaoschain_process_integrity_proof_v2",
+        // v2 includes TEE
+        proof: {
+          proof_id: proof.proof_id,
+          function_name: proof.function_name,
+          code_hash: proof.code_hash,
+          execution_hash: proof.execution_hash,
+          timestamp: proof.timestamp.toISOString(),
+          agent_name: proof.agent_name,
+          verification_status: proof.verification_status,
+          // TEE attestation (if available)
+          tee_attestation: proof.tee_attestation,
+          tee_provider: proof.tee_provider,
+          tee_job_id: proof.tee_job_id,
+          tee_execution_hash: proof.tee_execution_hash
+        },
+        verification_layers: {
+          local_code_hash: true,
+          tee_attestation: !!proof.tee_attestation
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        agent_name: this.agentName
+      };
+      const filename = `process_integrity_proof_${proof.proof_id}.json`;
+      const cid = await this.storageManager.uploadJson(proofData, filename);
+      if (cid) {
+        proof.ipfs_cid = cid;
+        console.log(`\u{1F4C1} Process Integrity Proof stored on IPFS: ${cid}`);
+      }
+    } catch (e) {
+      console.warn(`\u26A0\uFE0F  Failed to store process integrity proof on IPFS: ${e}`);
+    }
+  }
+  /**
+   * Serialize function result for hashing.
+   */
+  serializeResult(result) {
+    try {
+      JSON.stringify(result);
+      return result;
+    } catch {
+      return String(result);
+    }
+  }
+  /**
+   * Create a process insurance policy for a function.
+   */
+  createInsurancePolicy(functionName, coverageAmount, conditions) {
+    const policyId = `policy_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+    const policy = {
+      policy_id: policyId,
+      function_name: functionName,
+      agent_name: this.agentName,
+      coverage_amount: coverageAmount,
+      conditions,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "active"
+    };
+    console.log(`\u{1F6E1}\uFE0F  Process insurance policy created: ${policyId}`);
+    console.log(`   Function: ${functionName}`);
+    console.log(`   Coverage: $${coverageAmount}`);
+    return policy;
+  }
+  /**
+   * Configure autonomous agent capabilities with integrity verification.
+   */
+  configureAutonomousAgent(capabilities, constraints) {
+    const configId = `config_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+    const configuration = {
+      config_id: configId,
+      agent_name: this.agentName,
+      capabilities,
+      constraints,
+      integrity_verification: true,
+      registered_functions: Array.from(this.registeredFunctions.keys()),
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    console.log(`\u{1F916} Autonomous agent configured: ${configId}`);
+    console.log(`   Capabilities: ${capabilities.length}`);
+    console.log(`   Registered functions: ${this.registeredFunctions.size}`);
+    return configuration;
+  }
+};
+var LocalIPFSStorage = class {
+  apiUrl;
+  constructor(apiUrl = "http://127.0.0.1:5001") {
+    this.apiUrl = apiUrl;
+    console.log(`\u{1F4E6} Local IPFS Storage initialized: ${apiUrl}`);
+  }
+  async put(data, mime = "application/json") {
+    try {
+      const buffer = typeof data === "string" ? Buffer.from(data) : data;
+      const FormData2 = __require("form-data");
+      const form = new FormData2();
+      form.append("file", buffer, { contentType: mime });
+      const response = await axios2__default.default.post(`${this.apiUrl}/api/v0/add`, form, {
+        headers: form.getHeaders(),
+        maxBodyLength: Infinity
+      });
+      const cid = response.data.Hash;
+      console.log(`\u2705 Uploaded to local IPFS: ${cid}`);
+      return {
+        cid,
+        url: `ipfs://${cid}`,
+        size: response.data.Size,
+        provider: "local-ipfs"
+      };
+    } catch (e) {
+      if (e.code === "ECONNREFUSED") {
+        throw new StorageError(
+          "Local IPFS daemon not running. Start with: ipfs daemon",
+          { api_url: this.apiUrl }
+        );
+      }
+      throw new StorageError(`Local IPFS upload failed: ${e.message}`);
+    }
+  }
+  async get(cid) {
+    try {
+      const response = await axios2__default.default.post(
+        `${this.apiUrl}/api/v0/cat`,
+        null,
+        {
+          params: { arg: cid },
+          responseType: "arraybuffer"
+        }
+      );
+      return Buffer.from(response.data);
+    } catch (e) {
+      throw new StorageError(`Failed to retrieve from IPFS: ${e.message}`);
+    }
+  }
+  async pin(cid) {
+    try {
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/pin/add`, null, {
+        params: { arg: cid }
+      });
+      console.log(`\u{1F4CC} Pinned to local IPFS: ${cid}`);
+    } catch (e) {
+      throw new StorageError(`Failed to pin CID: ${e.message}`);
+    }
+  }
+  async unpin(cid) {
+    try {
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/pin/rm`, null, {
+        params: { arg: cid }
+      });
+      console.log(`\u{1F4CC} Unpinned from local IPFS: ${cid}`);
+    } catch (e) {
+      throw new StorageError(`Failed to unpin CID: ${e.message}`);
+    }
+  }
+};
+var PinataStorage = class {
+  jwtToken;
+  gatewayUrl;
+  constructor(jwtToken, gatewayUrl = "https://gateway.pinata.cloud") {
+    this.jwtToken = jwtToken;
+    this.gatewayUrl = gatewayUrl;
+    console.log(`\u{1F310} Pinata Storage initialized`);
+  }
+  async put(data, mime = "application/json") {
+    try {
+      const buffer = typeof data === "string" ? Buffer.from(data) : data;
+      const FormData2 = __require("form-data");
+      const form = new FormData2();
+      form.append("file", buffer, {
+        contentType: mime,
+        filename: `file_${Date.now()}`
+      });
+      const response = await axios2__default.default.post("https://api.pinata.cloud/pinning/pinFileToIPFS", form, {
+        headers: {
+          ...form.getHeaders(),
+          Authorization: `Bearer ${this.jwtToken}`
+        },
+        maxBodyLength: Infinity
+      });
+      const cid = response.data.IpfsHash;
+      console.log(`\u2705 Uploaded to Pinata: ${cid}`);
+      return {
+        cid,
+        url: `${this.gatewayUrl}/ipfs/${cid}`,
+        size: response.data.PinSize,
+        provider: "pinata"
+      };
+    } catch (e) {
+      throw new StorageError(`Pinata upload failed: ${e.message}`);
+    }
+  }
+  async get(cid) {
+    try {
+      const response = await axios2__default.default.get(`${this.gatewayUrl}/ipfs/${cid}`, {
+        responseType: "arraybuffer"
+      });
+      return Buffer.from(response.data);
+    } catch (e) {
+      throw new StorageError(`Failed to retrieve from Pinata: ${e.message}`);
+    }
+  }
+  async pin(cid) {
+    try {
+      await axios2__default.default.post(
+        "https://api.pinata.cloud/pinning/pinByHash",
+        { hashToPin: cid },
+        {
+          headers: {
+            Authorization: `Bearer ${this.jwtToken}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      console.log(`\u{1F4CC} Pinned to Pinata: ${cid}`);
+    } catch (e) {
+      throw new StorageError(`Failed to pin to Pinata: ${e.message}`);
+    }
+  }
+  async unpin(cid) {
+    try {
+      await axios2__default.default.delete(`https://api.pinata.cloud/pinning/unpin/${cid}`, {
+        headers: {
+          Authorization: `Bearer ${this.jwtToken}`
+        }
+      });
+      console.log(`\u{1F4CC} Unpinned from Pinata: ${cid}`);
+    } catch (e) {
+      throw new StorageError(`Failed to unpin from Pinata: ${e.message}`);
+    }
+  }
+};
+var IrysStorage = class {
+  walletKey;
+  constructor(walletKey) {
+    this.walletKey = walletKey;
+    console.log(`\u{1F48E} Irys (Arweave) Storage initialized`);
+  }
+  async put(data, mime = "application/json") {
+    try {
+      const mockCid = `ar_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 15)}`;
+      console.log(`\u2705 Uploaded to Irys: ${mockCid}`);
+      return {
+        cid: mockCid,
+        url: `https://arweave.net/${mockCid}`,
+        provider: "irys"
+      };
+    } catch (e) {
+      throw new StorageError(`Irys upload failed: ${e.message}`);
+    }
+  }
+  async get(cid) {
+    try {
+      const response = await axios2__default.default.get(`https://arweave.net/${cid}`, {
+        responseType: "arraybuffer"
+      });
+      return Buffer.from(response.data);
+    } catch (e) {
+      throw new StorageError(`Failed to retrieve from Arweave: ${e.message}`);
+    }
+  }
+};
+var ZeroGStorage = class {
+  grpcUrl;
+  privateKey;
+  constructor(privateKey, grpcUrl = "localhost:50051") {
+    this.privateKey = privateKey;
+    this.grpcUrl = grpcUrl;
+    console.log(`\u26A1 0G Storage initialized: ${grpcUrl}`);
+  }
+  async put(data, mime = "application/json") {
+    try {
+      const mockCid = `0g_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 15)}`;
+      console.log(`\u2705 Uploaded to 0G Storage: ${mockCid}`);
+      return {
+        cid: mockCid,
+        url: `0g://${mockCid}`,
+        provider: "0g-storage"
+      };
+    } catch (e) {
+      throw new StorageError(`0G Storage upload failed: ${e.message}`);
+    }
+  }
+  async get(cid) {
+    try {
+      throw new StorageError("0G Storage retrieval not yet implemented");
+    } catch (e) {
+      throw new StorageError(`Failed to retrieve from 0G Storage: ${e.message}`);
+    }
+  }
+};
+var AutoStorageManager = class {
+  backends = [];
+  preferredBackend = null;
+  constructor() {
+    this.detectAvailableBackends();
+  }
+  detectAvailableBackends() {
+    console.log("\u{1F50D} Auto-detecting available storage backends...");
+    try {
+      const localIpfs = new LocalIPFSStorage();
+      this.backends.push(localIpfs);
+      this.preferredBackend = localIpfs;
+      console.log("\u2705 Local IPFS available");
+    } catch (e) {
+      console.log("\u274C Local IPFS not available");
+    }
+    const pinataJwt = process.env.PINATA_JWT;
+    if (pinataJwt) {
+      const pinata = new PinataStorage(pinataJwt);
+      this.backends.push(pinata);
+      if (!this.preferredBackend) this.preferredBackend = pinata;
+      console.log("\u2705 Pinata available");
+    }
+    const irysKey = process.env.IRYS_WALLET_KEY;
+    if (irysKey) {
+      const irys = new IrysStorage(irysKey);
+      this.backends.push(irys);
+      if (!this.preferredBackend) this.preferredBackend = irys;
+      console.log("\u2705 Irys available");
+    }
+    const zerogKey = process.env.ZEROG_TESTNET_PRIVATE_KEY;
+    if (zerogKey) {
+      const zerog = new ZeroGStorage(zerogKey);
+      this.backends.push(zerog);
+      if (!this.preferredBackend) this.preferredBackend = zerog;
+      console.log("\u2705 0G Storage available");
+    }
+    if (this.backends.length === 0) {
+      console.warn("\u26A0\uFE0F  No storage backends available! Please configure at least one.");
+    } else {
+      console.log(`\u{1F4E6} ${this.backends.length} storage backend(s) available`);
+    }
+  }
+  async put(data, mime) {
+    if (!this.preferredBackend) {
+      throw new StorageError("No storage backends available");
+    }
+    try {
+      return await this.preferredBackend.put(data, mime);
+    } catch (e) {
+      for (const backend of this.backends) {
+        if (backend !== this.preferredBackend) {
+          try {
+            console.log(`\u26A0\uFE0F  Trying fallback storage backend...`);
+            return await backend.put(data, mime);
+          } catch (fallbackError) {
+            continue;
+          }
+        }
+      }
+      throw new StorageError(`All storage backends failed: ${e}`);
+    }
+  }
+  async get(cid) {
+    if (!this.preferredBackend) {
+      throw new StorageError("No storage backends available");
+    }
+    return await this.preferredBackend.get(cid);
+  }
+  getAvailableBackends() {
+    return this.backends.map((backend) => backend.constructor.name);
+  }
+};
+
+// src/utils/networks.ts
+var ERC8004_ADDRESSES = {
+  "ethereum-sepolia": {
+    identity: "0x8004a6090Cd10A7288092483047B097295Fb8847",
+    reputation: "0x8004B8FD1A363aa02fDC07635C0c5F94f6Af5B7E",
+    validation: "0x8004CB39f29c09145F24Ad9dDe2A108C1A2cdfC5"
+  },
+  "base-sepolia": {
+    identity: "0x8004AA63c570c570eBF15376c0dB199918BFe9Fb",
+    reputation: "0x8004bd8daB57f14Ed299135749a5CB5c42d341BF",
+    validation: "0x8004C269D0A5647E51E121FeB226200ECE932d55"
+  },
+  "linea-sepolia": {
+    identity: "0x8004aa7C931bCE1233973a0C6A667f73F66282e7",
+    reputation: "0x8004bd8483b99310df121c46ED8858616b2Bba02",
+    validation: "0x8004c44d1EFdd699B2A26e781eF7F77c56A9a4EB"
+  },
+  "hedera-testnet": {
+    identity: "0x4c74ebd72921d537159ed2053f46c12a7d8e5923",
+    reputation: "0xc565edcba77e3abeade40bfd6cf6bf583b3293e0",
+    validation: "0x18df085d85c586e9241e0cd121ca422f571c2da6"
+  },
+  "0g-testnet": {
+    identity: "0x80043ed9cf33a3472768dcd53175bb44e03a1e4a",
+    reputation: "0x80045d7b72c47bf5ff73737b780cb1a5ba8ee202",
+    validation: "0x80041728e0aadf1d1427f9be18d52b7f3afefafb"
+  }
+};
+var NETWORK_INFO = {
+  "ethereum-sepolia": {
+    chainId: 11155111,
+    name: "Ethereum Sepolia Testnet",
+    rpcUrl: process.env.ETHEREUM_SEPOLIA_RPC_URL || "https://rpc.sepolia.org",
+    contracts: ERC8004_ADDRESSES["ethereum-sepolia"],
+    nativeCurrency: {
+      name: "Sepolia ETH",
+      symbol: "ETH",
+      decimals: 18
+    }
+  },
+  "base-sepolia": {
+    chainId: 84532,
+    name: "Base Sepolia Testnet",
+    rpcUrl: process.env.BASE_SEPOLIA_RPC_URL || "https://sepolia.base.org",
+    contracts: ERC8004_ADDRESSES["base-sepolia"],
+    nativeCurrency: {
+      name: "Sepolia ETH",
+      symbol: "ETH",
+      decimals: 18
+    }
+  },
+  "linea-sepolia": {
+    chainId: 59141,
+    name: "Linea Sepolia Testnet",
+    rpcUrl: process.env.LINEA_SEPOLIA_RPC_URL || "https://rpc.sepolia.linea.build",
+    contracts: ERC8004_ADDRESSES["linea-sepolia"],
+    nativeCurrency: {
+      name: "Linea ETH",
+      symbol: "ETH",
+      decimals: 18
+    }
+  },
+  "hedera-testnet": {
+    chainId: 296,
+    name: "Hedera Testnet",
+    rpcUrl: process.env.HEDERA_TESTNET_RPC_URL || "https://testnet.hashio.io/api",
+    contracts: ERC8004_ADDRESSES["hedera-testnet"],
+    nativeCurrency: {
+      name: "HBAR",
+      symbol: "HBAR",
+      decimals: 18
+    }
+  },
+  "0g-testnet": {
+    chainId: 16600,
+    name: "0G Network Testnet",
+    rpcUrl: process.env.ZEROG_TESTNET_RPC_URL || "https://evmrpc-testnet.0g.ai",
+    contracts: ERC8004_ADDRESSES["0g-testnet"],
+    nativeCurrency: {
+      name: "A0GI",
+      symbol: "A0GI",
+      decimals: 18
+    }
+  },
+  local: {
+    chainId: 31337,
+    name: "Local Network",
+    rpcUrl: process.env.LOCAL_RPC_URL || "http://localhost:8545",
+    contracts: {
+      identity: "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+      reputation: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+      validation: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0"
+    },
+    nativeCurrency: {
+      name: "ETH",
+      symbol: "ETH",
+      decimals: 18
+    }
+  }
+};
+function getNetworkInfo(network) {
+  const networkKey = typeof network === "string" ? network : network.valueOf();
+  const info = NETWORK_INFO[networkKey];
+  if (!info) {
+    throw new Error(`Unsupported network: ${networkKey}`);
+  }
+  return info;
+}
+function getContractAddresses(network) {
+  return getNetworkInfo(network).contracts;
+}
+
+// src/ChaosChainSDK.ts
+var ChaosChainSDK = class {
+  // Core components
+  walletManager;
+  chaosAgent;
+  x402PaymentManager;
+  paymentManager;
+  storageBackend;
+  computeProvider;
+  provider;
+  // Advanced integrations
+  googleAP2;
+  a2aX402Extension;
+  processIntegrity;
+  // Configuration
+  agentName;
+  agentDomain;
+  agentRole;
+  network;
+  networkInfo;
+  // Current agent ID (set after registration)
+  _agentId;
+  constructor(config) {
+    this.agentName = config.agentName;
+    this.agentDomain = config.agentDomain;
+    this.agentRole = config.agentRole;
+    this.network = config.network;
+    this.networkInfo = getNetworkInfo(config.network);
+    const rpcUrl = config.rpcUrl || this.networkInfo.rpcUrl;
+    this.provider = new ethers.ethers.JsonRpcProvider(rpcUrl);
+    this.walletManager = new WalletManager(
+      {
+        privateKey: config.privateKey,
+        mnemonic: config.mnemonic,
+        walletFile: config.walletFile
+      },
+      this.provider
+    );
+    const contractAddresses = getContractAddresses(config.network);
+    this.chaosAgent = new ChaosAgent(
+      contractAddresses,
+      this.walletManager.getWallet(),
+      this.provider
+    );
+    if (config.storageProvider) {
+      this.storageBackend = config.storageProvider;
+    } else if (config.enableStorage !== false) {
+      this.storageBackend = new AutoStorageManager();
+    } else {
+      this.storageBackend = {
+        put: async () => ({ cid: "", provider: "none" }),
+        get: async () => Buffer.from("")
+      };
+    }
+    if (config.enablePayments !== false) {
+      this.x402PaymentManager = new X402PaymentManager(
+        this.walletManager.getWallet(),
+        typeof config.network === "string" ? config.network : config.network
+      );
+      const paymentCredentials = {
+        stripe_secret_key: process.env.STRIPE_SECRET_KEY,
+        google_pay_merchant_id: process.env.GOOGLE_PAY_MERCHANT_ID,
+        apple_pay_merchant_id: process.env.APPLE_PAY_MERCHANT_ID,
+        paypal_client_id: process.env.PAYPAL_CLIENT_ID,
+        paypal_client_secret: process.env.PAYPAL_CLIENT_SECRET
+      };
+      this.paymentManager = new PaymentManager(
+        this.agentName,
+        typeof config.network === "string" ? config.network : config.network,
+        this.walletManager.getWallet(),
+        paymentCredentials
+      );
+      this.a2aX402Extension = new A2AX402Extension(
+        this.agentName,
+        typeof config.network === "string" ? config.network : config.network,
+        this.paymentManager
+      );
+    }
+    if (config.enableAP2 !== false) {
+      this.googleAP2 = new GoogleAP2Integration(
+        this.agentName,
+        process.env.GOOGLE_AP2_MERCHANT_PRIVATE_KEY
+      );
+    }
+    if (config.enableProcessIntegrity !== false) {
+      this.processIntegrity = new ProcessIntegrity(
+        this.storageBackend,
+        this.computeProvider
+      );
+    }
+    this.computeProvider = config.computeProvider;
+    console.log(`\u{1F680} ChaosChain SDK initialized for ${this.agentName}`);
+    console.log(`   Network: ${this.network}`);
+    console.log(`   Wallet: ${this.walletManager.getAddress()}`);
+    console.log(`   Features:`);
+    console.log(`     - ERC-8004: \u2705`);
+    console.log(`     - x402 Payments: ${this.x402PaymentManager ? "\u2705" : "\u274C"}`);
+    console.log(`     - Multi-Payment: ${this.paymentManager ? "\u2705" : "\u274C"}`);
+    console.log(`     - Google AP2: ${this.googleAP2 ? "\u2705" : "\u274C"}`);
+    console.log(`     - Process Integrity: ${this.processIntegrity ? "\u2705" : "\u274C"}`);
+    console.log(`     - Storage: \u2705`);
+  }
+  // ============================================================================
+  // ERC-8004 Identity Methods
+  // ============================================================================
+  /**
+   * Register agent identity on-chain
+   */
+  async registerIdentity(metadata) {
+    const meta = metadata || {
+      name: this.agentName,
+      domain: this.agentDomain,
+      role: this.agentRole
+    };
+    const registration = await this.chaosAgent.registerIdentity(meta);
+    this._agentId = registration.agentId;
+    console.log(`\u2705 Agent #${registration.agentId} registered on-chain`);
+    return registration;
+  }
+  /**
+   * Get agent metadata
+   */
+  async getAgentMetadata(agentId) {
+    return this.chaosAgent.getAgentMetadata(agentId);
+  }
+  /**
+   * Update agent metadata
+   */
+  async updateAgentMetadata(agentId, metadata) {
+    return this.chaosAgent.updateAgentMetadata(agentId, metadata);
+  }
+  /**
+   * Get current agent ID
+   */
+  getAgentId() {
+    return this._agentId;
+  }
+  // ============================================================================
+  // ERC-8004 Reputation Methods
+  // ============================================================================
+  /**
+   * Generate feedback authorization (EIP-191 signing)
+   */
+  async generateFeedbackAuthorization(agentId, clientAddress, indexLimit, expiry) {
+    return this.chaosAgent.generateFeedbackAuthorization(agentId, clientAddress, indexLimit, expiry);
+  }
+  /**
+   * Give feedback to an agent
+   */
+  async giveFeedback(params) {
+    return this.chaosAgent.giveFeedback(params);
+  }
+  /**
+   * Submit feedback with payment proof (ERC-8004 reputation enrichment)
+   */
+  async submitFeedbackWithPayment(agentId, score, feedbackData, paymentProof) {
+    const fullFeedbackData = {
+      ...feedbackData,
+      score,
+      proof_of_payment: paymentProof,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const feedbackJson = JSON.stringify(fullFeedbackData);
+    const result = await this.storageBackend.put(Buffer.from(feedbackJson), "application/json");
+    const feedbackUri = `ipfs://${result.cid}`;
+    const txHash = await this.chaosAgent.giveFeedback({
+      agentId,
+      rating: score,
+      feedbackUri
+    });
+    console.log(`\u2705 Feedback submitted with payment proof`);
+    console.log(`   TX: ${txHash}`);
+    console.log(`   URI: ${feedbackUri}`);
+    return { feedbackTxHash: txHash, feedbackUri };
+  }
+  /**
+   * Get agent reputation score
+   */
+  async getReputationScore(_agentId) {
+    return 0;
+  }
+  // ============================================================================
+  // ERC-8004 Validation Methods
+  // ============================================================================
+  /**
+   * Request validation from validator
+   */
+  async requestValidation(params) {
+    return this.chaosAgent.requestValidation(params);
+  }
+  /**
+   * Respond to validation request
+   */
+  async respondToValidation(requestId, approved, responseUri) {
+    return this.chaosAgent.respondToValidation(requestId, approved, responseUri);
+  }
+  // ============================================================================
+  // x402 Crypto Payment Methods
+  // ============================================================================
+  /**
+   * Create x402 payment request
+   */
+  createX402PaymentRequest(fromAgent, toAgent, amount, currency = "USDC", serviceDescription = "AI Agent Service") {
+    if (!this.x402PaymentManager) {
+      throw new Error("x402 payments not enabled");
+    }
+    return this.x402PaymentManager.createPaymentRequest(fromAgent, toAgent, amount, currency, serviceDescription);
+  }
+  /**
+   * Execute x402 crypto payment
+   */
+  async executeX402Payment(paymentRequest, recipientAddress) {
+    if (!this.x402PaymentManager) {
+      throw new Error("x402 payments not enabled");
+    }
+    return this.x402PaymentManager.executePayment(paymentRequest, recipientAddress);
+  }
+  /**
+   * Create x402 payment requirements (for receiving payments)
+   */
+  createX402PaymentRequirements(amount, currency = "USDC", serviceDescription = "AI Agent Service", expiryMinutes = 30) {
+    if (!this.x402PaymentManager) {
+      throw new Error("x402 payments not enabled");
+    }
+    return this.x402PaymentManager.createPaymentRequirements(amount, currency, serviceDescription, expiryMinutes);
+  }
+  /**
+   * Create x402 paywall server
+   */
+  createX402PaywallServer(port = 8402) {
+    if (!this.x402PaymentManager) {
+      throw new Error("x402 payments not enabled");
+    }
+    return new X402Server(this.x402PaymentManager, { port });
+  }
+  /**
+   * Get x402 payment history
+   */
+  async getX402PaymentHistory(limit = 10) {
+    if (!this.x402PaymentManager) {
+      throw new Error("x402 payments not enabled");
+    }
+    return this.x402PaymentManager.getPaymentHistory(limit);
+  }
+  // ============================================================================
+  // Traditional Payment Methods (Cards, Google Pay, Apple Pay, PayPal)
+  // ============================================================================
+  /**
+   * Execute traditional payment
+   */
+  executeTraditionalPayment(paymentMethod, amount, currency, paymentData2) {
+    if (!this.paymentManager) {
+      throw new Error("Payment manager not enabled");
+    }
+    return this.paymentManager.executeTraditionalPayment(paymentMethod, amount, currency, paymentData2);
+  }
+  /**
+   * Get supported payment methods
+   */
+  getSupportedPaymentMethods() {
+    if (!this.paymentManager) {
+      return [];
+    }
+    return this.paymentManager.getSupportedPaymentMethods();
+  }
+  /**
+   * Get payment methods status
+   */
+  getPaymentMethodsStatus() {
+    if (!this.paymentManager) {
+      return {};
+    }
+    return this.paymentManager.getPaymentMethodsStatus();
+  }
+  // ============================================================================
+  // Google AP2 Intent Verification Methods
+  // ============================================================================
+  /**
+   * Create Google AP2 intent mandate
+   */
+  createIntentMandate(userDescription, merchants, skus, requiresRefundability = false, expiryMinutes = 60) {
+    if (!this.googleAP2) {
+      throw new Error("Google AP2 not enabled");
+    }
+    return this.googleAP2.createIntentMandate(userDescription, merchants, skus, requiresRefundability, expiryMinutes);
+  }
+  /**
+   * Create Google AP2 cart mandate with JWT signing
+   */
+  async createCartMandate(cartId, items, totalAmount, currency = "USD", merchantName, expiryMinutes = 15) {
+    if (!this.googleAP2) {
+      throw new Error("Google AP2 not enabled");
+    }
+    return this.googleAP2.createCartMandate(cartId, items, totalAmount, currency, merchantName, expiryMinutes);
+  }
+  /**
+   * Verify JWT token
+   */
+  async verifyJwtToken(token) {
+    if (!this.googleAP2) {
+      throw new Error("Google AP2 not enabled");
+    }
+    return this.googleAP2.verifyJwtToken(token);
+  }
+  // ============================================================================
+  // Process Integrity Methods
+  // ============================================================================
+  /**
+   * Register function for integrity verification
+   */
+  registerFunction(func) {
+    if (!this.processIntegrity) {
+      throw new Error("Process integrity not enabled");
+    }
+    this.processIntegrity.registerFunction(func);
+  }
+  /**
+   * Execute function with integrity proof
+   */
+  async executeWithIntegrityProof(functionName, args) {
+    if (!this.processIntegrity) {
+      throw new Error("Process integrity not enabled");
+    }
+    const [result, proof] = await this.processIntegrity.executeWithProof(functionName, args);
+    return { result, proof };
+  }
+  /**
+   * Verify integrity proof
+   */
+  async verifyIntegrityProof(_proof) {
+    if (!this.processIntegrity) {
+      throw new Error("Process integrity not enabled");
+    }
+    return true;
+  }
+  // ============================================================================
+  // Storage Methods
+  // ============================================================================
+  /**
+   * Upload data to storage
+   */
+  async upload(data, _options) {
+    const jsonData = typeof data === "string" ? data : JSON.stringify(data);
+    const buffer = Buffer.from(jsonData);
+    const result = await this.storageBackend.put(buffer, "application/json");
+    return {
+      cid: result.cid,
+      uri: result.url || `ipfs://${result.cid}`
+    };
+  }
+  /**
+   * Download data from storage
+   */
+  async download(cid) {
+    const buffer = await this.storageBackend.get(cid);
+    const data = buffer.toString("utf-8");
+    try {
+      return JSON.parse(data);
+    } catch {
+      return data;
+    }
+  }
+  /**
+   * Store evidence (convenience method)
+   */
+  async storeEvidence(evidenceData) {
+    const result = await this.storageBackend.put(Buffer.from(JSON.stringify(evidenceData)), "application/json");
+    console.log(`\u{1F4E6} Stored evidence: ${result.cid}`);
+    return result.cid;
+  }
+  // ============================================================================
+  // Wallet & Network Methods
+  // ============================================================================
+  /**
+   * Get wallet address
+   */
+  getAddress() {
+    return this.walletManager.getAddress();
+  }
+  /**
+   * Get wallet balance
+   */
+  async getBalance() {
+    return this.walletManager.getBalance();
+  }
+  /**
+   * Get network info
+   */
+  getNetworkInfo() {
+    return this.networkInfo;
+  }
+  /**
+   * Get SDK capabilities summary
+   */
+  getCapabilities() {
+    return {
+      agent_name: this.agentName,
+      agent_domain: this.agentDomain,
+      agent_role: this.agentRole,
+      network: this.network,
+      wallet_address: this.walletManager.getAddress(),
+      agent_id: this._agentId ? this._agentId.toString() : void 0,
+      features: {
+        erc_8004_identity: true,
+        erc_8004_reputation: true,
+        erc_8004_validation: true,
+        x402_crypto_payments: !!this.x402PaymentManager,
+        traditional_payments: !!this.paymentManager,
+        google_ap2_intents: !!this.googleAP2,
+        process_integrity: !!this.processIntegrity,
+        storage: true,
+        compute: !!this.computeProvider
+      },
+      supported_payment_methods: this.paymentManager ? this.paymentManager.getSupportedPaymentMethods() : [],
+      storage_backends: this.storageBackend instanceof AutoStorageManager ? this.storageBackend.getAvailableBackends() : [this.storageBackend.constructor.name]
+    };
+  }
+};
+var IPFSLocalStorage = class {
+  apiUrl;
+  gatewayUrl;
+  constructor(apiUrl = "http://localhost:5001", gatewayUrl = "http://localhost:8080") {
+    this.apiUrl = apiUrl;
+    this.gatewayUrl = gatewayUrl;
+  }
+  /**
+   * Upload data to local IPFS
+   */
+  async upload(data, options) {
+    try {
+      let buffer;
+      if (Buffer.isBuffer(data)) {
+        buffer = data;
+      } else if (typeof data === "string") {
+        buffer = Buffer.from(data, "utf-8");
+      } else {
+        buffer = Buffer.from(JSON.stringify(data), "utf-8");
+      }
+      const formData = new FormData();
+      const blob = new Blob([buffer], { type: options?.mime || "application/octet-stream" });
+      formData.append("file", blob);
+      const response = await axios2__default.default.post(`${this.apiUrl}/api/v0/add`, formData, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        },
+        params: {
+          pin: options?.pin !== false
+          // Pin by default
+        }
+      });
+      const cid = response.data.Hash;
+      return {
+        cid,
+        uri: `ipfs://${cid}`,
+        size: response.data.Size
+      };
+    } catch (error) {
+      throw new Error(`Failed to upload to IPFS: ${error.message}`);
+    }
+  }
+  /**
+   * Download data from IPFS
+   */
+  async download(cid) {
+    try {
+      const response = await axios2__default.default.get(`${this.gatewayUrl}/ipfs/${cid}`, {
+        responseType: "arraybuffer"
+      });
+      return Buffer.from(response.data);
+    } catch (error) {
+      throw new Error(`Failed to download from IPFS: ${error.message}`);
+    }
+  }
+  /**
+   * Pin content
+   */
+  async pin(cid) {
+    try {
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/pin/add`, null, {
+        params: { arg: cid }
+      });
+    } catch (error) {
+      throw new Error(`Failed to pin content: ${error.message}`);
+    }
+  }
+  /**
+   * Unpin content
+   */
+  async unpin(cid) {
+    try {
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/pin/rm`, null, {
+        params: { arg: cid }
+      });
+    } catch (error) {
+      throw new Error(`Failed to unpin content: ${error.message}`);
+    }
+  }
+  /**
+   * Check if IPFS daemon is running
+   */
+  async isAvailable() {
+    try {
+      await axios2__default.default.post(`${this.apiUrl}/api/v0/version`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get IPFS version
+   */
+  async getVersion() {
+    try {
+      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}`);
+    }
+  }
+};
+
+// src/types.ts
+var AgentRole = /* @__PURE__ */ ((AgentRole2) => {
+  AgentRole2["SERVER"] = "server";
+  AgentRole2["CLIENT"] = "client";
+  AgentRole2["VALIDATOR"] = "validator";
+  AgentRole2["BOTH"] = "both";
+  return AgentRole2;
+})(AgentRole || {});
+var ValidationStatus = /* @__PURE__ */ ((ValidationStatus2) => {
+  ValidationStatus2[ValidationStatus2["PENDING"] = 0] = "PENDING";
+  ValidationStatus2[ValidationStatus2["APPROVED"] = 1] = "APPROVED";
+  ValidationStatus2[ValidationStatus2["REJECTED"] = 2] = "REJECTED";
+  return ValidationStatus2;
+})(ValidationStatus || {});
+
+// src/index.ts
+var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
+  PaymentMethod2["BASIC_CARD"] = "basic-card";
+  PaymentMethod2["GOOGLE_PAY"] = "https://google.com/pay";
+  PaymentMethod2["APPLE_PAY"] = "https://apple.com/apple-pay";
+  PaymentMethod2["PAYPAL"] = "https://paypal.com";
+  PaymentMethod2["A2A_X402"] = "https://a2a.org/x402";
+  return PaymentMethod2;
+})(PaymentMethod || {});
+var SDK_VERSION = "0.1.0";
+var ERC8004_VERSION = "1.0";
+var X402_VERSION = "1.0";
+var src_default = ChaosChainSDK;
+function initChaosChainSDK(config) {
+  return new ChaosChainSDK(config);
+}
+
+exports.A2AX402Extension = A2AX402Extension;
+exports.AgentRegistrationError = AgentRegistrationError;
+exports.AgentRole = AgentRole;
+exports.AutoStorageManager = AutoStorageManager;
+exports.ChaosAgent = ChaosAgent;
+exports.ChaosChainSDK = ChaosChainSDK;
+exports.ChaosChainSDKError = ChaosChainSDKError;
+exports.ConfigurationError = ConfigurationError;
+exports.ContractError = ContractError;
+exports.ERC8004_VERSION = ERC8004_VERSION;
+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.PaymentError = PaymentError2;
+exports.PaymentManager = PaymentManager;
+exports.PaymentMethod = PaymentMethod;
+exports.PinataStorage = PinataStorage;
+exports.REPUTATION_REGISTRY_ABI = REPUTATION_REGISTRY_ABI;
+exports.SDK_VERSION = SDK_VERSION;
+exports.StorageError = StorageError;
+exports.VALIDATION_REGISTRY_ABI = VALIDATION_REGISTRY_ABI;
+exports.ValidationStatus = ValidationStatus;
+exports.WalletManager = WalletManager;
+exports.X402PaymentManager = X402PaymentManager;
+exports.X402Server = X402Server;
+exports.X402_VERSION = X402_VERSION;
+exports.ZeroGStorage = ZeroGStorage;
+exports.default = src_default;
+exports.getContractAddresses = getContractAddresses;
+exports.getNetworkInfo = getNetworkInfo;
+exports.initChaosChainSDK = initChaosChainSDK;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map