@ghostspeak/sdk 2.0.7 → 2.0.10

package/dist/index.js

@@ -1,29 +1,29 @@
 export { batchGetAccounts, batchGetAccountsWithRetry, batchGetAndMap, batchGetExistingAccounts, createBatchFetcher } from './chunk-SKMJJ3Q6.js';
 export { BaseReputationAdapter, GHOSTSPEAK_PROGRAM_ID, ReputationSource } from './chunk-TTB4OS2D.js';
-export { AuthorizationModule, DidModule, GhostSpeakClient, PrivacyModule, UnifiedCredentialService, calculateVisibleScore, canViewerAccess, GhostSpeakClient_default as default, filterMetricsByVisibility, getDefaultMetricVisibility, getRangeDisplayString, getReputationTier, getScoreRange, getTierDisplayName, lamportsToSol, sol, validatePrivacySettings } from './chunk-E3FD2CNY.js';
-import { init_MultiSourceAggregator } from './chunk-SZGFSCNU.js';
-export { AgentModule, BaseModule, CacheManager, CredentialKind, CredentialModule, CredentialStatus, DEFAULT_IPFS_CONFIG, DidError, DidErrorClass, GovernanceModule, IPFSUtils, InstructionBuilder, MultiSourceAggregator, MultisigModule, PayAIClient, ReputationModule, RpcClient, ServiceEndpointType, VerificationMethodType, VerificationRelationship, canPerformAction, createEd25519VerificationMethod, createIPFSUtils, createMetadataUri, createPayAIClient, createServiceEndpoint, deriveDidDocumentPda, determineStorageMethod, didDocumentToJson, exportAsW3CDidDocument, extractPaymentRequirements, generateDidString, getIdentifierFromDid, getMethodsForRelationship, getNetworkFromDid, isDidActive, isPaymentRequired, parseDidString, payAIFetch, validateDidString } from './chunk-SZGFSCNU.js';
+export { AuthorizationModule, DidModule, GhostSpeakClient, PrivacyModule, UnifiedCredentialService, calculateVisibleScore, canViewerAccess, GhostSpeakClient_default as default, filterMetricsByVisibility, getDefaultMetricVisibility, getRangeDisplayString, getReputationTier, getScoreRange, getTierDisplayName, lamportsToSol, sol, validatePrivacySettings } from './chunk-5SS3OL4B.js';
+import { init_MultiSourceAggregator, BaseModule } from './chunk-63A7F2YP.js';
+export { ATTESTATION_SEED, AgentModule, BaseModule, CREDENTIAL_SEED, CacheManager, CredentialKind, CredentialModule, CredentialStatus, DEFAULT_IPFS_CONFIG, DidError, DidErrorClass, GhostModule, GovernanceModule, IPFSUtils, InstructionBuilder, MultiSourceAggregator, 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, isDidActive, parseDidString, validateDidString } from './chunk-63A7F2YP.js';
 export { AccountNotFoundError, ErrorFactory, ErrorHandler, GhostSpeakError, InsufficientBalanceError, InvalidInputError, NetworkError, SimulationFailedError, TimeoutError, TransactionFailedError, ValidationError } from './chunk-5DMB3UAV.js';
 export { decrypt, elgamal_exports as elgamal, encrypt, generateKeypair, generateTransferProof, generateWithdrawProof, isWasmAvailable, loadWasmModule, wasm_bridge_exports as wasmBridge } from './chunk-VQZQCHUT.js';
-import { getFeatureFlags, ClientEncryptionService } from './chunk-G7S6B6WB.js';
-export { ClientEncryptionService, FeatureFlagManager, TokenExtension, TokenProgram, createDiscriminatorErrorMessage, createMigrationPlan, createMigrationReport, deriveAssociatedTokenAddress, deriveMultisigPda, deriveProposalPda, deriveSplTokenAssociatedTokenAddress, deriveToken2022AssociatedTokenAddress, detectTokenProgram, diagnoseAccountFromChain, diagnoseBatchFromChain, exportDiagnosticReport, extractLegacyData, formatTokenAmount, generateLocalPrivacyProof, getAllAssociatedTokenAddresses, getAssociatedTokenAccount, getConfidentialTransferConfig, getFeatureFlags, getInterestBearingConfig, getMigrationInstructions, getTokenProgramAddress, getTokenProgramFromAddress, getTokenProgramType, getTransferFeeConfig, hasConfidentialTransferExtension, hasInterestBearingExtension, hasTransferFeeExtension, inspectAccountData, isFeatureEnabled, isToken2022Mint, parseTokenAmount, runAccountDiagnostics, runBatchDiagnostics, safeDecodeAgent, simulateMigration, validateAccountDiscriminator, validateAssociatedTokenAddress, verifyLocalPrivacyProof } from './chunk-G7S6B6WB.js';
+import { getFeatureFlags, ClientEncryptionService } from './chunk-EU6PHSM5.js';
+export { ClientEncryptionService, FeatureFlagManager, TokenExtension, TokenProgram, createDiscriminatorErrorMessage, createMigrationPlan, createMigrationReport, deriveAssociatedTokenAddress, deriveMultisigPda, deriveProposalPda, deriveSplTokenAssociatedTokenAddress, deriveToken2022AssociatedTokenAddress, detectTokenProgram, diagnoseAccountFromChain, diagnoseBatchFromChain, exportDiagnosticReport, extractLegacyData, formatTokenAmount, generateLocalPrivacyProof, getAllAssociatedTokenAddresses, getAssociatedTokenAccount, getConfidentialTransferConfig, getFeatureFlags, getInterestBearingConfig, getMigrationInstructions, getTokenProgramAddress, getTokenProgramFromAddress, getTokenProgramType, getTransferFeeConfig, hasConfidentialTransferExtension, hasInterestBearingExtension, hasTransferFeeExtension, inspectAccountData, isFeatureEnabled, isToken2022Mint, parseTokenAmount, runAccountDiagnostics, runBatchDiagnostics, safeDecodeAgent, simulateMigration, validateAccountDiscriminator, validateAssociatedTokenAddress, verifyLocalPrivacyProof } from './chunk-EU6PHSM5.js';
 export { deriveAgentPda, deriveAgentVerificationPda, deriveUserRegistryPda, findProgramDerivedAddress } from './chunk-BF3IQ35I.js';
-export { createAuthorizationMessage, createSignedAuthorization, deserializeAuthorization, generateNonce, getAuthorizationId, isAuthorizationExhausted, isAuthorizationExpired, serializeAuthorization, signAuthorizationMessage, validateAuthorizationNetwork, verifyAuthorizationSignature } from './chunk-BQDGRTVP.js';
-import { init_reputation_tag_engine, init_reputation_tags } from './chunk-C5CDA3WX.js';
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BadgeType, BehaviorTag, ComplianceTag, DEFAULT_TAG_DECAY, GhostSpeakSDKError, INSTRUCTION_MAPPINGS, IPFSClient, InstructionValidationError, NATIVE_MINT_ADDRESS, PRIVACY_CONSTANTS, PrivacyMode, PrivacyPresets, REPUTATION_CONSTANTS, ReputationTagEngine, ReputationTier, ScoreRange, SkillTag, TAG_CONSTANTS, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, TagCategory, TagConfidenceLevel, VisibilityLevel, createAccountMismatchError, createErrorContext, debugInstructionCall, enhanceErrorMessage, enhanceTransactionError, extractInstructionName, generateAccountValidationError, getAccountRequirements, getInstructionMapping, getPDAAccounts, getRequiredSigners, getWritableAccounts, isKnownInstruction, logEnhancedError, validateInstructionAccounts, validatePreconditions, withEnhancedErrors, withEnhancedErrorsSync } from './chunk-C5CDA3WX.js';
-export { getApproveDeliveryInstruction, getArbitrateDisputeInstruction, getCreateDidDocumentInstructionAsync, getCreateEscrowInstructionAsync, getDeactivateDidDocumentInstructionAsync, getFileDisputeInstruction, getGhostProtectEscrowDecoder, getInitializeStakingConfigInstructionAsync, getRegisterAgentInstructionAsync, getResolveDidDocumentInstructionAsync, getSlashStakeInstructionAsync, getStakeGhostInstructionAsync, getStakingAccountDecoder, getStakingConfigDecoder, getSubmitDeliveryInstruction, getUnstakeGhostInstructionAsync, getUpdateDidDocumentInstructionAsync, getUpdateReputationTagsInstructionAsync } from './chunk-S74EH3KD.js';
-export { ProposalStatus, getAgentDecoder } from './chunk-IHVDQ4YI.js';
-import './chunk-SFTSZ3LC.js';
-import './chunk-JV2SWONF.js';
-import './chunk-KB6CKIUK.js';
-export { GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS } from './chunk-AL3HQN73.js';
+export { createAuthorizationMessage, createSignedAuthorization, deserializeAuthorization, generateNonce, getAuthorizationId, isAuthorizationExhausted, isAuthorizationExpired, serializeAuthorization, signAuthorizationMessage, validateAuthorizationNetwork, verifyAuthorizationSignature } from './chunk-QWQTPTZ4.js';
+import { init_reputation_tag_engine, init_reputation_tags, ExternalIdNotFoundError, GhostSpeakError, GhostNotFoundError } from './chunk-HIDBANFS.js';
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BadgeType, BehaviorTag, ComplianceTag, DEFAULT_TAG_DECAY, GhostSpeakSDKError, INSTRUCTION_MAPPINGS, IPFSClient, InstructionValidationError, NATIVE_MINT_ADDRESS, PRIVACY_CONSTANTS, PrivacyMode, PrivacyPresets, REPUTATION_CONSTANTS, ReputationTagEngine, ReputationTier, ScoreRange, SkillTag, TAG_CONSTANTS, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, TagCategory, TagConfidenceLevel, VisibilityLevel, createAccountMismatchError, createErrorContext, debugInstructionCall, enhanceErrorMessage, enhanceTransactionError, extractInstructionName, generateAccountValidationError, getAccountRequirements, getInstructionMapping, getPDAAccounts, getRequiredSigners, getWritableAccounts, isKnownInstruction, logEnhancedError, validateInstructionAccounts, validatePreconditions, withEnhancedErrors, withEnhancedErrorsSync } from './chunk-HIDBANFS.js';
+import { getCreateEscrowInstructionAsync, getSubmitDeliveryInstruction, getApproveDeliveryInstruction, getFileDisputeInstruction, getArbitrateDisputeInstruction } from './chunk-IQM5RASO.js';
+export { getApproveDeliveryInstruction, getArbitrateDisputeInstruction, getClaimGhostInstruction, getCreateDidDocumentInstructionAsync, getCreateEscrowInstructionAsync, getDeactivateDidDocumentInstructionAsync, getFileDisputeInstruction, getGhostProtectEscrowDecoder, getInitializeStakingConfigInstructionAsync, getRegisterAgentInstructionAsync, getResolveDidDocumentInstructionAsync, getSlashStakeInstructionAsync, getStakeGhostInstructionAsync, getStakingAccountDecoder, getStakingConfigDecoder, getSubmitDeliveryInstruction, getUnstakeGhostInstructionAsync, getUpdateDidDocumentInstructionAsync, getUpdateReputationTagsInstructionAsync } from './chunk-IQM5RASO.js';
+export { ProposalStatus, decodeAgent, fetchAgent, fetchMaybeAgent, getAgentDecoder } from './chunk-5QZVFUXB.js';
+import './chunk-46QWY3MG.js';
+import './chunk-A7ALCVUI.js';
+import './chunk-QLRWUHN2.js';
+export { GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS } from './chunk-AWMGX3OX.js';
 export { AgentType, ChannelType, ErrorCode, EscrowStatus, MessageType, ParticipantType, isError, isSuccess, unwrap } from './chunk-SRS2SKFS.js';
 export { CrossmintVCClient, GHOSTSPEAK_CREDENTIAL_TYPES } from './chunk-RIZZPLLB.js';
 import { __require } from './chunk-UP2VWCW5.js';
 import { createSolanaRpc, lamports, pipe, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, getBase64EncodedWireTransaction, createKeyPairSignerFromBytes, generateKeyPairSigner } from '@solana/kit';
 export { address, createKeyPairSignerFromBytes, createSolanaRpc, generateKeyPairSigner } from '@solana/kit';
-import { EventEmitter } from 'events';
-import { timingSafeEqual, createHmac } from 'crypto';
+import { address } from '@solana/addresses';
 import { getTransferSolInstruction } from '@solana-program/system';
 import { promises } from 'fs';
 import process2 from 'process';
@@ -32,8 +32,323 @@ import tty from 'tty';
 import bs58 from 'bs58';
 import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex, hexToBytes } from '@noble/curves/abstract/utils';
-import { address } from '@solana/addresses';
 
+var DEFAULT_API_URL = "https://api.ghostspeak.ai";
+var DEVNET_API_URL = "https://api-devnet.ghostspeak.ai";
+var LOCALNET_API_URL = "http://localhost:3001";
+var ExternalIdResolver = class {
+  apiUrl;
+  constructor(config) {
+    if (config?.apiUrl) {
+      this.apiUrl = config.apiUrl;
+    } else {
+      const cluster = config?.cluster || "devnet";
+      this.apiUrl = cluster === "mainnet-beta" ? DEFAULT_API_URL : cluster === "localnet" ? LOCALNET_API_URL : DEVNET_API_URL;
+    }
+  }
+  /**
+   * Resolve external ID to Ghost address
+   *
+   * @example
+   * const address = await resolver.resolve('payai', 'agent-123');
+   */
+  async resolve(platform, externalId) {
+    const result = await this.lookup(platform, externalId);
+    return address(result.mapping.ghostAddress);
+  }
+  /**
+   * Lookup external ID with full Ghost data
+   *
+   * @example
+   * const { mapping, ghost } = await resolver.lookup('payai', 'agent-123');
+   */
+  async lookup(platform, externalId) {
+    try {
+      const response = await fetch(
+        `${this.apiUrl}/ghosts/external/${encodeURIComponent(platform)}/${encodeURIComponent(externalId)}`
+      );
+      if (response.status === 404) {
+        throw new ExternalIdNotFoundError(platform, externalId);
+      }
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new GhostSpeakError(
+          error.message || "Failed to lookup external ID",
+          error.code || "LOOKUP_FAILED"
+        );
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error instanceof GhostSpeakError || error instanceof ExternalIdNotFoundError) throw error;
+      throw new GhostSpeakError(
+        "Failed to lookup external ID",
+        "LOOKUP_FAILED"
+      );
+    }
+  }
+  /**
+   * Get Ghost by Solana address via API
+   *
+   * Faster than on-chain lookup for read operations
+   */
+  async getGhost(ghostAddress) {
+    try {
+      const addrString = typeof ghostAddress === "string" ? ghostAddress : ghostAddress;
+      const response = await fetch(
+        `${this.apiUrl}/ghosts/${encodeURIComponent(addrString)}`
+      );
+      if (response.status === 404) {
+        throw new GhostNotFoundError(addrString);
+      }
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new GhostSpeakError(
+          error.message || "Failed to fetch Ghost",
+          error.code || "FETCH_FAILED"
+        );
+      }
+      const ghost = await response.json();
+      return ghost;
+    } catch (error) {
+      if (error instanceof GhostSpeakError || error instanceof GhostNotFoundError) throw error;
+      throw new GhostSpeakError(
+        "Failed to fetch Ghost",
+        "FETCH_FAILED"
+      );
+    }
+  }
+  /**
+   * Get Ghost Score via API
+   */
+  async getGhostScore(ghostAddress) {
+    try {
+      const addrString = typeof ghostAddress === "string" ? ghostAddress : ghostAddress;
+      const response = await fetch(
+        `${this.apiUrl}/ghosts/${encodeURIComponent(addrString)}/score`
+      );
+      if (response.status === 404) {
+        throw new GhostNotFoundError(addrString);
+      }
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new GhostSpeakError(
+          error.message || "Failed to fetch Ghost Score",
+          error.code || "FETCH_FAILED"
+        );
+      }
+      const score = await response.json();
+      return score;
+    } catch (error) {
+      if (error instanceof GhostSpeakError || error instanceof GhostNotFoundError) throw error;
+      throw new GhostSpeakError(
+        "Failed to fetch Ghost Score",
+        "FETCH_FAILED"
+      );
+    }
+  }
+  /**
+   * Get detailed reputation breakdown via API
+   */
+  async getGhostReputation(ghostAddress) {
+    try {
+      const addrString = typeof ghostAddress === "string" ? ghostAddress : ghostAddress;
+      const response = await fetch(
+        `${this.apiUrl}/ghosts/${encodeURIComponent(addrString)}/reputation`
+      );
+      if (response.status === 404) {
+        throw new GhostNotFoundError(addrString);
+      }
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new GhostSpeakError(
+          error.message || "Failed to fetch reputation",
+          error.code || "FETCH_FAILED"
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof GhostSpeakError || error instanceof GhostNotFoundError) throw error;
+      throw new GhostSpeakError(
+        "Failed to fetch reputation",
+        "FETCH_FAILED"
+      );
+    }
+  }
+  /**
+   * Batch resolve multiple external IDs
+   */
+  async resolveBatch(identifiers) {
+    const promises = identifiers.map(
+      ({ platform, externalId }) => this.resolve(platform, externalId).catch(() => null)
+    );
+    return Promise.all(promises);
+  }
+  /**
+   * Check if external ID exists
+   */
+  async exists(platform, externalId) {
+    try {
+      await this.resolve(platform, externalId);
+      return true;
+    } catch (error) {
+      if (error instanceof ExternalIdNotFoundError) return false;
+      throw error;
+    }
+  }
+  /**
+   * Get all external IDs for a Ghost
+   *
+   * Fetches Ghost data and returns external identifiers
+   */
+  async getExternalIds(ghostAddress) {
+    const ghost = await this.getGhost(ghostAddress);
+    return ghost.externalIdentifiers;
+  }
+  /**
+   * Search for Ghost by partial platform ID
+   *
+   * Note: This is a client-side filter, not server-side search
+   * For production, implement server-side search endpoint
+   */
+  async searchByExternalId(platform, partialId) {
+    throw new GhostSpeakError(
+      "Search not yet implemented",
+      "NOT_IMPLEMENTED"
+    );
+  }
+  /**
+   * Set custom API URL
+   */
+  setApiUrl(apiUrl) {
+    this.apiUrl = apiUrl;
+  }
+  /**
+   * Get current API URL
+   */
+  getApiUrl() {
+    return this.apiUrl;
+  }
+  /**
+   * Check API health
+   */
+  async checkHealth() {
+    try {
+      const response = await fetch(`${this.apiUrl}/health`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return await response.json();
+    } catch (error) {
+      throw new GhostSpeakError(
+        "Failed to check API health",
+        "HEALTH_CHECK_FAILED"
+      );
+    }
+  }
+};
+
+// src/modules/escrow/EscrowModule.ts
+var EscrowModule = class extends BaseModule {
+  /**
+   * Create a new escrow for a service agreement
+   *
+   * @param params - Escrow creation parameters
+   * @returns Transaction signature
+   */
+  async createEscrow(params) {
+    const instruction = await getCreateEscrowInstructionAsync({
+      agent: params.agent,
+      clientTokenAccount: params.clientTokenAccount,
+      escrowVault: params.escrowVault,
+      tokenMint: params.tokenMint,
+      client: params.client,
+      escrowId: params.escrowId,
+      amount: params.amount,
+      jobDescription: params.jobDescription,
+      deadline: params.deadline
+    }, { programAddress: this.programId });
+    return this.execute("createEscrow", () => instruction, [params.client]);
+  }
+  /**
+   * Submit proof of delivery for an escrow
+   *
+   * @param params - Delivery submission parameters
+   * @returns Transaction signature
+   */
+  async submitDelivery(params) {
+    const instruction = getSubmitDeliveryInstruction({
+      escrow: params.escrow,
+      agent: params.agent,
+      agentOwner: params.agentOwner,
+      deliveryProof: params.deliveryProof
+    }, { programAddress: this.programId });
+    return this.execute("submitDelivery", () => instruction, [params.agentOwner]);
+  }
+  /**
+   * Approve delivery and release funds to agent
+   *
+   * @param params - Approval parameters
+   * @returns Transaction signature
+   */
+  async approveDelivery(params) {
+    const instruction = getApproveDeliveryInstruction({
+      escrow: params.escrow,
+      escrowVault: params.escrowVault,
+      agentTokenAccount: params.agentTokenAccount,
+      client: params.client
+    }, { programAddress: this.programId });
+    return this.execute("approveDelivery", () => instruction, [params.client]);
+  }
+  /**
+   * File a dispute for an escrow
+   *
+   * @param params - Dispute filing parameters
+   * @returns Transaction signature
+   */
+  async fileDispute(params) {
+    const instruction = getFileDisputeInstruction({
+      escrow: params.escrow,
+      client: params.client,
+      reason: params.reason
+    }, { programAddress: this.programId });
+    return this.execute("fileDispute", () => instruction, [params.client]);
+  }
+  /**
+   * Arbitrate a disputed escrow
+   *
+   * @param params - Arbitration parameters
+   * @returns Transaction signature
+   */
+  async arbitrateDispute(params) {
+    const instruction = getArbitrateDisputeInstruction({
+      escrow: params.escrow,
+      escrowVault: params.escrowVault,
+      agentTokenAccount: params.agentTokenAccount,
+      clientTokenAccount: params.clientTokenAccount,
+      agentStaking: params.agentStaking,
+      arbitrator: params.arbitrator,
+      decision: params.decision
+    }, { programAddress: this.programId });
+    return this.execute("arbitrateDispute", () => instruction, [params.arbitrator]);
+  }
+  /**
+   * Get escrow account data
+   *
+   * @param escrowAddress - The escrow account address
+   * @returns Escrow data or null if not found
+   */
+  async getEscrow(escrowAddress) {
+    try {
+      return await this.getAccount(escrowAddress, "getGhostProtectEscrowDecoder");
+    } catch (error) {
+      console.error("Error fetching escrow:", error);
+      return null;
+    }
+  }
+};
+
+// src/index.ts
 init_reputation_tag_engine();
 
 // src/modules/indexer/X402TransactionIndexer.ts
@@ -139,26 +454,37 @@ var X402TransactionIndexer = class {
    * Check if transaction is an x402 payment
    *
    * x402 payments are characterized by:
-   * - SPL token transfer (TokenProgram or Token2022Program)
+   * - SPL token transfer (TokenProgram or Token2022Program) for USDC
+   * - Native SOL transfer (System Program)
    * - Transfer TO the facilitator address
    * - Optional memo instruction with payment metadata
+   *
+   * Supports both devnet and mainnet for all payment types
    */
   isX402Payment(transaction) {
     try {
       const instructions = transaction.transaction?.message?.instructions || [];
-      const hasTokenTransfer = instructions.some((ix) => {
+      const hasPaymentTransfer = instructions.some((ix) => {
         const programId = ix.programId?.toString();
         const isTokenProgram = programId === "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" || // SPL Token
         programId === "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
-        if (!isTokenProgram) return false;
-        const parsed = ix.parsed;
-        if (parsed?.type === "transfer" || parsed?.type === "transferChecked") {
-          const destination = parsed.info?.destination;
-          return destination === this.facilitatorAddress.toString();
+        if (isTokenProgram) {
+          const parsed = ix.parsed;
+          if (parsed?.type === "transfer" || parsed?.type === "transferChecked") {
+            const destination = parsed.info?.destination;
+            return destination === this.facilitatorAddress.toString();
+          }
+        }
+        if (programId === "11111111111111111111111111111111") {
+          const parsed = ix.parsed;
+          if (parsed?.type === "transfer") {
+            const destination = parsed.info?.destination;
+            return destination === this.facilitatorAddress.toString();
+          }
         }
         return false;
       });
-      return hasTokenTransfer;
+      return hasPaymentTransfer;
     } catch (error) {
       console.error("[X402 Indexer] Error checking if x402 payment:", error);
       return false;
@@ -172,7 +498,11 @@ var X402TransactionIndexer = class {
       const instructions = transaction.transaction?.message?.instructions || [];
       const transferIx = instructions.find((ix) => {
         const parsed = ix.parsed;
-        return parsed?.type === "transfer" || parsed?.type === "transferChecked";
+        const programId = ix.programId?.toString();
+        if (parsed?.type === "transfer" || parsed?.type === "transferChecked") {
+          return true;
+        }
+        return false;
       });
       if (!transferIx) {
         return null;
@@ -180,7 +510,7 @@ var X402TransactionIndexer = class {
       const transferInfo = transferIx.parsed.info;
       const merchant = transferInfo.destination;
       const payer = transferInfo.source;
-      const amount = transferInfo.amount || transferInfo.tokenAmount?.amount || "0";
+      const amount = transferInfo.amount || transferInfo.tokenAmount?.amount || transferInfo.lamports || "0";
       const success = transaction.meta?.err === null;
       const blockTime = transaction.blockTime;
       const timestamp = blockTime ? new Date(blockTime * 1e3) : /* @__PURE__ */ new Date();
@@ -189,12 +519,21 @@ var X402TransactionIndexer = class {
       );
       let responseTimeMs;
       let metadata;
-      if (memoIx && memoIx.data) {
+      if (memoIx) {
         try {
-          const memoText = Buffer.from(memoIx.data, "base64").toString("utf-8");
-          const memoData = JSON.parse(memoText);
-          responseTimeMs = memoData.responseTimeMs;
-          metadata = memoData;
+          let memoText;
+          if (memoIx.parsed) {
+            memoText = memoIx.parsed;
+          } else if (memoIx.data) {
+            memoText = Buffer.from(memoIx.data, "base64").toString("utf-8");
+          } else {
+            memoText = "";
+          }
+          if (memoText) {
+            const memoData = JSON.parse(memoText);
+            responseTimeMs = memoData.responseTimeMs;
+            metadata = memoData;
+          }
         } catch {
         }
       }
@@ -219,510 +558,6 @@ var X402TransactionIndexer = class {
 // src/index.ts
 init_reputation_tags();
 init_MultiSourceAggregator();
-var TIMESTAMP_TOLERANCE_MS = 5 * 60 * 1e3;
-var SIGNATURE_HEADER = "x-payai-signature";
-var TIMESTAMP_HEADER = "x-payai-timestamp";
-var PayAIWebhookHandler = class extends EventEmitter {
-  options;
-  verifySignatures;
-  authorizationModule;
-  payAIFacilitatorAddress;
-  constructor(options = {}, authorizationModule, payAIFacilitatorAddress) {
-    super();
-    this.options = options;
-    this.verifySignatures = options.verifySignatures ?? process.env.NODE_ENV === "production";
-    this.authorizationModule = authorizationModule;
-    this.payAIFacilitatorAddress = payAIFacilitatorAddress;
-  }
-  // =====================================================
-  // PUBLIC METHODS
-  // =====================================================
-  /**
-   * Handle an incoming webhook request
-   *
-   * @param request - The incoming HTTP request (must have headers and body)
-   * @returns Processing result
-   */
-  async handleWebhook(request) {
-    try {
-      const payload = typeof request.body === "string" ? JSON.parse(request.body) : request.body;
-      if (this.verifySignatures && this.options.webhookSecret) {
-        const bodyStr = typeof request.body === "string" ? request.body : JSON.stringify(request.body);
-        const verification = await this.verifySignature(
-          request.headers,
-          bodyStr
-        );
-        if (!verification.valid) {
-          return {
-            success: false,
-            error: verification.error ?? "Invalid signature"
-          };
-        }
-      }
-      return await this.processPayload(payload);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.emit("error", new Error(`Webhook processing failed: ${errorMessage}`));
-      return {
-        success: false,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * Verify webhook signature
-   */
-  async verifySignature(headers, body) {
-    const getHeader = (name) => {
-      if (headers instanceof Headers) {
-        return headers.get(name) ?? void 0;
-      }
-      return headers[name];
-    };
-    const signature = getHeader(SIGNATURE_HEADER);
-    const timestamp = getHeader(TIMESTAMP_HEADER);
-    if (!signature) {
-      return { valid: false, error: "Missing signature header" };
-    }
-    if (!timestamp) {
-      return { valid: false, error: "Missing timestamp header" };
-    }
-    const timestampMs = parseInt(timestamp, 10);
-    if (isNaN(timestampMs)) {
-      return { valid: false, error: "Invalid timestamp format" };
-    }
-    const now = Date.now();
-    if (Math.abs(now - timestampMs) > TIMESTAMP_TOLERANCE_MS) {
-      return { valid: false, error: "Timestamp too old or too far in future" };
-    }
-    if (!this.options.webhookSecret) {
-      return { valid: false, error: "Webhook secret not configured" };
-    }
-    const expectedSignature = this.computeSignature(
-      timestamp,
-      body,
-      this.options.webhookSecret
-    );
-    const signatureBuffer = Buffer.from(signature, "hex");
-    const expectedBuffer = Buffer.from(expectedSignature, "hex");
-    if (signatureBuffer.length !== expectedBuffer.length) {
-      return { valid: false, error: "Invalid signature" };
-    }
-    if (!timingSafeEqual(signatureBuffer, expectedBuffer)) {
-      return { valid: false, error: "Invalid signature" };
-    }
-    return { valid: true };
-  }
-  /**
-   * Convert a PayAI payment to a reputation record
-   */
-  paymentToReputationRecord(data) {
-    return {
-      agentAddress: data.merchant,
-      paymentSignature: data.transactionSignature,
-      amount: BigInt(data.amount),
-      success: data.success ?? data.status === "settled",
-      responseTimeMs: data.responseTimeMs ?? 0,
-      payerAddress: data.payer,
-      timestamp: new Date(data.settledAt ?? data.verifiedAt ?? Date.now()),
-      network: data.network
-    };
-  }
-  // =====================================================
-  // PRIVATE METHODS
-  // =====================================================
-  /**
-   * Process a verified webhook payload
-   */
-  async processPayload(payload) {
-    const { type, data } = payload;
-    switch (type) {
-      case "payment.verified":
-        this.emit("payment:verified", data);
-        await this.options.onPaymentVerified?.(data);
-        break;
-      case "payment.settled":
-        this.emit("payment:settled", data);
-        await this.options.onPaymentSettled?.(data);
-        if (this.options.onRecordReputation) {
-          if (this.authorizationModule && this.payAIFacilitatorAddress) {
-            const isAuthorized = await this.verifyOnChainAuthorization(data.merchant);
-            if (!isAuthorized) {
-              return {
-                success: false,
-                eventType: type,
-                paymentId: data.paymentId,
-                error: "Agent has not authorized PayAI facilitator to update reputation",
-                reputationRecorded: false
-              };
-            }
-          }
-          const record = this.paymentToReputationRecord(data);
-          await this.options.onRecordReputation(record);
-          this.emit("reputation:recorded", record);
-          return {
-            success: true,
-            eventType: type,
-            paymentId: data.paymentId,
-            reputationRecorded: true
-          };
-        }
-        break;
-      case "payment.failed":
-        this.emit("payment:failed", data);
-        await this.options.onPaymentFailed?.(data);
-        if (this.options.onRecordReputation) {
-          const record = this.paymentToReputationRecord(data);
-          record.success = false;
-          await this.options.onRecordReputation(record);
-          this.emit("reputation:recorded", record);
-          return {
-            success: true,
-            eventType: type,
-            paymentId: data.paymentId,
-            reputationRecorded: true
-          };
-        }
-        break;
-      case "payment.refunded":
-        break;
-      default:
-        return {
-          success: false,
-          error: `Unknown event type: ${type}`
-        };
-    }
-    return {
-      success: true,
-      eventType: type,
-      paymentId: data.paymentId,
-      reputationRecorded: false
-    };
-  }
-  /**
-   * Verify on-chain authorization for an agent
-   *
-   * Checks if the agent has pre-authorized the PayAI facilitator
-   * to update their reputation on-chain.
-   */
-  async verifyOnChainAuthorization(agentAddress) {
-    if (!this.authorizationModule || !this.payAIFacilitatorAddress) {
-      return true;
-    }
-    try {
-      const authorization = await this.authorizationModule.fetchAuthorization(
-        agentAddress,
-        this.payAIFacilitatorAddress
-      );
-      if (!authorization) {
-        return false;
-      }
-      const status = this.authorizationModule.getAuthorizationStatus(
-        authorization,
-        authorization.currentIndex
-      );
-      return status.isValid;
-    } catch (error) {
-      console.error("Failed to verify on-chain authorization:", error);
-      return false;
-    }
-  }
-  /**
-   * Compute HMAC-SHA256 signature for a webhook payload
-   */
-  computeSignature(timestamp, body, secret) {
-    const signedPayload = `${timestamp}.${body}`;
-    const hmac = createHmac("sha256", secret);
-    hmac.update(signedPayload);
-    return hmac.digest("hex");
-  }
-};
-function createPayAIWebhookHandler(options = {}) {
-  return new PayAIWebhookHandler(options);
-}
-function generateTestWebhookSignature(body, secret, timestamp) {
-  const ts = (timestamp ?? Date.now()).toString();
-  const signedPayload = `${ts}.${body}`;
-  const hmac = createHmac("sha256", secret);
-  hmac.update(signedPayload);
-  return {
-    signature: hmac.digest("hex"),
-    timestamp: ts
-  };
-}
-function createMockPayAIWebhook(overrides = {}) {
-  return {
-    id: `evt_${Date.now()}`,
-    type: "payment.settled",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    data: {
-      paymentId: `pay_${Date.now()}`,
-      transactionSignature: `${Math.random().toString(36).slice(2)}${Math.random().toString(36).slice(2)}`,
-      network: "solana",
-      payer: "PayerWalletAddress111111111111111111111111",
-      merchant: "MerchantAgentAddress11111111111111111111",
-      amount: "1000000",
-      // 1 USDC
-      asset: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-      assetSymbol: "USDC",
-      status: "settled",
-      resource: "https://api.example.com/ai/generate",
-      responseTimeMs: 250,
-      httpStatusCode: 200,
-      success: true,
-      settledAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...overrides
-    }
-  };
-}
-var DEFAULT_MARKETPLACE_URL = "https://marketplace.payai.network/api";
-var PayAIAgentSync = class extends EventEmitter {
-  config;
-  constructor(config = {}) {
-    super();
-    this.config = {
-      marketplaceUrl: config.marketplaceUrl ?? DEFAULT_MARKETPLACE_URL,
-      apiKey: config.apiKey,
-      network: config.network ?? "solana",
-      timeout: config.timeout ?? 3e4
-    };
-  }
-  // =====================================================
-  // PUBLIC METHODS
-  // =====================================================
-  /**
-   * Register a GhostSpeak agent with PayAI marketplace
-   *
-   * @param agent - Agent data from GhostSpeak
-   * @returns Registration result
-   */
-  async registerAgent(agent) {
-    try {
-      const registration = this.toPayAIRegistration(agent);
-      const response = await this.makeRequest("/merchants/register", {
-        method: "POST",
-        body: JSON.stringify(registration)
-      });
-      if (!response.ok) {
-        const error = await response.text();
-        return {
-          success: false,
-          error: `Registration failed: ${error}`
-        };
-      }
-      const data = await response.json();
-      this.emit("agent:registered", {
-        agentAddress: agent.address,
-        agentId: data.agentId
-      });
-      return {
-        success: true,
-        agentId: data.agentId,
-        marketplaceUrl: data.url
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      return {
-        success: false,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * Update an agent's registration on PayAI marketplace
-   *
-   * @param agentId - PayAI agent ID
-   * @param agent - Updated agent data
-   * @returns Update result
-   */
-  async updateAgent(agentId, agent) {
-    try {
-      const response = await this.makeRequest(`/merchants/${agentId}`, {
-        method: "PATCH",
-        body: JSON.stringify(agent)
-      });
-      if (!response.ok) {
-        const error = await response.text();
-        return {
-          success: false,
-          error: `Update failed: ${error}`
-        };
-      }
-      this.emit("agent:updated", { agentId });
-      return {
-        success: true,
-        agentId
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      return {
-        success: false,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * Remove an agent from PayAI marketplace
-   *
-   * @param agentId - PayAI agent ID
-   * @returns Removal result
-   */
-  async removeAgent(agentId) {
-    try {
-      const response = await this.makeRequest(`/merchants/${agentId}`, {
-        method: "DELETE"
-      });
-      if (!response.ok) {
-        const error = await response.text();
-        return {
-          success: false,
-          error: `Removal failed: ${error}`
-        };
-      }
-      this.emit("agent:removed", { agentId });
-      return {
-        success: true,
-        agentId
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      return {
-        success: false,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * Check if an agent is registered on PayAI marketplace
-   *
-   * @param agentAddress - Agent's Solana address
-   * @returns Whether agent is registered
-   */
-  async isAgentRegistered(agentAddress) {
-    try {
-      const response = await this.makeRequest(
-        `/merchants/check?address=${agentAddress}&network=${this.config.network}`
-      );
-      if (!response.ok) {
-        return false;
-      }
-      const data = await response.json();
-      return data.registered;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get agent's PayAI marketplace listing
-   *
-   * @param agentAddress - Agent's Solana address
-   * @returns Agent listing or null
-   */
-  async getAgentListing(agentAddress) {
-    try {
-      const response = await this.makeRequest(
-        `/merchants/by-address?address=${agentAddress}&network=${this.config.network}`
-      );
-      if (!response.ok) {
-        return null;
-      }
-      return response.json();
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Sync reputation score to PayAI marketplace
-   *
-   * Updates the agent's reputation score on PayAI based on
-   * GhostSpeak reputation calculations.
-   *
-   * @param agentId - PayAI agent ID
-   * @param reputationScore - New reputation score (0-10000)
-   * @returns Update result
-   */
-  async syncReputationScore(agentId, reputationScore) {
-    try {
-      const response = await this.makeRequest(`/merchants/${agentId}/reputation`, {
-        method: "POST",
-        body: JSON.stringify({
-          score: reputationScore,
-          source: "ghostspeak",
-          timestamp: Date.now()
-        })
-      });
-      if (!response.ok) {
-        const error = await response.text();
-        return {
-          success: false,
-          error: `Reputation sync failed: ${error}`
-        };
-      }
-      this.emit("reputation:synced", { agentId, reputationScore });
-      return {
-        success: true,
-        agentId
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      return {
-        success: false,
-        error: errorMessage
-      };
-    }
-  }
-  // =====================================================
-  // PRIVATE METHODS
-  // =====================================================
-  /**
-   * Convert GhostSpeak agent data to PayAI registration format
-   */
-  toPayAIRegistration(agent) {
-    return {
-      agentAddress: agent.address,
-      serviceEndpoint: agent.serviceEndpoint,
-      capabilities: agent.capabilities,
-      acceptedTokens: agent.acceptedTokens,
-      pricing: agent.pricing,
-      metadata: {
-        name: agent.name,
-        description: agent.description,
-        logo: agent.logo,
-        website: agent.website
-      }
-    };
-  }
-  /**
-   * Make an authenticated request to PayAI marketplace
-   */
-  async makeRequest(path, options = {}) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-    const headers = {
-      "Content-Type": "application/json",
-      "X-Ghostspeak-Integration": "1.0"
-    };
-    if (this.config.apiKey) {
-      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
-    }
-    try {
-      const response = await fetch(`${this.config.marketplaceUrl}${path}`, {
-        ...options,
-        headers: {
-          ...headers,
-          ...options.headers
-        },
-        signal: controller.signal
-      });
-      return response;
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-};
-function createPayAIAgentSync(config = {}) {
-  return new PayAIAgentSync(config);
-}
 
 // src/utils/test-ipfs-config.ts
 var TEST_IPFS_CONFIG = {
@@ -2346,6 +2181,6 @@ function clearFeatureGateCache() {
   featureCache.clear();
 }
 
-export { CircuitBreaker, DEFAULT_RETRY_CONFIG, FEATURE_GATES, FallbackHandler, IPFSErrorHandler, IPFSOperationError, IPFSProvider, LocalStorageProvider, PayAIAgentSync, PayAIWebhookHandler, PrivateDataQuery, PrivateMetadataStorage, RetryHandler, TEST_IPFS_CONFIG, WalletFundingService, X402TransactionIndexer, checkFeatureGate, clearFeatureGateCache, createIPFSErrorHandler, createMockPayAIWebhook, createPayAIAgentSync, createPayAIWebhookHandler, createPrivacyManifest, createTestIPFSConfig, defaultFundingService, ensureMinimumBalance, estimateStorageCost, fundWallet, generateTestWebhookSignature, isIPFSError, withIPFSErrorHandling };
+export { CircuitBreaker, DEFAULT_RETRY_CONFIG, EscrowModule, ExternalIdResolver, FEATURE_GATES, FallbackHandler, IPFSErrorHandler, IPFSOperationError, IPFSProvider, LocalStorageProvider, PrivateDataQuery, PrivateMetadataStorage, RetryHandler, TEST_IPFS_CONFIG, WalletFundingService, X402TransactionIndexer, checkFeatureGate, clearFeatureGateCache, createIPFSErrorHandler, createPrivacyManifest, createTestIPFSConfig, defaultFundingService, ensureMinimumBalance, estimateStorageCost, fundWallet, isIPFSError, withIPFSErrorHandling };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map