@ghostspeak/sdk 2.0.6 → 2.0.7

package/dist/chunk-SZGFSCNU.js

@@ -0,0 +1,3682 @@
+import { init_reputation_tag_engine, createErrorContext, logEnhancedError, IPFSClient, SYSTEM_PROGRAM_ADDRESS, ReputationCalculator, ReputationTagEngine, REPUTATION_CONSTANTS } from './chunk-C5CDA3WX.js';
+import { getInitializeGovernanceProposalInstructionAsync, getInitializeStakingConfigInstructionAsync, getStakeGhostInstructionAsync, getUnstakeGhostInstructionAsync, getRegisterAgentInstructionAsync, getRegisterAgentCompressedInstructionAsync, getUpdateAgentInstruction, getVerifyAgentInstructionAsync, getDeactivateAgentInstruction, getActivateAgentInstruction } from './chunk-S74EH3KD.js';
+import { __export, __esm } from './chunk-UP2VWCW5.js';
+import { createSolanaRpc, createSolanaRpcSubscriptions, lamports, pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, setTransactionMessageFeePayer, compileTransactionMessage, getBase64EncodedWireTransaction, getProgramDerivedAddress, getAddressEncoder } from '@solana/kit';
+import { LRUCache } from 'lru-cache';
+import bs58 from 'bs58';
+import { sha256 } from '@noble/hashes/sha256';
+import { EventEmitter } from 'events';
+
+// src/modules/reputation/MultiSourceAggregator.ts
+var MultiSourceAggregator_exports = {};
+__export(MultiSourceAggregator_exports, {
+  MultiSourceAggregator: () => MultiSourceAggregator
+});
+var MultiSourceAggregator;
+var init_MultiSourceAggregator = __esm({
+  "src/modules/reputation/MultiSourceAggregator.ts"() {
+    MultiSourceAggregator = class {
+      adapters = /* @__PURE__ */ new Map();
+      configs = /* @__PURE__ */ new Map();
+      /** Conflict threshold (30% variance) */
+      CONFLICT_THRESHOLD = 300;
+      // 30% of 1000 scale
+      /**
+       * Create a new multi-source aggregator
+       */
+      constructor() {
+      }
+      /**
+       * Add a reputation source
+       *
+       * @param adapter - Reputation source adapter
+       * @param config - Source configuration
+       */
+      addSource(adapter, config) {
+        if (!config.enabled) {
+          return;
+        }
+        this.adapters.set(adapter.source, adapter);
+        this.configs.set(adapter.source, config);
+      }
+      /**
+       * Remove a reputation source
+       *
+       * @param source - Source to remove
+       */
+      removeSource(source) {
+        this.adapters.delete(source);
+        this.configs.delete(source);
+      }
+      /**
+       * Update source weight
+       *
+       * @param source - Source to update
+       * @param weight - New weight in basis points (0-10000)
+       */
+      updateSourceWeight(source, weight) {
+        const config = this.configs.get(source);
+        if (config) {
+          config.weight = weight;
+        }
+      }
+      /**
+       * Update source reliability
+       *
+       * @param source - Source to update
+       * @param reliability - New reliability in basis points (0-10000)
+       */
+      updateSourceReliability(source, reliability) {
+        const config = this.configs.get(source);
+        if (config) {
+          config.reliability = reliability;
+        }
+      }
+      /**
+       * Aggregate reputation from all sources
+       *
+       * @param agentId - Agent identifier
+       * @returns Aggregated reputation data
+       */
+      async aggregateReputation(agentId) {
+        const sourceDataList = [];
+        for (const [source, adapter] of this.adapters.entries()) {
+          try {
+            const data = await adapter.fetchReputationData(agentId.toString());
+            if (adapter.validateData(data)) {
+              sourceDataList.push(data);
+            }
+          } catch (error) {
+            console.warn(`Failed to fetch reputation from ${source}:`, error);
+          }
+        }
+        const aggregateScore = this.calculateWeightedScore(sourceDataList);
+        const { hasConflicts, conflicts } = this.detectConflicts(sourceDataList);
+        const sourceScores = this.buildSourceBreakdowns(sourceDataList);
+        const totalDataPoints = sourceDataList.reduce((sum, data) => sum + data.dataPoints, 0);
+        return {
+          agentId,
+          aggregateScore,
+          sourceScores,
+          hasConflicts,
+          conflicts,
+          totalDataPoints,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      }
+      /**
+       * Calculate weighted aggregate score
+       *
+       * Formula: Σ(score × weight × reliability) / Σ(weight × reliability)
+       *
+       * @param sourceDataList - Data from all sources
+       * @returns Weighted aggregate score (0-1000)
+       */
+      calculateWeightedScore(sourceDataList) {
+        if (sourceDataList.length === 0) {
+          return 0;
+        }
+        let totalContribution = 0;
+        let totalNormalization = 0;
+        for (const data of sourceDataList) {
+          const config = this.configs.get(data.source);
+          if (!config) continue;
+          const weight = config.weight / 1e4;
+          const reliability = data.reliability;
+          const contribution = data.score * weight * reliability;
+          const normalization = weight * reliability;
+          totalContribution += contribution;
+          totalNormalization += normalization;
+        }
+        if (totalNormalization === 0) {
+          return 0;
+        }
+        return Math.round(totalContribution / totalNormalization);
+      }
+      /**
+       * Detect conflicts between sources
+       *
+       * Flags conflicts if max_score - min_score > 30%
+       *
+       * @param sourceDataList - Data from all sources
+       * @returns Conflict detection result
+       */
+      detectConflicts(sourceDataList) {
+        if (sourceDataList.length < 2) {
+          return { hasConflicts: false, conflicts: [] };
+        }
+        const scores = sourceDataList.map((d) => d.score);
+        const maxScore = Math.max(...scores);
+        const minScore = Math.min(...scores);
+        const variance = maxScore - minScore;
+        const conflicts = [];
+        if (variance > this.CONFLICT_THRESHOLD) {
+          const maxSource = sourceDataList.find((d) => d.score === maxScore)?.source;
+          const minSource = sourceDataList.find((d) => d.score === minScore)?.source;
+          conflicts.push(
+            `High variance detected: ${variance} (${(variance / 1e3 * 100).toFixed(1)}%) between ${maxSource} (${maxScore}) and ${minSource} (${minScore})`
+          );
+          return { hasConflicts: true, conflicts };
+        }
+        return { hasConflicts: false, conflicts: [] };
+      }
+      /**
+       * Build source score breakdowns
+       *
+       * @param sourceDataList - Data from all sources
+       * @returns Source score breakdowns
+       */
+      buildSourceBreakdowns(sourceDataList) {
+        return sourceDataList.map((data) => {
+          const config = this.configs.get(data.source);
+          if (!config) {
+            throw new Error(`No config found for source: ${data.source}`);
+          }
+          const weight = config.weight;
+          const reliability = data.reliability * 1e4;
+          const contribution = data.score * (weight / 1e4) * (reliability / 1e4) / this.calculateNormalizationFactor(sourceDataList);
+          return {
+            source: data.source,
+            score: data.score,
+            weight,
+            reliability: Math.round(reliability),
+            dataPoints: data.dataPoints,
+            contribution: Math.round(contribution),
+            lastUpdated: data.timestamp
+          };
+        });
+      }
+      /**
+       * Calculate normalization factor for weighted scoring
+       */
+      calculateNormalizationFactor(sourceDataList) {
+        let total = 0;
+        for (const data of sourceDataList) {
+          const config = this.configs.get(data.source);
+          if (!config) continue;
+          const weight = config.weight / 1e4;
+          const reliability = data.reliability;
+          total += weight * reliability;
+        }
+        return total || 1;
+      }
+      /**
+       * Get detailed source breakdown for an agent
+       *
+       * @param agentId - Agent identifier
+       * @returns Source breakdowns with full details
+       */
+      async getSourceBreakdown(agentId) {
+        const result = await this.aggregateReputation(agentId);
+        return result.sourceScores;
+      }
+      /**
+       * Get list of registered sources
+       */
+      getRegisteredSources() {
+        return Array.from(this.adapters.keys());
+      }
+      /**
+       * Get source configuration
+       *
+       * @param source - Source identifier
+       * @returns Source configuration or undefined
+       */
+      getSourceConfig(source) {
+        return this.configs.get(source);
+      }
+      /**
+       * Enable a source
+       *
+       * @param source - Source to enable
+       */
+      enableSource(source) {
+        const config = this.configs.get(source);
+        if (config) {
+          config.enabled = true;
+        }
+      }
+      /**
+       * Disable a source
+       *
+       * @param source - Source to disable
+       */
+      disableSource(source) {
+        const config = this.configs.get(source);
+        if (config) {
+          config.enabled = false;
+        }
+      }
+      /**
+       * Check if source is enabled
+       *
+       * @param source - Source to check
+       * @returns True if enabled
+       */
+      isSourceEnabled(source) {
+        const config = this.configs.get(source);
+        return config?.enabled ?? false;
+      }
+    };
+  }
+});
+var RpcClient = class {
+  rpc;
+  rpcSubscriptions;
+  commitment;
+  endpoint;
+  maxRetries;
+  retryDelay;
+  timeout;
+  constructor(config) {
+    this.endpoint = config.endpoint;
+    this.rpc = createSolanaRpc(config.endpoint);
+    this.commitment = config.commitment ?? "confirmed";
+    this.maxRetries = config.maxRetries ?? 3;
+    this.retryDelay = config.retryDelay ?? 1e3;
+    this.timeout = config.timeout ?? 6e4;
+    if (config.wsEndpoint) {
+      this.rpcSubscriptions = createSolanaRpcSubscriptions(config.wsEndpoint);
+    }
+  }
+  /**
+   * Get account information with automatic retries
+   */
+  async getAccountInfo(address, options) {
+    return this.withRetry(async () => {
+      const result = await this.rpc.getAccountInfo(address, {
+        commitment: options?.commitment ?? this.commitment,
+        encoding: "base64"
+      }).send();
+      if (!result.value) return null;
+      return this.parseAccountInfo(result.value);
+    });
+  }
+  /**
+   * Get multiple accounts efficiently
+   */
+  async getMultipleAccounts(addresses, options) {
+    return this.withRetry(async () => {
+      const result = await this.rpc.getMultipleAccounts(addresses, {
+        commitment: options?.commitment ?? this.commitment,
+        encoding: "base64"
+      }).send();
+      return result.value.map(
+        (account) => account ? this.parseAccountInfo(account) : null
+      );
+    });
+  }
+  /**
+   * Get program accounts with filters
+   */
+  async getProgramAccounts(programId, options) {
+    return this.withRetry(async () => {
+      const result = await this.rpc.getProgramAccounts(programId, {
+        commitment: options?.commitment ?? this.commitment,
+        encoding: "base64",
+        filters: options?.filters
+      }).send();
+      return result.map((item) => {
+        const typedItem = item;
+        return {
+          pubkey: typedItem.pubkey,
+          account: this.parseAccountInfo(typedItem.account)
+        };
+      });
+    });
+  }
+  /**
+   * Get latest blockhash with automatic caching
+   */
+  blockhashCache = null;
+  async getLatestBlockhash() {
+    const now = Date.now();
+    if (this.blockhashCache && now - this.blockhashCache.timestamp < 1e3) {
+      return this.blockhashCache.value;
+    }
+    const result = await this.withRetry(async () => {
+      const response = await this.rpc.getLatestBlockhash({
+        commitment: this.commitment
+      }).send();
+      return {
+        blockhash: response.value.blockhash,
+        lastValidBlockHeight: BigInt(response.value.lastValidBlockHeight)
+      };
+    });
+    this.blockhashCache = { value: result, timestamp: now };
+    return result;
+  }
+  /**
+   * Send transaction with enhanced error handling
+   */
+  async sendTransaction(transaction, options) {
+    return this.withRetry(async () => {
+      const result = await this.rpc.sendTransaction(transaction, {
+        encoding: "base64",
+        skipPreflight: options?.skipPreflight ?? false,
+        preflightCommitment: options?.preflightCommitment ?? this.commitment,
+        maxRetries: options?.maxRetries ? BigInt(options.maxRetries) : void 0
+      }).send();
+      return result;
+    });
+  }
+  /**
+   * Get signature statuses with batch support
+   */
+  async getSignatureStatuses(signatures) {
+    return this.withRetry(async () => {
+      const result = await this.rpc.getSignatureStatuses(signatures).send();
+      return result.value.map((status) => {
+        if (!status) return null;
+        const typedStatus = status;
+        return {
+          slot: typedStatus.slot,
+          confirmations: typedStatus.confirmations,
+          err: typedStatus.err,
+          confirmationStatus: typedStatus.confirmationStatus
+        };
+      });
+    });
+  }
+  /**
+   * Simulate transaction with detailed error info
+   */
+  async simulateTransaction(transaction, options) {
+    return this.withRetry(async () => {
+      const result = await this.rpc.simulateTransaction(transaction, {
+        encoding: "base64",
+        commitment: options?.commitment ?? this.commitment,
+        replaceRecentBlockhash: options?.replaceRecentBlockhash ?? false
+      }).send();
+      return {
+        err: result.value.err,
+        logs: result.value.logs ?? [],
+        unitsConsumed: result.value.unitsConsumed ? BigInt(result.value.unitsConsumed) : void 0,
+        returnData: result.value.returnData
+      };
+    });
+  }
+  /**
+   * Get fee for message
+   */
+  async getFeeForMessage(encodedMessage) {
+    return this.withRetry(async () => {
+      const result = await this.rpc.getFeeForMessage(encodedMessage, {
+        commitment: this.commitment
+      }).send();
+      return result.value ? BigInt(result.value) : null;
+    });
+  }
+  /**
+   * Health check
+   */
+  async isHealthy() {
+    try {
+      await this.rpc.getHealth().send();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get RPC node version
+   */
+  async getVersion() {
+    const result = await this.rpc.getVersion().send();
+    return result;
+  }
+  /**
+   * Subscribe to account changes (WebSocket) 
+   * Note: This is a placeholder implementation. In production, you would use the actual subscription API
+   */
+  async subscribeToAccount(address, callback) {
+    if (!this.rpcSubscriptions) {
+      throw new Error("WebSocket endpoint not configured");
+    }
+    console.warn("Account subscription is not fully implemented in this version");
+    const intervalId = setInterval(async () => {
+      try {
+        const accountInfo = await this.getAccountInfo(address);
+        callback(accountInfo);
+      } catch (error) {
+        console.error("Subscription polling error:", error);
+      }
+    }, 5e3);
+    return () => {
+      clearInterval(intervalId);
+    };
+  }
+  // Private helper methods
+  async withRetry(operation, retries = this.maxRetries) {
+    let lastError;
+    for (let i = 0; i <= retries; i++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (i < retries) {
+          await new Promise((resolve) => setTimeout(resolve, this.retryDelay * Math.pow(2, i)));
+        }
+      }
+    }
+    throw lastError;
+  }
+  parseAccountInfo(rawAccount) {
+    const account = rawAccount;
+    const dataArray = account.data;
+    const base64Data = Array.isArray(dataArray) ? dataArray[0] : dataArray;
+    return {
+      executable: account.executable,
+      lamports: typeof account.lamports === "number" ? lamports(BigInt(account.lamports)) : account.lamports,
+      owner: account.owner,
+      rentEpoch: account.rentEpoch !== void 0 ? typeof account.rentEpoch === "number" ? BigInt(account.rentEpoch) : account.rentEpoch : BigInt(0),
+      data: Buffer.from(base64Data, "base64"),
+      space: account.space ? typeof account.space === "number" ? BigInt(account.space) : account.space : void 0
+    };
+  }
+};
+
+// src/utils/transaction-urls.ts
+function getSolanaExplorerUrl(signature, cluster = "mainnet-beta") {
+  const baseUrl = "https://explorer.solana.com/tx";
+  switch (cluster) {
+    case "devnet":
+      return `${baseUrl}/${signature}?cluster=devnet`;
+    case "testnet":
+      return `${baseUrl}/${signature}?cluster=testnet`;
+    case "localnet":
+      return `${baseUrl}/${signature}?cluster=custom&customUrl=http://localhost:8899`;
+    default:
+      return `${baseUrl}/${signature}`;
+  }
+}
+function getSolscanUrl(signature, cluster = "mainnet-beta") {
+  const baseUrl = "https://solscan.io/tx";
+  switch (cluster) {
+    case "devnet":
+      return `${baseUrl}/${signature}?cluster=devnet`;
+    case "testnet":
+      return `${baseUrl}/${signature}?cluster=testnet`;
+    case "localnet":
+      return `Local transaction: ${signature} (not viewable on Solscan)`;
+    default:
+      return `${baseUrl}/${signature}`;
+  }
+}
+function getSolanaFMUrl(signature, cluster = "mainnet-beta") {
+  const baseUrl = "https://solana.fm/tx";
+  switch (cluster) {
+    case "devnet":
+      return `${baseUrl}/${signature}?cluster=devnet-solana`;
+    case "testnet":
+      return `${baseUrl}/${signature}?cluster=testnet-solana`;
+    case "localnet":
+      return `Local transaction: ${signature} (not viewable on SolanaFM)`;
+    default:
+      return `${baseUrl}/${signature}`;
+  }
+}
+function getXrayUrl(signature, cluster = "mainnet-beta") {
+  const baseUrl = "https://xray.helius.xyz/tx";
+  switch (cluster) {
+    case "devnet":
+      return `${baseUrl}/${signature}?network=devnet`;
+    case "testnet":
+      return `${baseUrl}/${signature}?network=testnet`;
+    case "localnet":
+      return `Local transaction: ${signature} (not viewable on XRAY)`;
+    default:
+      return `${baseUrl}/${signature}`;
+  }
+}
+function generateExplorerUrls(signature, cluster = "mainnet-beta") {
+  return {
+    solanaExplorer: getSolanaExplorerUrl(signature, cluster),
+    solscan: getSolscanUrl(signature, cluster),
+    solanaFM: getSolanaFMUrl(signature, cluster),
+    xray: getXrayUrl(signature, cluster)
+  };
+}
+function createTransactionResult(signature, cluster, commitment = "confirmed") {
+  return {
+    signature,
+    cluster,
+    urls: generateExplorerUrls(signature, cluster),
+    commitment,
+    timestamp: Date.now()
+  };
+}
+
+// src/core/DevTools.ts
+var DevTools = class _DevTools {
+  static instance = null;
+  rpcClient;
+  config;
+  isDevelopment;
+  logs = [];
+  timings = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+    this.rpcClient = new RpcClient({
+      endpoint: config.rpcEndpoint ?? "https://api.devnet.solana.com",
+      commitment: config.commitment
+    });
+    this.isDevelopment = process.env.NODE_ENV === "development" || config.cluster === "localnet" || false;
+  }
+  /**
+   * Get singleton instance
+   */
+  static getInstance(config) {
+    if (!_DevTools.instance && config) {
+      _DevTools.instance = new _DevTools(config);
+    }
+    if (!_DevTools.instance) {
+      throw new Error("DevTools not initialized. Call with config first.");
+    }
+    return _DevTools.instance;
+  }
+  /**
+   * Enable development mode
+   */
+  enableDevMode() {
+    this.isDevelopment = true;
+    console.log("\u{1F6E0}\uFE0F GhostSpeak Development Mode Enabled");
+    console.log("   - Transaction simulation before sending");
+    console.log("   - Cost estimates for all operations");
+    console.log("   - Enhanced error messages");
+    console.log("   - Performance timing");
+  }
+  /**
+   * Check if in development mode
+   */
+  isDevMode() {
+    return this.isDevelopment;
+  }
+  /**
+   * Analyze transaction instructions
+   */
+  analyzeTransaction(instructions) {
+    const writableAccounts = /* @__PURE__ */ new Set();
+    const readonlyAccounts = /* @__PURE__ */ new Set();
+    const signers = /* @__PURE__ */ new Set();
+    const warnings = [];
+    let totalSize = 64;
+    const instructionAnalyses = instructions.map((instr, index) => {
+      totalSize += 32;
+      totalSize += (instr.accounts?.length ?? 0) * 32;
+      totalSize += instr.data?.length ?? 0;
+      const accounts = (instr.accounts ?? []).map((acc) => {
+        const isWritable = acc.role.toString().includes("writable") || acc.role.toString().includes("WRITABLE") || acc.role === 1 || // AccountRole.WRITABLE = 1
+        acc.role === 3;
+        const isSigner = acc.role.toString().includes("signer") || acc.role.toString().includes("SIGNER") || typeof acc === "object" && "signer" in acc || acc.role === 3;
+        if (isWritable) {
+          writableAccounts.add(acc.address);
+        } else {
+          readonlyAccounts.add(acc.address);
+        }
+        if (isSigner) {
+          signers.add(acc.address);
+        }
+        return {
+          address: acc.address,
+          isWritable,
+          isSigner,
+          role: acc.role
+        };
+      });
+      const humanReadable = this.getInstructionDescription(instr, index);
+      return {
+        index,
+        programId: instr.programAddress,
+        accountCount: accounts.length,
+        dataSize: instr.data?.length ?? 0,
+        humanReadable,
+        accounts
+      };
+    });
+    const estimatedComputeUnits = this.estimateComputeUnits(instructions);
+    const estimatedFee = this.estimateFee(estimatedComputeUnits, instructions.length);
+    if (totalSize > 1232) {
+      warnings.push(`Transaction size (${totalSize} bytes) exceeds limit (1232 bytes)`);
+    }
+    if (signers.size === 0) {
+      warnings.push("No signers found in transaction");
+    }
+    if (estimatedComputeUnits > BigInt(14e5)) {
+      warnings.push(`High compute usage: ${estimatedComputeUnits} units`);
+    }
+    return {
+      instructions: instructionAnalyses,
+      totalAccounts: writableAccounts.size + readonlyAccounts.size,
+      signerCount: signers.size,
+      writableAccounts: Array.from(writableAccounts),
+      readonlyAccounts: Array.from(readonlyAccounts),
+      estimatedSize: totalSize,
+      estimatedComputeUnits,
+      estimatedFee,
+      warnings
+    };
+  }
+  /**
+   * Get human-readable instruction description
+   */
+  getInstructionDescription(instruction, _index) {
+    const programId = instruction.programAddress;
+    if (programId === this.config.programId) {
+      return this.decodeGhostSpeakInstruction(instruction);
+    }
+    if (programId === "11111111111111111111111111111111") {
+      return "System Program: Transfer or Create Account";
+    }
+    if (programId === "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA") {
+      return "Token Program: Token Operation";
+    }
+    if (programId === "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb") {
+      return "Token-2022 Program: Advanced Token Operation";
+    }
+    return `Unknown Instruction`;
+  }
+  /**
+   * Decode GhostSpeak instruction
+   */
+  decodeGhostSpeakInstruction(instruction) {
+    if (!instruction.data || instruction.data.length < 8) {
+      return "GhostSpeak: Unknown Instruction";
+    }
+    const discriminator = Array.from(instruction.data.slice(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const instructionMap = {
+      "a8c5e109d3d1b8d5": "Register Agent",
+      "b7f3c8e0a2d4e9f1": "Create Escrow",
+      "c4d2f7a9b8e1c3f5": "Send Message",
+      "d9e8f2b5c1a7e4f8": "Create Channel"
+      // Add more mappings as needed
+    };
+    return `GhostSpeak: ${instructionMap[discriminator] ?? "Custom Instruction"}`;
+  }
+  /**
+   * Estimate compute units for instructions
+   */
+  estimateComputeUnits(instructions) {
+    let totalUnits = BigInt(0);
+    for (const instr of instructions) {
+      totalUnits += BigInt(200);
+      totalUnits += BigInt((instr.accounts?.length ?? 0) * 150);
+      totalUnits += BigInt((instr.data?.length ?? 0) * 10);
+      if (instr.programAddress === this.config.programId) {
+        totalUnits += BigInt(5e3);
+      }
+    }
+    return totalUnits;
+  }
+  /**
+   * Estimate transaction fee
+   */
+  estimateFee(computeUnits, instructionCount) {
+    const baseFee = BigInt(5e3);
+    const computeFee = computeUnits * BigInt(5) / BigInt(1e6);
+    const priorityFee = BigInt(instructionCount * 1e3);
+    return baseFee + computeFee + priorityFee;
+  }
+  /**
+   * Log debug message
+   */
+  log(message, data) {
+    if (!this.isDevelopment) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logEntry = `[${timestamp}] ${message}`;
+    this.logs.push(logEntry);
+    console.log(`\u{1F50D} ${logEntry}`);
+    if (data) {
+      console.log("   Data:", data);
+    }
+  }
+  /**
+   * Start timing an operation
+   */
+  startTiming(label) {
+    if (!this.isDevelopment) return;
+    const perfNow = typeof performance !== "undefined" ? performance.now() : Date.now();
+    this.timings.set(label, perfNow);
+  }
+  /**
+   * End timing and log result
+   */
+  endTiming(label) {
+    if (!this.isDevelopment) return;
+    const start = this.timings.get(label);
+    if (!start) return;
+    const perfNow = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const duration = perfNow - start;
+    this.log(`${label} took ${duration.toFixed(2)}ms`);
+    this.timings.delete(label);
+  }
+  /**
+   * Format transaction for display
+   */
+  formatTransaction(analysis) {
+    const lines = [
+      "\u{1F4CB} Transaction Analysis",
+      "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+      `Instructions: ${analysis.instructions.length}`,
+      `Total Accounts: ${analysis.totalAccounts}`,
+      `Signers: ${analysis.signerCount}`,
+      `Estimated Size: ${analysis.estimatedSize} bytes`,
+      `Estimated Compute Units: ${analysis.estimatedComputeUnits.toLocaleString()}`,
+      `Estimated Fee: ${(Number(analysis.estimatedFee) / 1e9).toFixed(6)} SOL`,
+      ""
+    ];
+    lines.push("Instructions:");
+    for (const instr of analysis.instructions) {
+      lines.push(`  ${instr.index + 1}. ${instr.humanReadable}`);
+      lines.push(`     Program: ${instr.programId.slice(0, 8)}...`);
+      lines.push(`     Accounts: ${instr.accountCount}, Data: ${instr.dataSize} bytes`);
+    }
+    if (analysis.warnings.length > 0) {
+      lines.push("");
+      lines.push("\u26A0\uFE0F Warnings:");
+      for (const warning of analysis.warnings) {
+        lines.push(`  - ${warning}`);
+      }
+    }
+    lines.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    return lines.join("\n");
+  }
+  /**
+   * Export debug logs
+   */
+  exportLogs() {
+    return [...this.logs];
+  }
+  /**
+   * Clear debug logs
+   */
+  clearLogs() {
+    this.logs = [];
+    this.timings.clear();
+  }
+};
+function validateInstruction(instruction) {
+  const inst = instruction;
+  if (!inst.programAddress) {
+    throw new Error("Invalid instruction format");
+  }
+}
+var InstructionBuilder = class {
+  rpcClient;
+  config;
+  devTools;
+  debugMode = false;
+  constructor(config) {
+    this.config = config;
+    this.rpcClient = new RpcClient({
+      endpoint: config.rpcEndpoint ?? "https://api.devnet.solana.com",
+      wsEndpoint: config.wsEndpoint,
+      commitment: config.commitment ?? "confirmed"
+    });
+    this.devTools = DevTools.getInstance(config);
+  }
+  /**
+   * Execute a single instruction with unified error handling and transaction patterns
+   */
+  async execute(instructionName, instructionGetter, signers, options) {
+    const context = createErrorContext(
+      "execute",
+      instructionName,
+      signers.map((s) => ({ address: s.address, name: "signer" })),
+      { programId: this.config.programId }
+    );
+    try {
+      if (this.devTools.isDevMode()) {
+        this.devTools.startTiming(instructionName);
+      }
+      const instruction = await Promise.resolve(instructionGetter());
+      validateInstruction(instruction);
+      if (this.debugMode || this.devTools.isDevMode()) {
+        const analysis = this.devTools.analyzeTransaction([instruction]);
+        console.log(this.devTools.formatTransaction(analysis));
+        this.debugMode = false;
+      }
+      if (options?.simulate) {
+        return await this.simulateInstruction(instruction, signers);
+      }
+      const latestBlockhashResult = await this.rpcClient.getLatestBlockhash();
+      const latestBlockhash = {
+        blockhash: latestBlockhashResult.blockhash,
+        lastValidBlockHeight: latestBlockhashResult.lastValidBlockHeight
+      };
+      const transactionMessage = pipe(
+        createTransactionMessage({ version: 0 }),
+        (tx) => setTransactionMessageFeePayerSigner(signers[0], tx),
+        (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+        (tx) => appendTransactionMessageInstructions([instruction], tx)
+      );
+      const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
+      const signatureResult = await this.sendAndConfirm(
+        signedTransaction,
+        options?.skipPreflight ?? false,
+        options?.maxRetries ?? 30
+      );
+      if (typeof signatureResult !== "string") {
+        throw new Error("Transaction signature is not a string");
+      }
+      const signature = signatureResult;
+      if (options?.returnDetails) {
+        const cluster = this.config.cluster ?? "devnet";
+        const result = createTransactionResult(signature, cluster, this.config.commitment ?? "confirmed");
+        if (this.devTools.isDevMode()) {
+          this.devTools.endTiming(instructionName);
+        }
+        return result;
+      }
+      if (this.devTools.isDevMode()) {
+        this.devTools.endTiming(instructionName);
+      }
+      return signature;
+    } catch (error) {
+      logEnhancedError(error, context);
+      throw error;
+    }
+  }
+  /**
+   * Execute multiple instructions in a single transaction
+   */
+  async executeBatch(batchName, instructionGetters, signers, options) {
+    const context = createErrorContext(
+      "executeBatch",
+      batchName,
+      signers.map((s) => ({ address: s.address, name: "signer" })),
+      { programId: this.config.programId, instructionCount: instructionGetters.length }
+    );
+    try {
+      const instructions = await Promise.all(
+        instructionGetters.map(async (getter, i) => {
+          const instruction = await Promise.resolve(getter());
+          try {
+            validateInstruction(instruction);
+            return instruction;
+          } catch (error) {
+            throw new Error(`Instruction ${i} in ${batchName}: ${error.message}`);
+          }
+        })
+      );
+      const estimatedSize = this.estimateTransactionSize(instructions);
+      if (estimatedSize > 1232) {
+        throw new Error(`Transaction too large: ${estimatedSize} bytes (max: 1232)`);
+      }
+      if (options?.simulate) {
+        return await this.simulateBatch(instructions, signers);
+      }
+      const latestBlockhashResult = await this.rpcClient.getLatestBlockhash();
+      const latestBlockhash = {
+        blockhash: latestBlockhashResult.blockhash,
+        lastValidBlockHeight: latestBlockhashResult.lastValidBlockHeight
+      };
+      const transactionMessage = pipe(
+        createTransactionMessage({ version: 0 }),
+        (tx) => setTransactionMessageFeePayerSigner(signers[0], tx),
+        (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+        (tx) => appendTransactionMessageInstructions(instructions, tx)
+      );
+      const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
+      const signatureResult = await this.sendAndConfirm(
+        signedTransaction,
+        options?.skipPreflight ?? false
+      );
+      if (typeof signatureResult !== "string") {
+        throw new Error("Transaction signature is not a string");
+      }
+      const signature = signatureResult;
+      if (options?.returnDetails) {
+        const cluster = this.config.cluster ?? "devnet";
+        const result = createTransactionResult(signature, cluster, this.config.commitment ?? "confirmed");
+        if (this.devTools.isDevMode()) {
+          this.devTools.endTiming(batchName);
+        }
+        return result;
+      }
+      if (this.devTools.isDevMode()) {
+        this.devTools.endTiming(batchName);
+      }
+      return signature;
+    } catch (error) {
+      logEnhancedError(error, context);
+      throw error;
+    }
+  }
+  /**
+   * Get and decode account data with unified error handling
+   */
+  async getAccount(address, decoderImportName) {
+    try {
+      const accountInfo = await this.rpcClient.getAccountInfo(address, {
+        commitment: this.config.commitment
+      });
+      if (!accountInfo) return null;
+      const generated = await import('./generated-EG5USUFG.js');
+      const decoderGetter = generated[decoderImportName];
+      const decoder = decoderGetter();
+      const rawData = this.extractRawData(accountInfo.data);
+      return decoder.decode(rawData);
+    } catch (error) {
+      console.warn(`Failed to fetch account ${address}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Get multiple accounts with unified pattern
+   */
+  async getAccounts(addresses, decoderImportName) {
+    try {
+      const accounts = await this.rpcClient.getMultipleAccounts(addresses, {
+        commitment: this.config.commitment
+      });
+      const generated = await import('./generated-EG5USUFG.js');
+      const decoderGetter = generated[decoderImportName];
+      const decoder = decoderGetter();
+      return accounts.map((accountInfo) => {
+        if (!accountInfo) return null;
+        try {
+          const rawData = this.extractRawData(accountInfo.data);
+          return decoder.decode(rawData);
+        } catch {
+          return null;
+        }
+      });
+    } catch (error) {
+      console.warn("Failed to fetch multiple accounts:", error);
+      return addresses.map(() => null);
+    }
+  }
+  /**
+   * Get program accounts with filters
+   */
+  async getProgramAccounts(decoderImportName, filters) {
+    try {
+      const convertedFilters = filters?.map((filter) => {
+        if ("dataSize" in filter) {
+          return { dataSize: filter.dataSize };
+        } else {
+          const encoding = filter.memcmp.encoding ?? "base58";
+          if (encoding === "base64") {
+            return {
+              memcmp: {
+                offset: filter.memcmp.offset,
+                bytes: filter.memcmp.bytes,
+                encoding: "base64"
+              }
+            };
+          } else {
+            return {
+              memcmp: {
+                offset: filter.memcmp.offset,
+                bytes: filter.memcmp.bytes,
+                encoding: "base58"
+              }
+            };
+          }
+        }
+      });
+      const accounts = await this.rpcClient.getProgramAccounts(this.config.programId, {
+        commitment: this.config.commitment,
+        filters: convertedFilters ?? []
+      });
+      const generated = await import('./generated-EG5USUFG.js');
+      const decoderGetter = generated[decoderImportName];
+      const decoder = decoderGetter();
+      const decodedAccounts = [];
+      for (const { pubkey, account } of accounts) {
+        try {
+          const rawData = this.extractRawData(account.data);
+          const decodedData = decoder.decode(rawData);
+          decodedAccounts.push({ address: pubkey, data: decodedData });
+        } catch {
+        }
+      }
+      return decodedAccounts;
+    } catch (error) {
+      console.error("Failed to get program accounts:", error);
+      return [];
+    }
+  }
+  /**
+   * Enable debug mode for next transaction
+   */
+  enableDebug() {
+    this.debugMode = true;
+    return this;
+  }
+  /**
+   * Debug transaction - analyze without executing
+   */
+  async debug(instructionName, instructionGetters) {
+    this.devTools.log(`Debugging ${instructionName}`);
+    const instructions = await Promise.all(
+      instructionGetters.map(async (getter) => {
+        const instruction = await Promise.resolve(getter());
+        validateInstruction(instruction);
+        return instruction;
+      })
+    );
+    const analysis = this.devTools.analyzeTransaction(instructions);
+    console.log(this.devTools.formatTransaction(analysis));
+    return analysis;
+  }
+  /**
+   * Get human-readable explanation of transaction
+   */
+  async explain(instructionName, instructionGetters) {
+    const analysis = await this.debug(instructionName, instructionGetters);
+    const lines = [
+      `\u{1F50D} Transaction: ${instructionName}`,
+      "",
+      "This transaction will:",
+      ...analysis.instructions.map((instr, i) => `  ${i + 1}. ${instr.humanReadable}`),
+      "",
+      `Cost: ~${(Number(analysis.estimatedFee) / 1e9).toFixed(6)} SOL`,
+      `Size: ${analysis.estimatedSize} bytes`,
+      `Compute: ${analysis.estimatedComputeUnits.toLocaleString()} units`
+    ];
+    if (analysis.warnings.length > 0) {
+      lines.push("", "\u26A0\uFE0F Warnings:");
+      lines.push(...analysis.warnings.map((w) => `  - ${w}`));
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Estimate transaction cost
+   */
+  async estimateCost(instructionGetters) {
+    try {
+      const instructions = await Promise.all(
+        instructionGetters.map(async (getter) => {
+          const instruction = await Promise.resolve(getter());
+          validateInstruction(instruction);
+          return instruction;
+        })
+      );
+      const latestBlockhashResult = await this.rpcClient.getLatestBlockhash();
+      const latestBlockhash = {
+        blockhash: latestBlockhashResult.blockhash,
+        lastValidBlockHeight: latestBlockhashResult.lastValidBlockHeight
+      };
+      const transactionMessage = pipe(
+        createTransactionMessage({ version: 0 }),
+        (tx) => setTransactionMessageFeePayer(this.config.defaultFeePayer, tx),
+        (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+        (tx) => appendTransactionMessageInstructions(instructions, tx)
+      );
+      const compiledMessage = compileTransactionMessage(transactionMessage);
+      const encodedMessage = Buffer.from(compiledMessage).toString("base64");
+      const fee = await this.rpcClient.getFeeForMessage(encodedMessage);
+      return BigInt(fee ?? 0);
+    } catch {
+      const baseFee = 5000n;
+      const perInstructionFee = 1000n;
+      return baseFee + BigInt(instructionGetters.length) * perInstructionFee;
+    }
+  }
+  // Private helper methods
+  async sendAndConfirm(signedTransaction, skipPreflight, maxRetries = 30) {
+    const wireTransaction = getBase64EncodedWireTransaction(signedTransaction);
+    const signature = await this.rpcClient.sendTransaction(wireTransaction, {
+      skipPreflight,
+      preflightCommitment: this.config.commitment
+    });
+    console.log("\u{1F50D} Transaction sent, signature:", signature);
+    console.log("\u{1F50D} Signature length:", signature.length);
+    console.log("\u{1F50D} Signature type:", typeof signature);
+    let confirmed = false;
+    let attempts = 0;
+    let currentDelay = 1e3;
+    const maxConfirmationTime = 3e4;
+    const startTime = Date.now();
+    while (!confirmed && attempts < maxRetries && Date.now() - startTime < maxConfirmationTime) {
+      try {
+        console.log(`\u{1F50D} Confirmation attempt ${attempts + 1}/${maxRetries}`);
+        const statuses = await this.rpcClient.getSignatureStatuses([signature]);
+        if (statuses[0]) {
+          console.log("\u{1F50D} Status found:", statuses[0]);
+          if (statuses[0].err) {
+            throw new Error(`Transaction failed: ${JSON.stringify(statuses[0].err, (_, v) => typeof v === "bigint" ? v.toString() : v)}`);
+          }
+          const confirmationStatus = statuses[0].confirmationStatus;
+          if (confirmationStatus === this.config.commitment || this.config.commitment === "confirmed" && confirmationStatus === "finalized") {
+            confirmed = true;
+            console.log("\u2705 Transaction confirmed via status check");
+            break;
+          }
+        } else {
+          console.log("\u{1F50D} No status found, trying transaction details...");
+          try {
+            const { createSolanaRpc: createSolanaRpc2 } = await import('@solana/kit');
+            const directRpc = createSolanaRpc2(this.config.rpcEndpoint ?? "https://api.devnet.solana.com");
+            const transaction = await directRpc.getTransaction(signature, {
+              commitment: this.config.commitment ?? "confirmed",
+              encoding: "json",
+              maxSupportedTransactionVersion: 0
+            }).send();
+            if (transaction && transaction.meta) {
+              if (transaction.meta.err) {
+                throw new Error(`Transaction failed: ${JSON.stringify(transaction.meta.err, (_, v) => typeof v === "bigint" ? v.toString() : v)}`);
+              }
+              confirmed = true;
+              console.log("\u2705 Transaction confirmed via direct lookup");
+              break;
+            }
+          } catch {
+            console.log("\u{1F50D} Transaction details not yet available");
+          }
+        }
+        attempts++;
+        await new Promise((resolve) => setTimeout(resolve, currentDelay));
+        currentDelay = Math.min(currentDelay * 1.5, 5e3);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Transaction failed")) {
+          throw error;
+        }
+        console.log(`\u{1F50D} Confirmation attempt failed:`, error.message);
+        attempts++;
+        await new Promise((resolve) => setTimeout(resolve, currentDelay * 2));
+      }
+    }
+    if (!confirmed) {
+      console.log("\u{1F50D} Final confirmation attempt via transaction lookup...");
+      try {
+        const { createSolanaRpc: createSolanaRpc2 } = await import('@solana/kit');
+        const directRpc = createSolanaRpc2(this.config.rpcEndpoint ?? "https://api.devnet.solana.com");
+        const transaction = await directRpc.getTransaction(signature, {
+          commitment: this.config.commitment ?? "confirmed",
+          encoding: "json",
+          maxSupportedTransactionVersion: 0
+        }).send();
+        if (transaction && transaction.meta) {
+          if (transaction.meta.err) {
+            throw new Error(`Transaction failed: ${JSON.stringify(transaction.meta.err, (_, v) => typeof v === "bigint" ? v.toString() : v)}`);
+          }
+          console.log("\u2705 Transaction confirmed on final check - returning success");
+          return signature;
+        }
+      } catch (finalError) {
+        console.log("\u{1F50D} Final check failed:", finalError.message);
+      }
+      console.log("\u26A0\uFE0F Transaction confirmation timed out, but transaction was sent");
+      console.log(`   Check status at: https://explorer.solana.com/tx/${signature}?cluster=${this.config.cluster || "devnet"}`);
+      return signature;
+    }
+    return signature;
+  }
+  async simulateInstruction(instruction, signers) {
+    const latestBlockhashResult = await this.rpcClient.getLatestBlockhash();
+    const latestBlockhash = {
+      blockhash: latestBlockhashResult.blockhash,
+      lastValidBlockHeight: latestBlockhashResult.lastValidBlockHeight
+    };
+    const transactionMessage = pipe(
+      createTransactionMessage({ version: 0 }),
+      (tx) => setTransactionMessageFeePayerSigner(signers[0], tx),
+      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+      (tx) => appendTransactionMessageInstructions([instruction], tx)
+    );
+    const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
+    const wireTransaction = getBase64EncodedWireTransaction(signedTransaction);
+    return this.rpcClient.simulateTransaction(wireTransaction, {
+      commitment: this.config.commitment,
+      replaceRecentBlockhash: true
+    });
+  }
+  async simulateBatch(instructions, signers) {
+    const latestBlockhashResult = await this.rpcClient.getLatestBlockhash();
+    const latestBlockhash = {
+      blockhash: latestBlockhashResult.blockhash,
+      lastValidBlockHeight: latestBlockhashResult.lastValidBlockHeight
+    };
+    const transactionMessage = pipe(
+      createTransactionMessage({ version: 0 }),
+      (tx) => setTransactionMessageFeePayerSigner(signers[0], tx),
+      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+      (tx) => appendTransactionMessageInstructions(instructions, tx)
+    );
+    const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
+    const wireTransaction = getBase64EncodedWireTransaction(signedTransaction);
+    return this.rpcClient.simulateTransaction(wireTransaction, {
+      commitment: this.config.commitment,
+      replaceRecentBlockhash: true
+    });
+  }
+  estimateTransactionSize(instructions) {
+    let totalSize = 64;
+    for (const instruction of instructions) {
+      totalSize += 32;
+      totalSize += (instruction.accounts?.length ?? 0) * 32;
+      totalSize += instruction.data.length;
+    }
+    return totalSize;
+  }
+  extractRawData(data) {
+    if (Buffer.isBuffer(data) || data instanceof Uint8Array) {
+      return new Uint8Array(data);
+    }
+    if (typeof data === "object" && data !== null && "data" in data) {
+      return Buffer.from(data.data, "base64");
+    }
+    if (typeof data === "string") {
+      return Buffer.from(data, "base64");
+    }
+    throw new Error("Invalid account data format");
+  }
+  // =====================================================
+  // H2A PROTOCOL INSTRUCTION METHODS
+  // =====================================================
+  /**
+   * Create a communication session instruction
+   */
+  async createCommunicationSession(_params) {
+    return {
+      programAddress: this.config.programId,
+      accounts: [],
+      data: new Uint8Array(0)
+      // Placeholder - would contain serialized instruction data
+    };
+  }
+  /**
+   * Send a communication message instruction
+   */
+  async sendCommunicationMessage(_sessionAddress, _params) {
+    return {
+      programAddress: this.config.programId,
+      accounts: [],
+      data: new Uint8Array(0)
+      // Placeholder - would contain serialized instruction data
+    };
+  }
+  /**
+   * Update participant status instruction
+   */
+  async updateParticipantStatus(_params) {
+    return {
+      programAddress: this.config.programId,
+      accounts: [],
+      data: new Uint8Array(0)
+      // Placeholder - would contain serialized instruction data
+    };
+  }
+};
+var DEFAULT_TTLS = {
+  processed: 500,
+  // 500ms - very volatile
+  confirmed: 2e3,
+  // 2s - less volatile
+  finalized: 3e4
+  // 30s - stable
+};
+var CacheManager = class {
+  accountCache;
+  pdaCache;
+  config;
+  ttls;
+  constructor(config = {}) {
+    this.config = {
+      enabled: config.enabled ?? false,
+      maxSize: config.maxSize ?? 1e3,
+      ttlOverrides: config.ttlOverrides ?? {}
+    };
+    this.ttls = {
+      processed: config.ttlOverrides?.processed ?? DEFAULT_TTLS.processed,
+      confirmed: config.ttlOverrides?.confirmed ?? DEFAULT_TTLS.confirmed,
+      finalized: config.ttlOverrides?.finalized ?? DEFAULT_TTLS.finalized
+    };
+    this.accountCache = new LRUCache({
+      max: this.config.maxSize,
+      ttl: DEFAULT_TTLS.finalized
+      // Default TTL (overridden per entry)
+    });
+    this.pdaCache = new LRUCache({
+      max: this.config.maxSize
+    });
+  }
+  /**
+   * Check if caching is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Get cached account data
+   *
+   * @param address - Account address
+   * @param commitment - Commitment level
+   * @param currentSlot - Current blockchain slot (for staleness check)
+   * @returns Cached data or undefined
+   */
+  getAccount(address, commitment, currentSlot) {
+    if (!this.config.enabled) return void 0;
+    const key = `${address}:${commitment}`;
+    const entry = this.accountCache.get(key);
+    if (!entry) return void 0;
+    if (currentSlot !== void 0 && entry.slot < currentSlot) {
+      this.accountCache.delete(key);
+      return void 0;
+    }
+    return entry.data;
+  }
+  /**
+   * Cache account data
+   *
+   * @param address - Account address
+   * @param data - Account data to cache
+   * @param commitment - Commitment level
+   * @param slot - Blockchain slot when data was fetched
+   */
+  setAccount(address, data, commitment, slot) {
+    if (!this.config.enabled) return;
+    const key = `${address}:${commitment}`;
+    const entry = {
+      data,
+      slot,
+      commitment,
+      timestamp: Date.now()
+    };
+    this.accountCache.set(key, entry, {
+      ttl: this.ttls[commitment]
+    });
+  }
+  /**
+   * Get cached PDA
+   *
+   * PDAs are cached indefinitely as they're deterministic.
+   *
+   * @param seeds - Serialized seed components
+   * @returns Cached PDA or undefined
+   */
+  getPDA(seeds) {
+    if (!this.config.enabled) return void 0;
+    return this.pdaCache.get(seeds);
+  }
+  /**
+   * Cache PDA derivation
+   *
+   * @param seeds - Serialized seed components (use JSON.stringify for consistency)
+   * @param pda - Derived PDA address
+   */
+  setPDA(seeds, pda) {
+    if (!this.config.enabled) return;
+    this.pdaCache.set(seeds, pda);
+  }
+  /**
+   * Invalidate account cache entry
+   *
+   * @param address - Account address to invalidate
+   * @param commitment - Optional commitment level (invalidates all if not specified)
+   */
+  invalidateAccount(address, commitment) {
+    if (!this.config.enabled) return;
+    if (commitment) {
+      this.accountCache.delete(`${address}:${commitment}`);
+    } else {
+      ["processed", "confirmed", "finalized"].forEach((c) => {
+        this.accountCache.delete(`${address}:${c}`);
+      });
+    }
+  }
+  /**
+   * Clear all caches
+   */
+  clear() {
+    this.accountCache.clear();
+    this.pdaCache.clear();
+  }
+  /**
+   * Get cache statistics
+   *
+   * @returns Cache size and hit/miss stats
+   */
+  getStats() {
+    return {
+      accountCache: {
+        size: this.accountCache.size,
+        max: this.config.maxSize
+      },
+      pdaCache: {
+        size: this.pdaCache.size,
+        max: this.config.maxSize
+      }
+    };
+  }
+};
+
+// src/core/BaseModule.ts
+var BaseModule = class {
+  builder;
+  config;
+  logger;
+  cacheManager;
+  _debugMode = false;
+  constructor(config) {
+    this.config = config;
+    this.builder = new InstructionBuilder(config);
+    this.cacheManager = new CacheManager(config.cache);
+    this.logger = config.logger;
+  }
+  /**
+   * Enable debug mode for next operation
+   */
+  debug() {
+    this._debugMode = true;
+    this.builder.enableDebug();
+    return this;
+  }
+  /**
+   * Execute a single instruction
+   */
+  async execute(instructionName, instructionGetter, signers) {
+    return this.builder.execute(
+      instructionName,
+      instructionGetter,
+      signers
+    );
+  }
+  /**
+   * Execute a single instruction with detailed result
+   */
+  async executeWithDetails(instructionName, instructionGetter, signers) {
+    return this.builder.execute(
+      instructionName,
+      instructionGetter,
+      signers,
+      { returnDetails: true }
+    );
+  }
+  /**
+   * Execute multiple instructions in a batch
+   */
+  async executeBatch(batchName, instructionGetters, signers) {
+    return this.builder.executeBatch(
+      batchName,
+      instructionGetters.map((getter) => () => Promise.resolve(getter())),
+      signers
+    );
+  }
+  /**
+   * Simulate an instruction
+   */
+  async simulate(instructionName, instructionGetter, signers) {
+    return this.builder.execute(
+      instructionName,
+      () => Promise.resolve(instructionGetter()),
+      signers,
+      { simulate: true }
+    );
+  }
+  /**
+   * Simulate an instruction (public accessor)
+   */
+  async simulateInstruction(instructionName, instructionGetter, signers) {
+    return this.simulate(instructionName, instructionGetter, signers);
+  }
+  /**
+   * Estimate transaction cost
+   */
+  async estimateCost(instructionGetters) {
+    return this.builder.estimateCost(instructionGetters);
+  }
+  /**
+   * Get cost estimation for an instruction
+   */
+  async getCost(instructionName, instructionGetter) {
+    return this.builder.estimateCost([instructionGetter]);
+  }
+  /**
+   * Get human-readable explanation
+   */
+  async explain(instructionName, instructionGetter) {
+    return this.builder.explain(instructionName, [instructionGetter]);
+  }
+  /**
+   * Debug analyze without executing
+   */
+  async analyze(instructionName, instructionGetter) {
+    return this.builder.debug(instructionName, [instructionGetter]);
+  }
+  /**
+   * Get decoded account (with optional caching)
+   */
+  async getAccount(address, decoderImportName) {
+    if (this.cacheManager.isEnabled()) {
+      const cached = this.cacheManager.getAccount(address, this.commitment);
+      if (cached !== void 0) {
+        this.logger?.info(`[Cache HIT] ${address}`);
+        return cached;
+      }
+    }
+    const account = await this.builder.getAccount(address, decoderImportName);
+    if (this.cacheManager.isEnabled() && account !== null) {
+      const slot = 0;
+      this.cacheManager.setAccount(address, account, this.commitment, slot);
+      this.logger?.info(`[Cache SET] ${address}`);
+    }
+    return account;
+  }
+  /**
+   * Get multiple decoded accounts (with optional caching)
+   */
+  async getAccounts(addresses, decoderImportName) {
+    if (!this.cacheManager.isEnabled()) {
+      return this.builder.getAccounts(addresses, decoderImportName);
+    }
+    const results = new Array(addresses.length);
+    const uncachedIndices = [];
+    const uncachedAddresses = [];
+    for (let i = 0; i < addresses.length; i++) {
+      const cached = this.cacheManager.getAccount(addresses[i], this.commitment);
+      if (cached !== void 0) {
+        results[i] = cached;
+        this.logger?.info(`[Cache HIT] ${addresses[i]}`);
+      } else {
+        uncachedIndices.push(i);
+        uncachedAddresses.push(addresses[i]);
+      }
+    }
+    if (uncachedAddresses.length > 0) {
+      this.logger?.info(`[Cache MISS] Fetching ${uncachedAddresses.length}/${addresses.length} accounts`);
+      const fetched = await this.builder.getAccounts(uncachedAddresses, decoderImportName);
+      const slot = 0;
+      for (let i = 0; i < fetched.length; i++) {
+        const originalIndex = uncachedIndices[i];
+        const account = fetched[i];
+        results[originalIndex] = account;
+        if (account !== null) {
+          this.cacheManager.setAccount(uncachedAddresses[i], account, this.commitment, slot);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Get program accounts
+   */
+  async getProgramAccounts(decoderImportName, filters) {
+    return this.builder.getProgramAccounts(decoderImportName, filters);
+  }
+  /**
+   * Get program ID
+   */
+  get programId() {
+    return this.config.programId;
+  }
+  /**
+   * Get program ID (public accessor)
+   */
+  getProgramId() {
+    return this.config.programId;
+  }
+  /**
+   * Get commitment level
+   */
+  get commitment() {
+    return this.config.commitment ?? "confirmed";
+  }
+  /**
+   * Get commitment level (public accessor)
+   */
+  getCommitment() {
+    return this.config.commitment ?? "confirmed";
+  }
+  /**
+   * Invalidate cache for specific account
+   */
+  invalidateCache(address) {
+    this.cacheManager.invalidateAccount(address);
+    this.logger?.info(`[Cache INVALIDATE] ${address}`);
+  }
+  /**
+   * Clear all caches
+   */
+  clearCache() {
+    this.cacheManager.clear();
+    this.logger?.info("[Cache CLEAR] All caches cleared");
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return this.cacheManager.getStats();
+  }
+};
+
+// src/utils/ipfs-utils.ts
+var DEFAULT_IPFS_CONFIG = {
+  provider: {
+    name: "pinata",
+    endpoint: "https://api.pinata.cloud"
+  },
+  gateways: [
+    "https://gateway.pinata.cloud",
+    "https://ipfs.io",
+    "https://cloudflare-ipfs.com",
+    "https://gateway.ipfs.io"
+  ],
+  autoPinning: true,
+  sizeThreshold: 800,
+  // 800 bytes threshold to stay under Solana transaction limits
+  maxRetries: 3,
+  retryDelay: 1e3,
+  enableCache: true,
+  cacheTTL: 3e5
+  // 5 minutes
+};
+var IPFSUtils = class {
+  client;
+  constructor(config) {
+    this.client = new IPFSClient(config);
+  }
+  /**
+   * Store agent metadata with automatic IPFS/inline decision
+   */
+  async storeAgentMetadata(metadata, options) {
+    const metadataJson = JSON.stringify({
+      ...metadata,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "1.0.0"
+    });
+    return this.client.storeContent(metadataJson, "agent-metadata", {
+      filename: `agent-${metadata.agentId ?? "metadata"}.json`,
+      metadata: {
+        type: "agent-metadata",
+        agentId: metadata.agentId,
+        name: metadata.name
+      },
+      contentType: "application/json",
+      ...options
+    });
+  }
+  /**
+   * Store channel message content with automatic IPFS/inline decision
+   */
+  async storeChannelMessage(message, options) {
+    const messageJson = JSON.stringify({
+      ...message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "1.0.0"
+    });
+    return this.client.storeContent(messageJson, "channel-message", {
+      filename: `message-${Date.now()}.json`,
+      metadata: {
+        type: "channel-message",
+        channelId: message.channelId,
+        messageType: message.messageType ?? 0
+      },
+      contentType: "application/json",
+      ...options
+    });
+  }
+  /**
+   * Store file attachments on IPFS
+   */
+  async storeFileAttachment(fileContent, filename, contentType, options) {
+    const content = typeof fileContent === "string" ? fileContent : new TextDecoder().decode(fileContent);
+    return this.client.storeContent(content, "file-attachment", {
+      filename,
+      contentType,
+      metadata: {
+        type: "file-attachment",
+        originalFilename: filename,
+        mimeType: contentType
+      },
+      ...options
+    });
+  }
+  /**
+   * Retrieve and parse agent metadata
+   */
+  async retrieveAgentMetadata(uri) {
+    const content = await this.client.retrieveContent(uri);
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error("Retrieved agent metadata is not a valid object");
+    }
+    return parsed;
+  }
+  /**
+   * Retrieve and parse channel message content
+   */
+  async retrieveChannelMessage(uri) {
+    const content = await this.client.retrieveContent(uri);
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error("Retrieved channel message is not a valid object");
+    }
+    return parsed;
+  }
+  /**
+   * Batch upload multiple content items
+   */
+  async batchUpload(items) {
+    const results = await Promise.allSettled(
+      items.map(
+        (item) => this.client.storeContent(item.content, item.type, {
+          filename: item.filename,
+          ...item.options
+        })
+      )
+    );
+    return results.map((result) => {
+      if (result.status === "fulfilled") {
+        return {
+          success: true,
+          data: result.value
+        };
+      } else {
+        return {
+          success: false,
+          error: "UPLOAD_FAILED",
+          message: result.reason instanceof Error ? result.reason.message : String(result.reason)
+        };
+      }
+    });
+  }
+  /**
+   * Pin existing content by hash
+   */
+  async pinContent(hash) {
+    const result = await this.client.pin(hash);
+    return {
+      ...result,
+      data: result.success
+    };
+  }
+  /**
+   * Check if a URI uses IPFS storage
+   */
+  isIPFSUri(uri) {
+    return uri.startsWith("ipfs://");
+  }
+  /**
+   * Extract IPFS hash from URI
+   */
+  extractIPFSHash(uri) {
+    if (!this.isIPFSUri(uri)) {
+      return null;
+    }
+    return uri.replace("ipfs://", "");
+  }
+  /**
+   * Convert IPFS hash to gateway URLs
+   */
+  getGatewayUrls(hash, gateways) {
+    const defaultGateways = gateways ?? DEFAULT_IPFS_CONFIG.gateways ?? [];
+    return defaultGateways.map((gateway) => `${gateway}/ipfs/${hash}`);
+  }
+  /**
+   * Validate IPFS hash format
+   */
+  isValidIPFSHash(hash) {
+    if (hash.length < 44) return false;
+    if (hash.startsWith("Qm") && hash.length === 46) {
+      return /^Qm[A-Za-z0-9]{44}$/.test(hash);
+    }
+    if (hash.length > 46) {
+      return /^[A-Za-z0-9]+$/.test(hash);
+    }
+    return false;
+  }
+  /**
+   * Calculate content size to determine if IPFS should be used
+   */
+  shouldUseIPFS(content, threshold) {
+    const size = new TextEncoder().encode(content).length;
+    const sizeThreshold = threshold ?? DEFAULT_IPFS_CONFIG.sizeThreshold ?? 800;
+    return size > sizeThreshold;
+  }
+  /**
+   * Compress content before IPFS upload using modern compression APIs
+   */
+  async compressContent(content) {
+    try {
+      if (typeof CompressionStream !== "undefined") {
+        const compressedStream = new CompressionStream("gzip");
+        const writer = compressedStream.writable.getWriter();
+        const reader = compressedStream.readable.getReader();
+        const encoder = new TextEncoder();
+        const input = encoder.encode(content);
+        const writePromise = writer.write(input).then(() => writer.close());
+        const chunks = [];
+        const readCompressed = async () => {
+          const result = await reader.read();
+          const { done, value } = result;
+          if (!done && value) {
+            chunks.push(value);
+            await readCompressed();
+          }
+        };
+        await Promise.all([writePromise, readCompressed()]);
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const compressedData = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          compressedData.set(chunk, offset);
+          offset += chunk.length;
+        }
+        const compressed = Buffer.from(compressedData).toString("base64");
+        return {
+          compressed,
+          algorithm: "gzip"
+        };
+      } else {
+        console.warn("Compression not available in this environment, storing uncompressed");
+        return {
+          compressed: content,
+          algorithm: "none"
+        };
+      }
+    } catch (error) {
+      console.warn("Compression failed, falling back to uncompressed:", error);
+      return {
+        compressed: content,
+        algorithm: "none"
+      };
+    }
+  }
+  /**
+   * Decompress content after IPFS retrieval using modern decompression APIs
+   */
+  async decompressContent(compressed, algorithm) {
+    if (algorithm === "none") {
+      return compressed;
+    }
+    try {
+      if (algorithm === "gzip") {
+        if (typeof DecompressionStream !== "undefined") {
+          const decompressedStream = new DecompressionStream("gzip");
+          const writer = decompressedStream.writable.getWriter();
+          const reader = decompressedStream.readable.getReader();
+          const compressedData = Buffer.from(compressed, "base64");
+          const writePromise = writer.write(compressedData).then(() => writer.close());
+          const chunks = [];
+          const readDecompressed = async () => {
+            const result = await reader.read();
+            const { done, value } = result;
+            if (!done && value) {
+              chunks.push(value);
+              await readDecompressed();
+            }
+          };
+          await Promise.all([writePromise, readDecompressed()]);
+          const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+          const decompressedData = new Uint8Array(totalLength);
+          let offset = 0;
+          for (const chunk of chunks) {
+            decompressedData.set(chunk, offset);
+            offset += chunk.length;
+          }
+          const decoder = new TextDecoder();
+          return decoder.decode(decompressedData);
+        } else {
+          console.warn("Decompression not available in this environment, returning compressed data");
+          return compressed;
+        }
+      } else {
+        console.warn(`Unknown compression algorithm: ${algorithm}`);
+        return compressed;
+      }
+    } catch (error) {
+      console.error("Decompression failed, returning compressed data:", error);
+      return compressed;
+    }
+  }
+  /**
+   * Get client stats
+   */
+  getStats() {
+    return {
+      cacheStats: this.client.getCacheStats(),
+      config: DEFAULT_IPFS_CONFIG
+    };
+  }
+  /**
+   * Clear client cache
+   */
+  clearCache() {
+    this.client.clearCache();
+  }
+};
+function createIPFSUtils(config) {
+  const finalConfig = {
+    ...DEFAULT_IPFS_CONFIG,
+    ...config,
+    provider: {
+      ...DEFAULT_IPFS_CONFIG.provider,
+      ...config?.provider
+    }
+  };
+  return new IPFSUtils(finalConfig);
+}
+function determineStorageMethod(content, options) {
+  if (options?.forceInline) return "inline";
+  if (options?.forceIPFS) return "ipfs";
+  const size = new TextEncoder().encode(content).length;
+  const threshold = options?.sizeThreshold ?? DEFAULT_IPFS_CONFIG.sizeThreshold ?? 800;
+  return size > threshold ? "ipfs" : "inline";
+}
+async function createMetadataUri(metadata, ipfsUtils, options) {
+  const metadataJson = JSON.stringify(metadata);
+  const storageMethod = determineStorageMethod(metadataJson, {
+    forceIPFS: options?.forceIPFS
+  });
+  if (storageMethod === "inline" || !ipfsUtils) {
+    const encoded = Buffer.from(metadataJson).toString("base64");
+    return `data:application/json;base64,${encoded}`;
+  } else {
+    const result = await ipfsUtils.client.storeContent(
+      metadataJson,
+      options?.type ?? "custom",
+      {
+        filename: options?.filename,
+        contentType: "application/json"
+      }
+    );
+    return result.uri;
+  }
+}
+
+// src/core/modules/AgentModule.ts
+var AgentModule = class extends BaseModule {
+  ipfsUtils = null;
+  constructor(config) {
+    super(config);
+    if (config.ipfsConfig) {
+      this.ipfsUtils = createIPFSUtils(config.ipfsConfig);
+    }
+  }
+  /**
+   * Register a new agent
+   */
+  async register(signer, params) {
+    const pricingModel = params.pricingModel ?? 0 /* Fixed */;
+    const registerGetter = async () => {
+      const agentAccount = await this.deriveAgentPda(params.agentId, signer.address);
+      const ix = await getRegisterAgentInstructionAsync({
+        agentAccount,
+        signer,
+        systemProgram: this.systemProgramId,
+        agentType: params.agentType,
+        name: params.name,
+        description: params.description,
+        metadataUri: params.metadataUri,
+        agentId: params.agentId,
+        pricingModel
+      });
+      return ix;
+    };
+    const heapGetter = () => {
+      const heapData = new Uint8Array(5);
+      heapData[0] = 1;
+      new DataView(heapData.buffer).setUint32(1, 256 * 1024, true);
+      return {
+        programAddress: "ComputeBudget111111111111111111111111111111",
+        accounts: [],
+        data: heapData
+      };
+    };
+    this.debug();
+    if (params.skipSimulation) {
+      console.log("\u{1F680} SKIPPING SIMULATION - Sending transaction directly");
+      return this.builder.executeBatch(
+        "registerAgent",
+        [heapGetter, registerGetter],
+        [signer],
+        { simulate: false, skipPreflight: true }
+      );
+    }
+    return this.builder.executeBatch(
+      "registerAgent",
+      [heapGetter, registerGetter],
+      [signer]
+    );
+  }
+  // registerX402Agent method removed - use PayAI integration
+  /**
+   * Register a compressed agent (5000x cheaper)
+   */
+  async registerCompressed(signer, params) {
+    const instructionGetter = async () => {
+      const treeConfig = params.treeConfig || await this.deriveTreeConfigPda(signer.address);
+      const result = await getRegisterAgentCompressedInstructionAsync({
+        merkleTree: params.merkleTree,
+        treeAuthority: treeConfig,
+        // Map to correct instruction field (it's treeAuthority in IDL?)
+        signer,
+        systemProgram: this.systemProgramId,
+        compressionProgram: this.compressionProgramId,
+        agentType: params.agentType,
+        name: params.name,
+        description: params.description,
+        metadataUri: params.metadataUri,
+        agentId: params.agentId,
+        pricingModel: params.pricingModel ?? 0 /* Fixed */,
+        logWrapper: "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV"
+        // Explicitly provide Noop program
+      });
+      return result;
+    };
+    return this.execute(
+      "registerAgentCompressed",
+      instructionGetter,
+      [signer]
+    );
+  }
+  /**
+   * Update agent metadata
+   */
+  async update(signer, params) {
+    const instructionGetter = () => {
+      const result = getUpdateAgentInstruction({
+        agentAccount: params.agentAddress,
+        signer,
+        metadataUri: params.metadataUri,
+        agentType: params.agentType,
+        agentId: params.agentId,
+        name: params.name ?? null,
+        description: params.description ?? null,
+        pricingModel: params.pricingModel ?? 0 /* Fixed */
+      });
+      return result;
+    };
+    return this.execute(
+      "updateAgent",
+      instructionGetter,
+      [signer]
+    );
+  }
+  /**
+   * Verify an agent
+   */
+  async verify(signer, params) {
+    const instructionGetter = async () => {
+      const result = await getVerifyAgentInstructionAsync({
+        agent: params.agentAddress,
+        verifier: signer,
+        agentPubkey: params.agentPubkey,
+        serviceEndpoint: params.serviceEndpoint,
+        supportedCapabilities: params.supportedCapabilities,
+        verifiedAt: params.verifiedAt
+      });
+      return result;
+    };
+    return this.execute(
+      "verifyAgent",
+      instructionGetter,
+      [signer]
+    );
+  }
+  /**
+   * Deactivate an agent
+   */
+  async deactivate(signer, params) {
+    const instructionGetter = () => {
+      const result = getDeactivateAgentInstruction({
+        agentAccount: params.agentAddress,
+        signer,
+        agentId: params.agentId
+      });
+      return result;
+    };
+    return this.execute(
+      "deactivateAgent",
+      instructionGetter,
+      [signer]
+    );
+  }
+  /**
+   * Activate an agent
+   */
+  async activate(signer, params) {
+    const instructionGetter = () => {
+      const result = getActivateAgentInstruction({
+        agentAccount: params.agentAddress,
+        signer,
+        agentId: params.agentId
+      });
+      return result;
+    };
+    return this.execute(
+      "activateAgent",
+      instructionGetter,
+      [signer]
+    );
+  }
+  /**
+   * Get agent account
+   */
+  async getAgentAccount(address) {
+    return super.getAccount(address, "getAgentDecoder");
+  }
+  /**
+   * Get all agents
+   */
+  async getAllAgents() {
+    return this.getProgramAccounts("getAgentDecoder");
+  }
+  /**
+   * Get agents by type
+   */
+  async getAgentsByType(agentType) {
+    const typeBytes = Buffer.alloc(1);
+    typeBytes.writeUInt8(agentType, 0);
+    const filters = [{
+      memcmp: {
+        offset: BigInt(8),
+        // Skip discriminator
+        bytes: typeBytes.toString("base64"),
+        encoding: "base64"
+      }
+    }];
+    return this.getProgramAccounts("getAgentDecoder", filters);
+  }
+  /**
+   * Get user's agents
+   */
+  async getUserAgents(authority) {
+    const filters = [{
+      memcmp: {
+        offset: BigInt(9),
+        // Skip discriminator + type
+        bytes: authority,
+        encoding: "base58"
+      }
+    }];
+    return this.getProgramAccounts("getAgentDecoder", filters);
+  }
+  /**
+   * Batch get multiple agent accounts
+   *
+   * Uses efficient batching (100 accounts per RPC call) with optional caching.
+   *
+   * @param addresses - Agent addresses to fetch
+   * @param onProgress - Optional progress callback
+   * @returns Array of agent accounts (null for non-existent)
+   *
+   * @example
+   * ```typescript
+   * const agents = await client.agents.batchGetAgents(
+   *   ['agent1...', 'agent2...', 'agent3...'],
+   *   (completed, total) => console.log(`${completed}/${total}`)
+   * )
+   * ```
+   */
+  async batchGetAgents(addresses, onProgress) {
+    return super.getAccounts(addresses, "getAgentDecoder");
+  }
+  /**
+   * Batch get only existing agent accounts
+   *
+   * Filters out non-existent addresses.
+   *
+   * @param addresses - Agent addresses to fetch
+   * @param onProgress - Optional progress callback
+   * @returns Array of existing agents with their addresses
+   *
+   * @example
+   * ```typescript
+   * const existingAgents = await client.agents.batchGetExistingAgents(['addr1', 'addr2'])
+   * // Returns: [{ address: 'addr1', account: Agent }, ...]
+   * ```
+   */
+  async batchGetExistingAgents(addresses, onProgress) {
+    const { batchGetExistingAccounts } = await import('./batch-operations-45CQFEID.js');
+    return batchGetExistingAccounts(
+      this.config.rpc,
+      addresses,
+      { onProgress }
+    );
+  }
+  /**
+   * Batch get and map agents to a simplified format
+   *
+   * Useful for creating agent summaries or lists.
+   *
+   * @param addresses - Agent addresses to fetch
+   * @param mapper - Transform function
+   * @returns Array of mapped results
+   *
+   * @example
+   * ```typescript
+   * const summaries = await client.agents.batchGetAndMapAgents(
+   *   addresses,
+   *   (agent, address) => agent ? {
+   *     address,
+   *     name: agent.name,
+   *     type: agent.agentType,
+   *     active: agent.isActive
+   *   } : null
+   * )
+   * ```
+   */
+  async batchGetAndMapAgents(addresses, mapper) {
+    const { batchGetAndMap } = await import('./batch-operations-45CQFEID.js');
+    return batchGetAndMap(
+      this.config.rpc,
+      addresses,
+      mapper
+    );
+  }
+  // Helper methods
+  async deriveAgentPda(agentId, owner) {
+    const { deriveAgentPda } = await import('./pda-4KP7CURF.js');
+    const [address] = await deriveAgentPda({ programAddress: this.programId, owner, agentId });
+    return address;
+  }
+  async deriveUserRegistryPda(owner) {
+    const { deriveUserRegistryPda } = await import('./pda-4KP7CURF.js');
+    return deriveUserRegistryPda(this.programId, owner);
+  }
+  async deriveTreeConfigPda(owner) {
+    const { getProgramDerivedAddress: getProgramDerivedAddress2, getAddressEncoder: getAddressEncoder2 } = await import('@solana/addresses');
+    const addressEncoder = getAddressEncoder2();
+    const ownerBytes = addressEncoder.encode(owner);
+    const [pda] = await getProgramDerivedAddress2({
+      programAddress: this.programId,
+      seeds: [
+        new TextEncoder().encode("agent_tree_config"),
+        ownerBytes
+      ]
+    });
+    return pda;
+  }
+  get systemProgramId() {
+    return SYSTEM_PROGRAM_ADDRESS;
+  }
+  get compressionProgramId() {
+    return "cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK";
+  }
+};
+
+// src/modules/governance/GovernanceModule.ts
+var GovernanceModule = class extends BaseModule {
+  // =====================================================
+  // DIRECT INSTRUCTION ACCESS
+  // These methods provide direct access to generated instructions
+  // with minimal wrapping for maximum flexibility
+  // =====================================================
+  /**
+   * Get initialize governance proposal instruction
+   */
+  getInitializeGovernanceProposalInstruction(params) {
+    return getInitializeGovernanceProposalInstructionAsync(params);
+  }
+  // =====================================================
+  // CONVENIENCE METHODS
+  // These methods provide simplified access to common operations
+  // =====================================================
+  /**
+   * Create a new governance proposal
+   */
+  async createProposal(params) {
+    const proposalAddress = this.deriveProposalPda(params.signer.address, params.title);
+    const instruction = await this.getInitializeGovernanceProposalInstruction({
+      proposal: proposalAddress,
+      proposer: params.signer,
+      title: params.title,
+      description: params.description,
+      proposalType: { kind: params.proposalType, data: {} },
+      executionParams: {
+        instructions: [],
+        accounts: [],
+        targetProgram: proposalAddress,
+        executeAfter: BigInt(params.executionDelay ?? 0)
+      },
+      proposalId: BigInt(Date.now())
+    });
+    return this.execute("createProposal", () => instruction, [params.signer]);
+  }
+  // =====================================================
+  // QUERY OPERATIONS
+  // =====================================================
+  /**
+   * Get governance proposal account
+   */
+  async getProposal(address) {
+    return super.getAccount(address, "getGovernanceProposalDecoder");
+  }
+  /**
+   * Get all active proposals
+   */
+  async getActiveProposals() {
+    return this.getProgramAccounts("getGovernanceProposalDecoder");
+  }
+  /**
+   * Get proposals by proposer
+   */
+  async getProposalsByProposer(proposer) {
+    const filters = [{
+      memcmp: {
+        offset: BigInt(8),
+        // Skip discriminator
+        bytes: proposer,
+        encoding: "base58"
+      }
+    }];
+    return this.getProgramAccounts("getGovernanceProposalDecoder", filters);
+  }
+  /**
+   * Get proposals by status
+   */
+  async getProposalsByStatus(_status) {
+    const allProposals = await this.getProgramAccounts("getGovernanceProposalDecoder");
+    return allProposals.filter((_proposal) => {
+      return allProposals.length > 0;
+    });
+  }
+  // =====================================================
+  // HELPER METHODS
+  // =====================================================
+  deriveProposalPda(proposer, title) {
+    return `proposal_${proposer}_${title}`;
+  }
+};
+
+// src/modules/multisig/MultisigModule.ts
+var MultisigModule = class extends BaseModule {
+  /**
+   * Create a new multisig account
+   */
+  async createMultisig(params) {
+    throw new Error("createMultisig: Instruction not available - requires IDL regeneration");
+  }
+  /**
+   * Create a proposal (Uses Governance Protocol)
+   * 
+   * Note: This creates a GovernanceProposal. The proposer must be a signer.
+   */
+  async createProposal(params) {
+    const instruction = await getInitializeGovernanceProposalInstructionAsync({
+      proposer: params.proposer,
+      proposalId: params.proposalId,
+      title: params.title,
+      description: params.description,
+      proposalType: params.proposalType,
+      executionParams: params.executionParams
+    }, { programAddress: this.programId });
+    return this.execute("createProposal", () => instruction, [params.proposer]);
+  }
+  /**
+   * Execute a proposal (Note: Approval/voting removed, use protocol_config instead)
+   */
+  async executeProposal(params) {
+    throw new Error("executeProposal: Use protocol_config instructions for execution");
+  }
+};
+
+// src/modules/did/did-types.ts
+var DID_DOCUMENT_SEED = "did_document";
+var VerificationMethodType = /* @__PURE__ */ ((VerificationMethodType2) => {
+  VerificationMethodType2["Ed25519VerificationKey2020"] = "Ed25519VerificationKey2020";
+  VerificationMethodType2["X25519KeyAgreementKey2020"] = "X25519KeyAgreementKey2020";
+  VerificationMethodType2["EcdsaSecp256k1VerificationKey2019"] = "EcdsaSecp256k1VerificationKey2019";
+  return VerificationMethodType2;
+})(VerificationMethodType || {});
+var VerificationRelationship = /* @__PURE__ */ ((VerificationRelationship2) => {
+  VerificationRelationship2["Authentication"] = "authentication";
+  VerificationRelationship2["AssertionMethod"] = "assertionMethod";
+  VerificationRelationship2["KeyAgreement"] = "keyAgreement";
+  VerificationRelationship2["CapabilityInvocation"] = "capabilityInvocation";
+  VerificationRelationship2["CapabilityDelegation"] = "capabilityDelegation";
+  return VerificationRelationship2;
+})(VerificationRelationship || {});
+var ServiceEndpointType = /* @__PURE__ */ ((ServiceEndpointType2) => {
+  ServiceEndpointType2["AIAgentService"] = "AIAgentService";
+  ServiceEndpointType2["DIDCommMessaging"] = "DIDCommMessaging";
+  ServiceEndpointType2["CredentialRepository"] = "CredentialRepository";
+  ServiceEndpointType2["LinkedDomains"] = "LinkedDomains";
+  ServiceEndpointType2["Custom"] = "Custom";
+  return ServiceEndpointType2;
+})(ServiceEndpointType || {});
+var DidError = /* @__PURE__ */ ((DidError2) => {
+  DidError2["AlreadyDeactivated"] = "AlreadyDeactivated";
+  DidError2["TooManyVerificationMethods"] = "TooManyVerificationMethods";
+  DidError2["TooManyServiceEndpoints"] = "TooManyServiceEndpoints";
+  DidError2["DuplicateMethodId"] = "DuplicateMethodId";
+  DidError2["DuplicateServiceId"] = "DuplicateServiceId";
+  DidError2["MethodNotFound"] = "MethodNotFound";
+  DidError2["ServiceNotFound"] = "ServiceNotFound";
+  DidError2["InvalidDidFormat"] = "InvalidDidFormat";
+  DidError2["UnauthorizedDidOperation"] = "UnauthorizedDidOperation";
+  DidError2["DidDeactivated"] = "DidDeactivated";
+  return DidError2;
+})(DidError || {});
+var DidErrorClass = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message || code);
+    this.name = "DidError";
+    this.code = code;
+  }
+};
+async function deriveDidDocumentPda(programId, controller) {
+  const [address, bump] = await getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      new TextEncoder().encode(DID_DOCUMENT_SEED),
+      getAddressEncoder().encode(controller)
+    ]
+  });
+  return [address, bump];
+}
+function generateDidString(network, pubkey) {
+  const normalizedNetwork = network === "mainnet" ? "mainnet-beta" : network;
+  return `did:sol:${normalizedNetwork}:${pubkey.toString()}`;
+}
+function validateDidString(did) {
+  if (!did.startsWith("did:sol:")) {
+    throw new DidErrorClass(
+      "InvalidDidFormat" /* InvalidDidFormat */,
+      'DID must start with "did:sol:"'
+    );
+  }
+  const parts = did.split(":");
+  if (parts.length !== 4) {
+    throw new DidErrorClass(
+      "InvalidDidFormat" /* InvalidDidFormat */,
+      'DID must have format "did:sol:network:identifier"'
+    );
+  }
+  const validNetworks = ["mainnet-beta", "devnet", "testnet", "localnet"];
+  if (!validNetworks.includes(parts[2])) {
+    throw new DidErrorClass(
+      "InvalidDidFormat" /* InvalidDidFormat */,
+      `Invalid network "${parts[2]}". Must be one of: ${validNetworks.join(", ")}`
+    );
+  }
+  try {
+    bs58.decode(parts[3]);
+  } catch {
+    throw new DidErrorClass(
+      "InvalidDidFormat" /* InvalidDidFormat */,
+      "DID identifier must be a valid base58-encoded Solana public key"
+    );
+  }
+}
+function parseDidString(did) {
+  validateDidString(did);
+  const parts = did.split(":");
+  return {
+    method: parts[1],
+    network: parts[2],
+    identifier: parts[3]
+  };
+}
+function exportAsW3CDidDocument(didDocument) {
+  const verificationMethod = didDocument.verificationMethods.filter((m) => !m.revoked).map((method) => ({
+    id: `${didDocument.did}#${method.id}`,
+    type: method.methodType,
+    controller: method.controller,
+    publicKeyMultibase: method.publicKeyMultibase
+  }));
+  const authentication = didDocument.verificationMethods.filter((m) => !m.revoked && m.relationships.includes("authentication" /* Authentication */)).map((m) => `${didDocument.did}#${m.id}`);
+  const assertionMethod = didDocument.verificationMethods.filter((m) => !m.revoked && m.relationships.includes("assertionMethod" /* AssertionMethod */)).map((m) => `${didDocument.did}#${m.id}`);
+  const keyAgreement = didDocument.verificationMethods.filter((m) => !m.revoked && m.relationships.includes("keyAgreement" /* KeyAgreement */)).map((m) => `${didDocument.did}#${m.id}`);
+  const capabilityInvocation = didDocument.verificationMethods.filter((m) => !m.revoked && m.relationships.includes("capabilityInvocation" /* CapabilityInvocation */)).map((m) => `${didDocument.did}#${m.id}`);
+  const capabilityDelegation = didDocument.verificationMethods.filter((m) => !m.revoked && m.relationships.includes("capabilityDelegation" /* CapabilityDelegation */)).map((m) => `${didDocument.did}#${m.id}`);
+  const service = didDocument.serviceEndpoints.map((endpoint) => ({
+    id: `${didDocument.did}#${endpoint.id}`,
+    type: endpoint.serviceType,
+    serviceEndpoint: endpoint.serviceEndpoint,
+    description: endpoint.description || void 0
+  }));
+  return {
+    "@context": didDocument.context,
+    id: didDocument.did,
+    controller: didDocument.controller.toString(),
+    verificationMethod,
+    authentication: authentication.length > 0 ? authentication : void 0,
+    assertionMethod: assertionMethod.length > 0 ? assertionMethod : void 0,
+    keyAgreement: keyAgreement.length > 0 ? keyAgreement : void 0,
+    capabilityInvocation: capabilityInvocation.length > 0 ? capabilityInvocation : void 0,
+    capabilityDelegation: capabilityDelegation.length > 0 ? capabilityDelegation : void 0,
+    service: service.length > 0 ? service : void 0,
+    alsoKnownAs: didDocument.alsoKnownAs.length > 0 ? didDocument.alsoKnownAs : void 0
+  };
+}
+function createEd25519VerificationMethod(id, controller, publicKey, relationships = ["authentication" /* Authentication */]) {
+  const publicKeyMultibase = `z${publicKey}`;
+  return {
+    id,
+    methodType: "Ed25519VerificationKey2020" /* Ed25519VerificationKey2020 */,
+    controller,
+    publicKeyMultibase,
+    relationships,
+    createdAt: Math.floor(Date.now() / 1e3),
+    revoked: false
+  };
+}
+function createServiceEndpoint(id, serviceType, serviceEndpoint, description = "") {
+  return {
+    id,
+    serviceType,
+    serviceEndpoint,
+    description
+  };
+}
+function isDidActive(didDocument) {
+  return !didDocument.deactivated;
+}
+function getMethodsForRelationship(didDocument, relationship) {
+  return didDocument.verificationMethods.filter(
+    (m) => !m.revoked && m.relationships.includes(relationship)
+  );
+}
+function canPerformAction(didDocument, publicKey, relationship) {
+  if (publicKey.toString() === didDocument.controller.toString()) {
+    return true;
+  }
+  const pubkeyMultibase = `z${publicKey.toString()}`;
+  return didDocument.verificationMethods.some(
+    (method) => !method.revoked && method.publicKeyMultibase === pubkeyMultibase && method.relationships.includes(relationship)
+  );
+}
+function didDocumentToJson(didDocument, pretty = true) {
+  const w3cDoc = exportAsW3CDidDocument(didDocument);
+  return pretty ? JSON.stringify(w3cDoc, null, 2) : JSON.stringify(w3cDoc);
+}
+function getNetworkFromDid(did) {
+  const parts = parseDidString(did);
+  return parts.network;
+}
+function getIdentifierFromDid(did) {
+  const parts = parseDidString(did);
+  return parts.identifier;
+}
+var base58Encode = (data) => bs58.encode(data);
+var DEFAULT_PROGRAM_ID = "GHosT3wqDfNq9bKz8dNEQ1F5mLuN7bKdNYx3Z1111111";
+var CredentialKind = /* @__PURE__ */ ((CredentialKind2) => {
+  CredentialKind2["AgentIdentity"] = "AgentIdentity";
+  CredentialKind2["ReputationScore"] = "ReputationScore";
+  CredentialKind2["JobCompletion"] = "JobCompletion";
+  CredentialKind2["DelegatedSigner"] = "DelegatedSigner";
+  CredentialKind2["Custom"] = "Custom";
+  return CredentialKind2;
+})(CredentialKind || {});
+var CredentialStatus = /* @__PURE__ */ ((CredentialStatus2) => {
+  CredentialStatus2["Pending"] = "Pending";
+  CredentialStatus2["Active"] = "Active";
+  CredentialStatus2["Revoked"] = "Revoked";
+  CredentialStatus2["Expired"] = "Expired";
+  return CredentialStatus2;
+})(CredentialStatus || {});
+var CredentialModule = class {
+  programId;
+  didModule;
+  constructor(programId = DEFAULT_PROGRAM_ID, didModule) {
+    this.programId = programId;
+    this.didModule = didModule;
+  }
+  /**
+   * Set the DID module for enhanced DID resolution
+   * This enables automatic DID creation and resolution for credentials
+   */
+  setDidModule(didModule) {
+    this.didModule = didModule;
+  }
+  // --------------------------------------------------------------------------
+  // Hashing
+  // --------------------------------------------------------------------------
+  hashSubjectData(subjectData) {
+    const json = JSON.stringify(subjectData, Object.keys(subjectData).sort());
+    return sha256(new TextEncoder().encode(json));
+  }
+  generateCredentialId(kind, subject) {
+    const timestamp = Date.now();
+    const input = `${kind}-${subject}-${timestamp}`;
+    const hash = sha256(new TextEncoder().encode(input));
+    const shortHash = base58Encode(hash.slice(0, 8));
+    return `${kind.toLowerCase()}-${shortHash}`;
+  }
+  // --------------------------------------------------------------------------
+  // Export W3C
+  // --------------------------------------------------------------------------
+  exportAsW3CCredential(credential, template, credentialType, subjectData, options) {
+    const network = options?.network || "mainnet";
+    const issuerDid = generateDidString(network, this.programId);
+    const subjectDid = generateDidString(network, credential.subject);
+    const statusId = `solana:${this.programId}:credential:${credential.credentialId}`;
+    return {
+      "@context": [
+        "https://www.w3.org/ns/credentials/v2",
+        "https://w3id.org/security/data-integrity/v2",
+        "https://ghostspeak.io/ns/credentials/v1"
+      ],
+      type: ["VerifiableCredential", `GhostSpeak${credentialType.kind}Credential`],
+      id: `urn:ghostspeak:${credential.credentialId}`,
+      issuer: {
+        id: issuerDid,
+        name: "GhostSpeak Protocol"
+      },
+      validFrom: new Date(credential.issuedAt * 1e3).toISOString(),
+      validUntil: credential.expiresAt ? new Date(credential.expiresAt * 1e3).toISOString() : void 0,
+      credentialSubject: {
+        id: subjectDid,
+        ...subjectData
+      },
+      credentialSchema: {
+        id: credentialType.schemaUri,
+        type: "JsonSchema"
+      },
+      credentialStatus: {
+        id: statusId,
+        type: "SolanaAccountStatus2025",
+        statusPurpose: "revocation"
+      },
+      relatedResource: options?.includeRelatedResource ? [
+        {
+          id: credential.subjectDataUri,
+          digestMultibase: `mEi${base58Encode(credential.subjectDataHash)}`
+        }
+      ] : void 0,
+      proof: {
+        type: "DataIntegrityProof",
+        created: new Date(credential.issuedAt * 1e3).toISOString(),
+        verificationMethod: `${issuerDid}#key-1`,
+        cryptosuite: "eddsa-rdfc-2022",
+        proofPurpose: "assertionMethod",
+        proofValue: base58Encode(credential.signature)
+      }
+    };
+  }
+  /**
+   * Export credential with DID resolution
+   * Resolves DIDs for issuer and subject to get full DID documents
+   *
+   * @param credential - Credential to export
+   * @param template - Credential template
+   * @param credentialType - Credential type
+   * @param subjectData - Subject data
+   * @param options - Export options
+   * @returns W3C credential with resolved DIDs
+   */
+  async exportWithDidResolution(credential, template, credentialType, subjectData, options) {
+    if (!this.didModule) {
+      return this.exportAsW3CCredential(
+        credential,
+        template,
+        credentialType,
+        subjectData,
+        options
+      );
+    }
+    const network = options?.network || "mainnet";
+    const issuerDid = generateDidString(network, this.programId);
+    const subjectDid = generateDidString(network, credential.subject);
+    const issuerDidDoc = await this.didModule.resolve(this.programId).catch(() => null);
+    await this.didModule.resolve(credential.subject).catch(() => null);
+    const statusId = `solana:${this.programId}:credential:${credential.credentialId}`;
+    const verificationMethod = issuerDidDoc?.verificationMethods?.[0] ? `${issuerDid}#${issuerDidDoc.verificationMethods[0].id}` : `${issuerDid}#key-1`;
+    return {
+      "@context": [
+        "https://www.w3.org/ns/credentials/v2",
+        "https://w3id.org/security/data-integrity/v2",
+        "https://ghostspeak.io/ns/credentials/v1"
+      ],
+      type: ["VerifiableCredential", `GhostSpeak${credentialType.kind}Credential`],
+      id: `urn:ghostspeak:${credential.credentialId}`,
+      issuer: {
+        id: issuerDid,
+        name: "GhostSpeak Protocol"
+      },
+      validFrom: new Date(credential.issuedAt * 1e3).toISOString(),
+      validUntil: credential.expiresAt ? new Date(credential.expiresAt * 1e3).toISOString() : void 0,
+      credentialSubject: {
+        id: subjectDid,
+        ...subjectData
+      },
+      credentialSchema: {
+        id: credentialType.schemaUri,
+        type: "JsonSchema"
+      },
+      credentialStatus: {
+        id: statusId,
+        type: "SolanaAccountStatus2025",
+        statusPurpose: "revocation"
+      },
+      relatedResource: options?.includeRelatedResource ? [
+        {
+          id: credential.subjectDataUri,
+          digestMultibase: `mEi${base58Encode(credential.subjectDataHash)}`
+        }
+      ] : void 0,
+      proof: {
+        type: "DataIntegrityProof",
+        created: new Date(credential.issuedAt * 1e3).toISOString(),
+        verificationMethod,
+        cryptosuite: "eddsa-rdfc-2022",
+        proofPurpose: "assertionMethod",
+        proofValue: base58Encode(credential.signature)
+      }
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Helpers for Subject Building
+  // --------------------------------------------------------------------------
+  static buildAgentIdentitySubject(params) {
+    return params;
+  }
+  // --------------------------------------------------------------------------
+  // x402 Agent Credential Issuance
+  // --------------------------------------------------------------------------
+  /**
+   * Issue an AgentIdentity credential for a newly registered x402 agent
+   * 
+   * This creates a W3C Verifiable Credential that can be:
+   * - Stored on-chain for reputation
+   * - Exported as standard W3C VC JSON
+   * - Verified by third parties
+   * 
+   * @example
+   * ```typescript
+   * const result = await credentialModule.issueX402AgentCredential({
+   *   agentAddress: 'EPjFWdd5...',
+   *   agentId: 'x402-abc123',
+   *   owner: 'HN7cAB...',
+   *   name: 'My Coinbase Agent',
+   *   serviceEndpoint: 'https://my-agent.com/api',
+   *   frameworkOrigin: 'coinbase-x402',
+   *   x402PaymentAddress: 'EPjFWdd5...',
+   *   x402AcceptedTokens: ['EPjFWdd5...'],
+   *   x402PricePerCall: '1000000'
+   * })
+   * ```
+   */
+  issueX402AgentCredential(params) {
+    const now = Math.floor(Date.now() / 1e3);
+    const subjectData = {
+      agentId: params.agentId,
+      owner: params.owner,
+      name: params.name,
+      capabilities: params.capabilities || [],
+      serviceEndpoint: params.serviceEndpoint,
+      frameworkOrigin: params.frameworkOrigin,
+      x402Enabled: true,
+      x402PaymentAddress: params.x402PaymentAddress,
+      x402AcceptedTokens: params.x402AcceptedTokens,
+      x402PricePerCall: params.x402PricePerCall,
+      registeredAt: now,
+      verifiedAt: now,
+      type: "external-x402-agent",
+      verificationResponseTimeMs: params.verificationResponseTimeMs
+    };
+    const credentialId = this.generateCredentialId(
+      "AgentIdentity" /* AgentIdentity */,
+      params.agentAddress
+    );
+    const subjectDataHash = this.hashSubjectData(subjectData);
+    const credential = {
+      template: `x402-agent-identity-template`,
+      subject: params.agentAddress,
+      issuer: this.programId,
+      credentialId,
+      subjectDataHash,
+      subjectDataUri: `data:application/json;base64,${Buffer.from(JSON.stringify(subjectData)).toString("base64")}`,
+      status: "Active" /* Active */,
+      signature: subjectDataHash,
+      // Self-signed with hash (for demo; real impl would sign with authority key)
+      issuedAt: now
+    };
+    const credentialType = {
+      authority: this.programId,
+      name: "x402 Agent Identity",
+      kind: "AgentIdentity" /* AgentIdentity */,
+      schemaUri: "https://ghostspeak.io/schemas/x402-agent-identity-v1.json",
+      description: "Verifiable credential for x402-compatible AI agents registered with GhostSpeak",
+      isActive: true,
+      totalIssued: 1,
+      createdAt: now
+    };
+    const template = {
+      credentialType: credentialType.authority,
+      name: "x402 Agent Identity",
+      imageUri: "https://ghostspeak.io/assets/credential-badge-x402.png",
+      issuer: this.programId,
+      isActive: true,
+      totalIssued: 1,
+      createdAt: now
+    };
+    const w3cCredential = this.exportAsW3CCredential(
+      credential,
+      template,
+      credentialType,
+      subjectData,
+      { network: params.network || "devnet", includeRelatedResource: true }
+    );
+    return {
+      credentialId,
+      credential,
+      w3cCredential,
+      subjectData
+    };
+  }
+  /**
+   * Export an existing credential to W3C JSON format
+   */
+  exportCredentialToJSON(credential, subjectData, options) {
+    const template = {
+      credentialType: "x402-agent",
+      name: credential.credentialId.includes("agentidentity") ? "Agent Identity" : "Custom",
+      imageUri: "https://ghostspeak.io/assets/credential-badge.png",
+      issuer: credential.issuer,
+      isActive: true,
+      totalIssued: 1,
+      createdAt: credential.issuedAt
+    };
+    const credentialType = {
+      authority: credential.issuer,
+      name: "GhostSpeak Credential",
+      kind: "AgentIdentity" /* AgentIdentity */,
+      schemaUri: "https://ghostspeak.io/schemas/credential-v1.json",
+      description: "GhostSpeak verifiable credential",
+      isActive: true,
+      totalIssued: 1,
+      createdAt: credential.issuedAt
+    };
+    const w3c = this.exportAsW3CCredential(
+      credential,
+      template,
+      credentialType,
+      subjectData,
+      { network: options?.network || "devnet", includeRelatedResource: true }
+    );
+    return options?.pretty ? JSON.stringify(w3c, null, 2) : JSON.stringify(w3c);
+  }
+};
+var DEFAULT_FACILITATOR_URL = "https://facilitator.payai.network";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRY = { attempts: 3, delayMs: 1e3 };
+function isPaymentRequired(response) {
+  return response.status === 402;
+}
+async function extractPaymentRequirements(response) {
+  const body = await response.text();
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed.accepts && Array.isArray(parsed.accepts)) {
+      return parsed.accepts;
+    }
+    if (parsed.paymentRequirements && Array.isArray(parsed.paymentRequirements)) {
+      return parsed.paymentRequirements;
+    }
+    if (parsed.scheme && parsed.payTo) {
+      return [parsed];
+    }
+  } catch {
+  }
+  const paymentHeader = response.headers.get("x-payment-required");
+  if (paymentHeader) {
+    try {
+      return JSON.parse(paymentHeader);
+    } catch {
+    }
+  }
+  return [];
+}
+var PayAIClient = class extends EventEmitter {
+  config;
+  localRecords = [];
+  constructor(config) {
+    super();
+    this.config = {
+      facilitatorUrl: config.facilitatorUrl ?? DEFAULT_FACILITATOR_URL,
+      rpcUrl: config.rpcUrl,
+      wallet: config.wallet,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      retry: config.retry ?? DEFAULT_RETRY
+    };
+  }
+  // =====================================================
+  // PUBLIC METHODS
+  // =====================================================
+  /**
+   * Make a fetch request with automatic x402 payment handling
+   *
+   * @param url - The resource URL
+   * @param init - Fetch options
+   * @returns Response from the resource
+   */
+  async fetch(url, init) {
+    this.emit("request:started", url);
+    const startTime = Date.now();
+    try {
+      let response = await this.fetchWithTimeout(url, init);
+      if (isPaymentRequired(response)) {
+        const requirements = await extractPaymentRequirements(response);
+        this.emit("payment:required", requirements);
+        if (requirements.length === 0) {
+          throw new Error("Payment required but no payment options provided");
+        }
+        const requirement = this.selectPaymentOption(requirements);
+        if (!requirement) {
+          throw new Error("No compatible payment option found");
+        }
+        response = await this.makePaymentAndRetry(url, init ?? {}, requirement);
+      }
+      const durationMs = Date.now() - startTime;
+      this.emit("request:completed", url, response.ok, durationMs);
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      this.emit("request:completed", url, false, durationMs);
+      if (error instanceof Error) {
+        this.emit("payment:failed", error);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Verify a payment through the PayAI facilitator
+   *
+   * @param paymentHeader - The payment header/payload
+   * @param requirement - The payment requirement
+   * @returns Verification result
+   */
+  async verifyPayment(paymentHeader, requirement) {
+    const response = await this.fetchWithTimeout(
+      `${this.config.facilitatorUrl}/verify`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          paymentHeader,
+          paymentRequirements: requirement
+        })
+      }
+    );
+    return response.json();
+  }
+  /**
+   * Settle a payment through the PayAI facilitator
+   *
+   * @param paymentHeader - The payment header/payload
+   * @param requirement - The payment requirement
+   * @returns Settlement result
+   */
+  async settlePayment(paymentHeader, requirement) {
+    const response = await this.fetchWithTimeout(
+      `${this.config.facilitatorUrl}/settle`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          paymentHeader,
+          paymentRequirements: requirement
+        })
+      }
+    );
+    return response.json();
+  }
+  /**
+   * List available resources from the PayAI facilitator
+   *
+   * @param options - Filter options
+   * @returns List of available resources
+   */
+  async listResources(options) {
+    const params = new URLSearchParams();
+    if (options?.network) params.set("network", options.network);
+    if (options?.capability) params.set("capability", options.capability);
+    if (options?.maxPrice) params.set("maxPrice", options.maxPrice.toString());
+    const response = await this.fetchWithTimeout(
+      `${this.config.facilitatorUrl}/list?${params.toString()}`
+    );
+    return response.json();
+  }
+  /**
+   * Get locally tracked reputation records
+   * (For payments made through this client instance)
+   */
+  getLocalReputationRecords() {
+    return [...this.localRecords];
+  }
+  /**
+   * Clear local reputation records
+   */
+  clearLocalReputationRecords() {
+    this.localRecords.length = 0;
+  }
+  // =====================================================
+  // PRIVATE METHODS
+  // =====================================================
+  /**
+   * Select the best payment option from requirements
+   */
+  selectPaymentOption(requirements) {
+    const solanaOption = requirements.find((r) => r.network === "solana");
+    if (solanaOption) return solanaOption;
+    return requirements[0] ?? null;
+  }
+  /**
+   * Make payment and retry the original request
+   */
+  async makePaymentAndRetry(url, init, requirement) {
+    this.emit("payment:started", requirement);
+    const paymentHeader = await this.createPaymentHeader(requirement);
+    const verification = await this.verifyPayment(paymentHeader, requirement);
+    if (!verification.valid) {
+      throw new Error(`Payment verification failed: ${verification.error ?? "Unknown error"}`);
+    }
+    const settlement = await this.settlePayment(paymentHeader, requirement);
+    if (!settlement.success) {
+      throw new Error(`Payment settlement failed: ${settlement.error ?? "Unknown error"}`);
+    }
+    this.emit("payment:completed", {
+      success: true,
+      transactionSignature: settlement.transaction,
+      paymentId: `pay_${Date.now()}`
+    });
+    const startTime = Date.now();
+    const response = await this.fetchWithTimeout(url, {
+      ...init,
+      headers: {
+        ...init.headers,
+        "X-Payment": paymentHeader,
+        "X-Payment-Signature": settlement.transaction ?? ""
+      }
+    });
+    const responseTime = Date.now() - startTime;
+    if (settlement.transaction) {
+      this.localRecords.push({
+        agentAddress: requirement.payTo,
+        paymentSignature: settlement.transaction,
+        amount: BigInt(requirement.maxAmountRequired),
+        success: response.ok,
+        responseTimeMs: responseTime,
+        payerAddress: this.config.wallet?.publicKey ?? "unknown",
+        timestamp: /* @__PURE__ */ new Date(),
+        network: requirement.network
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a payment header for a requirement
+   * (In production, this would sign a real Solana transaction)
+   */
+  async createPaymentHeader(requirement) {
+    if (!this.config.wallet) {
+      throw new Error("Wallet not configured for payments");
+    }
+    const paymentData = {
+      version: "1.0",
+      scheme: requirement.scheme,
+      network: requirement.network,
+      payer: this.config.wallet.publicKey,
+      payTo: requirement.payTo,
+      amount: requirement.maxAmountRequired,
+      asset: requirement.asset,
+      resource: requirement.resource,
+      nonce: Date.now().toString(),
+      signature: `mock_sig_${Date.now()}`
+    };
+    return Buffer.from(JSON.stringify(paymentData)).toString("base64");
+  }
+  /**
+   * Fetch with timeout
+   */
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        ...init,
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function createPayAIClient(config) {
+  return new PayAIClient(config);
+}
+async function payAIFetch(url, config, init) {
+  const client = createPayAIClient(config);
+  return client.fetch(url, init);
+}
+
+// src/modules/reputation/ReputationModule.ts
+init_reputation_tag_engine();
+var ReputationModule = class extends BaseModule {
+  calculator;
+  tagEngine;
+  constructor(config) {
+    super(config);
+    this.calculator = new ReputationCalculator();
+    this.tagEngine = new ReputationTagEngine();
+  }
+  /**
+   * Calculate reputation change for a job
+   */
+  calculateReputationChange(currentData, jobPerformance) {
+    return this.calculator.calculateReputation(currentData, jobPerformance);
+  }
+  /**
+   * Get tier name from tier enum
+   */
+  getTierName(tier) {
+    switch (tier) {
+      case "None" /* None */:
+        return "Unranked";
+      case "Bronze" /* Bronze */:
+        return "Bronze";
+      case "Silver" /* Silver */:
+        return "Silver";
+      case "Gold" /* Gold */:
+        return "Gold";
+      case "Platinum" /* Platinum */:
+        return "Platinum";
+      default:
+        return "Unknown";
+    }
+  }
+  /**
+   * Get tier from score
+   */
+  getTierFromScore(score) {
+    if (score >= REPUTATION_CONSTANTS.PLATINUM_TIER_THRESHOLD) {
+      return "Platinum" /* Platinum */;
+    } else if (score >= REPUTATION_CONSTANTS.GOLD_TIER_THRESHOLD) {
+      return "Gold" /* Gold */;
+    } else if (score >= REPUTATION_CONSTANTS.SILVER_TIER_THRESHOLD) {
+      return "Silver" /* Silver */;
+    } else if (score >= REPUTATION_CONSTANTS.BRONZE_TIER_THRESHOLD) {
+      return "Bronze" /* Bronze */;
+    }
+    return "None" /* None */;
+  }
+  /**
+   * Get badge display name
+   */
+  getBadgeName(badge) {
+    switch (badge) {
+      case "FirstJob" /* FirstJob */:
+        return "First Job";
+      case "TenJobs" /* TenJobs */:
+        return "10 Jobs";
+      case "HundredJobs" /* HundredJobs */:
+        return "100 Jobs";
+      case "ThousandJobs" /* ThousandJobs */:
+        return "1000 Jobs";
+      case "PerfectRating" /* PerfectRating */:
+        return "Perfect Rating";
+      case "QuickResponder" /* QuickResponder */:
+        return "Quick Responder";
+      case "DisputeResolver" /* DisputeResolver */:
+        return "Dispute Resolver";
+      case "CategoryExpert" /* CategoryExpert */:
+        return "Category Expert";
+      case "CrossCategoryMaster" /* CrossCategoryMaster */:
+        return "Cross-Category Master";
+      default:
+        return "Unknown Badge";
+    }
+  }
+  /**
+   * Calculate estimated APY boost from reputation
+   */
+  calculateApyBoost(score) {
+    return Math.floor(score / 1e3) * 50;
+  }
+  /**
+   * Get reputation tier color for UI
+   */
+  getTierColor(tier) {
+    switch (tier) {
+      case "Platinum" /* Platinum */:
+        return "#E5E4E2";
+      // Platinum gray
+      case "Gold" /* Gold */:
+        return "#FFD700";
+      // Gold
+      case "Silver" /* Silver */:
+        return "#C0C0C0";
+      // Silver
+      case "Bronze" /* Bronze */:
+        return "#CD7F32";
+      // Bronze
+      default:
+        return "#808080";
+    }
+  }
+  /**
+   * Create default reputation data for new agents
+   */
+  createDefaultReputationData(agentAddress) {
+    return {
+      agent: agentAddress,
+      overallScore: 5e3,
+      // Start at 50%
+      totalJobsCompleted: 0,
+      totalJobsFailed: 0,
+      avgResponseTime: 0,
+      disputesAgainst: 0,
+      disputesResolved: 0,
+      lastUpdated: Math.floor(Date.now() / 1e3),
+      categoryReputations: [],
+      badges: [],
+      performanceHistory: [],
+      factors: {
+        completionWeight: 25,
+        qualityWeight: 25,
+        timelinessWeight: 20,
+        satisfactionWeight: 20,
+        disputeWeight: 10
+      }
+    };
+  }
+  /**
+   * Check if agent qualifies for a specific tier
+   */
+  qualifiesForTier(score, tier) {
+    switch (tier) {
+      case "Platinum" /* Platinum */:
+        return score >= REPUTATION_CONSTANTS.PLATINUM_TIER_THRESHOLD;
+      case "Gold" /* Gold */:
+        return score >= REPUTATION_CONSTANTS.GOLD_TIER_THRESHOLD;
+      case "Silver" /* Silver */:
+        return score >= REPUTATION_CONSTANTS.SILVER_TIER_THRESHOLD;
+      case "Bronze" /* Bronze */:
+        return score >= REPUTATION_CONSTANTS.BRONZE_TIER_THRESHOLD;
+      default:
+        return true;
+    }
+  }
+  /**
+   * Calculate points needed for next tier
+   */
+  pointsToNextTier(score) {
+    const currentTier = this.getTierFromScore(score);
+    switch (currentTier) {
+      case "None" /* None */:
+        return { nextTier: "Bronze" /* Bronze */, pointsNeeded: REPUTATION_CONSTANTS.BRONZE_TIER_THRESHOLD - score };
+      case "Bronze" /* Bronze */:
+        return { nextTier: "Silver" /* Silver */, pointsNeeded: REPUTATION_CONSTANTS.SILVER_TIER_THRESHOLD - score };
+      case "Silver" /* Silver */:
+        return { nextTier: "Gold" /* Gold */, pointsNeeded: REPUTATION_CONSTANTS.GOLD_TIER_THRESHOLD - score };
+      case "Gold" /* Gold */:
+        return { nextTier: "Platinum" /* Platinum */, pointsNeeded: REPUTATION_CONSTANTS.PLATINUM_TIER_THRESHOLD - score };
+      case "Platinum" /* Platinum */:
+        return null;
+      // Already at max tier
+      default:
+        return null;
+    }
+  }
+  // =====================================================
+  // PAYAI INTEGRATION
+  // =====================================================
+  /**
+   * Record a PayAI payment event to update reputation
+   *
+   * Converts PayAI webhook data to JobPerformance format and
+   * calculates reputation change.
+   *
+   * @param record - PayAI reputation record from webhook
+   * @param currentData - Current agent reputation data (fetched from on-chain or cache)
+   * @returns Reputation calculation result
+   */
+  recordPayAIPayment(record, currentData) {
+    const jobPerformance = this.payAIRecordToJobPerformance(record);
+    return this.calculateReputationChange(currentData, jobPerformance);
+  }
+  /**
+   * Convert a PayAI reputation record to JobPerformance format
+   *
+   * PayAI provides basic payment data, so we derive quality metrics
+   * from response time and success status.
+   */
+  payAIRecordToJobPerformance(record) {
+    const qualityRating = this.estimateQualityFromResponseTime(record.responseTimeMs);
+    const expectedDuration = this.estimateExpectedDuration(record.amount);
+    return {
+      completed: record.success,
+      qualityRating,
+      expectedDuration,
+      actualDuration: Math.ceil(record.responseTimeMs / 1e3),
+      // Convert to seconds
+      clientSatisfaction: record.success ? qualityRating : 20,
+      // Lower satisfaction on failure
+      hadDispute: false,
+      // PayAI webhook doesn't include dispute info
+      disputeResolvedFavorably: false,
+      category: this.categorizeFromNetwork(record.network),
+      paymentAmount: Number(record.amount) / 1e6
+      // Convert from base units (e.g., USDC 6 decimals)
+    };
+  }
+  /**
+   * Estimate quality rating from response time
+   *
+   * Fast responses (< 500ms) = 100 quality
+   * Average responses (500ms-2s) = 70-90 quality
+   * Slow responses (2s-10s) = 40-70 quality
+   * Very slow responses (> 10s) = 20-40 quality
+   */
+  estimateQualityFromResponseTime(responseTimeMs) {
+    if (responseTimeMs <= 500) {
+      return 100;
+    } else if (responseTimeMs <= 2e3) {
+      return Math.round(90 - (responseTimeMs - 500) / 1500 * 20);
+    } else if (responseTimeMs <= 1e4) {
+      return Math.round(70 - (responseTimeMs - 2e3) / 8e3 * 30);
+    } else {
+      return Math.max(20, Math.round(40 - (responseTimeMs - 1e4) / 5e4 * 20));
+    }
+  }
+  /**
+   * Estimate expected duration based on payment amount
+   *
+   * Larger payments = longer expected processing time
+   */
+  estimateExpectedDuration(amountBaseUnits) {
+    const amountUSDC = Number(amountBaseUnits) / 1e6;
+    return Math.max(2, Math.ceil(2 + amountUSDC * 10));
+  }
+  /**
+   * Categorize payment by network
+   */
+  categorizeFromNetwork(network) {
+    switch (network) {
+      case "solana":
+        return "ai-services-solana";
+      case "base":
+        return "ai-services-base";
+      case "ethereum":
+        return "ai-services-ethereum";
+      default:
+        return "ai-services";
+    }
+  }
+  /**
+   * Create a PayAI-compatible performance snapshot
+   * Useful for tracking payment patterns
+   */
+  createPayAIPerformanceSnapshot(record, reputationResult) {
+    return {
+      timestamp: record.timestamp.getTime(),
+      paymentId: record.paymentSignature,
+      network: record.network,
+      amount: record.amount.toString(),
+      success: record.success,
+      responseTimeMs: record.responseTimeMs,
+      reputationChange: reputationResult.jobScore,
+      newScore: reputationResult.overallScore,
+      tier: reputationResult.tier
+    };
+  }
+  // =====================================================
+  // REPUTATION TAGGING METHODS
+  // =====================================================
+  /**
+   * Calculate tags for an agent based on metrics
+   *
+   * Automatically evaluates all tag criteria and assigns tags
+   * with appropriate confidence scores.
+   *
+   * @param metrics - Agent reputation metrics
+   * @returns Array of tag scores
+   */
+  async calculateTagsForAgent(metrics) {
+    return this.tagEngine.calculateTags(metrics);
+  }
+  /**
+   * Get tags by category
+   *
+   * Filters tags to only those in the specified category.
+   *
+   * @param tags - All tag scores
+   * @param category - Category to filter by
+   * @returns Filtered tag scores
+   */
+  getTagsByCategory(tags, category) {
+    return this.tagEngine.filterTags(tags, { category });
+  }
+  /**
+   * Check if agent has a specific tag
+   *
+   * @param tags - Agent's tag scores
+   * @param tagName - Tag to check for
+   * @returns Whether the tag exists
+   */
+  hasTag(tags, tagName) {
+    return tags.some((tag) => tag.tagName === tagName);
+  }
+  /**
+   * Get tag confidence score
+   *
+   * @param tags - Agent's tag scores
+   * @param tagName - Tag to check
+   * @returns Confidence score or undefined if tag doesn't exist
+   */
+  getTagConfidence(tags, tagName) {
+    const tag = tags.find((t) => t.tagName === tagName);
+    return tag?.confidence;
+  }
+  /**
+   * Filter tags by criteria
+   *
+   * @param tags - Tags to filter
+   * @param filters - Filter criteria
+   * @returns Filtered tags
+   */
+  filterTags(tags, filters) {
+    return this.tagEngine.filterTags(tags, filters);
+  }
+  /**
+   * Apply tag decay based on age
+   *
+   * Reduces confidence scores for old tags and removes stale tags.
+   *
+   * @param tags - Current tag scores
+   * @param currentTimestamp - Current Unix timestamp (optional)
+   * @returns Tags with decay applied
+   */
+  applyTagDecay(tags, currentTimestamp) {
+    return this.tagEngine.applyTagDecay(tags, currentTimestamp);
+  }
+  /**
+   * Merge new tags with existing tags
+   *
+   * Updates existing tags or adds new ones, preferring higher confidence.
+   *
+   * @param existingTags - Current tags
+   * @param newTags - New tags to merge
+   * @returns Merged tag list
+   */
+  mergeTags(existingTags, newTags) {
+    return this.tagEngine.mergeTags(existingTags, newTags);
+  }
+  /**
+   * Categorize tags by type
+   *
+   * Organizes tags into skill, behavior, and compliance categories.
+   *
+   * @param tags - Tags to categorize
+   * @returns Categorized tag result
+   */
+  categorizeTags(tags) {
+    return this.tagEngine.categorizeTags(tags);
+  }
+  /**
+   * Get top N tags by confidence
+   *
+   * @param tags - Tags to sort
+   * @param count - Number of tags to return
+   * @returns Top tags
+   */
+  getTopTags(tags, count) {
+    return this.tagEngine.getTopTags(tags, count);
+  }
+  /**
+   * Sort tags by confidence (descending)
+   *
+   * @param tags - Tags to sort
+   * @returns Sorted tags
+   */
+  sortTagsByConfidence(tags) {
+    return this.tagEngine.sortByConfidence(tags);
+  }
+  /**
+   * Sort tags by evidence count (descending)
+   *
+   * @param tags - Tags to sort
+   * @returns Sorted tags
+   */
+  sortTagsByEvidence(tags) {
+    return this.tagEngine.sortByEvidence(tags);
+  }
+  /**
+   * Sort tags by most recently updated
+   *
+   * @param tags - Tags to sort
+   * @returns Sorted tags
+   */
+  sortTagsByRecent(tags) {
+    return this.tagEngine.sortByRecent(tags);
+  }
+  /**
+   * Get confidence level description
+   *
+   * @param confidence - Confidence score (0-10000)
+   * @returns Human-readable confidence level
+   */
+  getConfidenceLevel(confidence) {
+    return this.tagEngine.getConfidenceLevel(confidence);
+  }
+  /**
+   * Validate tag name length
+   *
+   * @param tagName - Tag name to validate
+   * @returns Whether tag name is valid
+   */
+  validateTagName(tagName) {
+    return this.tagEngine.validateTagName(tagName);
+  }
+  /**
+   * Validate confidence score
+   *
+   * @param confidence - Confidence to validate
+   * @returns Whether confidence is valid (0-10000)
+   */
+  validateConfidence(confidence) {
+    return this.tagEngine.validateConfidence(confidence);
+  }
+  /**
+   * Convert on-chain ReputationMetrics to TagEngine format
+   *
+   * Helper to convert blockchain data to the format needed for tag calculation.
+   *
+   * @param onChainMetrics - Metrics from blockchain
+   * @returns Metrics in TagEngine format
+   */
+  convertMetricsForTagging(onChainMetrics) {
+    const avgResponseTime = onChainMetrics.responseTimeCount > 0n ? Number(onChainMetrics.totalResponseTime / onChainMetrics.responseTimeCount) : 0;
+    const totalPayments = onChainMetrics.successfulPayments + onChainMetrics.failedPayments;
+    const successRate = totalPayments > 0n ? Number(onChainMetrics.successfulPayments * 10000n / totalPayments) : 0;
+    const avgRating = onChainMetrics.totalRatingsCount > 0 ? Math.floor(
+      onChainMetrics.totalRating * 100 / (onChainMetrics.totalRatingsCount * 5)
+    ) : 0;
+    const disputeResolutionRate = onChainMetrics.totalDisputes > 0 ? Math.floor(onChainMetrics.disputesResolved * 1e4 / onChainMetrics.totalDisputes) : 1e4;
+    return {
+      successfulPayments: onChainMetrics.successfulPayments,
+      failedPayments: onChainMetrics.failedPayments,
+      totalResponseTime: onChainMetrics.totalResponseTime,
+      responseTimeCount: onChainMetrics.responseTimeCount,
+      totalDisputes: onChainMetrics.totalDisputes,
+      disputesResolved: onChainMetrics.disputesResolved,
+      totalRating: onChainMetrics.totalRating,
+      totalRatingsCount: onChainMetrics.totalRatingsCount,
+      createdAt: onChainMetrics.createdAt,
+      updatedAt: onChainMetrics.updatedAt,
+      avgResponseTime,
+      successRate,
+      avgRating,
+      disputeResolutionRate
+    };
+  }
+};
+
+// src/modules/staking/StakingModule.ts
+var StakingModule = class extends BaseModule {
+  /**
+   * Initialize the global staking configuration (admin only)
+   */
+  async initializeStakingConfig(params) {
+    const instruction = await getInitializeStakingConfigInstructionAsync({
+      authority: params.authority,
+      minStake: params.minStake,
+      treasury: params.treasury
+    }, { programAddress: this.programId });
+    return this.execute("initializeStakingConfig", () => instruction, [params.authority]);
+  }
+  /**
+   * Stake GHOST tokens for an agent
+   *
+   * @param params - Staking parameters
+   * @returns Transaction signature
+   */
+  async stake(params) {
+    const instruction = await getStakeGhostInstructionAsync({
+      ownerTokenAccount: params.agentTokenAccount,
+      stakingVault: params.stakingVault,
+      stakingConfig: params.stakingConfig,
+      ghostMint: params.ghostMint,
+      owner: params.agentOwner,
+      amount: params.amount,
+      lockDuration: params.lockDuration
+    }, { programAddress: this.programId });
+    return this.execute("stakeGhost", () => instruction, [params.agentOwner]);
+  }
+  /**
+   * Unstake GHOST tokens from an agent
+   *
+   * @param params - Unstaking parameters
+   * @returns Transaction signature
+   */
+  async unstake(params) {
+    const instruction = await getUnstakeGhostInstructionAsync({
+      stakingAccount: params.stakingAccount,
+      stakingVault: params.stakingVault,
+      ownerTokenAccount: params.agentTokenAccount,
+      owner: params.agentOwner
+    }, { programAddress: this.programId });
+    return this.execute("unstakeGhost", () => instruction, [params.agentOwner]);
+  }
+  /**
+   * Get staking account for an agent
+   *
+   * @param stakingAccountAddress - The staking account address
+   * @returns Staking account data or null if not found
+   */
+  async getStakingAccount(stakingAccountAddress) {
+    try {
+      return await this.getAccount(stakingAccountAddress, "getStakingAccountDecoder");
+    } catch (error) {
+      console.error("Error fetching staking account:", error);
+      return null;
+    }
+  }
+  /**
+   * Get the global staking configuration
+   *
+   * @param stakingConfigAddress - The staking config account address
+   * @returns Staking config data or null if not initialized
+   */
+  async getStakingConfig(stakingConfigAddress) {
+    try {
+      return await this.getAccount(stakingConfigAddress, "getStakingConfigDecoder");
+    } catch (error) {
+      console.error("Error fetching staking config:", error);
+      return null;
+    }
+  }
+};
+
+export { AgentModule, BaseModule, CacheManager, CredentialKind, CredentialModule, CredentialStatus, DEFAULT_IPFS_CONFIG, DidError, DidErrorClass, GovernanceModule, IPFSUtils, InstructionBuilder, MultiSourceAggregator, MultiSourceAggregator_exports, MultisigModule, PayAIClient, ReputationModule, RpcClient, ServiceEndpointType, StakingModule, VerificationMethodType, VerificationRelationship, canPerformAction, createEd25519VerificationMethod, createIPFSUtils, createMetadataUri, createPayAIClient, createServiceEndpoint, deriveDidDocumentPda, determineStorageMethod, didDocumentToJson, exportAsW3CDidDocument, extractPaymentRequirements, generateDidString, getIdentifierFromDid, getMethodsForRelationship, getNetworkFromDid, init_MultiSourceAggregator, isDidActive, isPaymentRequired, parseDidString, payAIFetch, validateDidString };
+//# sourceMappingURL=chunk-SZGFSCNU.js.map
+//# sourceMappingURL=chunk-SZGFSCNU.js.map