@ghostspeak/sdk 2.0.7 → 2.0.8

package/dist/{chunk-SZGFSCNU.js → chunk-JYXSOXCP.js}

@@ -1,11 +1,11 @@
-import { init_reputation_tag_engine, createErrorContext, logEnhancedError, IPFSClient, SYSTEM_PROGRAM_ADDRESS, ReputationCalculator, ReputationTagEngine, REPUTATION_CONSTANTS } from './chunk-C5CDA3WX.js';
-import { getInitializeGovernanceProposalInstructionAsync, getInitializeStakingConfigInstructionAsync, getStakeGhostInstructionAsync, getUnstakeGhostInstructionAsync, getRegisterAgentInstructionAsync, getRegisterAgentCompressedInstructionAsync, getUpdateAgentInstruction, getVerifyAgentInstructionAsync, getDeactivateAgentInstruction, getActivateAgentInstruction } from './chunk-S74EH3KD.js';
+import { init_reputation_tag_engine, createErrorContext, logEnhancedError, IPFSClient, SYSTEM_PROGRAM_ADDRESS, ReputationCalculator, ReputationTagEngine, REPUTATION_CONSTANTS } from './chunk-OXA7MECJ.js';
+import { getInitializeGovernanceProposalInstructionAsync, getInitializeStakingConfigInstructionAsync, getStakeGhostInstructionAsync, getUnstakeGhostInstructionAsync, getRegisterAgentInstructionAsync, getRegisterAgentCompressedInstructionAsync, getUpdateAgentInstruction, getVerifyAgentInstructionAsync, getDeactivateAgentInstruction, getActivateAgentInstruction, getClaimGhostInstruction } from './chunk-IQM5RASO.js';
 import { __export, __esm } from './chunk-UP2VWCW5.js';
-import { createSolanaRpc, createSolanaRpcSubscriptions, lamports, pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, setTransactionMessageFeePayer, compileTransactionMessage, getBase64EncodedWireTransaction, getProgramDerivedAddress, getAddressEncoder } from '@solana/kit';
+import { createSolanaRpc, createSolanaRpcSubscriptions, lamports, pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, setTransactionMessageFeePayer, compileTransactionMessage, getBase64EncodedWireTransaction, getProgramDerivedAddress, getUtf8Encoder, getAddressEncoder } from '@solana/kit';
 import { LRUCache } from 'lru-cache';
+import { address } from '@solana/addresses';
 import bs58 from 'bs58';
 import { sha256 } from '@noble/hashes/sha256';
-import { EventEmitter } from 'events';
 
 // src/modules/reputation/MultiSourceAggregator.ts
 var MultiSourceAggregator_exports = {};
@@ -282,9 +282,9 @@ var RpcClient = class {
   /**
    * Get account information with automatic retries
    */
-  async getAccountInfo(address, options) {
+  async getAccountInfo(address2, options) {
     return this.withRetry(async () => {
-      const result = await this.rpc.getAccountInfo(address, {
+      const result = await this.rpc.getAccountInfo(address2, {
         commitment: options?.commitment ?? this.commitment,
         encoding: "base64"
       }).send();
@@ -429,14 +429,14 @@ var RpcClient = class {
    * Subscribe to account changes (WebSocket) 
    * Note: This is a placeholder implementation. In production, you would use the actual subscription API
    */
-  async subscribeToAccount(address, callback) {
+  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(address);
+        const accountInfo = await this.getAccountInfo(address2);
         callback(accountInfo);
       } catch (error) {
         console.error("Subscription polling error:", error);
@@ -946,19 +946,19 @@ var InstructionBuilder = class {
   /**
    * Get and decode account data with unified error handling
    */
-  async getAccount(address, decoderImportName) {
+  async getAccount(address2, decoderImportName) {
     try {
-      const accountInfo = await this.rpcClient.getAccountInfo(address, {
+      const accountInfo = await this.rpcClient.getAccountInfo(address2, {
         commitment: this.config.commitment
       });
       if (!accountInfo) return null;
-      const generated = await import('./generated-EG5USUFG.js');
+      const generated = await import('./generated-QJREJQ2C.js');
       const decoderGetter = generated[decoderImportName];
       const decoder = decoderGetter();
       const rawData = this.extractRawData(accountInfo.data);
       return decoder.decode(rawData);
     } catch (error) {
-      console.warn(`Failed to fetch account ${address}:`, error);
+      console.warn(`Failed to fetch account ${address2}:`, error);
       return null;
     }
   }
@@ -970,7 +970,7 @@ var InstructionBuilder = class {
       const accounts = await this.rpcClient.getMultipleAccounts(addresses, {
         commitment: this.config.commitment
       });
-      const generated = await import('./generated-EG5USUFG.js');
+      const generated = await import('./generated-QJREJQ2C.js');
       const decoderGetter = generated[decoderImportName];
       const decoder = decoderGetter();
       return accounts.map((accountInfo) => {
@@ -1020,7 +1020,7 @@ var InstructionBuilder = class {
         commitment: this.config.commitment,
         filters: convertedFilters ?? []
       });
-      const generated = await import('./generated-EG5USUFG.js');
+      const generated = await import('./generated-QJREJQ2C.js');
       const decoderGetter = generated[decoderImportName];
       const decoder = decoderGetter();
       const decodedAccounts = [];
@@ -1348,9 +1348,9 @@ var CacheManager = class {
    * @param currentSlot - Current blockchain slot (for staleness check)
    * @returns Cached data or undefined
    */
-  getAccount(address, commitment, currentSlot) {
+  getAccount(address2, commitment, currentSlot) {
     if (!this.config.enabled) return void 0;
-    const key = `${address}:${commitment}`;
+    const key = `${address2}:${commitment}`;
     const entry = this.accountCache.get(key);
     if (!entry) return void 0;
     if (currentSlot !== void 0 && entry.slot < currentSlot) {
@@ -1367,9 +1367,9 @@ var CacheManager = class {
    * @param commitment - Commitment level
    * @param slot - Blockchain slot when data was fetched
    */
-  setAccount(address, data, commitment, slot) {
+  setAccount(address2, data, commitment, slot) {
     if (!this.config.enabled) return;
-    const key = `${address}:${commitment}`;
+    const key = `${address2}:${commitment}`;
     const entry = {
       data,
       slot,
@@ -1408,13 +1408,13 @@ var CacheManager = class {
    * @param address - Account address to invalidate
    * @param commitment - Optional commitment level (invalidates all if not specified)
    */
-  invalidateAccount(address, commitment) {
+  invalidateAccount(address2, commitment) {
     if (!this.config.enabled) return;
     if (commitment) {
-      this.accountCache.delete(`${address}:${commitment}`);
+      this.accountCache.delete(`${address2}:${commitment}`);
     } else {
       ["processed", "confirmed", "finalized"].forEach((c) => {
-        this.accountCache.delete(`${address}:${c}`);
+        this.accountCache.delete(`${address2}:${c}`);
       });
     }
   }
@@ -1540,19 +1540,19 @@ var BaseModule = class {
   /**
    * Get decoded account (with optional caching)
    */
-  async getAccount(address, decoderImportName) {
+  async getAccount(address2, decoderImportName) {
     if (this.cacheManager.isEnabled()) {
-      const cached = this.cacheManager.getAccount(address, this.commitment);
+      const cached = this.cacheManager.getAccount(address2, this.commitment);
       if (cached !== void 0) {
-        this.logger?.info(`[Cache HIT] ${address}`);
+        this.logger?.info(`[Cache HIT] ${address2}`);
         return cached;
       }
     }
-    const account = await this.builder.getAccount(address, decoderImportName);
+    const account = await this.builder.getAccount(address2, decoderImportName);
     if (this.cacheManager.isEnabled() && account !== null) {
       const slot = 0;
-      this.cacheManager.setAccount(address, account, this.commitment, slot);
-      this.logger?.info(`[Cache SET] ${address}`);
+      this.cacheManager.setAccount(address2, account, this.commitment, slot);
+      this.logger?.info(`[Cache SET] ${address2}`);
     }
     return account;
   }
@@ -1624,9 +1624,9 @@ var BaseModule = class {
   /**
    * Invalidate cache for specific account
    */
-  invalidateCache(address) {
-    this.cacheManager.invalidateAccount(address);
-    this.logger?.info(`[Cache INVALIDATE] ${address}`);
+  invalidateCache(address2) {
+    this.cacheManager.invalidateAccount(address2);
+    this.logger?.info(`[Cache INVALIDATE] ${address2}`);
   }
   /**
    * Clear all caches
@@ -2147,8 +2147,8 @@ var AgentModule = class extends BaseModule {
   /**
    * Get agent account
    */
-  async getAgentAccount(address) {
-    return super.getAccount(address, "getAgentDecoder");
+  async getAgentAccount(address2) {
+    return super.getAccount(address2, "getAgentDecoder");
   }
   /**
    * Get all agents
@@ -2262,18 +2262,18 @@ var AgentModule = class extends BaseModule {
   // Helper methods
   async deriveAgentPda(agentId, owner) {
     const { deriveAgentPda } = await import('./pda-4KP7CURF.js');
-    const [address] = await deriveAgentPda({ programAddress: this.programId, owner, agentId });
-    return address;
+    const [address2] = await deriveAgentPda({ programAddress: this.programId, owner, agentId });
+    return address2;
   }
   async deriveUserRegistryPda(owner) {
     const { deriveUserRegistryPda } = await import('./pda-4KP7CURF.js');
     return deriveUserRegistryPda(this.programId, owner);
   }
   async deriveTreeConfigPda(owner) {
-    const { getProgramDerivedAddress: getProgramDerivedAddress2, getAddressEncoder: getAddressEncoder2 } = await import('@solana/addresses');
-    const addressEncoder = getAddressEncoder2();
+    const { getProgramDerivedAddress: getProgramDerivedAddress4, getAddressEncoder: getAddressEncoder4 } = await import('@solana/addresses');
+    const addressEncoder = getAddressEncoder4();
     const ownerBytes = addressEncoder.encode(owner);
-    const [pda] = await getProgramDerivedAddress2({
+    const [pda] = await getProgramDerivedAddress4({
       programAddress: this.programId,
       seeds: [
         new TextEncoder().encode("agent_tree_config"),
@@ -2289,6 +2289,427 @@ var AgentModule = class extends BaseModule {
     return "cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK";
   }
 };
+var SAS_PROGRAM_ID = address("22zoJMtdu4tQc2PzL74ZUT7FrwgB1Udec8DdW4yw4BdG");
+var ATTESTATION_SEED = "attestation";
+var CREDENTIAL_SEED = "credential";
+var SCHEMA_SEED = "schema";
+var SASAttestationHelper = class {
+  /**
+   * Derive attestation PDA for a given credential, schema, and nonce
+   *
+   * PDA seeds: ["attestation", credential, schema, nonce]
+   *
+   * @param credentialAddress - SAS Credential address (issuer)
+   * @param schemaAddress - SAS Schema address (defines structure)
+   * @param nonce - Unique nonce (typically the x402_payment_address)
+   * @returns Attestation PDA and bump
+   */
+  static async deriveAttestationPda(credentialAddress, schemaAddress, nonce) {
+    const [pda, bump] = await getProgramDerivedAddress({
+      programAddress: SAS_PROGRAM_ID,
+      seeds: [
+        getUtf8Encoder().encode(ATTESTATION_SEED),
+        getAddressEncoder().encode(credentialAddress),
+        getAddressEncoder().encode(schemaAddress),
+        getAddressEncoder().encode(nonce)
+      ]
+    });
+    return {
+      attestationPda: pda,
+      bump
+    };
+  }
+  /**
+   * Derive credential PDA for an issuer
+   *
+   * PDA seeds: ["credential", issuer]
+   *
+   * @param issuer - Issuer's public key
+   * @returns Credential PDA and bump
+   */
+  static async deriveCredentialPda(issuer) {
+    const [pda, bump] = await getProgramDerivedAddress({
+      programAddress: SAS_PROGRAM_ID,
+      seeds: [
+        getUtf8Encoder().encode(CREDENTIAL_SEED),
+        getAddressEncoder().encode(issuer)
+      ]
+    });
+    return {
+      attestationPda: pda,
+      bump
+    };
+  }
+  /**
+   * Derive schema PDA for a credential
+   *
+   * PDA seeds: ["schema", credential, schema_name]
+   *
+   * @param credentialAddress - Credential address
+   * @param schemaName - Schema identifier
+   * @returns Schema PDA and bump
+   */
+  static async deriveSchemaPda(credentialAddress, schemaName) {
+    const [pda, bump] = await getProgramDerivedAddress({
+      programAddress: SAS_PROGRAM_ID,
+      seeds: [
+        getUtf8Encoder().encode(SCHEMA_SEED),
+        getAddressEncoder().encode(credentialAddress),
+        getUtf8Encoder().encode(schemaName)
+      ]
+    });
+    return {
+      attestationPda: pda,
+      bump
+    };
+  }
+  /**
+   * Serialize Ghost ownership attestation data for on-chain storage
+   *
+   * Format: Borsh serialization
+   * - x402_payment_address: 32 bytes
+   * - network: String (length-prefixed)
+   * - github_username: Option<String>
+   * - twitter_handle: Option<String>
+   * - timestamp: i64 (8 bytes)
+   *
+   * @param data - Attestation data to serialize
+   * @returns Serialized buffer
+   */
+  static serializeAttestationData(data) {
+    const encoder = new TextEncoder();
+    const networkBytes = encoder.encode(data.network);
+    const githubBytes = data.githubUsername ? encoder.encode(data.githubUsername) : new Uint8Array();
+    const twitterBytes = data.twitterHandle ? encoder.encode(data.twitterHandle) : new Uint8Array();
+    const totalSize = 32 + // x402_payment_address
+    4 + networkBytes.length + // network (length prefix + data)
+    1 + (data.githubUsername ? 4 + githubBytes.length : 0) + // github option
+    1 + (data.twitterHandle ? 4 + twitterBytes.length : 0) + // twitter option
+    8;
+    const buffer = new Uint8Array(totalSize);
+    let offset = 0;
+    const addressBytes = Buffer.from(data.x402PaymentAddress);
+    buffer.set(addressBytes.slice(0, 32), offset);
+    offset += 32;
+    const networkLengthView = new DataView(buffer.buffer, offset, 4);
+    networkLengthView.setUint32(0, networkBytes.length, true);
+    offset += 4;
+    buffer.set(networkBytes, offset);
+    offset += networkBytes.length;
+    if (data.githubUsername) {
+      buffer[offset] = 1;
+      offset += 1;
+      const githubLengthView = new DataView(buffer.buffer, offset, 4);
+      githubLengthView.setUint32(0, githubBytes.length, true);
+      offset += 4;
+      buffer.set(githubBytes, offset);
+      offset += githubBytes.length;
+    } else {
+      buffer[offset] = 0;
+      offset += 1;
+    }
+    if (data.twitterHandle) {
+      buffer[offset] = 1;
+      offset += 1;
+      const twitterLengthView = new DataView(buffer.buffer, offset, 4);
+      twitterLengthView.setUint32(0, twitterBytes.length, true);
+      offset += 4;
+      buffer.set(twitterBytes, offset);
+      offset += twitterBytes.length;
+    } else {
+      buffer[offset] = 0;
+      offset += 1;
+    }
+    const timestampView = new DataView(buffer.buffer, offset, 8);
+    timestampView.setBigInt64(0, data.timestamp, true);
+    return buffer;
+  }
+  /**
+   * Get GhostSpeak default credential configuration
+   *
+   * This returns the official GhostSpeak credential issuer settings
+   * for production use.
+   *
+   * @param issuer - Credential issuer address (typically the GhostSpeak program authority)
+   * @returns Default credential configuration
+   */
+  static getDefaultCredentialConfig(issuer) {
+    return {
+      issuer,
+      name: "GhostSpeak AI Agent Ownership",
+      description: "Attestation proving ownership of an AI agent registered on the GhostSpeak protocol",
+      schemaUri: "https://ghostspeak.ai/schemas/agent-ownership-v1.json"
+    };
+  }
+  /**
+   * Check if an attestation is expired
+   *
+   * @param expiryTimestamp - Expiry timestamp (Unix seconds)
+   * @param currentTimestamp - Current timestamp (defaults to now)
+   * @returns True if expired
+   */
+  static isAttestationExpired(expiryTimestamp, currentTimestamp) {
+    const now = currentTimestamp ?? BigInt(Math.floor(Date.now() / 1e3));
+    return expiryTimestamp < now;
+  }
+  /**
+   * Calculate default expiry timestamp (1 year from now)
+   *
+   * @param fromTimestamp - Starting timestamp (defaults to now)
+   * @returns Expiry timestamp
+   */
+  static calculateDefaultExpiry(fromTimestamp) {
+    const now = fromTimestamp ?? BigInt(Math.floor(Date.now() / 1e3));
+    const oneYear = BigInt(365 * 24 * 60 * 60);
+    return now + oneYear;
+  }
+  /**
+   * Create attestation instruction data
+   *
+   * NOTE: This is a helper for building the SAS create_attestation instruction.
+   * The actual instruction building should be done using the SAS SDK or program IDL.
+   *
+   * @param config - Attestation configuration
+   * @returns Prepared attestation data and PDA
+   */
+  static async prepareAttestation(config) {
+    const { attestationPda, bump } = await this.deriveAttestationPda(
+      config.credentialAddress,
+      config.schemaAddress,
+      config.x402PaymentAddress
+      // Use x402 address as nonce
+    );
+    const expiryTimestamp = config.expiryTimestamp ?? this.calculateDefaultExpiry();
+    const attestationData = this.serializeAttestationData({
+      x402PaymentAddress: config.x402PaymentAddress,
+      network: config.network,
+      githubUsername: config.githubUsername,
+      twitterHandle: config.twitterHandle,
+      timestamp: BigInt(Math.floor(Date.now() / 1e3))
+    });
+    return {
+      attestationData,
+      attestationPda,
+      bump,
+      expiryTimestamp
+    };
+  }
+};
+var DID_DOCUMENT_SEED = "did_document";
+var GhostModule = class extends BaseModule {
+  constructor(config) {
+    super(config);
+  }
+  /**
+   * Claim ownership of a Ghost using SAS attestation
+   *
+   * This method performs the complete claim flow:
+   * 1. Derives required PDAs (attestation, DID document)
+   * 2. Builds the claim_ghost instruction
+   * 3. Executes the transaction
+   *
+   * **Prerequisites:**
+   * - The claimer must have already created a SAS attestation proving ownership
+   *   of the agent's x402_payment_address
+   * - The agent must be in Unregistered or Registered status (not already claimed)
+   *
+   * **Results:**
+   * - Agent status transitions to Claimed
+   * - DID document is auto-created with did:sol:<network>:<address>
+   * - Claimer becomes the owner of the agent
+   *
+   * @param claimer - Transaction signer (must own the SAS attestation)
+   * @param params - Claim parameters
+   * @returns Transaction signature
+   *
+   * @example
+   * ```typescript
+   * const signature = await client.ghosts.claim(signer, {
+   *   agentAddress: 'GhostAgent123...',
+   *   x402PaymentAddress: 'PaymentAddr456...',
+   *   sasCredential: 'SASCredential789...',
+   *   sasSchema: 'SASSchema012...',
+   *   network: 'devnet',
+   *   ipfsMetadataUri: 'ipfs://QmHash...',
+   *   githubUsername: 'myusername'
+   * })
+   * ```
+   */
+  async claim(claimer, params) {
+    const prepared = await this.prepareClaim(params);
+    const instructionGetter = () => {
+      return getClaimGhostInstruction({
+        agentAccount: params.agentAddress,
+        didDocument: prepared.didDocumentPda,
+        sasAttestation: prepared.attestationPda,
+        claimer,
+        systemProgram: this.systemProgramId,
+        sasCredential: params.sasCredential,
+        sasSchema: params.sasSchema,
+        ipfsMetadataUri: params.ipfsMetadataUri ?? null,
+        network: params.network
+      });
+    };
+    return this.execute(
+      "claimGhost",
+      instructionGetter,
+      [claimer]
+    );
+  }
+  /**
+   * Prepare a Ghost claim by deriving all required PDAs
+   *
+   * This is useful for:
+   * - Pre-flight validation (checking if PDAs are correct)
+   * - Building custom transactions with manual PDA management
+   * - Debugging claim issues
+   *
+   * @param params - Claim parameters
+   * @returns Prepared claim data with derived PDAs
+   *
+   * @example
+   * ```typescript
+   * const prepared = await client.ghosts.prepareClaim({
+   *   agentAddress: 'GhostAgent123...',
+   *   x402PaymentAddress: 'PaymentAddr456...',
+   *   sasCredential: 'SASCredential789...',
+   *   sasSchema: 'SASSchema012...',
+   *   network: 'devnet'
+   * })
+   *
+   * console.log('Attestation PDA:', prepared.attestationPda)
+   * console.log('DID Document PDA:', prepared.didDocumentPda)
+   * ```
+   */
+  async prepareClaim(params) {
+    const { attestationPda, bump: attestationBump } = await SASAttestationHelper.deriveAttestationPda(
+      params.sasCredential,
+      params.sasSchema,
+      params.x402PaymentAddress
+    );
+    const [didDocumentPda, didDocumentBump] = await this.deriveDidDocumentPda(params.x402PaymentAddress);
+    return {
+      attestationPda,
+      didDocumentPda,
+      attestationBump,
+      didDocumentBump
+    };
+  }
+  /**
+   * Get Ghost agent account
+   *
+   * @param address - Agent account address
+   * @returns Agent account data or null if not found
+   */
+  async getGhostAgent(address2) {
+    return super.getAccount(address2, "getAgentDecoder");
+  }
+  /**
+   * Get all Ghost agents (agents with type 10 - external x402 agents)
+   *
+   * @returns Array of Ghost agents
+   */
+  async getAllGhosts() {
+    const GHOST_AGENT_TYPE = 10;
+    return this.getGhostsByType(GHOST_AGENT_TYPE);
+  }
+  /**
+   * Get Ghost agents by type
+   *
+   * @param agentType - Agent type filter (default: 10 for x402 ghosts)
+   * @returns Array of matching Ghost agents
+   */
+  async getGhostsByType(agentType = 10) {
+    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 claimed Ghosts by owner
+   *
+   * @param owner - Owner address
+   * @returns Array of Ghost agents owned by the address
+   */
+  async getClaimedGhosts(owner) {
+    const filters = [{
+      memcmp: {
+        offset: BigInt(9),
+        // Skip discriminator + type
+        bytes: owner,
+        encoding: "base58"
+      }
+    }];
+    return this.getProgramAccounts("getAgentDecoder", filters);
+  }
+  /**
+   * Validate claim parameters
+   *
+   * Performs pre-flight checks to ensure claim will succeed:
+   * - Agent exists and is in correct status
+   * - Agent is not already claimed
+   * - PDAs are correctly derived
+   *
+   * @param params - Claim parameters
+   * @returns Validation result with error messages if any
+   */
+  async validateClaim(params) {
+    const errors = [];
+    const warnings = [];
+    const validNetworks = ["devnet", "testnet", "mainnet-beta", "localnet"];
+    if (!validNetworks.includes(params.network)) {
+      errors.push(`Invalid network: ${params.network}. Must be one of: ${validNetworks.join(", ")}`);
+    }
+    if (params.ipfsMetadataUri && !params.ipfsMetadataUri.startsWith("ipfs://")) {
+      warnings.push('IPFS metadata URI should start with "ipfs://"');
+    }
+    const agent = await this.getGhostAgent(params.agentAddress);
+    if (!agent) {
+      errors.push(`Agent not found at address: ${params.agentAddress}`);
+    } else {
+      if (agent.owner !== null) {
+        errors.push(`Agent is already claimed by: ${agent.owner}`);
+      }
+      if (agent.agentType !== 10) {
+        warnings.push(`Agent type is ${agent.agentType}, expected 10 (external x402 agent)`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  // Helper methods
+  /**
+   * Derive DID document PDA
+   *
+   * Pattern: ['did_document', x402_payment_address]
+   *
+   * @param x402PaymentAddress - Agent's x402 payment address
+   * @returns [DID document PDA, bump]
+   */
+  async deriveDidDocumentPda(x402PaymentAddress) {
+    const [pda, bump] = await getProgramDerivedAddress({
+      programAddress: this.programId,
+      seeds: [
+        getUtf8Encoder().encode(DID_DOCUMENT_SEED),
+        getAddressEncoder().encode(x402PaymentAddress)
+      ]
+    });
+    return [pda, bump];
+  }
+  get systemProgramId() {
+    return SYSTEM_PROGRAM_ADDRESS;
+  }
+};
 
 // src/modules/governance/GovernanceModule.ts
 var GovernanceModule = class extends BaseModule {
@@ -2334,8 +2755,8 @@ var GovernanceModule = class extends BaseModule {
   /**
    * Get governance proposal account
    */
-  async getProposal(address) {
-    return super.getAccount(address, "getGovernanceProposalDecoder");
+  async getProposal(address2) {
+    return super.getAccount(address2, "getGovernanceProposalDecoder");
   }
   /**
    * Get all active proposals
@@ -2407,7 +2828,7 @@ var MultisigModule = class extends BaseModule {
 };
 
 // src/modules/did/did-types.ts
-var DID_DOCUMENT_SEED = "did_document";
+var DID_DOCUMENT_SEED2 = "did_document";
 var VerificationMethodType = /* @__PURE__ */ ((VerificationMethodType2) => {
   VerificationMethodType2["Ed25519VerificationKey2020"] = "Ed25519VerificationKey2020";
   VerificationMethodType2["X25519KeyAgreementKey2020"] = "X25519KeyAgreementKey2020";
@@ -2452,14 +2873,14 @@ var DidErrorClass = class extends Error {
   }
 };
 async function deriveDidDocumentPda(programId, controller) {
-  const [address, bump] = await getProgramDerivedAddress({
+  const [address2, bump] = await getProgramDerivedAddress({
     programAddress: programId,
     seeds: [
-      new TextEncoder().encode(DID_DOCUMENT_SEED),
+      new TextEncoder().encode(DID_DOCUMENT_SEED2),
       getAddressEncoder().encode(controller)
     ]
   });
-  return [address, bump];
+  return [address2, bump];
 }
 function generateDidString(network, pubkey) {
   const normalizedNetwork = network === "mainnet" ? "mainnet-beta" : network;
@@ -2885,259 +3306,6 @@ var CredentialModule = class {
     return options?.pretty ? JSON.stringify(w3c, null, 2) : JSON.stringify(w3c);
   }
 };
-var DEFAULT_FACILITATOR_URL = "https://facilitator.payai.network";
-var DEFAULT_TIMEOUT = 3e4;
-var DEFAULT_RETRY = { attempts: 3, delayMs: 1e3 };
-function isPaymentRequired(response) {
-  return response.status === 402;
-}
-async function extractPaymentRequirements(response) {
-  const body = await response.text();
-  try {
-    const parsed = JSON.parse(body);
-    if (parsed.accepts && Array.isArray(parsed.accepts)) {
-      return parsed.accepts;
-    }
-    if (parsed.paymentRequirements && Array.isArray(parsed.paymentRequirements)) {
-      return parsed.paymentRequirements;
-    }
-    if (parsed.scheme && parsed.payTo) {
-      return [parsed];
-    }
-  } catch {
-  }
-  const paymentHeader = response.headers.get("x-payment-required");
-  if (paymentHeader) {
-    try {
-      return JSON.parse(paymentHeader);
-    } catch {
-    }
-  }
-  return [];
-}
-var PayAIClient = class extends EventEmitter {
-  config;
-  localRecords = [];
-  constructor(config) {
-    super();
-    this.config = {
-      facilitatorUrl: config.facilitatorUrl ?? DEFAULT_FACILITATOR_URL,
-      rpcUrl: config.rpcUrl,
-      wallet: config.wallet,
-      timeout: config.timeout ?? DEFAULT_TIMEOUT,
-      retry: config.retry ?? DEFAULT_RETRY
-    };
-  }
-  // =====================================================
-  // PUBLIC METHODS
-  // =====================================================
-  /**
-   * Make a fetch request with automatic x402 payment handling
-   *
-   * @param url - The resource URL
-   * @param init - Fetch options
-   * @returns Response from the resource
-   */
-  async fetch(url, init) {
-    this.emit("request:started", url);
-    const startTime = Date.now();
-    try {
-      let response = await this.fetchWithTimeout(url, init);
-      if (isPaymentRequired(response)) {
-        const requirements = await extractPaymentRequirements(response);
-        this.emit("payment:required", requirements);
-        if (requirements.length === 0) {
-          throw new Error("Payment required but no payment options provided");
-        }
-        const requirement = this.selectPaymentOption(requirements);
-        if (!requirement) {
-          throw new Error("No compatible payment option found");
-        }
-        response = await this.makePaymentAndRetry(url, init ?? {}, requirement);
-      }
-      const durationMs = Date.now() - startTime;
-      this.emit("request:completed", url, response.ok, durationMs);
-      return response;
-    } catch (error) {
-      const durationMs = Date.now() - startTime;
-      this.emit("request:completed", url, false, durationMs);
-      if (error instanceof Error) {
-        this.emit("payment:failed", error);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Verify a payment through the PayAI facilitator
-   *
-   * @param paymentHeader - The payment header/payload
-   * @param requirement - The payment requirement
-   * @returns Verification result
-   */
-  async verifyPayment(paymentHeader, requirement) {
-    const response = await this.fetchWithTimeout(
-      `${this.config.facilitatorUrl}/verify`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          paymentHeader,
-          paymentRequirements: requirement
-        })
-      }
-    );
-    return response.json();
-  }
-  /**
-   * Settle a payment through the PayAI facilitator
-   *
-   * @param paymentHeader - The payment header/payload
-   * @param requirement - The payment requirement
-   * @returns Settlement result
-   */
-  async settlePayment(paymentHeader, requirement) {
-    const response = await this.fetchWithTimeout(
-      `${this.config.facilitatorUrl}/settle`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          paymentHeader,
-          paymentRequirements: requirement
-        })
-      }
-    );
-    return response.json();
-  }
-  /**
-   * List available resources from the PayAI facilitator
-   *
-   * @param options - Filter options
-   * @returns List of available resources
-   */
-  async listResources(options) {
-    const params = new URLSearchParams();
-    if (options?.network) params.set("network", options.network);
-    if (options?.capability) params.set("capability", options.capability);
-    if (options?.maxPrice) params.set("maxPrice", options.maxPrice.toString());
-    const response = await this.fetchWithTimeout(
-      `${this.config.facilitatorUrl}/list?${params.toString()}`
-    );
-    return response.json();
-  }
-  /**
-   * Get locally tracked reputation records
-   * (For payments made through this client instance)
-   */
-  getLocalReputationRecords() {
-    return [...this.localRecords];
-  }
-  /**
-   * Clear local reputation records
-   */
-  clearLocalReputationRecords() {
-    this.localRecords.length = 0;
-  }
-  // =====================================================
-  // PRIVATE METHODS
-  // =====================================================
-  /**
-   * Select the best payment option from requirements
-   */
-  selectPaymentOption(requirements) {
-    const solanaOption = requirements.find((r) => r.network === "solana");
-    if (solanaOption) return solanaOption;
-    return requirements[0] ?? null;
-  }
-  /**
-   * Make payment and retry the original request
-   */
-  async makePaymentAndRetry(url, init, requirement) {
-    this.emit("payment:started", requirement);
-    const paymentHeader = await this.createPaymentHeader(requirement);
-    const verification = await this.verifyPayment(paymentHeader, requirement);
-    if (!verification.valid) {
-      throw new Error(`Payment verification failed: ${verification.error ?? "Unknown error"}`);
-    }
-    const settlement = await this.settlePayment(paymentHeader, requirement);
-    if (!settlement.success) {
-      throw new Error(`Payment settlement failed: ${settlement.error ?? "Unknown error"}`);
-    }
-    this.emit("payment:completed", {
-      success: true,
-      transactionSignature: settlement.transaction,
-      paymentId: `pay_${Date.now()}`
-    });
-    const startTime = Date.now();
-    const response = await this.fetchWithTimeout(url, {
-      ...init,
-      headers: {
-        ...init.headers,
-        "X-Payment": paymentHeader,
-        "X-Payment-Signature": settlement.transaction ?? ""
-      }
-    });
-    const responseTime = Date.now() - startTime;
-    if (settlement.transaction) {
-      this.localRecords.push({
-        agentAddress: requirement.payTo,
-        paymentSignature: settlement.transaction,
-        amount: BigInt(requirement.maxAmountRequired),
-        success: response.ok,
-        responseTimeMs: responseTime,
-        payerAddress: this.config.wallet?.publicKey ?? "unknown",
-        timestamp: /* @__PURE__ */ new Date(),
-        network: requirement.network
-      });
-    }
-    return response;
-  }
-  /**
-   * Create a payment header for a requirement
-   * (In production, this would sign a real Solana transaction)
-   */
-  async createPaymentHeader(requirement) {
-    if (!this.config.wallet) {
-      throw new Error("Wallet not configured for payments");
-    }
-    const paymentData = {
-      version: "1.0",
-      scheme: requirement.scheme,
-      network: requirement.network,
-      payer: this.config.wallet.publicKey,
-      payTo: requirement.payTo,
-      amount: requirement.maxAmountRequired,
-      asset: requirement.asset,
-      resource: requirement.resource,
-      nonce: Date.now().toString(),
-      signature: `mock_sig_${Date.now()}`
-    };
-    return Buffer.from(JSON.stringify(paymentData)).toString("base64");
-  }
-  /**
-   * Fetch with timeout
-   */
-  async fetchWithTimeout(url, init) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-    try {
-      const response = await fetch(url, {
-        ...init,
-        signal: controller.signal
-      });
-      return response;
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-};
-function createPayAIClient(config) {
-  return new PayAIClient(config);
-}
-async function payAIFetch(url, config, init) {
-  const client = createPayAIClient(config);
-  return client.fetch(url, init);
-}
 
 // src/modules/reputation/ReputationModule.ts
 init_reputation_tag_engine();
@@ -3677,6 +3845,6 @@ var StakingModule = class extends BaseModule {
   }
 };
 
-export { AgentModule, BaseModule, CacheManager, CredentialKind, CredentialModule, CredentialStatus, DEFAULT_IPFS_CONFIG, DidError, DidErrorClass, GovernanceModule, IPFSUtils, InstructionBuilder, MultiSourceAggregator, MultiSourceAggregator_exports, MultisigModule, PayAIClient, ReputationModule, RpcClient, ServiceEndpointType, StakingModule, VerificationMethodType, VerificationRelationship, canPerformAction, createEd25519VerificationMethod, createIPFSUtils, createMetadataUri, createPayAIClient, createServiceEndpoint, deriveDidDocumentPda, determineStorageMethod, didDocumentToJson, exportAsW3CDidDocument, extractPaymentRequirements, generateDidString, getIdentifierFromDid, getMethodsForRelationship, getNetworkFromDid, init_MultiSourceAggregator, isDidActive, isPaymentRequired, parseDidString, payAIFetch, validateDidString };
-//# sourceMappingURL=chunk-SZGFSCNU.js.map
-//# sourceMappingURL=chunk-SZGFSCNU.js.map
+export { ATTESTATION_SEED, AgentModule, BaseModule, CREDENTIAL_SEED, CacheManager, CredentialKind, CredentialModule, CredentialStatus, DEFAULT_IPFS_CONFIG, DidError, DidErrorClass, GhostModule, GovernanceModule, IPFSUtils, InstructionBuilder, MultiSourceAggregator, MultiSourceAggregator_exports, MultisigModule, ReputationModule, RpcClient, SASAttestationHelper, SAS_PROGRAM_ID, SCHEMA_SEED, ServiceEndpointType, StakingModule, VerificationMethodType, VerificationRelationship, canPerformAction, createEd25519VerificationMethod, createIPFSUtils, createMetadataUri, createServiceEndpoint, deriveDidDocumentPda, determineStorageMethod, didDocumentToJson, exportAsW3CDidDocument, generateDidString, getIdentifierFromDid, getMethodsForRelationship, getNetworkFromDid, init_MultiSourceAggregator, isDidActive, parseDidString, validateDidString };
+//# sourceMappingURL=chunk-JYXSOXCP.js.map
+//# sourceMappingURL=chunk-JYXSOXCP.js.map