@ghostspeak/sdk 2.0.6 → 2.0.8

package/dist/chunk-TVVGXYCI.js

@@ -1,2887 +0,0 @@
-import { createErrorContext, logEnhancedError, IPFSClient, SYSTEM_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS, NATIVE_MINT_ADDRESS, ASSOCIATED_TOKEN_PROGRAM_ADDRESS } from './chunk-OWYHJG6H.js';
-import { getCreateEscrowInstructionAsync, getCreateEscrowWithSolInstructionAsync, getCompleteEscrowInstruction, getCancelEscrowInstruction, getDisputeEscrowInstruction, getProcessPartialRefundInstruction, getCreateEnhancedChannelInstructionAsync, getSendEnhancedMessageInstructionAsync, getJoinChannelInstruction, getLeaveChannelInstruction, getUpdateChannelSettingsInstruction, getAddMessageReactionInstruction, getCreateServiceListingInstructionAsync, getPurchaseServiceInstruction, getCreateJobPostingInstructionAsync, getApplyToJobInstructionAsync, getAcceptJobApplicationInstructionAsync, getCreateServiceAuctionInstructionAsync, getPlaceAuctionBidInstruction, getFinalizeAuctionInstruction, getUpdateAgentServiceInstruction, getInitializeGovernanceProposalInstructionAsync, getCastVoteInstruction, getDelegateVoteInstruction, getExecuteProposalInstruction, getTallyVotesInstruction, getCreateToken2022MintInstructionAsync, getInitializeConfidentialTransferMintInstructionAsync, getInitializeInterestBearingConfigInstructionAsync, getInitializeMintCloseAuthorityInstructionAsync, getInitializeDefaultAccountStateInstructionAsync, getApproveExtensionInstruction, getRegisterAgentInstructionAsync, getRegisterAgentCompressedInstructionAsync, getUpdateAgentInstruction, getVerifyAgentInstructionAsync, getDeactivateAgentInstruction, getActivateAgentInstruction } from './chunk-COGZFWOT.js';
-import { deriveChannelPda, deriveMessagePda, deriveJobPostingPda, deriveAuctionPda } from './chunk-ASQXX4IT.js';
-import { createSolanaRpc, createSolanaRpcSubscriptions, lamports, pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, setTransactionMessageFeePayer, compileTransactionMessage, getBase64EncodedWireTransaction, getProgramDerivedAddress, getAddressEncoder } from '@solana/kit';
-import { address } from '@solana/addresses';
-import { generateKeyPairSigner } from '@solana/signers';
-
-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(address2, options) {
-    return this.withRetry(async () => {
-      const result = await this.rpc.getAccountInfo(address2, {
-        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(address2, 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(address2);
-        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(address2, decoderImportName) {
-    try {
-      const accountInfo = await this.rpcClient.getAccountInfo(address2, {
-        commitment: this.config.commitment
-      });
-      if (!accountInfo) return null;
-      const generated = await import('./generated-VNLHMR6Y.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 ${address2}:`, 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-VNLHMR6Y.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-VNLHMR6Y.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
-    };
-  }
-};
-
-// src/core/BaseModule.ts
-var BaseModule = class {
-  builder;
-  config;
-  _debugMode = false;
-  constructor(config) {
-    this.config = config;
-    this.builder = new InstructionBuilder(config);
-  }
-  /**
-   * 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
-   */
-  async getAccount(address2, decoderImportName) {
-    return this.builder.getAccount(address2, decoderImportName);
-  }
-  /**
-   * Get multiple decoded accounts
-   */
-  async getAccounts(addresses, decoderImportName) {
-    return this.builder.getAccounts(addresses, decoderImportName);
-  }
-  /**
-   * 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";
-  }
-};
-
-// 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 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
-      });
-      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]
-    );
-  }
-  /**
-   * 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,
-        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
-      });
-      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(address2) {
-    return super.getAccount(address2, "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);
-  }
-  // Helper methods
-  async deriveAgentPda(agentId, owner) {
-    const { deriveAgentPdaOriginal } = await import('./pda-S4BFJVGE.js');
-    return deriveAgentPdaOriginal(this.programId, owner, agentId);
-  }
-  async deriveUserRegistryPda(owner) {
-    const { deriveUserRegistryPda } = await import('./pda-S4BFJVGE.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";
-  }
-};
-var GHOSTSPEAK_PROGRAM_ID = address("GpvFxus2eecFKcqa2bhxXeRjpstPeCEJNX216TQCcNC9");
-var NETWORK_CONFIG = {
-  devnet: {
-    programId: "GpvFxus2eecFKcqa2bhxXeRjpstPeCEJNX216TQCcNC9",
-    rpcUrl: "https://api.devnet.solana.com"
-  },
-  testnet: {
-    programId: "GpvFxus2eecFKcqa2bhxXeRjpstPeCEJNX216TQCcNC9",
-    rpcUrl: "https://api.testnet.solana.com"
-  },
-  mainnet: {
-    programId: "GpvFxus2eecFKcqa2bhxXeRjpstPeCEJNX216TQCcNC9",
-    rpcUrl: "https://api.mainnet-beta.solana.com"
-  }
-};
-var TOKEN_PROGRAM_ADDRESS = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-var NATIVE_SOL_MINT = "So11111111111111111111111111111111111111112";
-async function deriveEscrowPdaFromTaskId(programId, taskId) {
-  const encoder = new TextEncoder();
-  const [pda] = await getProgramDerivedAddress({
-    programAddress: programId,
-    seeds: [
-      new Uint8Array([101, 115, 99, 114, 111, 119]),
-      // "escrow"
-      encoder.encode(taskId)
-    ]
-  });
-  return pda;
-}
-async function deriveReentrancyGuardPda(programId) {
-  const [pda] = await getProgramDerivedAddress({
-    programAddress: programId,
-    seeds: [
-      new Uint8Array([114, 101, 101, 110, 116, 114, 97, 110, 99, 121, 95, 103, 117, 97, 114, 100])
-      // "reentrancy_guard"
-    ]
-  });
-  return pda;
-}
-async function deriveToken2022ATA(wallet, mint) {
-  const [ata] = await getProgramDerivedAddress({
-    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-    seeds: [
-      getAddressEncoder().encode(wallet),
-      getAddressEncoder().encode(TOKEN_2022_PROGRAM_ADDRESS),
-      getAddressEncoder().encode(mint)
-    ]
-  });
-  return ata;
-}
-async function deriveTokenATA(wallet, mint) {
-  const [ata] = await getProgramDerivedAddress({
-    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-    seeds: [
-      getAddressEncoder().encode(wallet),
-      getAddressEncoder().encode(TOKEN_PROGRAM_ADDRESS),
-      getAddressEncoder().encode(mint)
-    ]
-  });
-  return ata;
-}
-var EscrowModule = class extends BaseModule {
-  /**
-   * Create a new escrow
-   * @param params.paymentToken - The Token2022 mint to use (defaults to Token2022 native wSOL)
-   */
-  async create(params) {
-    const taskId = params.description;
-    const paymentToken = params.paymentToken ?? this.defaultPaymentToken;
-    const expiresAt = BigInt(Math.floor(Date.now() / 1e3) + (params.expiresInDays ?? 30) * 24 * 60 * 60);
-    const escrowAddress = await deriveEscrowPdaFromTaskId(GHOSTSPEAK_PROGRAM_ID, taskId);
-    const clientTokenAccount = await deriveToken2022ATA(params.signer.address, paymentToken);
-    const escrowTokenAccount = await deriveToken2022ATA(escrowAddress, paymentToken);
-    return this.execute(
-      "createEscrow",
-      () => getCreateEscrowInstructionAsync({
-        escrow: escrowAddress,
-        // reentrancyGuard auto-derived by generated instruction
-        client: params.signer,
-        agent: params.seller,
-        paymentToken,
-        clientTokenAccount,
-        escrowTokenAccount,
-        taskId,
-        amount: params.amount,
-        expiresAt,
-        transferHook: null,
-        isConfidential: false
-      }),
-      [params.signer]
-    );
-  }
-  /**
-   * Create an escrow with native SOL (auto-wraps to wSOL)
-   * This is the easiest way to create an escrow - just send SOL!
-   */
-  async createWithSol(params) {
-    const taskId = params.description;
-    const expiresAt = BigInt(Math.floor(Date.now() / 1e3) + (params.expiresInDays ?? 30) * 24 * 60 * 60);
-    const escrowAddress = await deriveEscrowPdaFromTaskId(GHOSTSPEAK_PROGRAM_ID, taskId);
-    const clientWsolAccount = await deriveTokenATA(params.signer.address, NATIVE_SOL_MINT);
-    const escrowWsolAccount = await deriveTokenATA(escrowAddress, NATIVE_SOL_MINT);
-    return this.execute(
-      "createEscrowWithSol",
-      () => getCreateEscrowWithSolInstructionAsync({
-        escrow: escrowAddress,
-        client: params.signer,
-        agent: params.seller,
-        clientWsolAccount,
-        escrowWsolAccount,
-        taskId,
-        amount: params.amount,
-        expiresAt,
-        transferHook: null,
-        isConfidential: false
-      }),
-      [params.signer]
-    );
-  }
-  /**
-   * Complete an escrow - releases funds to the agent
-   * @param taskId - The original task description used to derive the escrow PDA
-   */
-  async complete(signer, taskId, paymentToken) {
-    const mint = paymentToken ?? this.defaultPaymentToken;
-    const escrowAddress = await deriveEscrowPdaFromTaskId(GHOSTSPEAK_PROGRAM_ID, taskId);
-    const reentrancyGuard = await deriveReentrancyGuardPda(GHOSTSPEAK_PROGRAM_ID);
-    const escrowTokenAccount = await deriveToken2022ATA(escrowAddress, mint);
-    const agentTokenAccount = await deriveToken2022ATA(signer.address, mint);
-    return this.execute(
-      "completeEscrow",
-      () => getCompleteEscrowInstruction({
-        escrow: escrowAddress,
-        reentrancyGuard,
-        agent: signer.address,
-        escrowTokenAccount,
-        agentTokenAccount,
-        authority: signer,
-        tokenProgram: TOKEN_2022_PROGRAM_ADDRESS,
-        resolutionNotes: "Work completed successfully"
-      }),
-      [signer]
-    );
-  }
-  /**
-   * Cancel an escrow - refunds the client
-   */
-  async cancel(signer, taskId, params) {
-    const mint = params.paymentToken ?? this.defaultPaymentToken;
-    const escrowAddress = await deriveEscrowPdaFromTaskId(GHOSTSPEAK_PROGRAM_ID, taskId);
-    const reentrancyGuard = await deriveReentrancyGuardPda(GHOSTSPEAK_PROGRAM_ID);
-    const escrowTokenAccount = await deriveToken2022ATA(escrowAddress, mint);
-    const clientRefundAccount = await deriveToken2022ATA(params.buyer, mint);
-    return this.execute(
-      "cancelEscrow",
-      () => getCancelEscrowInstruction({
-        escrow: escrowAddress,
-        reentrancyGuard,
-        authority: signer,
-        clientRefundAccount,
-        paymentToken: mint,
-        cancellationReason: params.reason ?? "User cancelled",
-        escrowTokenAccount,
-        tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
-      }),
-      [signer]
-    );
-  }
-  /**
-   * Dispute an escrow
-   */
-  async dispute(signer, taskId, reason) {
-    const escrowAddress = await deriveEscrowPdaFromTaskId(GHOSTSPEAK_PROGRAM_ID, taskId);
-    const reentrancyGuard = await deriveReentrancyGuardPda(GHOSTSPEAK_PROGRAM_ID);
-    return this.execute(
-      "disputeEscrow",
-      () => getDisputeEscrowInstruction({
-        escrow: escrowAddress,
-        reentrancyGuard,
-        authority: signer,
-        disputeReason: reason
-      }),
-      [signer]
-    );
-  }
-  /**
-   * Process partial refund
-   */
-  async processPartialRefund(signer, taskId, refundAmount, totalAmount, clientAddress, agentAddress, paymentToken) {
-    const mint = paymentToken ?? this.defaultPaymentToken;
-    const escrowAddress = await deriveEscrowPdaFromTaskId(GHOSTSPEAK_PROGRAM_ID, taskId);
-    const reentrancyGuard = await deriveReentrancyGuardPda(GHOSTSPEAK_PROGRAM_ID);
-    const escrowTokenAccount = await deriveToken2022ATA(escrowAddress, mint);
-    const clientRefundAccount = await deriveToken2022ATA(clientAddress, mint);
-    const agentPaymentAccount = await deriveToken2022ATA(agentAddress, mint);
-    return this.execute(
-      "processPartialRefund",
-      () => getProcessPartialRefundInstruction({
-        escrow: escrowAddress,
-        reentrancyGuard,
-        escrowTokenAccount,
-        clientRefundAccount,
-        agentPaymentAccount,
-        paymentToken: mint,
-        authority: signer,
-        tokenProgram: TOKEN_2022_PROGRAM_ADDRESS,
-        clientRefundPercentage: Math.min(100, Math.max(0, Number((refundAmount * BigInt(100) / totalAmount).toString())))
-      }),
-      [signer]
-    );
-  }
-  /**
-   * Get escrow account
-   */
-  async getEscrowAccount(address2) {
-    return super.getAccount(address2, "getEscrowDecoder");
-  }
-  /**
-   * Get escrow by taskId
-   */
-  async getEscrowByTaskId(taskId) {
-    const address2 = await deriveEscrowPdaFromTaskId(GHOSTSPEAK_PROGRAM_ID, taskId);
-    return this.getEscrowAccount(address2);
-  }
-  /**
-   * Get all escrows
-   */
-  async getAllEscrows() {
-    return this.getProgramAccounts("getEscrowDecoder");
-  }
-  /**
-   * Get escrows by buyer
-   */
-  async getEscrowsByBuyer(buyer) {
-    const filters = [{
-      memcmp: {
-        offset: BigInt(8),
-        // Skip discriminator
-        bytes: buyer,
-        encoding: "base58"
-      }
-    }];
-    return this.getProgramAccounts("getEscrowDecoder", filters);
-  }
-  /**
-   * Get escrows by seller
-   */
-  async getEscrowsBySeller(seller) {
-    const filters = [{
-      memcmp: {
-        offset: BigInt(40),
-        // Skip discriminator + buyer
-        bytes: seller,
-        encoding: "base58"
-      }
-    }];
-    return this.getProgramAccounts("getEscrowDecoder", filters);
-  }
-  /**
-   * Get escrows by status
-   */
-  async getEscrowsByStatus(status) {
-    const escrows = await this.getAllEscrows();
-    return escrows.filter(({ data }) => data.status === status);
-  }
-  // Helper methods
-  /**
-   * Default payment token - Token2022 native wSOL equivalent
-   */
-  get defaultPaymentToken() {
-    return NATIVE_MINT_ADDRESS;
-  }
-};
-
-// src/modules/channels/ChannelModule.ts
-var ChannelModule = class extends BaseModule {
-  /**
-   * Create a new channel
-   */
-  async create(params) {
-    const channelAddress = await this.deriveChannelPda(params.name);
-    return this.execute(
-      "createEnhancedChannel",
-      () => getCreateEnhancedChannelInstructionAsync({
-        channel: channelAddress,
-        reentrancyGuard: this.systemProgramId,
-        creator: params.signer,
-        creatorAgent: params.signer.address,
-        systemProgram: this.systemProgramId,
-        channelId: params.name,
-        participants: [params.signer.address],
-        channelType: params.channelType,
-        metadata: {
-          name: params.name,
-          description: params.description,
-          avatarUrl: null,
-          tags: [],
-          settings: {
-            allowFileSharing: true,
-            allowExternalInvites: !params.isPrivate,
-            messageRetentionDays: 30,
-            maxMessageSize: 4096,
-            requireEncryption: params.isPrivate ?? false,
-            autoArchiveAfterDays: 365
-          }
-        }
-      }),
-      [params.signer]
-    );
-  }
-  /**
-   * Send a message to a channel
-   */
-  async sendMessage(params) {
-    const messageAddress = await this.deriveMessagePda(params.channelAddress, Date.now());
-    return this.execute(
-      "sendEnhancedMessage",
-      () => getSendEnhancedMessageInstructionAsync({
-        channel: params.channelAddress,
-        message: messageAddress,
-        reentrancyGuard: this.systemProgramId,
-        sender: params.signer,
-        systemProgram: this.systemProgramId,
-        messageId: `msg_${Date.now()}`,
-        content: params.content,
-        messageType: params.messageType ?? 0 /* Text */,
-        metadata: {
-          replyTo: params.replyTo ?? null,
-          threadId: null,
-          attachments: params.attachmentUri ? [{ fileType: "application/octet-stream", fileSize: 0, fileHash: "", storageUrl: params.attachmentUri }] : [],
-          mentions: [],
-          reactions: []
-        },
-        isEncrypted: false
-      }),
-      [params.signer]
-    );
-  }
-  /**
-   * Join a channel
-   */
-  async join(signer, channelAddress) {
-    return this.execute(
-      "joinChannel",
-      () => getJoinChannelInstruction({
-        channel: channelAddress,
-        reentrancyGuard: this.systemProgramId,
-        user: signer,
-        userAgent: signer.address
-      }),
-      [signer]
-    );
-  }
-  /**
-   * Leave a channel
-   */
-  async leave(signer, channelAddress) {
-    return this.execute(
-      "leaveChannel",
-      () => getLeaveChannelInstruction({
-        channel: channelAddress,
-        reentrancyGuard: this.systemProgramId,
-        user: signer
-      }),
-      [signer]
-    );
-  }
-  /**
-   * Update channel settings
-   */
-  async updateSettings(signer, channelAddress, settings) {
-    return this.execute(
-      "updateChannelSettings",
-      () => getUpdateChannelSettingsInstruction({
-        channel: channelAddress,
-        reentrancyGuard: this.systemProgramId,
-        authority: signer,
-        newMetadata: {
-          name: settings.name ?? null,
-          description: settings.description ?? null,
-          avatarUrl: null,
-          tags: [],
-          settings: {
-            allowFileSharing: true,
-            allowExternalInvites: !settings.isPrivate,
-            messageRetentionDays: 30,
-            maxMessageSize: settings.maxMembers ? Number(settings.maxMembers) : 4096,
-            requireEncryption: settings.isPrivate ?? false,
-            autoArchiveAfterDays: 365
-          }
-        }
-      }),
-      [signer]
-    );
-  }
-  /**
-   * Add reaction to a message
-   */
-  async addReaction(signer, messageAddress, emoji) {
-    const channelAddress = await this.deriveChannelFromMessage(messageAddress);
-    return this.execute(
-      "addMessageReaction",
-      () => getAddMessageReactionInstruction({
-        channel: channelAddress,
-        message: messageAddress,
-        reentrancyGuard: this.systemProgramId,
-        user: signer,
-        reaction: emoji
-      }),
-      [signer]
-    );
-  }
-  /**
-   * Get channel account
-   */
-  async getChannelAccount(address2) {
-    return super.getAccount(address2, "getChannelDecoder");
-  }
-  /**
-   * Get message account
-   */
-  async getMessageAccount(address2) {
-    return super.getAccount(address2, "getMessageDecoder");
-  }
-  /**
-   * Get all channels
-   */
-  async getAllChannels() {
-    return this.getProgramAccounts("getChannelDecoder");
-  }
-  /**
-   * Get public channels
-   */
-  async getPublicChannels() {
-    const channels = await this.getAllChannels();
-    return channels.filter(({ data }) => !data.isPrivate);
-  }
-  /**
-   * Get channels by creator
-   */
-  async getChannelsByCreator(creator) {
-    const filters = [{
-      memcmp: {
-        offset: BigInt(8),
-        // Skip discriminator
-        bytes: creator,
-        encoding: "base58"
-      }
-    }];
-    return this.getProgramAccounts("getChannelDecoder", filters);
-  }
-  /**
-   * Get messages in channel
-   */
-  async getChannelMessages(channelAddress) {
-    const filters = [{
-      memcmp: {
-        offset: BigInt(8),
-        // Skip discriminator
-        bytes: channelAddress,
-        encoding: "base58"
-      }
-    }];
-    return this.getProgramAccounts("getMessageDecoder", filters);
-  }
-  // Helper methods
-  async deriveChannelPda(name) {
-    return await deriveChannelPda(GHOSTSPEAK_PROGRAM_ID, name);
-  }
-  async deriveMessagePda(channel, nonce) {
-    return await deriveMessagePda(GHOSTSPEAK_PROGRAM_ID, channel, nonce);
-  }
-  async deriveChannelFromMessage(messageAddress) {
-    return messageAddress;
-  }
-  get systemProgramId() {
-    return "11111111111111111111111111111111";
-  }
-};
-
-// src/modules/marketplace/MarketplaceModule.ts
-var MarketplaceModule = class extends BaseModule {
-  // =====================================================
-  // DIRECT INSTRUCTION ACCESS
-  // These methods provide direct access to generated instructions
-  // with minimal wrapping for maximum flexibility
-  // =====================================================
-  /**
-   * Get create service listing instruction
-   */
-  getCreateServiceListingInstruction(params) {
-    return getCreateServiceListingInstructionAsync(params);
-  }
-  /**
-   * Get purchase service instruction
-   */
-  getPurchaseServiceInstruction(params) {
-    return getPurchaseServiceInstruction(params);
-  }
-  /**
-   * Get create job posting instruction
-   */
-  getCreateJobPostingInstruction(params) {
-    return getCreateJobPostingInstructionAsync(params);
-  }
-  /**
-   * Get apply to job instruction
-   */
-  getApplyToJobInstruction(params) {
-    return getApplyToJobInstructionAsync(params);
-  }
-  /**
-   * Get accept job application instruction
-   */
-  getAcceptJobApplicationInstruction(params) {
-    return getAcceptJobApplicationInstructionAsync(params);
-  }
-  /**
-   * Get create service auction instruction
-   */
-  getCreateServiceAuctionInstruction(params) {
-    return getCreateServiceAuctionInstructionAsync(params);
-  }
-  /**
-   * Get place auction bid instruction
-   */
-  getPlaceAuctionBidInstruction(params) {
-    return getPlaceAuctionBidInstruction(params);
-  }
-  /**
-   * Get finalize auction instruction
-   */
-  getFinalizeAuctionInstruction(params) {
-    return getFinalizeAuctionInstruction(params);
-  }
-  /**
-   * Get update agent service instruction
-   */
-  getUpdateAgentServiceInstruction(params) {
-    return getUpdateAgentServiceInstruction(params);
-  }
-  // =====================================================
-  // CONVENIENCE METHODS
-  // These methods provide simplified access to common operations
-  // =====================================================
-  /**
-   * Execute create service listing with convenience wrapper
-   */
-  async createServiceListing(params) {
-    const instruction = await this.getCreateServiceListingInstruction({
-      agent: params.agentAddress,
-      creator: params.signer,
-      title: params.title,
-      description: params.description,
-      price: params.pricePerHour,
-      tokenMint: this.nativeMint,
-      serviceType: params.category,
-      paymentToken: this.nativeMint,
-      estimatedDelivery: Date.now() + 7 * 24 * 60 * 60 * 1e3,
-      // 7 days
-      tags: params.capabilities,
-      listingId: `${params.agentAddress}_${params.title}`
-    });
-    return this.execute("createServiceListing", () => instruction, [params.signer]);
-  }
-  /**
-   * Execute create job posting with convenience wrapper
-   */
-  async createJobPosting(params) {
-    const jobPostingAddress = await this.deriveJobPostingPda(params.signer.address, params.title);
-    const instruction = await this.getCreateJobPostingInstruction({
-      jobPosting: jobPostingAddress,
-      employer: params.signer,
-      title: params.title,
-      description: params.description,
-      requirements: [`Skills: ${params.requiredSkills.join(", ")}`],
-      budget: params.budget,
-      deadline: Date.now() + params.duration * 60 * 60 * 1e3,
-      skillsNeeded: params.requiredSkills,
-      budgetMin: params.budget,
-      budgetMax: params.budget,
-      paymentToken: this.nativeMint,
-      jobType: params.category,
-      experienceLevel: "intermediate"
-    });
-    return this.execute("createJobPosting", () => instruction, [params.signer]);
-  }
-  /**
-   * Execute create service auction with convenience wrapper
-   */
-  async createServiceAuction(params) {
-    const auctionAddress = await this.deriveAuctionPda(params.serviceListingAddress);
-    const instruction = await this.getCreateServiceAuctionInstruction({
-      auction: auctionAddress,
-      agent: params.serviceListingAddress,
-      // Placeholder mapping
-      userRegistry: auctionAddress,
-      // Placeholder mapping  
-      creator: params.signer,
-      auctionType: params.auctionType === "english" ? 0 /* English */ : 1 /* Dutch */,
-      startingPrice: params.startingPrice,
-      reservePrice: params.reservePrice,
-      isReserveHidden: false,
-      currentBid: BigInt(0),
-      currentBidder: null,
-      auctionEndTime: BigInt(Date.now() + params.duration * 60 * 60 * 1e3),
-      minimumBidIncrement: BigInt(1e3),
-      totalBids: 0,
-      dutchConfig: null
-    });
-    return this.execute("createServiceAuction", () => instruction, [params.signer]);
-  }
-  // =====================================================
-  // QUERY OPERATIONS
-  // =====================================================
-  /**
-   * Get service listing account
-   */
-  async getServiceListing(address2) {
-    return super.getAccount(address2, "getServiceListingDecoder");
-  }
-  /**
-   * Get job posting account
-   */
-  async getJobPosting(address2) {
-    return super.getAccount(address2, "getJobPostingDecoder");
-  }
-  /**
-   * Get job application account
-   */
-  async getJobApplication(address2) {
-    return super.getAccount(address2, "getJobApplicationDecoder");
-  }
-  /**
-   * Get auction account
-   */
-  async getAuction(address2) {
-    return super.getAccount(address2, "getAuctionMarketplaceDecoder");
-  }
-  /**
-   * Get service purchase account
-   */
-  async getServicePurchase(address2) {
-    return super.getAccount(address2, "getServicePurchaseDecoder");
-  }
-  /**
-   * Get all service listings
-   */
-  async getAllServiceListings() {
-    return this.getProgramAccounts("getServiceListingDecoder");
-  }
-  /**
-   * Get service listings by provider
-   */
-  async getServiceListingsByProvider(provider) {
-    const filters = [{
-      memcmp: {
-        offset: BigInt(8),
-        // Skip discriminator
-        bytes: provider,
-        encoding: "base58"
-      }
-    }];
-    return this.getProgramAccounts("getServiceListingDecoder", filters);
-  }
-  /**
-   * Get all job postings
-   */
-  async getAllJobPostings() {
-    return this.getProgramAccounts("getJobPostingDecoder");
-  }
-  /**
-   * Get job postings by client
-   */
-  async getJobPostingsByClient(client) {
-    const filters = [{
-      memcmp: {
-        offset: BigInt(8),
-        // Skip discriminator
-        bytes: client,
-        encoding: "base58"
-      }
-    }];
-    return this.getProgramAccounts("getJobPostingDecoder", filters);
-  }
-  /**
-   * Get applications for a job posting
-   */
-  async getJobApplications(jobPostingAddress) {
-    const filters = [{
-      memcmp: {
-        offset: BigInt(8),
-        // Skip discriminator
-        bytes: jobPostingAddress,
-        encoding: "base58"
-      }
-    }];
-    return this.getProgramAccounts("getJobApplicationDecoder", filters);
-  }
-  /**
-   * Get all auctions
-   */
-  async getAllAuctions() {
-    return this.getProgramAccounts("getAuctionMarketplaceDecoder");
-  }
-  /**
-   * Get service listing by ID (alias for getServiceListing)
-   */
-  async getServiceById(address2) {
-    return this.getServiceListing(address2);
-  }
-  /**
-   * Execute purchase service with convenience wrapper
-   */
-  async purchase(signer, params) {
-    const serviceListing = params.listingId.split("_")[0];
-    const servicePurchase = params.listingId.split("_")[0];
-    const instruction = this.getPurchaseServiceInstruction({
-      serviceListing,
-      servicePurchase,
-      buyer: signer,
-      listingId: 0,
-      // Placeholder - would be parsed from params
-      quantity: Number(params.amount),
-      requirements: [],
-      customInstructions: "",
-      deadline: Date.now() + 7 * 24 * 60 * 60 * 1e3
-    });
-    return this.execute("purchaseService", () => instruction, [signer]);
-  }
-  // =====================================================
-  // HELPER METHODS
-  // =====================================================
-  async deriveJobPostingPda(client, title) {
-    return await deriveJobPostingPda(GHOSTSPEAK_PROGRAM_ID, client, title);
-  }
-  async deriveAuctionPda(serviceListing) {
-    return await deriveAuctionPda(GHOSTSPEAK_PROGRAM_ID, serviceListing);
-  }
-  get nativeMint() {
-    return NATIVE_MINT_ADDRESS;
-  }
-};
-
-// 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);
-  }
-  /**
-   * Get cast vote instruction
-   */
-  getCastVoteInstruction(params) {
-    return getCastVoteInstruction(params);
-  }
-  /**
-   * Get delegate vote instruction
-   */
-  getDelegateVoteInstruction(params) {
-    return getDelegateVoteInstruction(params);
-  }
-  /**
-   * Get execute proposal instruction
-   */
-  getExecuteProposalInstruction(params) {
-    return getExecuteProposalInstruction(params);
-  }
-  /**
-   * Get tally votes instruction
-   */
-  getTallyVotesInstruction(params) {
-    return getTallyVotesInstruction(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]);
-  }
-  /**
-   * Cast a vote on a proposal
-   */
-  async vote(params) {
-    const voteChoice = this.mapVoteChoice(params.choice);
-    const instruction = this.getCastVoteInstruction({
-      proposal: params.proposalAddress,
-      voter: params.signer,
-      voterTokenAccount: params.tokenAccount,
-      voteChoice,
-      reasoning: params.reasoning ?? null
-    });
-    return this.execute("castVote", () => instruction, [params.signer]);
-  }
-  /**
-   * Delegate voting power to another address
-   */
-  async delegateVotingPower(params) {
-    const instruction = this.getDelegateVoteInstruction({
-      delegator: params.signer,
-      delegate: params.delegate,
-      delegatorTokenAccount: params.tokenAccount,
-      proposalId: BigInt(0),
-      // 0 for all proposals
-      scope: { kind: "All", value: void 0 },
-      // Delegate for all proposals
-      expiresAt: null
-    });
-    return this.execute("delegateVote", () => instruction, [params.signer]);
-  }
-  /**
-   * Execute a passed proposal
-   */
-  async executeProposal(params) {
-    const instruction = this.getExecuteProposalInstruction({
-      proposal: params.proposalAddress,
-      executor: params.signer,
-      targetProgram: this.getProgramId()
-    });
-    return this.execute("executeProposal", () => instruction, [params.signer]);
-  }
-  /**
-   * Tally votes for a proposal
-   */
-  async tallyVotes(params) {
-    const instruction = this.getTallyVotesInstruction({
-      proposal: params.proposalAddress,
-      authority: params.signer
-    });
-    return this.execute("tallyVotes", () => instruction, [params.signer]);
-  }
-  // =====================================================
-  // QUERY OPERATIONS
-  // =====================================================
-  /**
-   * Get governance proposal account
-   */
-  async getProposal(address2) {
-    return super.getAccount(address2, "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}`;
-  }
-  mapVoteChoice(choice) {
-    switch (choice) {
-      case "yes":
-        return 0 /* For */;
-      case "no":
-        return 1 /* Against */;
-      case "abstain":
-        return 2 /* Abstain */;
-      default:
-        throw new Error(`Invalid vote choice: ${choice}`);
-    }
-  }
-};
-var Token2022Module = class extends BaseModule {
-  // =====================================================
-  // DIRECT INSTRUCTION ACCESS
-  // These methods provide direct access to generated instructions
-  // with minimal wrapping for maximum flexibility
-  // =====================================================
-  /**
-   * Get create Token-2022 mint instruction
-   */
-  getCreateToken2022MintInstruction(params) {
-    return getCreateToken2022MintInstructionAsync({
-      ...params,
-      // Ensure defaults for optional fields if passed as undefined
-      transferFeeBasisPoints: params.transferFeeBasisPoints ?? null,
-      maximumFee: params.maximumFee ?? null,
-      transferFeeAuthority: params.transferFeeAuthority ?? null,
-      withdrawWithheldAuthority: params.withdrawWithheldAuthority ?? null,
-      autoApproveNewAccounts: params.autoApproveNewAccounts ?? null,
-      auditorElgamalPubkey: params.auditorElgamalPubkey ?? null,
-      interestRate: params.interestRate ?? null,
-      rateAuthority: params.rateAuthority ?? null,
-      closeAuthority: params.closeAuthority ?? null,
-      defaultAccountState: params.defaultAccountState ?? null
-    });
-  }
-  /**
-   * Get initialize confidential transfer mint instruction
-   */
-  getInitializeConfidentialTransferMintInstruction(params) {
-    return getInitializeConfidentialTransferMintInstructionAsync(params);
-  }
-  /**
-   * Get initialize interest bearing config instruction
-   */
-  getInitializeInterestBearingConfigInstruction(params) {
-    return getInitializeInterestBearingConfigInstructionAsync(params);
-  }
-  /**
-   * Get initialize mint close authority instruction
-   */
-  getInitializeMintCloseAuthorityInstruction(params) {
-    return getInitializeMintCloseAuthorityInstructionAsync(params);
-  }
-  /**
-   * Get initialize default account state instruction
-   */
-  getInitializeDefaultAccountStateInstruction(params) {
-    return getInitializeDefaultAccountStateInstructionAsync(params);
-  }
-  /**
-   * Get approve extension instruction
-   */
-  getApproveExtensionInstruction(params) {
-    return getApproveExtensionInstruction(params);
-  }
-  // =====================================================
-  // CONVENIENCE METHODS
-  // These methods provide simplified access to common operations
-  // =====================================================
-  /**
-   * Create a basic Token-2022 mint
-   */
-  async createMint(params) {
-    const mintKeypair = await this.generateKeypair();
-    const instruction = await this.getCreateToken2022MintInstruction({
-      authority: params.signer,
-      agent: params.agentAddress,
-      mint: mintKeypair,
-      decimals: params.decimals,
-      freezeAuthority: params.freezeAuthority ?? null,
-      enableTransferFee: false,
-      enableConfidentialTransfers: false,
-      enableInterestBearing: false
-    });
-    return this.execute("createToken2022Mint", () => instruction, [params.signer, mintKeypair]);
-  }
-  async createMintWithTransferFees(params) {
-    const mintKeypair = await this.generateKeypair();
-    const mintInstruction = await this.getCreateToken2022MintInstruction({
-      authority: params.signer,
-      agent: params.agentAddress,
-      mint: mintKeypair,
-      decimals: params.decimals,
-      freezeAuthority: null,
-      enableTransferFee: true,
-      enableConfidentialTransfers: false,
-      enableInterestBearing: false,
-      // Transfer fee extension params
-      transferFeeBasisPoints: params.transferFeeBasisPoints,
-      maximumFee: params.maxFee,
-      transferFeeAuthority: params.signer.address,
-      withdrawWithheldAuthority: params.withdrawWithheldAuthority ?? null
-    });
-    return this.execute("createMintWithFees", () => mintInstruction, [params.signer, mintKeypair]);
-  }
-  async createMintWithConfidentialTransfers(params) {
-    const mintKeypair = await this.generateKeypair();
-    const mintInstruction = await this.getCreateToken2022MintInstruction({
-      authority: params.signer,
-      agent: params.agentAddress,
-      mint: mintKeypair,
-      decimals: params.decimals,
-      freezeAuthority: null,
-      enableConfidentialTransfers: true,
-      enableTransferFee: false,
-      enableInterestBearing: false,
-      // Confidential transfer params
-      auditorElgamalPubkey: params.auditorElgamalPubkey ?? null,
-      autoApproveNewAccounts: params.autoApproveNewAccounts ?? false
-    });
-    return this.execute("createMintWithConfidential", () => mintInstruction, [params.signer, mintKeypair]);
-  }
-  async createMintWithInterestBearing(params) {
-    const mintKeypair = await this.generateKeypair();
-    const mintInstruction = await this.getCreateToken2022MintInstruction({
-      authority: params.signer,
-      agent: params.agentAddress,
-      mint: mintKeypair,
-      decimals: params.decimals,
-      freezeAuthority: null,
-      enableConfidentialTransfers: false,
-      enableTransferFee: false,
-      enableInterestBearing: true,
-      // Interest bearing params
-      interestRate: params.interestRate,
-      rateAuthority: params.rateAuthority ?? params.signer.address
-    });
-    return this.execute("createMintWithInterest", () => mintInstruction, [params.signer, mintKeypair]);
-  }
-  /**
-   * Create a full-featured Token-2022 mint with all extensions
-   */
-  async createAdvancedMint(params) {
-    const mintKeypair = await this.generateKeypair();
-    const instructions = [];
-    instructions.push(async () => this.getCreateToken2022MintInstruction({
-      authority: params.signer,
-      agent: params.agentAddress,
-      mint: mintKeypair,
-      decimals: params.decimals,
-      freezeAuthority: params.signer.address,
-      enableConfidentialTransfers: true,
-      enableTransferFee: true,
-      enableInterestBearing: true,
-      // Transfer fee params
-      transferFeeBasisPoints: params.transferFeeBasisPoints,
-      maximumFee: params.maxFee,
-      transferFeeAuthority: params.signer.address,
-      withdrawWithheldAuthority: params.signer.address,
-      // Confidential transfer params
-      auditorElgamalPubkey: null,
-      autoApproveNewAccounts: params.autoApproveConfidential ?? false,
-      // Interest bearing params
-      interestRate: params.interestRate,
-      rateAuthority: params.signer.address
-    }));
-    if (params.defaultAccountState) {
-      instructions.push(async () => this.getInitializeDefaultAccountStateInstruction({
-        mint: mintKeypair.address,
-        authority: params.signer,
-        state: params.defaultAccountState
-      }));
-    }
-    return this.executeMultiple("createAdvancedMint", instructions, [params.signer, mintKeypair]);
-  }
-  // =====================================================
-  // QUERY OPERATIONS
-  // =====================================================
-  /**
-   * Get Token-2022 mint account
-   */
-  async getMint(address2) {
-    return super.getAccount(address2, "getMintDecoder");
-  }
-  /**
-   * Get all Token-2022 mints created by this program
-   */
-  async getAllMints() {
-    return this.getProgramAccounts("getMintDecoder");
-  }
-  /**
-   * Get mints by authority
-   */
-  async getMintsByAuthority(authority) {
-    const filters = [{
-      memcmp: {
-        offset: BigInt(8),
-        // Skip discriminator
-        bytes: authority,
-        encoding: "base58"
-      }
-    }];
-    return this.getProgramAccounts("getMintDecoder", filters);
-  }
-  // =====================================================
-  // HELPER METHODS
-  // =====================================================
-  async generateKeypair() {
-    return generateKeyPairSigner();
-  }
-  async executeMultiple(operation, instructionFactories, signers) {
-    if (instructionFactories.length === 0) {
-      throw new Error("No instruction factories provided");
-    }
-    const instructions = [];
-    for (const factory of instructionFactories) {
-      try {
-        const instruction = await factory();
-        instructions.push(instruction);
-      } catch (error) {
-        throw new Error(`Failed to create instruction: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-    }
-    const firstInstruction = instructions[0];
-    if (!firstInstruction) {
-      throw new Error("First instruction is undefined");
-    }
-    return this.execute(operation, () => firstInstruction, signers);
-  }
-};
-
-export { AgentModule, BaseModule, ChannelModule, DEFAULT_IPFS_CONFIG, EscrowModule, GHOSTSPEAK_PROGRAM_ID, GovernanceModule, IPFSUtils, InstructionBuilder, MarketplaceModule, NETWORK_CONFIG, RpcClient, Token2022Module, createIPFSUtils, createMetadataUri, determineStorageMethod };
-//# sourceMappingURL=chunk-TVVGXYCI.js.map
-//# sourceMappingURL=chunk-TVVGXYCI.js.map