@ghostspeak/sdk 2.0.5 → 2.0.7

package/dist/index.js

@@ -1,31 +1,29 @@
-export { WorkOrderModule } from './chunk-ZWOYNHVK.js';
-export { CredentialKind, CredentialModule, CredentialStatus, CrossmintVCClient, GHOSTSPEAK_CREDENTIAL_TYPES, GhostSpeakClient, MultisigModule, UnifiedCredentialService, GhostSpeakClient_default as default, lamportsToSol, sol } from './chunk-FKRN4PW5.js';
-export { AgentModule, BaseModule, ChannelModule, DEFAULT_IPFS_CONFIG, EscrowModule, GHOSTSPEAK_PROGRAM_ID, GovernanceModule, IPFSUtils, InstructionBuilder, MarketplaceModule, RpcClient, Token2022Module, createIPFSUtils, createMetadataUri, determineStorageMethod } from './chunk-TVVGXYCI.js';
+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 { 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-UJUGGLMT.js';
-import { getFeatureFlags, ClientEncryptionService } from './chunk-V3SOFUAZ.js';
-export { ClientEncryptionService, FeatureFlagManager, TokenAccountState, TokenExtension, TokenProgram, basisPointsToPercentage, calculateCompoundInterest, calculateInterest, calculateRequiredAmountForNetTransfer, calculateTransferFee, canTransfer, createDiscriminatorErrorMessage, createMigrationPlan, createMigrationReport, createTransferHookInstruction, deriveAssociatedTokenAddress, deriveSplTokenAssociatedTokenAddress, deriveToken2022AssociatedTokenAddress, deserializeTokenMetadata, detectTokenProgram, diagnoseAccountFromChain, diagnoseBatchFromChain, estimateAccumulatedFees, estimateComputeUnits, exportDiagnosticReport, extractLegacyData, formatBasisPoints, formatTokenAmount, generateConfidentialTransferProof, generateLocalPrivacyProof, getAllAssociatedTokenAddresses, getAssociatedTokenAccount, getConfidentialTransferConfig, getFeatureFlags, getInterestBearingConfig, getMigrationInstructions, getRequiredExtensions, getTokenProgramAddress, getTokenProgramFromAddress, getTokenProgramType, getTransferFeeConfig, hasConfidentialTransferExtension, hasInterestBearingExtension, hasTransferFeeExtension, inspectAccountData, isFeatureEnabled, isToken2022Mint, parseTokenAmount, percentageToBasisPoints, runAccountDiagnostics, runBatchDiagnostics, safeDecodeAgent, serializeTokenMetadata, simulateMigration, validateAccountDiscriminator, validateAssociatedTokenAddress, validateTransferHookInstruction, verifyConfidentialTransferProof, verifyLocalPrivacyProof } from './chunk-V3SOFUAZ.js';
-import './chunk-IAWBZYPE.js';
-export { deriveMultisigPda, deriveProposalPda } from './chunk-ZGP5552B.js';
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, GhostSpeakSDKError, INSTRUCTION_MAPPINGS, IPFSClient, InstructionValidationError, NATIVE_MINT_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, createAccountMismatchError, createErrorContext, debugInstructionCall, enhanceErrorMessage, enhanceTransactionError, extractInstructionName, generateAccountValidationError, getAccountRequirements, getInstructionMapping, getPDAAccounts, getRequiredSigners, getWritableAccounts, isKnownInstruction, logEnhancedError, validateInstructionAccounts, validatePreconditions, withEnhancedErrors, withEnhancedErrorsSync } from './chunk-OWYHJG6H.js';
-import { GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, getCreateA2aSessionInstructionAsync, fetchA2ASession, getSendA2aMessageInstruction, getUpdateA2aStatusInstruction, fetchMaybeA2ASession, fetchA2AMessage, fetchA2AStatus, getCreateCommunicationSessionInstructionAsync, getSendCommunicationMessageInstruction } from './chunk-COGZFWOT.js';
-export { GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, getAddMessageReactionInstruction, getCancelEscrowInstruction, getChannelDecoder, getCompleteEscrowInstruction, getCreateEnhancedChannelInstructionAsync, getCreateEscrowInstructionAsync, getCreateWorkOrderInstruction, getDisputeEscrowInstruction, getEscrowDecoder, getJoinChannelInstruction, getLeaveChannelInstruction, getMessageDecoder, getProcessPartialRefundInstruction, getProcessPaymentInstruction, getRegisterAgentInstructionAsync, getRejectWorkDeliveryInstruction, getSendEnhancedMessageInstructionAsync, getSubmitWorkDeliveryInstruction, getUpdateChannelSettingsInstruction, getVerifyWorkDeliveryInstruction, getWorkDeliveryDecoder, getWorkOrderDecoder } from './chunk-COGZFWOT.js';
-export { deriveA2AMessagePda, deriveA2ASessionPda, deriveAgentPda, deriveAgentVerificationPda, deriveChannelPda, deriveEscrowPDA, deriveJobApplicationPda, deriveJobPostingPda, derivePaymentPda, deriveServiceListingPda, deriveServicePurchasePda, deriveUserRegistryPda, deriveWorkDeliveryPda, deriveWorkOrderPda, findProgramDerivedAddress } from './chunk-ASQXX4IT.js';
-import './chunk-RERCHKZP.js';
-import './chunk-RDDPOFR5.js';
-export { AgentType, ChannelType, ErrorCode, EscrowStatus, MessageType, isError, isSuccess, unwrap } from './chunk-SRS2SKFS.js';
-import { getAgentDecoder, fetchMaybeAgent, getCommunicationSessionDataDecoder } from './chunk-GMHIUK2R.js';
-export { AuctionStatus, AuctionType, DisputeStatus, ParticipantType, ProposalStatus, WorkOrderStatus, getAgentDecoder } from './chunk-GMHIUK2R.js';
-import { __export, __require } from './chunk-NSBPE2FW.js';
-import { createSolanaRpc, lamports, pipe, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, getBase64EncodedWireTransaction, createKeyPairSignerFromBytes, generateKeyPairSigner, appendTransactionMessageInstruction, getProgramDerivedAddress, getBytesEncoder, getAddressEncoder } from '@solana/kit';
+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';
+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 { 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 { address } from '@solana/addresses';
-import { pipe as pipe$1 } from '@solana/functional';
 import { EventEmitter } from 'events';
-import { eq, sql, and, desc } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/libsql';
-import { createClient } from '@libsql/client';
-import { sqliteTable, integer, text, index, real } from 'drizzle-orm/sqlite-core';
+import { timingSafeEqual, createHmac } from 'crypto';
 import { getTransferSolInstruction } from '@solana-program/system';
 import { promises } from 'fs';
 import process2 from 'process';
@@ -34,3625 +32,696 @@ 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 X402Client = class extends EventEmitter {
-  constructor(rpc, wallet) {
-    super();
-    this.rpc = rpc;
-    this.wallet = wallet;
-  }
-  /**
-   * Create an x402 payment request
-   * Returns HTTP 402 compatible headers
-   */
-  createPaymentRequest(params) {
-    if (!this.wallet) {
-      throw new Error("Wallet required to create payment request");
-    }
-    const recipient = this.wallet.address;
-    return {
-      recipient,
-      amount: params.amount,
-      token: params.token,
-      description: params.description,
-      metadata: params.metadata,
-      expiresAt: params.expiresAt ?? Date.now() + 3e5,
-      // 5 minutes default
-      requiresReceipt: true
-    };
-  }
-  /**
-   * Create HTTP 402 response headers
-   */
-  createPaymentHeaders(request) {
-    const headers = {
-      "X-Payment-Address": request.recipient,
-      "X-Payment-Amount": request.amount.toString(),
-      "X-Payment-Token": request.token,
-      "X-Payment-Blockchain": "solana"
-    };
-    if (request.description) {
-      headers["X-Payment-Description"] = request.description;
-    }
-    if (request.expiresAt) {
-      headers["X-Payment-Expires-At"] = request.expiresAt.toString();
-    }
-    return headers;
+init_reputation_tag_engine();
+
+// src/modules/indexer/X402TransactionIndexer.ts
+var X402TransactionIndexer = class {
+  rpc;
+  facilitatorAddress;
+  network;
+  batchSize;
+  constructor(config) {
+    this.rpc = config.rpc;
+    this.facilitatorAddress = config.facilitatorAddress;
+    this.network = config.network || "solana";
+    this.batchSize = config.batchSize || 100;
   }
+  // =====================================================
+  // PUBLIC METHODS
+  // =====================================================
   /**
-   * Execute an x402 payment
+   * Poll for new x402 transactions since last sync
+   *
+   * @param lastSignature - Last processed signature (for pagination)
+   * @param limit - Maximum transactions to fetch
+   * @returns Array of parsed x402 payment data
    */
-  async pay(request) {
-    if (!this.wallet) {
-      throw new Error("Wallet required to make payment");
-    }
-    if (request.amount <= 0n) {
-      throw new Error("Payment amount must be greater than zero");
-    }
-    if (!request.recipient) {
-      throw new Error("Payment recipient address is required");
-    }
-    if (!request.token) {
-      throw new Error("Payment token address is required");
-    }
-    this.emit("payment_created", {
-      type: "payment_created",
-      request,
-      timestamp: Date.now()
-    });
+  async pollTransactions(lastSignature, limit) {
     try {
-      const transferIx = await this.createTransferInstruction(
-        request.recipient,
-        request.amount,
-        request.token
-      ).catch((error) => {
-        throw new Error(
-          `Failed to create transfer instruction: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      });
-      const memoIx = this.createMemoInstruction(
-        `x402:${request.description}:${JSON.stringify(request.metadata ?? {})}`
-      );
-      const { value: latestBlockhash } = await this.rpc.getLatestBlockhash().send().catch((error) => {
-        throw new Error(
-          `Failed to fetch latest blockhash: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      });
-      const feePayerAddress = this.wallet.address;
-      const message = pipe$1(
-        createTransactionMessage({ version: 0 }),
-        (m) => setTransactionMessageFeePayer(feePayerAddress, m),
-        (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
-        (m) => appendTransactionMessageInstruction(transferIx, m),
-        (m) => appendTransactionMessageInstruction(memoIx, m)
-      );
-      const signedTransaction = await signTransactionMessageWithSigners(message).catch((error) => {
-        throw new Error(
-          `Failed to sign transaction: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      });
-      const signature = await this.sendAndConfirmTransactionManually(signedTransaction).catch((error) => {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        if (errorMessage.includes("insufficient funds")) {
-          throw new Error("Insufficient funds to complete payment");
-        }
-        if (errorMessage.includes("Blockhash not found")) {
-          throw new Error("Transaction expired. Please retry the payment.");
-        }
-        if (errorMessage.includes("InvalidAccountOwner")) {
-          throw new Error(
-            "Associated Token Account not found or invalid. Please ensure the token account exists for both sender and recipient."
-          );
+      const signatures = await this.getSignatures(lastSignature, limit);
+      if (signatures.length === 0) {
+        return [];
+      }
+      console.log(`[X402 Indexer] Found ${signatures.length} new transactions`);
+      const payments = [];
+      for (const sig of signatures) {
+        try {
+          const payment = await this.parseTransaction(sig.signature);
+          if (payment) {
+            payments.push(payment);
+          }
+        } catch (error) {
+          console.error(`[X402 Indexer] Failed to parse transaction ${sig.signature}:`, error);
         }
-        throw new Error(
-          `Transaction failed: ${errorMessage}`
-        );
-      });
-      this.emit("payment_sent", {
-        type: "payment_sent",
-        signature,
-        request,
-        timestamp: Date.now()
-      });
-      const tx = await this.rpc.getTransaction(signature, {
-        encoding: "jsonParsed",
-        maxSupportedTransactionVersion: 0
-      }).send().catch((error) => {
-        console.warn("Payment succeeded but failed to fetch transaction details:", error);
-        return null;
-      });
-      const receipt = {
-        signature,
-        recipient: request.recipient,
-        amount: request.amount,
-        token: request.token,
-        timestamp: Date.now(),
-        metadata: request.metadata,
-        blockTime: tx?.blockTime ? Number(tx.blockTime) : void 0,
-        slot: tx?.slot ?? void 0
-      };
-      this.emit("payment_confirmed", {
-        type: "payment_confirmed",
-        signature,
-        request,
-        receipt,
-        timestamp: Date.now()
-      });
-      return receipt;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.emit("payment_failed", {
-        type: "payment_failed",
-        request,
-        error: errorMessage,
-        timestamp: Date.now()
-      });
-      if (error instanceof Error) {
-        throw error;
       }
-      throw new Error(`Payment failed: ${String(error)}`);
+      console.log(`[X402 Indexer] Parsed ${payments.length} x402 payments`);
+      return payments;
+    } catch (error) {
+      console.error("[X402 Indexer] Failed to poll transactions:", error);
+      throw error;
     }
   }
   /**
-   * Verify an x402 payment
+   * Parse a specific transaction signature
+   *
+   * @param signature - Transaction signature to parse
+   * @returns Parsed x402 payment data or null if not an x402 payment
    */
-  async verifyPayment(signature) {
+  async parseTransaction(sig) {
     try {
-      const tx = await this.rpc.getTransaction(signature, {
-        encoding: "jsonParsed",
-        maxSupportedTransactionVersion: 0
+      const txSignature = typeof sig === "string" ? sig : sig;
+      const response = await this.rpc.getTransaction(txSignature, {
+        maxSupportedTransactionVersion: 0,
+        encoding: "jsonParsed"
       }).send();
-      if (!tx) {
-        return {
-          valid: false,
-          error: "Transaction not found"
-        };
+      if (!response || !response.transaction) {
+        return null;
       }
-      if (tx.meta?.err !== null) {
-        return {
-          valid: false,
-          error: "Transaction failed"
-        };
+      const isX402 = this.isX402Payment(response);
+      if (!isX402) {
+        return null;
       }
-      const receipt = this.parseTransactionReceipt(tx, signature);
-      return {
-        valid: true,
-        receipt
-      };
+      return this.extractPaymentData(response, typeof sig === "string" ? sig : String(sig));
     } catch (error) {
-      return {
-        valid: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Verify payment for specific recipient and amount
-   */
-  async verifyPaymentDetails(params) {
-    const result = await this.verifyPayment(params.signature);
-    if (!result.valid || !result.receipt) {
-      return result;
-    }
-    if (result.receipt.recipient !== params.expectedRecipient) {
-      return {
-        valid: false,
-        error: "Recipient mismatch"
-      };
-    }
-    if (result.receipt.amount !== params.expectedAmount) {
-      return {
-        valid: false,
-        error: "Amount mismatch"
-      };
-    }
-    if (result.receipt.token !== params.expectedToken) {
-      return {
-        valid: false,
-        error: "Token mismatch"
-      };
-    }
-    return {
-      valid: true,
-      receipt: result.receipt
-    };
-  }
-  /**
-   * Get payment status
-   */
-  async getPaymentStatus(signature) {
-    try {
-      const status = await this.rpc.getSignatureStatuses([signature]).send();
-      if (!status.value[0]) {
-        return { status: "not_found" };
-      }
-      const txStatus = status.value[0];
-      if (txStatus.err) {
-        return { status: "failed" };
-      }
-      if (txStatus.confirmationStatus === "finalized") {
-        return { status: "finalized", confirmations: 32 };
-      }
-      if (txStatus.confirmationStatus === "confirmed") {
-        return { status: "confirmed", confirmations: 1 };
-      }
-      return { status: "pending" };
-    } catch {
-      return { status: "not_found" };
+      console.error(`[X402 Indexer] Failed to fetch transaction ${sig}:`, error);
+      return null;
     }
   }
   // =====================================================
-  // PRIVATE HELPER METHODS
+  // PRIVATE METHODS
   // =====================================================
-  async createTransferInstruction(recipient, amount, token) {
-    if (!this.wallet) {
-      throw new Error("Wallet required");
-    }
-    const sourceAccount = await this.getAssociatedTokenAddress(
-      this.wallet.address,
-      token
-    );
-    const destinationAccount = await this.getAssociatedTokenAddress(
-      recipient,
-      token
-    );
-    const TOKEN_PROGRAM_ID = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
-    const keys = [
-      { address: sourceAccount, role: 1, isWritable: true, isSigner: false },
-      { address: destinationAccount, role: 1, isWritable: true, isSigner: false },
-      { address: this.wallet.address, role: 2, isWritable: false, isSigner: true }
-    ];
-    const data = new Uint8Array(9);
-    data[0] = 3;
-    const amountBytes = new BigUint64Array([amount]);
-    data.set(new Uint8Array(amountBytes.buffer), 1);
-    return {
-      programAddress: TOKEN_PROGRAM_ID,
-      accounts: keys,
-      data
-    };
-  }
-  createMemoInstruction(memo) {
-    const MEMO_PROGRAM_ID = address("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
-    return {
-      programAddress: MEMO_PROGRAM_ID,
-      accounts: [],
-      data: new TextEncoder().encode(memo)
-    };
-  }
-  async getAssociatedTokenAddress(owner, token) {
-    try {
-      const response = await this.rpc.getTokenAccountsByOwner(
-        owner,
-        { mint: token },
-        { encoding: "jsonParsed" }
-      ).send();
-      if (response.value.length > 0) {
-        return response.value[0].pubkey;
-      }
-      throw new Error(
-        `Associated Token Account not found for owner ${owner} and mint ${token}. Please ensure the ATA is initialized before making payments. Use createAssociatedTokenAccountInstruction to create it.`
-      );
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Associated Token Account not found")) {
-        throw error;
-      }
-      throw new Error(
-        `Failed to get Associated Token Account: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  parseTransactionReceipt(tx, signature) {
-    const instructions = tx.transaction?.message?.instructions ?? [];
-    const transferInstruction = instructions.find((ix) => {
-      const parsed2 = typeof ix.parsed === "object" ? ix.parsed : null;
-      return ix.program === "spl-token" && parsed2?.type === "transfer";
-    });
-    if (!transferInstruction) {
-      throw new Error("No SPL token transfer found in transaction");
-    }
-    const parsed = typeof transferInstruction.parsed === "object" ? transferInstruction.parsed : null;
-    const transferInfo = parsed?.info;
-    if (!transferInfo) {
-      throw new Error("Failed to parse SPL token transfer instruction");
-    }
-    const recipient = address(transferInfo.destination ?? transferInfo.account ?? "");
-    const amount = BigInt(transferInfo.amount ?? transferInfo.tokenAmount?.amount ?? "0");
-    let tokenMint;
-    const tokenBalances = tx.meta?.preTokenBalances ?? [];
-    if (tokenBalances.length > 0) {
-      tokenMint = address(String(tokenBalances[0].mint));
-    } else {
-      throw new Error("Failed to extract token mint from transaction");
-    }
-    const memoInstruction = instructions.find((ix) => {
-      const programIdStr = typeof ix.programId === "string" ? ix.programId : ix.programId?.toString() ?? "";
-      return ix.program === "spl-memo" || programIdStr === "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
-    });
-    let metadata;
-    if (memoInstruction) {
-      try {
-        const parsedMemo = typeof memoInstruction.parsed === "string" ? memoInstruction.parsed : typeof memoInstruction.parsed === "object" ? memoInstruction.parsed?.data ?? "" : "";
-        const memoText = parsedMemo || (memoInstruction.data ? new TextDecoder().decode(Buffer.from(memoInstruction.data, "base64")) : "");
-        if (typeof memoText === "string" && memoText.startsWith("x402:")) {
-          const parts = memoText.split(":");
-          if (parts.length >= 3) {
-            try {
-              metadata = JSON.parse(parts[2]);
-            } catch {
-            }
-          }
-        }
-      } catch {
-      }
-    }
-    const blockTimeNum = tx.blockTime != null ? typeof tx.blockTime === "bigint" ? Number(tx.blockTime) : tx.blockTime : void 0;
-    return {
-      signature,
-      recipient,
-      amount,
-      token: tokenMint,
-      timestamp: blockTimeNum != null ? blockTimeNum * 1e3 : Date.now(),
-      metadata,
-      blockTime: blockTimeNum,
-      slot: tx.slot
-    };
-  }
-  /**
-   * Send and confirm transaction manually (simplified implementation)
-   * This is a workaround for the missing rpcSubscriptions dependency
-   */
-  async sendAndConfirmTransactionManually(signedTransaction) {
-    const signatures = Object.values(signedTransaction.signatures);
-    if (signatures.length === 0) {
-      throw new Error("Transaction has no signatures");
-    }
-    const firstSig = signatures[0];
-    if (!firstSig) {
-      throw new Error("Transaction signature is null");
-    }
-    const signature = firstSig;
-    const wireTransaction = getBase64EncodedWireTransaction(signedTransaction);
-    await this.rpc.sendTransaction(wireTransaction).send();
-    for (let i = 0; i < 30; i++) {
-      const status = await this.rpc.getSignatureStatuses([signature]).send();
-      if (status.value[0]?.confirmationStatus === "confirmed" || status.value[0]?.confirmationStatus === "finalized") {
-        return signature;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-    }
-    throw new Error("Transaction confirmation timeout");
-  }
-};
-function createX402Client(rpcUrl, wallet) {
-  const rpc = createSolanaRpc(rpcUrl);
-  return new X402Client(rpc, wallet);
-}
-
-// src/database/config.ts
-var DEFAULT_CONFIG = {
-  mode: process.env.NODE_ENV === "production" ? "production" : "development",
-  pool: {
-    max: 10,
-    min: 2,
-    connectionTimeoutMs: 5e3,
-    idleTimeoutMs: 3e4
-  }
-};
-function getTursoConfig() {
-  const url = process.env.TURSO_DATABASE_URL ?? null;
-  const authToken = process.env.TURSO_AUTH_TOKEN ?? null;
-  const enabled = Boolean(url && authToken);
-  if (!enabled && (url ?? authToken)) {
-    console.warn(
-      "[GhostSpeak Database] Incomplete Turso configuration detected. Both TURSO_DATABASE_URL and TURSO_AUTH_TOKEN are required. Falling back to on-chain only mode."
-    );
-  }
-  return {
-    url,
-    authToken,
-    enabled,
-    ...DEFAULT_CONFIG
-  };
-}
-function validateConfig(config) {
-  if (!config.enabled) {
-    return false;
-  }
-  if (!config.url || !config.authToken) {
-    return false;
-  }
-  if (!config.url.startsWith("libsql://") && !config.url.startsWith("http://") && !config.url.startsWith("https://")) {
-    console.error("[GhostSpeak Database] Invalid TURSO_DATABASE_URL format. Expected libsql://, http://, or https://");
-    return false;
-  }
-  return true;
-}
-
-// src/database/connection.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 3,
-  initialDelayMs: 1e3,
-  maxDelayMs: 1e4,
-  backoffMultiplier: 2
-};
-var connectionState = {
-  client: null,
-  initialized: false,
-  healthy: false,
-  lastError: null,
-  retryCount: 0,
-  lastConnectAttempt: 0
-};
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function getRetryDelay(retryCount, config) {
-  const delay = Math.min(
-    config.initialDelayMs * Math.pow(config.backoffMultiplier, retryCount),
-    config.maxDelayMs
-  );
-  return delay;
-}
-async function initializeConnection(config, retryConfig = DEFAULT_RETRY_CONFIG) {
-  let lastError = null;
-  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
-    try {
-      connectionState.lastConnectAttempt = Date.now();
-      if (attempt > 0) {
-        const delay = getRetryDelay(attempt - 1, retryConfig);
-        console.log(`[GhostSpeak Database] Retrying connection (attempt ${attempt + 1}/${retryConfig.maxRetries + 1}) after ${delay}ms...`);
-        await sleep(delay);
-      }
-      const client = createClient({
-        url: config.url,
-        authToken: config.authToken
-      });
-      await client.execute("SELECT 1");
-      console.log("[GhostSpeak Database] Connection established successfully");
-      connectionState.retryCount = attempt;
-      connectionState.healthy = true;
-      connectionState.lastError = null;
-      return client;
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      console.error(`[GhostSpeak Database] Connection attempt ${attempt + 1} failed:`, lastError.message);
-      if (attempt === retryConfig.maxRetries) {
-        connectionState.healthy = false;
-        connectionState.lastError = lastError;
-        break;
-      }
-    }
-  }
-  throw new Error(
-    `Failed to connect to Turso database after ${retryConfig.maxRetries + 1} attempts. Last error: ${lastError?.message ?? "Unknown error"}`
-  );
-}
-async function getConnection() {
-  const config = getTursoConfig();
-  if (!config.enabled) {
-    throw new Error(
-      "Turso database not configured. Set TURSO_DATABASE_URL and TURSO_AUTH_TOKEN environment variables."
-    );
-  }
-  if (!validateConfig(config)) {
-    throw new Error("Invalid Turso database configuration");
-  }
-  if (connectionState.client && connectionState.healthy) {
-    return connectionState.client;
-  }
-  if (!connectionState.initialized || !connectionState.healthy) {
-    connectionState.initialized = true;
-    connectionState.client = await initializeConnection(config);
-  }
-  return connectionState.client;
-}
-async function isAvailable() {
-  const config = getTursoConfig();
-  if (!config.enabled) {
-    return false;
-  }
-  try {
-    await getConnection();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/database/schema/agents.ts
-var agents_exports = {};
-__export(agents_exports, {
-  agentCapabilities: () => agentCapabilities,
-  agentPricing: () => agentPricing,
-  agents: () => agents
-});
-var agents = sqliteTable("agents", {
-  // Primary key - Solana address
-  agentAddress: text("agent_address").primaryKey(),
-  // Basic info
-  owner: text("owner").notNull(),
-  name: text("name").notNull(),
-  description: text("description").notNull(),
-  // Reputation & stats
-  reputationScore: integer("reputation_score").notNull().default(0),
-  totalJobsCompleted: integer("total_jobs_completed").notNull().default(0),
-  totalEarnings: text("total_earnings").notNull().default("0"),
-  // Stored as text for u64
-  // Status
-  isActive: integer("is_active", { mode: "boolean" }).notNull().default(true),
-  isVerified: integer("is_verified", { mode: "boolean" }).notNull().default(false),
-  verificationTimestamp: integer("verification_timestamp").notNull().default(0),
-  // Pricing
-  originalPrice: text("original_price").notNull().default("0"),
-  replicationFee: text("replication_fee").notNull().default("0"),
-  // Configuration
-  genomeHash: text("genome_hash").notNull().default(""),
-  isReplicable: integer("is_replicable", { mode: "boolean" }).notNull().default(false),
-  serviceEndpoint: text("service_endpoint").notNull().default(""),
-  metadataUri: text("metadata_uri").notNull().default(""),
-  // Framework & lineage
-  frameworkOrigin: text("framework_origin").notNull().default(""),
-  cnftMint: text("cnft_mint"),
-  // Nullable
-  merkleTree: text("merkle_tree"),
-  // Nullable
-  supportsA2a: integer("supports_a2a", { mode: "boolean" }).notNull().default(false),
-  transferHook: text("transfer_hook"),
-  // Nullable
-  parentAgent: text("parent_agent"),
-  // Nullable
-  generation: integer("generation").notNull().default(0),
-  // x402 Payment Protocol
-  x402Enabled: integer("x402_enabled", { mode: "boolean" }).notNull().default(false),
-  x402PaymentAddress: text("x402_payment_address").notNull(),
-  x402PricePerCall: text("x402_price_per_call").notNull().default("0"),
-  x402ServiceEndpoint: text("x402_service_endpoint").notNull().default(""),
-  x402TotalPayments: text("x402_total_payments").notNull().default("0"),
-  x402TotalCalls: text("x402_total_calls").notNull().default("0"),
-  lastPaymentTimestamp: integer("last_payment_timestamp").notNull().default(0),
-  // API Schema
-  apiSpecUri: text("api_spec_uri").notNull().default(""),
-  apiVersion: text("api_version").notNull().default(""),
-  // Timestamps
-  createdAt: integer("created_at").notNull(),
-  updatedAt: integer("updated_at").notNull(),
-  cachedAt: integer("cached_at").notNull(),
-  // When cached from chain
-  // Bump seed for PDA
-  bump: integer("bump").notNull()
-}, (table) => ({
-  // Indexes for common queries
-  ownerIdx: index("idx_agents_owner").on(table.owner),
-  x402EnabledIdx: index("idx_agents_x402_enabled").on(table.x402Enabled),
-  reputationIdx: index("idx_agents_reputation").on(table.reputationScore),
-  frameworkIdx: index("idx_agents_framework").on(table.frameworkOrigin),
-  verifiedIdx: index("idx_agents_verified").on(table.isVerified),
-  cachedAtIdx: index("idx_agents_cached_at").on(table.cachedAt)
-}));
-var agentCapabilities = sqliteTable("agent_capabilities", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
-  agentAddress: text("agent_address").notNull().references(() => agents.agentAddress, { onDelete: "cascade" }),
-  capability: text("capability").notNull()
-}, (table) => ({
-  // Composite index for lookups
-  agentCapabilityIdx: index("idx_agent_capability").on(table.agentAddress, table.capability)
-}));
-var agentPricing = sqliteTable("agent_pricing", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
-  agentAddress: text("agent_address").notNull().references(() => agents.agentAddress, { onDelete: "cascade" }),
-  tokenAddress: text("token_address").notNull(),
-  // SPL token mint address
-  decimals: integer("decimals").notNull(),
-  symbol: text("symbol").notNull()
-}, (table) => ({
-  // Index for token lookups
-  agentTokenIdx: index("idx_agent_token").on(table.agentAddress, table.tokenAddress)
-}));
-
-// src/database/schema/transactions.ts
-var transactions_exports = {};
-__export(transactions_exports, {
-  x402Transactions: () => x402Transactions
-});
-var x402Transactions = sqliteTable("x402_transactions", {
-  // Primary key - Solana transaction signature
-  signature: text("signature").primaryKey(),
-  // Addresses
-  agentAddress: text("agent_address").notNull(),
-  // Agent that received payment
-  payerAddress: text("payer_address").notNull(),
-  // Who paid
-  recipientAddress: text("recipient_address").notNull(),
-  // Payment recipient
-  // Payment details
-  amount: text("amount").notNull(),
-  // Amount in token's smallest unit (stored as text for bigint)
-  tokenMint: text("token_mint").notNull(),
-  // Token used for payment
-  tokenDecimals: integer("token_decimals").notNull(),
-  // Transaction status
-  status: text("status").notNull().default("confirmed"),
-  // 'confirmed', 'finalized', 'failed'
-  // Timing
-  blockTime: integer("block_time").notNull(),
-  // Unix timestamp from Solana
-  responseTimeMs: integer("response_time_ms"),
-  // API response time (nullable)
-  // Metadata
-  metadataHash: text("metadata_hash"),
-  // IPFS hash if applicable (nullable)
-  // Timestamps
-  createdAt: integer("created_at").notNull(),
-  // When indexed
-  updatedAt: integer("updated_at").notNull()
-  // Last update
-}, (table) => ({
-  // Indexes for common queries
-  agentIdx: index("idx_tx_agent").on(table.agentAddress),
-  payerIdx: index("idx_tx_payer").on(table.payerAddress),
-  blockTimeIdx: index("idx_tx_block_time").on(table.blockTime),
-  statusIdx: index("idx_tx_status").on(table.status),
-  tokenIdx: index("idx_tx_token").on(table.tokenMint),
-  // Composite index for agent + time range queries
-  agentTimeIdx: index("idx_tx_agent_time").on(table.agentAddress, table.blockTime)
-}));
-
-// src/database/schema/analytics.ts
-var analytics_exports = {};
-__export(analytics_exports, {
-  agentAnalytics: () => agentAnalytics,
-  dailyMetrics: () => dailyMetrics,
-  marketAnalytics: () => marketAnalytics
-});
-var agentAnalytics = sqliteTable("agent_analytics", {
-  // Primary key - agent address
-  agentAddress: text("agent_address").primaryKey(),
-  // Revenue metrics
-  totalRevenue: text("total_revenue").notNull().default("0"),
-  // Stored as text for bigint
-  // Transaction metrics
-  totalTransactions: integer("total_transactions").notNull().default(0),
-  successfulTransactions: integer("successful_transactions").notNull().default(0),
-  successRate: real("success_rate").notNull().default(0),
-  // Percentage 0-100
-  // Quality metrics
-  averageRating: real("average_rating").notNull().default(0),
-  averageResponseTimeMs: integer("average_response_time_ms").notNull().default(0),
-  // Activity
-  lastTransactionAt: integer("last_transaction_at"),
-  // Unix timestamp (nullable)
-  // Timestamp
-  updatedAt: integer("updated_at").notNull()
-}, (table) => ({
-  updatedAtIdx: index("idx_agent_analytics_updated").on(table.updatedAt)
-}));
-var marketAnalytics = sqliteTable("market_analytics", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
-  // Date for this snapshot
-  metricDate: text("metric_date").notNull().unique(),
-  // ISO date string (YYYY-MM-DD)
-  // Volume metrics
-  totalVolume: text("total_volume").notNull().default("0"),
-  // Stored as text for bigint
-  totalTransactions: integer("total_transactions").notNull().default(0),
-  // Agent metrics
-  activeAgentsCount: integer("active_agents_count").notNull().default(0),
-  // Price metrics
-  averagePrice: text("average_price").notNull().default("0"),
-  // Average transaction amount
-  // User metrics
-  uniquePayers: integer("unique_payers").notNull().default(0),
-  // Timestamp
-  updatedAt: integer("updated_at").notNull()
-}, (table) => ({
-  dateIdx: index("idx_market_analytics_date").on(table.metricDate)
-}));
-var dailyMetrics = sqliteTable("daily_metrics", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
-  // Date and metric type
-  metricDate: text("metric_date").notNull(),
-  // ISO date (YYYY-MM-DD)
-  metricType: text("metric_type").notNull(),
-  // 'agent_revenue', 'market_volume', etc.
-  // Optional agent address (null for market-wide metrics)
-  agentAddress: text("agent_address"),
-  // Nullable
-  // Metric value and metadata
-  value: text("value").notNull(),
-  // Metric value as text (supports bigint)
-  metadata: text("metadata"),
-  // JSON string for additional data (nullable)
-  // Timestamp
-  createdAt: integer("created_at").notNull()
-}, (table) => ({
-  // Composite index for date + type queries
-  dateTypeIdx: index("idx_daily_metrics_date_type").on(table.metricDate, table.metricType),
-  // Index for agent-specific queries
-  agentIdx: index("idx_daily_metrics_agent").on(table.agentAddress),
-  // Index for time-series queries
-  dateIdx: index("idx_daily_metrics_date").on(table.metricDate)
-}));
-
-// src/database/schema/facilitators.ts
-var facilitators_exports = {};
-__export(facilitators_exports, {
-  facilitatorApiKeys: () => facilitatorApiKeys,
-  facilitatorHealthHistory: () => facilitatorHealthHistory,
-  facilitators: () => facilitators
-});
-var facilitators = sqliteTable(
-  "facilitators",
-  {
-    // Primary key - unique facilitator ID
-    id: text("id").primaryKey(),
-    // Basic info
-    name: text("name").notNull(),
-    description: text("description"),
-    logo: text("logo"),
-    website: text("website"),
-    // Network configuration (JSON serialized)
-    networks: text("networks").notNull(),
-    // JSON array of Network enum values
-    // Address configuration (JSON serialized)
-    addresses: text("addresses").notNull(),
-    // JSON Record<Network, FacilitatorAddress[]>
-    // Endpoints
-    discoveryUrl: text("discovery_url"),
-    settleUrl: text("settle_url").notNull(),
-    verifyUrl: text("verify_url").notNull(),
-    // API configuration
-    requiresApiKey: integer("requires_api_key", { mode: "boolean" }).notNull().default(false),
-    apiKeyHeader: text("api_key_header"),
-    // Status
-    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
-    // Health metrics
-    lastHealthCheck: integer("last_health_check"),
-    // Unix timestamp
-    healthStatus: text("health_status").default("unknown"),
-    // healthy, degraded, unhealthy, unknown
-    latencyMs: real("latency_ms"),
-    uptimePercent: real("uptime_percent"),
-    totalRequests: integer("total_requests").notNull().default(0),
-    successfulRequests: integer("successful_requests").notNull().default(0),
-    failedRequests: integer("failed_requests").notNull().default(0),
-    // Timestamps
-    createdAt: integer("created_at").notNull().default(0),
-    updatedAt: integer("updated_at").notNull().default(0)
-  },
-  (table) => ({
-    enabledIdx: index("facilitators_enabled_idx").on(table.enabled),
-    healthStatusIdx: index("facilitators_health_status_idx").on(table.healthStatus)
-  })
-);
-var facilitatorApiKeys = sqliteTable(
-  "facilitator_api_keys",
-  {
-    // Composite key
-    id: text("id").primaryKey(),
-    // UUID or generated
-    // Foreign keys
-    facilitatorId: text("facilitator_id").notNull().references(() => facilitators.id),
-    userId: text("user_id").notNull(),
-    // User or wallet address
-    // Key storage (encrypted)
-    encryptedApiKey: text("encrypted_api_key").notNull(),
-    keyLabel: text("key_label"),
-    // User-friendly label
-    // Metadata
-    lastUsed: integer("last_used"),
-    // Unix timestamp
-    usageCount: integer("usage_count").notNull().default(0),
-    // Timestamps
-    createdAt: integer("created_at").notNull().default(0),
-    updatedAt: integer("updated_at").notNull().default(0)
-  },
-  (table) => ({
-    facilitatorUserIdx: index("api_keys_facilitator_user_idx").on(
-      table.facilitatorId,
-      table.userId
-    )
-  })
-);
-var facilitatorHealthHistory = sqliteTable(
-  "facilitator_health_history",
-  {
-    // Primary key
-    id: text("id").primaryKey(),
-    // UUID
-    // Foreign key
-    facilitatorId: text("facilitator_id").notNull().references(() => facilitators.id),
-    // Health check result
-    status: text("status").notNull(),
-    // healthy, degraded, unhealthy
-    latencyMs: real("latency_ms").notNull(),
-    errorMessage: text("error_message"),
-    // Network-specific results (JSON serialized)
-    networkResults: text("network_results"),
-    // JSON array of network health
-    // Timestamp
-    checkedAt: integer("checked_at").notNull()
-  },
-  (table) => ({
-    facilitatorTimeIdx: index("health_history_facilitator_time_idx").on(
-      table.facilitatorId,
-      table.checkedAt
-    )
-  })
-);
-
-// src/database/schema/resources.ts
-var resources_exports = {};
-__export(resources_exports, {
-  resourceAccepts: () => resourceAccepts,
-  resourceOrigins: () => resourceOrigins,
-  resourcePingHistory: () => resourcePingHistory,
-  resourceTags: () => resourceTags,
-  resources: () => resources
-});
-var resourceOrigins = sqliteTable(
-  "resource_origins",
-  {
-    // Primary key - UUID
-    id: text("id").primaryKey(),
-    // Origin URL (e.g., https://api.example.com)
-    origin: text("origin").notNull().unique(),
-    // Metadata from scraping
-    name: text("name"),
-    description: text("description"),
-    faviconUrl: text("favicon_url"),
-    ogImageUrl: text("og_image_url"),
-    ogTitle: text("og_title"),
-    ogDescription: text("og_description"),
-    // Contact/attribution
-    contactEmail: text("contact_email"),
-    twitterHandle: text("twitter_handle"),
-    githubRepo: text("github_repo"),
-    // Verification
-    isVerified: integer("is_verified", { mode: "boolean" }).notNull().default(false),
-    verifiedAt: integer("verified_at"),
-    verifiedBy: text("verified_by"),
-    // Timestamps
-    createdAt: integer("created_at").notNull().default(0),
-    updatedAt: integer("updated_at").notNull().default(0),
-    lastScrapedAt: integer("last_scraped_at")
-  },
-  (table) => ({
-    originIdx: index("resource_origins_origin_idx").on(table.origin)
-  })
-);
-var resources = sqliteTable(
-  "resources",
-  {
-    // Primary key - UUID
-    id: text("id").primaryKey(),
-    // Resource URL (full endpoint URL)
-    url: text("url").notNull().unique(),
-    // Type of resource
-    type: text("type").notNull().default("http"),
-    // http, websocket, grpc
-    // x402 protocol version
-    x402Version: text("x402_version"),
-    // Foreign keys
-    originId: text("origin_id").references(() => resourceOrigins.id),
-    facilitatorId: text("facilitator_id").references(() => facilitators.id),
-    // Payment requirements (JSON serialized PaymentRequirement[])
-    accepts: text("accepts").notNull(),
-    // JSON array
-    // Pricing
-    maxAmount: text("max_amount"),
-    // bigint as string
-    minAmount: text("min_amount"),
-    // bigint as string
-    currency: text("currency").default("USDC"),
-    // Enhanced schema for AI integration (JSON Schema)
-    inputSchema: text("input_schema"),
-    // JSON Schema for input
-    outputSchema: text("output_schema"),
-    // JSON Schema for output
-    examplesJson: text("examples_json"),
-    // JSON array of { input, output }
-    // Metadata
-    name: text("name"),
-    description: text("description"),
-    tags: text("tags"),
-    // JSON array of strings
-    capabilities: text("capabilities"),
-    // JSON array of capabilities
-    category: text("category"),
-    // AI category
-    // HTTP metadata
-    httpMethod: text("http_method").default("POST"),
-    contentType: text("content_type").default("application/json"),
-    authType: text("auth_type"),
-    // none, bearer, api_key, x402
-    // Status
-    isActive: integer("is_active", { mode: "boolean" }).notNull().default(true),
-    isVerified: integer("is_verified", { mode: "boolean" }).notNull().default(false),
-    lastPingAt: integer("last_ping_at"),
-    lastPingStatus: integer("last_ping_status"),
-    // HTTP status code
-    lastPingLatencyMs: real("last_ping_latency_ms"),
-    consecutiveFailures: integer("consecutive_failures").notNull().default(0),
-    // Discovery source
-    discoveredFrom: text("discovered_from"),
-    // facilitator_id or 'manual'
-    discoveredAt: integer("discovered_at"),
-    // AI labeling
-    aiGeneratedTags: text("ai_generated_tags"),
-    // JSON array
-    aiLabeledAt: integer("ai_labeled_at"),
-    // Timestamps
-    createdAt: integer("created_at").notNull().default(0),
-    updatedAt: integer("updated_at").notNull().default(0)
-  },
-  (table) => ({
-    originIdx: index("resources_origin_idx").on(table.originId),
-    facilitatorIdx: index("resources_facilitator_idx").on(table.facilitatorId),
-    activeIdx: index("resources_active_idx").on(table.isActive),
-    categoryIdx: index("resources_category_idx").on(table.category)
-  })
-);
-var resourceTags = sqliteTable(
-  "resource_tags",
-  {
-    // Composite key
-    id: text("id").primaryKey(),
-    // UUID
-    // Foreign key
-    resourceId: text("resource_id").notNull().references(() => resources.id),
-    // Tag
-    tag: text("tag").notNull(),
-    isAiGenerated: integer("is_ai_generated", { mode: "boolean" }).notNull().default(false),
-    // Timestamps
-    createdAt: integer("created_at").notNull().default(0)
-  },
-  (table) => ({
-    resourceIdx: index("resource_tags_resource_idx").on(table.resourceId),
-    tagIdx: index("resource_tags_tag_idx").on(table.tag)
-  })
-);
-var resourcePingHistory = sqliteTable(
-  "resource_ping_history",
-  {
-    // Primary key - UUID
-    id: text("id").primaryKey(),
-    // Foreign key
-    resourceId: text("resource_id").notNull().references(() => resources.id),
-    // Ping result
-    statusCode: integer("status_code"),
-    latencyMs: real("latency_ms"),
-    success: integer("success", { mode: "boolean" }).notNull(),
-    errorMessage: text("error_message"),
-    // x402 response validation
-    hasValidX402: integer("has_valid_x402", { mode: "boolean" }),
-    x402ParseError: text("x402_parse_error"),
-    // Response details
-    responseBodySize: integer("response_body_size"),
-    contentType: text("content_type"),
-    // Timestamp
-    pingedAt: integer("pinged_at").notNull()
-  },
-  (table) => ({
-    resourceTimeIdx: index("ping_history_resource_time_idx").on(
-      table.resourceId,
-      table.pingedAt
-    )
-  })
-);
-var resourceAccepts = sqliteTable(
-  "resource_accepts",
-  {
-    // Primary key - UUID
-    id: text("id").primaryKey(),
-    // Foreign key
-    resourceId: text("resource_id").notNull().references(() => resources.id),
-    // Payment requirement fields
-    scheme: text("scheme").notNull(),
-    // exact, upto, base, tiered
-    network: text("network").notNull(),
-    // solana, base, polygon
-    maxAmountRequired: text("max_amount_required").notNull(),
-    // bigint as string
-    payTo: text("pay_to").notNull(),
-    // facilitator address
-    asset: text("asset").notNull(),
-    // token address
-    maxTimeoutSeconds: integer("max_timeout_seconds"),
-    description: text("description"),
-    mimeType: text("mime_type"),
-    // Extra fields (JSON)
-    extra: text("extra"),
-    // Timestamps
-    createdAt: integer("created_at").notNull().default(0),
-    updatedAt: integer("updated_at").notNull().default(0)
-  },
-  (table) => ({
-    resourceIdx: index("resource_accepts_resource_idx").on(table.resourceId),
-    networkIdx: index("resource_accepts_network_idx").on(table.network),
-    assetIdx: index("resource_accepts_asset_idx").on(table.asset)
-  })
-);
-
-// src/database/schema/resourceMetrics.ts
-var resourceMetrics_exports = {};
-__export(resourceMetrics_exports, {
-  TIME_WINDOWS: () => TIME_WINDOWS,
-  globalMetrics: () => globalMetrics,
-  resourceMetrics: () => resourceMetrics,
-  resourceOriginMetrics: () => resourceOriginMetrics
-});
-var TIME_WINDOWS = ["1h", "6h", "24h", "3d", "7d", "15d", "30d", "all"];
-var resourceMetrics = sqliteTable(
-  "resource_metrics",
-  {
-    // Primary key
-    id: text("id").primaryKey(),
-    // Foreign key to resource
-    resourceId: text("resource_id").notNull().references(() => resources.id),
-    // Snapshot timestamp
-    createdAt: integer("created_at").notNull(),
-    // =========================================================
-    // REQUEST COUNTS (8 time windows each)
-    // =========================================================
-    // Total requests
-    totalRequests1h: integer("total_requests_1h").notNull().default(0),
-    totalRequests6h: integer("total_requests_6h").notNull().default(0),
-    totalRequests24h: integer("total_requests_24h").notNull().default(0),
-    totalRequests3d: integer("total_requests_3d").notNull().default(0),
-    totalRequests7d: integer("total_requests_7d").notNull().default(0),
-    totalRequests15d: integer("total_requests_15d").notNull().default(0),
-    totalRequests30d: integer("total_requests_30d").notNull().default(0),
-    totalRequestsAll: integer("total_requests_all").notNull().default(0),
-    // Successful requests (2xx)
-    successCount1h: integer("success_count_1h").notNull().default(0),
-    successCount6h: integer("success_count_6h").notNull().default(0),
-    successCount24h: integer("success_count_24h").notNull().default(0),
-    successCount3d: integer("success_count_3d").notNull().default(0),
-    successCount7d: integer("success_count_7d").notNull().default(0),
-    successCount15d: integer("success_count_15d").notNull().default(0),
-    successCount30d: integer("success_count_30d").notNull().default(0),
-    successCountAll: integer("success_count_all").notNull().default(0),
-    // Failed requests (4xx, 5xx)
-    failureCount1h: integer("failure_count_1h").notNull().default(0),
-    failureCount6h: integer("failure_count_6h").notNull().default(0),
-    failureCount24h: integer("failure_count_24h").notNull().default(0),
-    failureCount3d: integer("failure_count_3d").notNull().default(0),
-    failureCount7d: integer("failure_count_7d").notNull().default(0),
-    failureCount15d: integer("failure_count_15d").notNull().default(0),
-    failureCount30d: integer("failure_count_30d").notNull().default(0),
-    failureCountAll: integer("failure_count_all").notNull().default(0),
-    // =========================================================
-    // LATENCY PERCENTILES (p50, p90, p99 for each window)
-    // =========================================================
-    // P50 (median) latency in ms
-    latencyP50_1h: real("latency_p50_1h"),
-    latencyP50_6h: real("latency_p50_6h"),
-    latencyP50_24h: real("latency_p50_24h"),
-    latencyP50_3d: real("latency_p50_3d"),
-    latencyP50_7d: real("latency_p50_7d"),
-    latencyP50_15d: real("latency_p50_15d"),
-    latencyP50_30d: real("latency_p50_30d"),
-    latencyP50All: real("latency_p50_all"),
-    // P90 latency in ms
-    latencyP90_1h: real("latency_p90_1h"),
-    latencyP90_6h: real("latency_p90_6h"),
-    latencyP90_24h: real("latency_p90_24h"),
-    latencyP90_3d: real("latency_p90_3d"),
-    latencyP90_7d: real("latency_p90_7d"),
-    latencyP90_15d: real("latency_p90_15d"),
-    latencyP90_30d: real("latency_p90_30d"),
-    latencyP90All: real("latency_p90_all"),
-    // P99 latency in ms
-    latencyP99_1h: real("latency_p99_1h"),
-    latencyP99_6h: real("latency_p99_6h"),
-    latencyP99_24h: real("latency_p99_24h"),
-    latencyP99_3d: real("latency_p99_3d"),
-    latencyP99_7d: real("latency_p99_7d"),
-    latencyP99_15d: real("latency_p99_15d"),
-    latencyP99_30d: real("latency_p99_30d"),
-    latencyP99All: real("latency_p99_all"),
-    // =========================================================
-    // STATUS CODE DISTRIBUTION
-    // =========================================================
-    // 2xx responses
-    status2xx1h: integer("status_2xx_1h").notNull().default(0),
-    status2xx24h: integer("status_2xx_24h").notNull().default(0),
-    status2xx7d: integer("status_2xx_7d").notNull().default(0),
-    status2xxAll: integer("status_2xx_all").notNull().default(0),
-    // 3xx responses
-    status3xx1h: integer("status_3xx_1h").notNull().default(0),
-    status3xx24h: integer("status_3xx_24h").notNull().default(0),
-    status3xx7d: integer("status_3xx_7d").notNull().default(0),
-    status3xxAll: integer("status_3xx_all").notNull().default(0),
-    // 4xx responses
-    status4xx1h: integer("status_4xx_1h").notNull().default(0),
-    status4xx24h: integer("status_4xx_24h").notNull().default(0),
-    status4xx7d: integer("status_4xx_7d").notNull().default(0),
-    status4xxAll: integer("status_4xx_all").notNull().default(0),
-    // 5xx responses
-    status5xx1h: integer("status_5xx_1h").notNull().default(0),
-    status5xx24h: integer("status_5xx_24h").notNull().default(0),
-    status5xx7d: integer("status_5xx_7d").notNull().default(0),
-    status5xxAll: integer("status_5xx_all").notNull().default(0),
-    // =========================================================
-    // UPTIME & AVAILABILITY
-    // =========================================================
-    // Uptime percentage (0-100)
-    uptimePercent1h: real("uptime_percent_1h"),
-    uptimePercent24h: real("uptime_percent_24h"),
-    uptimePercent7d: real("uptime_percent_7d"),
-    uptimePercent30d: real("uptime_percent_30d"),
-    uptimePercentAll: real("uptime_percent_all"),
-    // Number of outages
-    outageCount1h: integer("outage_count_1h").notNull().default(0),
-    outageCount24h: integer("outage_count_24h").notNull().default(0),
-    outageCount7d: integer("outage_count_7d").notNull().default(0),
-    outageCount30d: integer("outage_count_30d").notNull().default(0),
-    // =========================================================
-    // PAYMENT METRICS
-    // =========================================================
-    // Total payment volume (stored as text for bigint)
-    paymentVolume1h: text("payment_volume_1h").notNull().default("0"),
-    paymentVolume24h: text("payment_volume_24h").notNull().default("0"),
-    paymentVolume7d: text("payment_volume_7d").notNull().default("0"),
-    paymentVolume30d: text("payment_volume_30d").notNull().default("0"),
-    paymentVolumeAll: text("payment_volume_all").notNull().default("0"),
-    // Number of payments
-    paymentCount1h: integer("payment_count_1h").notNull().default(0),
-    paymentCount24h: integer("payment_count_24h").notNull().default(0),
-    paymentCount7d: integer("payment_count_7d").notNull().default(0),
-    paymentCount30d: integer("payment_count_30d").notNull().default(0),
-    paymentCountAll: integer("payment_count_all").notNull().default(0),
-    // Average payment amount
-    avgPayment1h: text("avg_payment_1h"),
-    avgPayment24h: text("avg_payment_24h"),
-    avgPayment7d: text("avg_payment_7d"),
-    avgPaymentAll: text("avg_payment_all"),
-    // Unique payers
-    uniquePayers1h: integer("unique_payers_1h").notNull().default(0),
-    uniquePayers24h: integer("unique_payers_24h").notNull().default(0),
-    uniquePayers7d: integer("unique_payers_7d").notNull().default(0),
-    uniquePayersAll: integer("unique_payers_all").notNull().default(0)
-  },
-  (table) => ({
-    resourceIdx: index("resource_metrics_resource_idx").on(table.resourceId),
-    createdAtIdx: index("resource_metrics_created_at_idx").on(table.createdAt),
-    resourceCreatedIdx: index("resource_metrics_resource_created_idx").on(
-      table.resourceId,
-      table.createdAt
-    )
-  })
-);
-var resourceOriginMetrics = sqliteTable(
-  "resource_origin_metrics",
-  {
-    // Primary key
-    id: text("id").primaryKey(),
-    // Foreign key to origin
-    originId: text("origin_id").notNull().references(() => resourceOrigins.id),
-    // Snapshot timestamp
-    createdAt: integer("created_at").notNull(),
-    // Resource count
-    resourceCount: integer("resource_count").notNull().default(0),
-    activeResourceCount: integer("active_resource_count").notNull().default(0),
-    // Aggregated request counts
-    totalRequests1h: integer("total_requests_1h").notNull().default(0),
-    totalRequests24h: integer("total_requests_24h").notNull().default(0),
-    totalRequests7d: integer("total_requests_7d").notNull().default(0),
-    totalRequestsAll: integer("total_requests_all").notNull().default(0),
-    // Aggregated success counts
-    successCount1h: integer("success_count_1h").notNull().default(0),
-    successCount24h: integer("success_count_24h").notNull().default(0),
-    successCount7d: integer("success_count_7d").notNull().default(0),
-    successCountAll: integer("success_count_all").notNull().default(0),
-    // Aggregated failure counts
-    failureCount1h: integer("failure_count_1h").notNull().default(0),
-    failureCount24h: integer("failure_count_24h").notNull().default(0),
-    failureCount7d: integer("failure_count_7d").notNull().default(0),
-    failureCountAll: integer("failure_count_all").notNull().default(0),
-    // Average latency across resources
-    avgLatencyP50_1h: real("avg_latency_p50_1h"),
-    avgLatencyP50_24h: real("avg_latency_p50_24h"),
-    avgLatencyP50_7d: real("avg_latency_p50_7d"),
-    avgLatencyP50All: real("avg_latency_p50_all"),
-    avgLatencyP90_1h: real("avg_latency_p90_1h"),
-    avgLatencyP90_24h: real("avg_latency_p90_24h"),
-    avgLatencyP90_7d: real("avg_latency_p90_7d"),
-    avgLatencyP90All: real("avg_latency_p90_all"),
-    // Aggregated uptime
-    avgUptimePercent1h: real("avg_uptime_percent_1h"),
-    avgUptimePercent24h: real("avg_uptime_percent_24h"),
-    avgUptimePercent7d: real("avg_uptime_percent_7d"),
-    avgUptimePercentAll: real("avg_uptime_percent_all"),
-    // Aggregated payment metrics
-    paymentVolume1h: text("payment_volume_1h").notNull().default("0"),
-    paymentVolume24h: text("payment_volume_24h").notNull().default("0"),
-    paymentVolume7d: text("payment_volume_7d").notNull().default("0"),
-    paymentVolumeAll: text("payment_volume_all").notNull().default("0"),
-    paymentCount1h: integer("payment_count_1h").notNull().default(0),
-    paymentCount24h: integer("payment_count_24h").notNull().default(0),
-    paymentCount7d: integer("payment_count_7d").notNull().default(0),
-    paymentCountAll: integer("payment_count_all").notNull().default(0)
-  },
-  (table) => ({
-    originIdx: index("origin_metrics_origin_idx").on(table.originId),
-    createdAtIdx: index("origin_metrics_created_at_idx").on(table.createdAt)
-  })
-);
-var globalMetrics = sqliteTable("global_metrics", {
-  // Primary key (single row, use 'global')
-  id: text("id").primaryKey(),
-  // Snapshot timestamp
-  createdAt: integer("created_at").notNull(),
-  // Resource counts
-  totalResources: integer("total_resources").notNull().default(0),
-  activeResources: integer("active_resources").notNull().default(0),
-  totalOrigins: integer("total_origins").notNull().default(0),
-  totalFacilitators: integer("total_facilitators").notNull().default(0),
-  // Request aggregates
-  totalRequests1h: integer("total_requests_1h").notNull().default(0),
-  totalRequests24h: integer("total_requests_24h").notNull().default(0),
-  totalRequests7d: integer("total_requests_7d").notNull().default(0),
-  totalRequestsAll: integer("total_requests_all").notNull().default(0),
-  // Payment aggregates
-  paymentVolume1h: text("payment_volume_1h").notNull().default("0"),
-  paymentVolume24h: text("payment_volume_24h").notNull().default("0"),
-  paymentVolume7d: text("payment_volume_7d").notNull().default("0"),
-  paymentVolumeAll: text("payment_volume_all").notNull().default("0"),
-  paymentCount1h: integer("payment_count_1h").notNull().default(0),
-  paymentCount24h: integer("payment_count_24h").notNull().default(0),
-  paymentCount7d: integer("payment_count_7d").notNull().default(0),
-  paymentCountAll: integer("payment_count_all").notNull().default(0),
-  // Unique users
-  uniquePayers1h: integer("unique_payers_1h").notNull().default(0),
-  uniquePayers24h: integer("unique_payers_24h").notNull().default(0),
-  uniquePayers7d: integer("unique_payers_7d").notNull().default(0),
-  uniquePayersAll: integer("unique_payers_all").notNull().default(0),
-  // Network breakdown (JSON)
-  networkBreakdown: text("network_breakdown"),
-  // JSON object
-  // Top performers (JSON arrays)
-  topResourcesByVolume: text("top_resources_by_volume"),
-  // JSON array
-  topResourcesByRequests: text("top_resources_by_requests"),
-  // JSON array
-  topOriginsByVolume: text("top_origins_by_volume")
-  // JSON array
-});
-
-// src/database/schema/index.ts
-var schema = {
-  ...agents_exports,
-  ...transactions_exports,
-  ...analytics_exports,
-  ...facilitators_exports,
-  ...resources_exports,
-  ...resourceMetrics_exports
-};
-
-// src/database/db.ts
-async function getDb() {
-  const client = await getConnection();
-  return drizzle(client, { schema });
-}
-
-// src/database/services/AgentCacheService.ts
-var AgentCacheService = class _AgentCacheService {
-  static instance = null;
-  defaultMaxAge = 5 * 60 * 1e3;
-  // 5 minutes
-  constructor() {
-  }
-  /**
-   * Get singleton instance
-   */
-  static getInstance() {
-    if (!_AgentCacheService.instance) {
-      _AgentCacheService.instance = new _AgentCacheService();
-    }
-    return _AgentCacheService.instance;
-  }
   /**
-   * Check if cache is available
+   * Fetch transaction signatures for the facilitator address
    */
-  async isCacheAvailable() {
-    return await isAvailable();
-  }
-  /**
-   * Get agent from cache
-   * 
-   * @param agentAddress - Agent's Solana address
-   * @param options - Cache options
-   * @returns Agent data or null if not found/expired
-   */
-  async getAgent(agentAddress, options = {}) {
-    if (!await this.isCacheAvailable()) {
-      return null;
-    }
-    const { maxAge = this.defaultMaxAge, forceRefresh = false } = options;
-    if (forceRefresh) {
-      return null;
-    }
+  async getSignatures(before, limit) {
     try {
-      const db = await getDb();
-      const results = await db.select().from(agents).where(eq(agents.agentAddress, agentAddress)).limit(1);
-      if (results.length === 0) {
-        return null;
-      }
-      const agent = results[0];
-      const age = Date.now() - agent.cachedAt;
-      if (age > maxAge) {
-        return null;
-      }
-      return agent;
+      const config = {
+        limit: limit || this.batchSize
+      };
+      if (before) {
+        config.before = before;
+      }
+      const response = await this.rpc.getSignaturesForAddress(this.facilitatorAddress, config).send();
+      return response.map((sig) => ({
+        signature: sig.signature,
+        slot: sig.slot,
+        blockTime: sig.blockTime,
+        err: sig.err ?? null
+      }));
     } catch (error) {
-      console.warn("[AgentCacheService] Failed to get agent from cache:", error);
-      return null;
+      console.error("[X402 Indexer] Failed to fetch signatures:", error);
+      throw error;
     }
   }
   /**
-   * Get multiple agents from cache
-   * 
-   * @param agentAddresses - Array of agent addresses
-   * @param options - Cache options
-   * @returns Map of address to agent data
+   * Check if transaction is an x402 payment
+   *
+   * x402 payments are characterized by:
+   * - SPL token transfer (TokenProgram or Token2022Program)
+   * - Transfer TO the facilitator address
+   * - Optional memo instruction with payment metadata
    */
-  async getAgents(agentAddresses, options = {}) {
-    if (!await this.isCacheAvailable() || agentAddresses.length === 0) {
-      return /* @__PURE__ */ new Map();
-    }
-    const { maxAge = this.defaultMaxAge } = options;
+  isX402Payment(transaction) {
     try {
-      const db = await getDb();
-      const results = await db.select().from(agents).where(sql`${agents.agentAddress} IN ${agentAddresses}`);
-      const now = Date.now();
-      const agentMap = /* @__PURE__ */ new Map();
-      for (const agent of results) {
-        const age = now - agent.cachedAt;
-        if (age <= maxAge) {
-          agentMap.set(agent.agentAddress, agent);
+      const instructions = transaction.transaction?.message?.instructions || [];
+      const hasTokenTransfer = 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();
         }
-      }
-      return agentMap;
+        return false;
+      });
+      return hasTokenTransfer;
     } catch (error) {
-      console.warn("[AgentCacheService] Failed to get agents from cache:", error);
-      return /* @__PURE__ */ new Map();
+      console.error("[X402 Indexer] Error checking if x402 payment:", error);
+      return false;
     }
   }
   /**
-   * Cache agent data
-   * 
-   * @param agent - Agent data to cache
-   * @param capabilities - Agent capabilities
-   * @param pricing - Agent pricing info
+   * Extract payment data from transaction
    */
-  async cacheAgent(agent, capabilities = [], pricing = []) {
-    if (!await this.isCacheAvailable()) {
-      return;
-    }
+  extractPaymentData(transaction, signature) {
     try {
-      const db = await getDb();
-      await db.insert(agents).values({
-        ...agent,
-        cachedAt: Date.now()
-      }).onConflictDoUpdate({
-        target: agents.agentAddress,
-        set: {
-          ...agent,
-          cachedAt: Date.now(),
-          updatedAt: Date.now()
-        }
+      const instructions = transaction.transaction?.message?.instructions || [];
+      const transferIx = instructions.find((ix) => {
+        const parsed = ix.parsed;
+        return parsed?.type === "transfer" || parsed?.type === "transferChecked";
       });
-      await db.delete(agentCapabilities).where(eq(agentCapabilities.agentAddress, agent.agentAddress));
-      if (capabilities.length > 0) {
-        await db.insert(agentCapabilities).values(
-          capabilities.map((cap) => ({
-            agentAddress: agent.agentAddress,
-            capability: cap
-          }))
-        );
+      if (!transferIx) {
+        return null;
       }
-      await db.delete(agentPricing).where(eq(agentPricing.agentAddress, agent.agentAddress));
-      if (pricing.length > 0) {
-        await db.insert(agentPricing).values(
-          pricing.map((p) => ({
-            agentAddress: agent.agentAddress,
-            ...p
-          }))
-        );
-      }
-    } catch (error) {
-      console.error("[AgentCacheService] Failed to cache agent:", error);
-    }
-  }
-  /**
-   * List agents with filters
-   * 
-   * @param filters - Query filters
-   * @returns Array of agents
-   */
-  async listAgents(filters = {}) {
-    if (!await this.isCacheAvailable()) {
-      return [];
-    }
-    try {
-      const db = await getDb();
-      const {
-        x402Enabled,
-        framework,
-        isVerified,
-        minReputation,
-        limit = 50,
-        offset = 0
-      } = filters;
-      const conditions = [];
-      if (x402Enabled !== void 0) {
-        conditions.push(eq(agents.x402Enabled, x402Enabled));
-      }
-      if (framework) {
-        conditions.push(eq(agents.frameworkOrigin, framework));
-      }
-      if (isVerified !== void 0) {
-        conditions.push(eq(agents.isVerified, isVerified));
-      }
-      if (minReputation !== void 0) {
-        conditions.push(sql`${agents.reputationScore} >= ${minReputation}`);
-      }
-      if (conditions.length > 0) {
-        const results = await db.select().from(agents).where(and(...conditions)).orderBy(desc(agents.reputationScore)).limit(limit).offset(offset);
-        return results;
-      } else {
-        const results = await db.select().from(agents).orderBy(desc(agents.reputationScore)).limit(limit).offset(offset);
-        return results;
-      }
-    } catch (error) {
-      console.warn("[AgentCacheService] Failed to list agents:", error);
-      return [];
-    }
-  }
-  /**
-   * Invalidate cached agent
-   * 
-   * @param agentAddress - Agent address to invalidate
-   */
-  async invalidateAgent(agentAddress) {
-    if (!await this.isCacheAvailable()) {
-      return;
-    }
-    try {
-      const db = await getDb();
-      await db.delete(agents).where(eq(agents.agentAddress, agentAddress));
-    } catch (error) {
-      console.warn("[AgentCacheService] Failed to invalidate agent:", error);
-    }
-  }
-  /**
-   * Clear all cached agents
-   */
-  async clearCache() {
-    if (!await this.isCacheAvailable()) {
-      return;
-    }
-    try {
-      const db = await getDb();
-      await db.delete(agents);
-    } catch (error) {
-      console.error("[AgentCacheService] Failed to clear cache:", error);
-    }
-  }
-  /**
-   * Get cache statistics
-   */
-  async getCacheStats() {
-    if (!await this.isCacheAvailable()) {
-      return null;
-    }
-    try {
-      const db = await getDb();
-      const result = await db.select({
-        count: sql`count(*)`,
-        avgAge: sql`avg(${Date.now()} - ${agents.cachedAt})`,
-        oldestCache: sql`min(${agents.cachedAt})`
-      }).from(agents);
-      return {
-        totalAgents: result[0].count,
-        averageAge: result[0].avgAge,
-        oldestCache: result[0].oldestCache
-      };
-    } catch (error) {
-      console.warn("[AgentCacheService] Failed to get cache stats:", error);
-      return null;
-    }
-  }
-};
-AgentCacheService.getInstance();
-
-// src/x402/AgentDiscoveryClient.ts
-var REPUTATION_BASIS_POINTS_PER_STAR = 2e3;
-var AgentDiscoveryClient = class {
-  rpc;
-  programId;
-  commitment;
-  cache = /* @__PURE__ */ new Map();
-  cacheEnabled;
-  cacheTTL;
-  useDatabaseCache;
-  dbCache;
-  constructor(options) {
-    this.rpc = createSolanaRpc(options.rpcEndpoint);
-    this.programId = options.programId;
-    this.commitment = options.commitment ?? "confirmed";
-    this.cacheEnabled = options.cacheEnabled ?? true;
-    this.cacheTTL = options.cacheTTL ?? 300;
-    this.useDatabaseCache = options.useDatabaseCache ?? true;
-    this.dbCache = AgentCacheService.getInstance();
-  }
-  /**
-   * Search for agents with filters
-   */
-  async searchAgents(params = {}) {
-    const cacheKey = this.getCacheKey("search", params);
-    if (this.cacheEnabled) {
-      const cached = this.getFromCache(cacheKey);
-      if (cached) return cached;
-    }
-    const page = params.page ?? 1;
-    const limit = Math.min(params.limit ?? 20, 100);
-    const sortBy = params.sort_by ?? "reputation";
-    const sortOrder = params.sort_order ?? "desc";
-    const allAgents = await this.fetchAgentsFromChain(params);
-    let filteredAgents = this.applyFilters(allAgents, params);
-    filteredAgents = this.sortAgents(filteredAgents, sortBy, sortOrder);
-    const total = filteredAgents.length;
-    const totalPages = Math.ceil(total / limit);
-    const startIndex = (page - 1) * limit;
-    const endIndex = startIndex + limit;
-    const paginatedAgents = filteredAgents.slice(startIndex, endIndex);
-    const response = {
-      agents: paginatedAgents,
-      pagination: {
-        page,
-        limit,
-        total,
-        totalPages
-      },
-      filters: params
-    };
-    if (this.cacheEnabled) {
-      this.setCache(cacheKey, response);
-    }
-    return response;
-  }
-  /**
-   * Get agent by address with database cache support
-   * 
-   * Cache hierarchy:
-   * 1. Check Turso database cache (if enabled)
-   * 2. Fallback to RPC fetch
-   * 3. Cache result in database for future requests
-   */
-  async getAgent(address6, forceRefresh = false) {
-    const cacheKey = this.getCacheKey("agent", { address: address6 });
-    if (this.useDatabaseCache && !forceRefresh) {
-      const cachedAgent = await this.dbCache.getAgent(address6, {
-        maxAge: this.cacheTTL * 1e3,
-        forceRefresh
-      });
-      if (cachedAgent) {
-        console.log(`[AgentDiscovery] Cache HIT for agent ${address6}`);
-        return this.transformCachedAgent(cachedAgent);
-      }
-    }
-    if (this.cacheEnabled && !forceRefresh) {
-      const cached = this.getFromCache(cacheKey);
-      if (cached) {
-        console.log(`[AgentDiscovery] Memory cache HIT for agent ${address6}`);
-        return cached;
-      }
-    }
-    console.log(`[AgentDiscovery] Cache MISS for agent ${address6}, fetching from RPC`);
-    try {
-      const result = await this.rpc.getAccountInfo(address6, {
-        commitment: this.commitment,
-        encoding: "base64"
-      }).send();
-      const accountInfo = result;
-      if (!accountInfo.value) return null;
-      const agent = this.parseAgentAccount(address6, accountInfo.value.data);
-      if (agent) {
-        if (this.useDatabaseCache) {
-          this.cacheAgentInDatabase(agent).catch(
-            (err) => console.warn("[AgentDiscovery] Failed to cache agent in database:", err)
-          );
-        }
-        if (this.cacheEnabled) {
-          this.setCache(cacheKey, agent);
-        }
-      }
-      return agent;
-    } catch (error) {
-      console.error(`Failed to fetch agent ${address6}:`, error);
-      return null;
-    }
-  }
-  /**
-   * Helper to cache agent in database
-   */
-  async cacheAgentInDatabase(agent) {
-    await this.dbCache.cacheAgent(
-      {
-        agentAddress: agent.address,
-        owner: agent.owner,
-        name: agent.name,
-        description: agent.description,
-        reputationScore: agent.reputation_score,
-        totalJobsCompleted: Number(agent.total_jobs),
-        totalEarnings: agent.total_earnings.toString(),
-        x402Enabled: agent.x402_enabled,
-        x402PaymentAddress: agent.x402_payment_address,
-        x402PricePerCall: agent.x402_price_per_call.toString(),
-        x402ServiceEndpoint: agent.x402_service_endpoint,
-        x402TotalPayments: agent.x402_total_payments.toString(),
-        x402TotalCalls: agent.x402_total_calls.toString(),
-        lastPaymentTimestamp: Number(agent.last_payment_timestamp),
-        metadataUri: agent.metadata_uri,
-        frameworkOrigin: agent.framework_origin,
-        isVerified: agent.is_verified,
-        createdAt: Number(agent.created_at),
-        updatedAt: Date.now(),
-        cachedAt: Date.now(),
-        bump: 0
-        // Placeholder
-      },
-      agent.capabilities,
-      []
-      // Pricing info would be added here
-    );
-  }
-  /**
-   * Transform cached database agent to Agent interface
-   */
-  transformCachedAgent(cachedAgent) {
-    return {
-      address: cachedAgent.agentAddress,
-      owner: cachedAgent.owner,
-      name: cachedAgent.name,
-      description: cachedAgent.description,
-      capabilities: [],
-      // Would need to join from agentCapabilities table
-      x402_enabled: Boolean(cachedAgent.x402Enabled),
-      x402_payment_address: cachedAgent.x402PaymentAddress,
-      x402_accepted_tokens: [],
-      // Would join from agentPricing table
-      x402_price_per_call: BigInt(cachedAgent.x402PricePerCall),
-      x402_service_endpoint: cachedAgent.x402ServiceEndpoint,
-      x402_total_payments: BigInt(cachedAgent.x402TotalPayments),
-      x402_total_calls: BigInt(cachedAgent.x402TotalCalls),
-      last_payment_timestamp: BigInt(cachedAgent.lastPaymentTimestamp),
-      reputation_score: cachedAgent.reputationScore,
-      total_jobs: BigInt(cachedAgent.totalJobsCompleted),
-      successful_jobs: BigInt(cachedAgent.totalJobsCompleted),
-      total_earnings: BigInt(cachedAgent.totalEarnings),
-      average_rating: cachedAgent.reputationScore / REPUTATION_BASIS_POINTS_PER_STAR,
-      created_at: BigInt(cachedAgent.createdAt),
-      metadata_uri: cachedAgent.metadataUri,
-      framework_origin: cachedAgent.frameworkOrigin,
-      is_verified: Boolean(cachedAgent.isVerified)
-    };
-  }
-  /**
-   * Get agent pricing information
-   */
-  async getAgentPricing(address6) {
-    const agent = await this.getAgent(address6);
-    if (!agent?.x402_enabled) return null;
-    return {
-      price_per_call: agent.x402_price_per_call,
-      accepted_tokens: await this.getTokenInfo(agent.x402_accepted_tokens),
-      payment_address: agent.x402_payment_address,
-      service_endpoint: agent.x402_service_endpoint
-    };
-  }
-  /**
-   * Get recommended agents based on criteria
-   */
-  async getRecommendedAgents(capability, limit = 10) {
-    const params = {
-      capability,
-      x402_enabled: true,
-      sort_by: "reputation",
-      sort_order: "desc",
-      limit,
-      min_reputation: 7e3
-      // Only recommend highly rated agents (7.0+)
-    };
-    const response = await this.searchAgents(params);
-    return response.agents;
-  }
-  /**
-   * Get agents by capability
-   */
-  async getAgentsByCapability(capability) {
-    const response = await this.searchAgents({
-      capability,
-      x402_enabled: true
-    });
-    return response.agents;
-  }
-  /**
-   * Get agents accepting specific token
-   */
-  async getAgentsByToken(tokenAddress) {
-    const response = await this.searchAgents({
-      accepted_tokens: [tokenAddress],
-      x402_enabled: true
-    });
-    return response.agents;
-  }
-  /**
-   * Get agents within price range
-   */
-  async getAgentsByPriceRange(maxPrice, capability) {
-    const response = await this.searchAgents({
-      max_price: maxPrice,
-      capability,
-      x402_enabled: true,
-      sort_by: "price",
-      sort_order: "asc"
-    });
-    return response.agents;
-  }
-  /**
-   * Search agents by text query
-   */
-  async searchByQuery(query) {
-    const response = await this.searchAgents({
-      query,
-      x402_enabled: true
-    });
-    return response.agents;
-  }
-  // Private helper methods
-  async fetchAgentsFromChain(params) {
-    try {
-      const filters = [];
-      filters.push({ dataSize: 359n });
-      const accounts = await this.rpc.getProgramAccounts(this.programId, {
-        commitment: this.commitment,
-        encoding: "base64",
-        filters
-      }).send();
-      const agents2 = [];
-      for (const { pubkey, account } of accounts) {
-        const agent = this.parseAgentAccount(pubkey, account.data);
-        if (agent) {
-          agents2.push(agent);
-        }
-      }
-      return agents2;
-    } catch (error) {
-      console.error("Failed to fetch agents from chain:", error);
-      return [];
-    }
-  }
-  parseAgentAccount(address6, data) {
-    try {
-      let dataBytes;
-      if (typeof data === "string") {
-        dataBytes = Uint8Array.from(Buffer.from(data, "base64"));
-      } else if (Array.isArray(data)) {
-        if (data.length === 2 && typeof data[0] === "string" && typeof data[1] === "string" && data[1] === "base64") {
-          dataBytes = Uint8Array.from(Buffer.from(data[0], "base64"));
-        } else {
-          dataBytes = Uint8Array.from(data);
-        }
-      } else if (data instanceof Uint8Array) {
-        dataBytes = data;
-      } else {
-        throw new Error("Invalid data format");
-      }
-      const decoder = getAgentDecoder();
-      const decodedData = decoder.decode(dataBytes);
-      const decodedAgent = Array.isArray(decodedData) ? decodedData[0] : decodedData;
-      return {
-        address: address6,
-        owner: decodedAgent.owner,
-        name: decodedAgent.name,
-        description: decodedAgent.description,
-        capabilities: decodedAgent.capabilities,
-        // x402 fields
-        x402_enabled: decodedAgent.x402Enabled,
-        x402_payment_address: decodedAgent.x402PaymentAddress,
-        x402_accepted_tokens: decodedAgent.x402AcceptedTokens,
-        x402_price_per_call: decodedAgent.x402PricePerCall,
-        x402_service_endpoint: decodedAgent.x402ServiceEndpoint,
-        x402_total_payments: decodedAgent.x402TotalPayments,
-        x402_total_calls: decodedAgent.x402TotalCalls,
-        last_payment_timestamp: decodedAgent.lastPaymentTimestamp,
-        // Standard fields
-        reputation_score: decodedAgent.reputationScore,
-        total_jobs: BigInt(decodedAgent.totalJobsCompleted),
-        successful_jobs: BigInt(decodedAgent.totalJobsCompleted),
-        // Assuming successful = completed
-        total_earnings: decodedAgent.totalEarnings,
-        average_rating: decodedAgent.reputationScore / REPUTATION_BASIS_POINTS_PER_STAR,
-        // Convert from basis points to 1-5 scale
-        created_at: decodedAgent.createdAt,
-        metadata_uri: decodedAgent.metadataUri,
-        framework_origin: decodedAgent.frameworkOrigin,
-        is_verified: decodedAgent.isVerified
-      };
-    } catch (error) {
-      console.error("Failed to parse agent account:", error);
-      return null;
-    }
-  }
-  applyFilters(agents2, params) {
-    let filtered = agents2;
-    if (params.x402_enabled !== void 0) {
-      filtered = filtered.filter((a) => a.x402_enabled === params.x402_enabled);
-    }
-    if (params.capability) {
-      filtered = filtered.filter(
-        (a) => a.capabilities.some(
-          (c) => c.toLowerCase().includes(params.capability.toLowerCase())
-        )
-      );
-    }
-    if (params.accepted_tokens?.length) {
-      filtered = filtered.filter(
-        (a) => params.accepted_tokens.some(
-          (token) => a.x402_accepted_tokens.includes(token)
-        )
-      );
-    }
-    if (params.min_reputation !== void 0) {
-      filtered = filtered.filter((a) => a.reputation_score >= params.min_reputation);
-    }
-    if (params.max_price !== void 0) {
-      filtered = filtered.filter((a) => a.x402_price_per_call <= params.max_price);
-    }
-    if (params.framework_origin) {
-      filtered = filtered.filter(
-        (a) => a.framework_origin.toLowerCase() === params.framework_origin.toLowerCase()
+      const transferInfo = transferIx.parsed.info;
+      const merchant = transferInfo.destination;
+      const payer = transferInfo.source;
+      const amount = transferInfo.amount || transferInfo.tokenAmount?.amount || "0";
+      const success = transaction.meta?.err === null;
+      const blockTime = transaction.blockTime;
+      const timestamp = blockTime ? new Date(blockTime * 1e3) : /* @__PURE__ */ new Date();
+      const memoIx = instructions.find(
+        (ix) => ix.programId?.toString()?.includes("Memo")
       );
-    }
-    if (params.is_verified !== void 0) {
-      filtered = filtered.filter((a) => a.is_verified === params.is_verified);
-    }
-    if (params.query) {
-      const query = params.query.toLowerCase();
-      filtered = filtered.filter(
-        (a) => a.name.toLowerCase().includes(query) || a.description.toLowerCase().includes(query)
-      );
-    }
-    return filtered;
-  }
-  sortAgents(agents2, sortBy, sortOrder) {
-    const sorted = [...agents2];
-    const order = sortOrder === "asc" ? 1 : -1;
-    sorted.sort((a, b) => {
-      let comparison = 0;
-      switch (sortBy) {
-        case "reputation":
-          comparison = a.reputation_score - b.reputation_score;
-          break;
-        case "price":
-          comparison = Number(a.x402_price_per_call - b.x402_price_per_call);
-          break;
-        case "total_jobs":
-          comparison = Number(a.total_jobs - b.total_jobs);
-          break;
-        case "created_at":
-          comparison = Number(a.created_at - b.created_at);
-          break;
-      }
-      return comparison * order;
-    });
-    return sorted;
-  }
-  async getTokenInfo(tokens) {
-    const tokenInfo = [];
-    for (const token of tokens) {
-      try {
-        const result = await this.rpc.getAccountInfo(token, {
-          commitment: this.commitment,
-          encoding: "base64"
-        }).send();
-        const mintInfo = result;
-        if (mintInfo.value) {
-          const data = Buffer.from(mintInfo.value.data[0], "base64");
-          const decimals = data[44];
-          tokenInfo.push({
-            token,
-            decimals,
-            symbol: "USDC"
-            // Placeholder - would look up from token registry or metadata
-          });
-        }
-      } catch (error) {
-        console.error(`Failed to fetch token info for ${token}:`, error);
-      }
-    }
-    return tokenInfo;
-  }
-  getCacheKey(prefix, params) {
-    return `${prefix}:${JSON.stringify(params)}`;
-  }
-  getFromCache(key) {
-    const cached = this.cache.get(key);
-    if (!cached) return null;
-    if (Date.now() > cached.expiry) {
-      this.cache.delete(key);
-      return null;
-    }
-    return cached.data;
-  }
-  setCache(key, data) {
-    const expiry = Date.now() + this.cacheTTL * 1e3;
-    this.cache.set(key, { data, expiry });
-    if (this.cache.size > 1e3) {
-      const entries = Array.from(this.cache.entries());
-      entries.sort((a, b) => a[1].expiry - b[1].expiry);
-      for (let i = 0; i < 100; i++) {
-        this.cache.delete(entries[i][0]);
-      }
-    }
-  }
-  /**
-   * Clear all cached data
-   */
-  clearCache() {
-    this.cache.clear();
-  }
-  /**
-   * Get cache statistics
-   */
-  getCacheStats() {
-    return {
-      size: this.cache.size,
-      enabled: this.cacheEnabled,
-      ttl: this.cacheTTL
-    };
-  }
-};
-function createAgentDiscoveryClient(options) {
-  return new AgentDiscoveryClient(options);
-}
-function toSignature(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  return value;
-}
-var SignatureCache = class {
-  cache = /* @__PURE__ */ new Map();
-  ttl;
-  cleanupInterval = null;
-  constructor(ttl = 3600) {
-    this.ttl = ttl * 1e3;
-    this.cleanupInterval = setInterval(() => this.cleanup(), 3e5);
-    if (this.cleanupInterval.unref) {
-      this.cleanupInterval.unref();
-    }
-  }
-  has(signature) {
-    const entry = this.cache.get(signature);
-    if (!entry) return false;
-    if (Date.now() > entry.expiresAt) {
-      this.cache.delete(signature);
-      return false;
-    }
-    return true;
-  }
-  add(signature) {
-    this.cache.set(signature, {
-      timestamp: Date.now(),
-      expiresAt: Date.now() + this.ttl
-    });
-  }
-  cleanup() {
-    const now = Date.now();
-    for (const [signature, entry] of this.cache.entries()) {
-      if (now > entry.expiresAt) {
-        this.cache.delete(signature);
-      }
-    }
-  }
-  getSize() {
-    return this.cache.size;
-  }
-  /**
-   * Destroy the cache and clear the cleanup interval
-   * Call this when shutting down to prevent memory leaks
-   */
-  destroy() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    this.cache.clear();
-  }
-};
-var globalSignatureCache = null;
-function createX402Middleware(options) {
-  const preventDuplicates = options.preventDuplicatePayments ?? true;
-  const enforceExpiration = options.enforceExpiration ?? true;
-  const cacheTTL = options.signatureCacheTTL ?? 3600;
-  const signatureCache = preventDuplicates ? options.signatureCacheTTL ? new SignatureCache(cacheTTL) : globalSignatureCache : null;
-  return async (req, res, next) => {
-    const requestStartTime = Date.now();
-    const paymentSignature = req.headers["x-payment-signature"];
-    const paymentExpiresAt = req.headers["x-payment-expires-at"];
-    if (options.allowBypass && shouldBypass(req, options)) {
-      return next();
-    }
-    const paymentRequest = options.x402Client.createPaymentRequest({
-      amount: options.requiredPayment,
-      token: options.token,
-      description: options.description
-    });
-    if (!paymentSignature) {
-      const headers = options.x402Client.createPaymentHeaders(paymentRequest);
-      res.status(402).set(headers).json({
-        error: "Payment Required",
-        message: "This endpoint requires x402 payment",
-        code: "PAYMENT_REQUIRED",
-        paymentDetails: {
-          address: paymentRequest.recipient,
-          amount: paymentRequest.amount.toString(),
-          token: paymentRequest.token,
-          blockchain: "solana",
-          description: options.description,
-          expiresAt: paymentRequest.expiresAt
-        },
-        documentation: "https://docs.ghostspeak.ai/x402"
-      });
-      return;
-    }
-    if (preventDuplicates && signatureCache?.has(paymentSignature)) {
-      if (options.onPaymentFailed) {
-        await options.onPaymentFailed("Payment signature already used", req);
-      }
-      res.status(402).json({
-        error: "Payment Already Used",
-        message: "This payment signature has already been used. Please create a new payment.",
-        code: "PAYMENT_DUPLICATE"
-      });
-      return;
-    }
-    if (enforceExpiration && paymentExpiresAt) {
-      const now = Date.now();
-      const expiresAtTimestamp = parseInt(paymentExpiresAt, 10);
-      if (isNaN(expiresAtTimestamp)) {
-        if (options.onPaymentFailed) {
-          await options.onPaymentFailed("Invalid expiration timestamp", req);
-        }
-        res.status(402).json({
-          error: "Invalid Payment Expiration",
-          message: "The x-payment-expires-at header contains an invalid timestamp.",
-          code: "PAYMENT_INVALID_EXPIRY"
-        });
-        return;
-      }
-      if (now > expiresAtTimestamp) {
-        if (options.onPaymentFailed) {
-          await options.onPaymentFailed("Payment request expired", req);
-        }
-        res.status(402).json({
-          error: "Payment Expired",
-          message: "This payment request has expired. Please create a new payment.",
-          code: "PAYMENT_EXPIRED",
-          expiresAt: expiresAtTimestamp,
-          currentTime: now
-        });
-        return;
-      }
-    }
-    try {
-      const verification = await options.x402Client.verifyPaymentDetails({
-        signature: toSignature(paymentSignature),
-        expectedRecipient: paymentRequest.recipient,
-        expectedAmount: options.requiredPayment,
-        expectedToken: options.token
-      });
-      if (!verification.valid) {
-        if (options.onPaymentFailed) {
-          await options.onPaymentFailed(verification.error ?? "Unknown error", req);
-        }
-        res.status(402).json({
-          error: "Payment Verification Failed",
-          message: verification.error ?? "Invalid payment",
-          code: "PAYMENT_INVALID"
-        });
-        return;
-      }
-      const responseTimeMs = Date.now() - requestStartTime;
-      let callerIdentity;
-      if (options.lookupCallerIdentity) {
+      let responseTimeMs;
+      let metadata;
+      if (memoIx && memoIx.data) {
         try {
-          callerIdentity = await lookupCallerIdentity(
-            verification.receipt.recipient,
-            options.rpcEndpoint,
-            options.programId
-          );
-        } catch (identityError) {
-          console.warn("[x402] Failed to lookup caller identity:", identityError);
+          const memoText = Buffer.from(memoIx.data, "base64").toString("utf-8");
+          const memoData = JSON.parse(memoText);
+          responseTimeMs = memoData.responseTimeMs;
+          metadata = memoData;
+        } catch {
         }
       }
-      req.x402Payment = {
-        signature: paymentSignature,
-        verified: true,
-        amount: verification.receipt.amount,
-        token: verification.receipt.token,
-        responseTimeMs,
-        timestamp: Date.now(),
-        caller: callerIdentity
-      };
-      if (preventDuplicates && signatureCache) {
-        signatureCache.add(paymentSignature);
-      }
-      if (options.recordPaymentOnChain && options.agentId) {
-        try {
-          console.log(`[x402] Would record payment on-chain for agent ${options.agentId}`);
-        } catch (reputationError) {
-          if (options.onReputationUpdateFailed && reputationError instanceof Error) {
-            options.onReputationUpdateFailed(reputationError);
-          } else {
-            console.error("[x402] Failed to record payment on-chain:", reputationError);
-          }
-        }
-      }
-      if (options.onPaymentVerified) {
-        await options.onPaymentVerified(paymentSignature, req);
-      }
-      next();
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (options.onPaymentFailed) {
-        await options.onPaymentFailed(errorMessage, req);
-      }
-      res.status(500).json({
-        error: "Payment Verification Error",
-        message: errorMessage,
-        code: "PAYMENT_VERIFICATION_ERROR"
-      });
-    }
-  };
-}
-function x402FastifyPlugin(fastify, options) {
-  fastify.addHook("preHandler", async (request, reply) => {
-    const route = request.url ? options.routes[request.url] : void 0;
-    if (!route) {
-      return;
-    }
-    const paymentSignature = request.headers["x-payment-signature"];
-    const paymentRequest = options.x402Client.createPaymentRequest({
-      amount: route.payment,
-      token: route.token,
-      description: route.description
-    });
-    if (!paymentSignature) {
-      const headers = options.x402Client.createPaymentHeaders(paymentRequest);
-      reply.code(402).headers(headers).send({
-        error: "Payment Required",
-        paymentDetails: {
-          address: paymentRequest.recipient,
-          amount: paymentRequest.amount.toString(),
-          token: paymentRequest.token
-        }
-      });
-      return;
-    }
-    const verification = await options.x402Client.verifyPaymentDetails({
-      signature: toSignature(paymentSignature),
-      expectedRecipient: paymentRequest.recipient,
-      expectedAmount: route.payment,
-      expectedToken: route.token
-    });
-    if (!verification.valid) {
-      reply.code(402).send({
-        error: "Payment Verification Failed",
-        message: verification.error
-      });
-      return;
-    }
-    request.x402Payment = {
-      signature: paymentSignature,
-      verified: true,
-      amount: verification.receipt.amount,
-      token: verification.receipt.token
-    };
-  });
-}
-function shouldBypass(req, options) {
-  const clientAddress = req.headers["x-client-address"];
-  if (clientAddress && options.bypassAddresses) {
-    return options.bypassAddresses.includes(clientAddress);
-  }
-  return false;
-}
-async function lookupCallerIdentity(sourceAddress, rpcEndpoint, programId) {
-  if (!rpcEndpoint) {
-    return {
-      type: "unknown",
-      address: sourceAddress
-    };
-  }
-  try {
-    const rpc = createSolanaRpc(rpcEndpoint);
-    const maybeAgent = await fetchMaybeAgent(rpc, sourceAddress);
-    if (!maybeAgent.exists) {
       return {
-        type: "unknown",
-        address: sourceAddress
-      };
-    }
-    const agent = maybeAgent.data;
-    return {
-      type: "agent",
-      address: sourceAddress,
-      agent: {
-        name: agent.name,
-        owner: agent.owner,
-        reputation_score: agent.reputationScore,
-        is_verified: agent.isVerified,
-        capabilities: agent.capabilities,
-        framework_origin: agent.frameworkOrigin,
-        x402_enabled: true
-        // Assume all agents support x402 (no explicit flag in schema)
-      }
-    };
-  } catch (error) {
-    console.warn("[x402] Agent lookup failed:", error);
-    return {
-      type: "unknown",
-      address: sourceAddress
-    };
-  }
-}
-function withX402RateLimit(options) {
-  const requests = /* @__PURE__ */ new Map();
-  return (target, propertyKey, descriptor) => {
-    const originalMethod = descriptor.value;
-    descriptor.value = async function(...args) {
-      const req = args[0];
-      const res = args[1];
-      const forwardedFor = req.headers["x-forwarded-for"];
-      const clientIp = forwardedFor?.split(",")[0]?.trim() ?? req.ip ?? "unknown";
-      const clientId = req.x402Payment?.signature ?? clientIp;
-      const now = Date.now();
-      const userRequests = requests.get(clientId) ?? [];
-      const recentRequests = userRequests.filter(
-        (timestamp) => now - timestamp < 6e4
-      );
-      if (recentRequests.length >= options.maxRequestsPerMinute) {
-        res.status(429).json({
-          error: "Rate Limit Exceeded",
-          message: `Maximum ${options.maxRequestsPerMinute} requests per minute`,
-          paymentRequired: options.paymentRequired.toString()
-        });
-        return;
-      }
-      recentRequests.push(now);
-      requests.set(clientId, recentRequests);
-      return originalMethod.apply(this, args);
-    };
-  };
-}
-
-// src/x402/schemas/enhanced-x402.ts
-function validatePaymentRequirement(req) {
-  const errors = [];
-  const r = req;
-  if (!r || typeof r !== "object") {
-    return { valid: false, errors: ["Payment requirement must be an object"] };
-  }
-  if (!r.network || typeof r.network !== "string") {
-    errors.push('Missing or invalid "network" field');
-  }
-  if (!r.maxAmountRequired && !r.max_amount_required && !r.amount) {
-    errors.push('Missing "maxAmountRequired" field');
-  }
-  if (!r.payTo && !r.pay_to && !r.recipient) {
-    errors.push('Missing "payTo" field');
-  }
-  if (!r.asset && !r.token) {
-    errors.push('Missing "asset" field');
-  }
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  const requirement = {
-    scheme: r.scheme ?? "exact",
-    network: r.network ?? r.chain,
-    maxAmountRequired: String(r.maxAmountRequired ?? r.max_amount_required ?? r.amount),
-    resource: r.resource,
-    description: r.description,
-    mimeType: r.mimeType ?? r.mime_type,
-    payTo: String(r.payTo ?? r.pay_to ?? r.recipient),
-    maxTimeoutSeconds: r.maxTimeoutSeconds ?? r.max_timeout_seconds,
-    asset: String(r.asset ?? r.token),
-    extra: r.extra
-  };
-  return { valid: true, requirement };
-}
-function validateX402Response(response) {
-  const errors = [];
-  const r = response;
-  if (!r || typeof r !== "object") {
-    return { valid: false, errors: ["Response must be an object"] };
-  }
-  const version = r.x402Version ?? r.x402_version;
-  if (!version) {
-    errors.push('Missing "x402Version" field');
-  }
-  const accepts = r.accepts ?? r.payment_requirements;
-  if (!accepts || !Array.isArray(accepts)) {
-    errors.push('Missing or invalid "accepts" array');
-  } else if (accepts.length === 0) {
-    errors.push('"accepts" array must not be empty');
-  } else {
-    for (let i = 0; i < accepts.length; i++) {
-      const result = validatePaymentRequirement(accepts[i]);
-      if (!result.valid) {
-        errors.push(`accepts[${i}]: ${result.errors.join(", ")}`);
-      }
-    }
-  }
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  const enhanced = {
-    x402Version: "1.0",
-    accepts: accepts.map((a) => {
-      const result = validatePaymentRequirement(a);
-      return result.valid ? result.requirement : {};
-    }),
-    error: r.error,
-    inputSchema: r.inputSchema ?? r.input_schema,
-    outputSchema: r.outputSchema ?? r.output_schema,
-    description: r.description,
-    name: r.name,
-    tags: r.tags,
-    category: r.category,
-    examples: r.examples,
-    apiVersion: r.apiVersion ?? r.api_version,
-    methods: r.methods,
-    rateLimit: r.rateLimit ?? r.rate_limit,
-    authRequired: r.authRequired ?? r.auth_required,
-    sla: r.sla,
-    termsUrl: r.termsUrl ?? r.terms_url,
-    privacyUrl: r.privacyUrl ?? r.privacy_url,
-    docsUrl: r.docsUrl ?? r.docs_url,
-    support: r.support
-  };
-  return { valid: true, response: enhanced };
-}
-function parseX402Response(body) {
-  try {
-    const parsed = JSON.parse(body);
-    return validateX402Response(parsed);
-  } catch (error) {
-    return {
-      valid: false,
-      errors: [`Failed to parse JSON: ${error instanceof Error ? error.message : "Unknown error"}`]
-    };
-  }
-}
-var FetchWithPaymentClient = class extends EventEmitter {
-  wallet;
-  createPaymentHeader;
-  maxPayment;
-  preferredNetwork;
-  preferredToken;
-  timeout;
-  retries;
-  userAgent;
-  constructor(options) {
-    super();
-    this.wallet = options.wallet;
-    this.createPaymentHeader = options.createPaymentHeader;
-    this.maxPayment = options.maxPayment ?? BigInt("1000000000");
-    this.preferredNetwork = options.preferredNetwork;
-    this.preferredToken = options.preferredToken;
-    this.timeout = options.timeout ?? 3e4;
-    this.retries = options.retries ?? 1;
-    this.userAgent = options.userAgent ?? "GhostSpeak-x402-Fetch/1.0";
-  }
-  /**
-   * Make an x402-enabled fetch request
-   */
-  async fetch(url, options) {
-    const mergedOptions = {
-      ...options,
-      maxPayment: options?.maxPayment ?? this.maxPayment,
-      preferredNetwork: options?.preferredNetwork ?? this.preferredNetwork,
-      preferredToken: options?.preferredToken ?? this.preferredToken,
-      timeout: options?.timeout ?? this.timeout,
-      retries: options?.retries ?? this.retries
-    };
-    return this.fetchWithPayment(url, mergedOptions);
-  }
-  /**
-   * Internal fetch with payment logic
-   */
-  async fetchWithPayment(url, options) {
-    const headers = new Headers(options.headers);
-    headers.set("User-Agent", this.userAgent);
-    const initialResponse = await fetch(url, {
-      ...options,
-      headers,
-      signal: options.timeout ? AbortSignal.timeout(options.timeout) : void 0
-    });
-    if (initialResponse.status !== 402) {
-      return initialResponse;
-    }
-    const body = await initialResponse.text();
-    const parseResult = parseX402Response(body);
-    if (!parseResult.valid) {
-      const errorResponse = new Response(body, {
-        status: 402,
-        statusText: "Payment Required - Invalid x402 Response",
-        headers: initialResponse.headers
-      });
-      errorResponse.x402Requirements = [];
-      return errorResponse;
-    }
-    const x402Response = parseResult.response;
-    this.emit("paymentRequired", x402Response.accepts);
-    options.onPaymentRequired?.(x402Response.accepts);
-    if (options.dryRun) {
-      const dryRunResponse = new Response(body, {
-        status: 402,
-        statusText: "Payment Required",
-        headers: initialResponse.headers
-      });
-      dryRunResponse.x402Requirements = x402Response.accepts;
-      return dryRunResponse;
-    }
-    const selectedRequirement = this.selectPaymentRequirement(
-      x402Response.accepts,
-      options
-    );
-    if (!selectedRequirement) {
-      throw new X402PaymentError(
-        "No suitable payment option found within max payment limit",
-        x402Response.accepts
-      );
-    }
-    const amount = BigInt(selectedRequirement.maxAmountRequired);
-    if (amount > (options.maxPayment ?? this.maxPayment)) {
-      throw new X402PaymentError(
-        `Payment amount ${amount} exceeds max payment ${options.maxPayment ?? this.maxPayment}`,
-        x402Response.accepts
-      );
-    }
-    let paymentHeader;
-    try {
-      paymentHeader = await this.createPaymentHeader(selectedRequirement, this.wallet);
-    } catch (error) {
-      throw new X402PaymentError(
-        `Failed to create payment header: ${error instanceof Error ? error.message : "Unknown error"}`,
-        x402Response.accepts
-      );
-    }
-    const retryHeaders = new Headers(headers);
-    retryHeaders.set("X-Payment", paymentHeader);
-    for (let attempt = 0; attempt <= (options.retries ?? this.retries); attempt++) {
-      try {
-        const paidResponse = await fetch(url, {
-          ...options,
-          headers: retryHeaders,
-          signal: options.timeout ? AbortSignal.timeout(options.timeout) : void 0
-        });
-        const paymentInfo = {
-          signature: paymentHeader.split(":")[0] ?? "",
-          amount,
-          recipient: selectedRequirement.payTo,
-          token: selectedRequirement.asset,
-          network: selectedRequirement.network,
-          timestamp: Date.now()
-        };
-        const response = paidResponse;
-        response.paymentInfo = paymentInfo;
-        response.x402Requirements = x402Response.accepts;
-        this.emit("payment", paymentInfo);
-        options.onPayment?.(paymentInfo);
-        return response;
-      } catch (error) {
-        if (attempt === (options.retries ?? this.retries)) {
-          throw error;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 1e3 * (attempt + 1)));
-      }
-    }
-    throw new Error("Failed to complete payment request after retries");
-  }
-  /**
-   * Select the best payment requirement based on options
-   */
-  selectPaymentRequirement(accepts, options) {
-    let candidates = [...accepts];
-    if (options.preferredNetwork) {
-      const networkMatches = candidates.filter(
-        (a) => a.network === options.preferredNetwork
-      );
-      if (networkMatches.length > 0) {
-        candidates = networkMatches;
-      }
-    }
-    if (options.preferredToken) {
-      const tokenMatches = candidates.filter(
-        (a) => a.asset.toLowerCase() === options.preferredToken.toLowerCase()
-      );
-      if (tokenMatches.length > 0) {
-        candidates = tokenMatches;
-      }
-    }
-    const maxPayment = options.maxPayment ?? this.maxPayment;
-    candidates = candidates.filter((a) => BigInt(a.maxAmountRequired) <= maxPayment);
-    if (candidates.length === 0) {
-      return null;
-    }
-    return candidates.sort(
-      (a, b) => Number(BigInt(a.maxAmountRequired) - BigInt(b.maxAmountRequired))
-    )[0];
-  }
-};
-var X402PaymentError = class extends Error {
-  constructor(message, requirements) {
-    super(message);
-    this.requirements = requirements;
-    this.name = "X402PaymentError";
-  }
-};
-async function fetchWithX402Payment(url, options, wallet, createPaymentHeader, paymentOptions) {
-  const client = new FetchWithPaymentClient({
-    wallet,
-    createPaymentHeader,
-    maxPayment: paymentOptions?.maxPayment,
-    preferredNetwork: paymentOptions?.preferredNetwork,
-    preferredToken: paymentOptions?.preferredToken,
-    timeout: paymentOptions?.timeout,
-    retries: paymentOptions?.retries
-  });
-  return client.fetch(url, {
-    ...options,
-    ...paymentOptions
-  });
-}
-function wrapFetchWithPayment(wallet, createPaymentHeader, defaultOptions) {
-  const client = new FetchWithPaymentClient({
-    wallet,
-    createPaymentHeader,
-    ...defaultOptions
-  });
-  return (url, options) => client.fetch(url, options);
-}
-var X402AnalyticsTracker = class extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.options = options;
-  }
-  paymentEvents = [];
-  agentEarnings = /* @__PURE__ */ new Map();
-  agentCallCounts = /* @__PURE__ */ new Map();
-  tokenVolumes = /* @__PURE__ */ new Map();
-  metricsTimer;
-  isActive = false;
-  // Integration with existing analytics system
-  analyticsStreamer;
-  analyticsAggregator;
-  /**
-   * Start analytics tracking
-   */
-  start() {
-    if (this.isActive) {
-      console.warn("x402 analytics tracker is already active");
-      return;
-    }
-    this.isActive = true;
-    if (this.options.metricsInterval) {
-      this.metricsTimer = setInterval(() => {
-        this.aggregateAndEmitMetrics();
-      }, this.options.metricsInterval);
-    }
-    this.emit("started");
-  }
-  /**
-   * Stop analytics tracking
-   */
-  stop() {
-    this.isActive = false;
-    if (this.metricsTimer) {
-      clearInterval(this.metricsTimer);
-      this.metricsTimer = void 0;
-    }
-    this.emit("stopped");
-  }
-  /**
-   * Record a new x402 payment event
-   */
-  recordPayment(event) {
-    if (!this.isActive) return;
-    this.paymentEvents.push(event);
-    if (event.agent && event.status === "confirmed") {
-      const currentEarnings = this.agentEarnings.get(event.agent) ?? 0n;
-      this.agentEarnings.set(event.agent, currentEarnings + event.amount);
-      const currentCalls = this.agentCallCounts.get(event.agent) ?? 0;
-      this.agentCallCounts.set(event.agent, currentCalls + 1);
-    }
-    if (event.status === "confirmed") {
-      const currentVolume = this.tokenVolumes.get(event.token) ?? 0n;
-      this.tokenVolumes.set(event.token, currentVolume + event.amount);
-    }
-    this.emit("payment", event);
-    if (this.options.onPayment) {
-      this.options.onPayment(event);
-    }
-    this.pruneOldEvents();
-  }
-  /**
-   * Record payment from transaction signature
-   */
-  async recordPaymentFromSignature(signature, payer, recipient, amount, token, agent) {
-    const event = {
-      signature,
-      timestamp: BigInt(Date.now()),
-      payer,
-      recipient,
-      amount,
-      token,
-      agent,
-      status: "pending"
-    };
-    this.recordPayment(event);
-  }
-  /**
-   * Update payment status
-   */
-  updatePaymentStatus(signature, status, metadata) {
-    const event = this.paymentEvents.find((e) => e.signature === signature);
-    if (event) {
-      event.status = status;
-      if (metadata) {
-        event.metadata = { ...event.metadata, ...metadata };
-      }
-      this.emit("paymentStatusChanged", event);
-    }
-  }
-  /**
-   * Get current metrics
-   */
-  getMetrics(periodSeconds) {
-    const now = BigInt(Date.now());
-    const startTime = periodSeconds ? now - BigInt(periodSeconds * 1e3) : this.getOldestEventTimestamp();
-    const periodEvents = this.paymentEvents.filter((e) => e.timestamp >= startTime);
-    const total = periodEvents.length;
-    const successful = periodEvents.filter((e) => e.status === "confirmed").length;
-    const failed = periodEvents.filter((e) => e.status === "failed").length;
-    const pending = periodEvents.filter((e) => e.status === "pending").length;
-    const successfulEvents = periodEvents.filter((e) => e.status === "confirmed");
-    const totalVolume = successfulEvents.reduce((sum, e) => sum + e.amount, 0n);
-    const averageVolume = successful > 0 ? totalVolume / BigInt(successful) : 0n;
-    const volumeByToken = /* @__PURE__ */ new Map();
-    for (const event of successfulEvents) {
-      const current = volumeByToken.get(event.token) ?? 0n;
-      volumeByToken.set(event.token, current + event.amount);
-    }
-    const activeAgents = new Set(
-      periodEvents.filter((e) => e.agent).map((e) => e.agent)
-    );
-    const topEarners = Array.from(this.agentEarnings.entries()).map(([agent, earnings]) => ({
-      agent,
-      earnings,
-      callCount: this.agentCallCounts.get(agent) ?? 0
-    })).sort((a, b) => Number(b.earnings - a.earnings)).slice(0, 10);
-    const confirmedEvents = periodEvents.filter((e) => e.status === "confirmed");
-    const confirmationTimes = confirmedEvents.map((e) => Number(e.metadata?.confirmationTime ?? 0)).filter((t) => t > 0);
-    const averageConfirmationTime = confirmationTimes.length > 0 ? confirmationTimes.reduce((a, b) => a + b, 0) / confirmationTimes.length : 0;
-    const successRate = total > 0 ? successful / total * 100 : 0;
-    const errorRate = total > 0 ? failed / total * 100 : 0;
-    return {
-      period: {
-        start: startTime,
-        end: now
-      },
-      payments: {
-        total,
-        successful,
-        failed,
-        pending
-      },
-      volume: {
-        total: totalVolume,
-        average: averageVolume,
-        byToken: volumeByToken
-      },
-      agents: {
-        totalActive: activeAgents.size,
-        topEarners
-      },
-      performance: {
-        averageConfirmationTime,
-        successRate,
-        errorRate
-      }
-    };
-  }
-  /**
-   * Get agent earnings
-   */
-  getAgentEarnings(agent) {
-    const totalEarnings = this.agentEarnings.get(agent) ?? 0n;
-    const totalCalls = this.agentCallCounts.get(agent) ?? 0;
-    const averagePerCall = totalCalls > 0 ? totalEarnings / BigInt(totalCalls) : 0n;
-    return {
-      totalEarnings,
-      totalCalls,
-      averagePerCall
-    };
-  }
-  /**
-   * Get token volume
-   */
-  getTokenVolume(token) {
-    return this.tokenVolumes.get(token) ?? 0n;
-  }
-  /**
-   * Get payment history for agent
-   */
-  getAgentPaymentHistory(agent, limit) {
-    const agentEvents = this.paymentEvents.filter((e) => e.agent === agent).sort((a, b) => Number(b.timestamp - a.timestamp));
-    return limit ? agentEvents.slice(0, limit) : agentEvents;
-  }
-  /**
-   * Get recent payments
-   */
-  getRecentPayments(limit = 100) {
-    return this.paymentEvents.slice(-limit).sort((a, b) => Number(b.timestamp - a.timestamp));
-  }
-  /**
-   * Integrate with existing analytics streamer
-   */
-  integrateWithStreamer(streamer) {
-    this.analyticsStreamer = streamer;
-    streamer.on("transactionAnalytics", (event) => {
-      if (this.isX402Transaction(event)) {
-        this.recordPaymentFromAnalyticsEvent(event);
-      }
-    });
-  }
-  /**
-   * Integrate with existing analytics aggregator
-   */
-  integrateWithAggregator(aggregator) {
-    this.analyticsAggregator = aggregator;
-    this.on("payment", (event) => {
-      if (event.status === "confirmed" && this.analyticsAggregator) {
-        const txEvent = {
-          transactionType: "x402_payment",
-          amount: event.amount,
-          from: event.payer,
-          to: event.recipient,
-          status: "completed",
-          timestamp: BigInt(event.timestamp),
-          blockHeight: 0n
-          // Would be populated from actual blockchain data
-        };
-        this.analyticsAggregator.processTransactionEvent(txEvent);
-      }
-    });
-  }
-  /**
-   * Get aggregated metrics from integrated aggregator
-   */
-  getAggregatedMetrics() {
-    return this.analyticsAggregator?.aggregate() ?? null;
-  }
-  // Private helper methods
-  aggregateAndEmitMetrics() {
-    try {
-      const metrics = this.getMetrics();
-      this.emit("metrics", metrics);
-      if (this.options.onMetrics) {
-        this.options.onMetrics(metrics);
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  pruneOldEvents() {
-    if (!this.options.retentionPeriod) return;
-    const cutoffTime = BigInt(Date.now()) - BigInt(this.options.retentionPeriod * 1e3);
-    this.paymentEvents = this.paymentEvents.filter((e) => e.timestamp > cutoffTime);
-  }
-  getOldestEventTimestamp() {
-    if (this.paymentEvents.length === 0) {
-      return BigInt(Date.now());
-    }
-    return this.paymentEvents[0].timestamp;
-  }
-  isX402Transaction(event) {
-    return event.transactionType === "x402_payment" || event.transactionType === "payment";
-  }
-  recordPaymentFromAnalyticsEvent(event) {
-    const paymentEvent = {
-      signature: "",
-      // Not available in TransactionAnalyticsEvent
-      timestamp: BigInt(event.timestamp),
-      payer: event.from,
-      recipient: event.to,
-      amount: event.amount,
-      token: "11111111111111111111111111111111",
-      // Would parse from event
-      status: event.status === "completed" ? "confirmed" : "failed"
-    };
-    this.recordPayment(paymentEvent);
-  }
-  handleError(error) {
-    this.emit("error", error);
-    if (this.options.onError) {
-      this.options.onError(error);
-    }
-  }
-  /**
-   * Clear all tracked data
-   */
-  clearData() {
-    this.paymentEvents = [];
-    this.agentEarnings.clear();
-    this.agentCallCounts.clear();
-    this.tokenVolumes.clear();
-  }
-  /**
-   * Get tracker statistics
-   */
-  getStats() {
-    return {
-      eventsTracked: this.paymentEvents.length,
-      agentsTracked: this.agentEarnings.size,
-      tokensTracked: this.tokenVolumes.size,
-      isActive: this.isActive
-    };
-  }
-};
-function createX402AnalyticsTracker(options) {
-  return new X402AnalyticsTracker(options);
-}
-var PaymentStreamingManager = class extends EventEmitter {
-  streams;
-  intervals;
-  x402Client;
-  connection;
-  constructor(x402Client, connection) {
-    super();
-    this.streams = /* @__PURE__ */ new Map();
-    this.intervals = /* @__PURE__ */ new Map();
-    this.x402Client = x402Client;
-    this.connection = connection;
-  }
-  /**
-   * Create a new payment stream
-   */
-  async createStream(config) {
-    const streamId = this.generateStreamId(config);
-    this.validateStreamConfig(config);
-    const stream = {
-      id: streamId,
-      config,
-      status: "active",
-      amountPaid: 0n,
-      payments: [],
-      startedAt: Date.now(),
-      nextPaymentAt: Date.now() + config.intervalMs
-    };
-    this.streams.set(streamId, stream);
-    this.startStreamInterval(stream);
-    this.emit("stream_created", stream);
-    return stream;
-  }
-  /**
-   * Pause a payment stream
-   */
-  pauseStream(streamId) {
-    const stream = this.streams.get(streamId);
-    if (!stream) {
-      throw new Error(`Stream ${streamId} not found`);
-    }
-    if (stream.status !== "active") {
-      throw new Error(`Stream ${streamId} is not active`);
-    }
-    this.stopStreamInterval(streamId);
-    stream.status = "paused";
-    this.emit("stream_paused", stream);
-  }
-  /**
-   * Resume a paused payment stream
-   */
-  resumeStream(streamId) {
-    const stream = this.streams.get(streamId);
-    if (!stream) {
-      throw new Error(`Stream ${streamId} not found`);
-    }
-    if (stream.status !== "paused") {
-      throw new Error(`Stream ${streamId} is not paused`);
-    }
-    stream.status = "active";
-    stream.nextPaymentAt = Date.now() + stream.config.intervalMs;
-    this.startStreamInterval(stream);
-    this.emit("stream_resumed", stream);
-  }
-  /**
-   * Cancel a payment stream
-   */
-  cancelStream(streamId) {
-    const stream = this.streams.get(streamId);
-    if (!stream) {
-      throw new Error(`Stream ${streamId} not found`);
+        signature,
+        merchant,
+        payer,
+        amount,
+        success,
+        timestamp,
+        network: this.network,
+        responseTimeMs,
+        metadata
+      };
+    } catch (error) {
+      console.error("[X402 Indexer] Failed to extract payment data:", error);
+      return null;
     }
-    this.stopStreamInterval(streamId);
-    stream.status = "cancelled";
-    stream.endedAt = Date.now();
-    this.emit("stream_cancelled", stream);
-  }
-  /**
-   * Get stream by ID
-   */
-  getStream(streamId) {
-    return this.streams.get(streamId);
-  }
-  /**
-   * Get all streams
-   */
-  getAllStreams() {
-    return Array.from(this.streams.values());
   }
-  /**
-   * Get active streams
-   */
-  getActiveStreams() {
-    return Array.from(this.streams.values()).filter((s) => s.status === "active");
+};
+
+// 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
+  // =====================================================
   /**
-   * Complete a milestone
+   * Handle an incoming webhook request
+   *
+   * @param request - The incoming HTTP request (must have headers and body)
+   * @returns Processing result
    */
-  async completeMilestone(streamId, milestoneId) {
-    const stream = this.streams.get(streamId);
-    if (!stream) {
-      throw new Error(`Stream ${streamId} not found`);
-    }
-    const milestone = stream.config.milestones?.find((m) => m.id === milestoneId);
-    if (!milestone) {
-      throw new Error(`Milestone ${milestoneId} not found`);
-    }
-    if (milestone.completed) {
-      throw new Error(`Milestone ${milestoneId} already completed`);
-    }
-    const conditionMet = await milestone.condition();
-    if (!conditionMet) {
-      throw new Error(`Milestone ${milestoneId} condition not met`);
-    }
+  async handleWebhook(request) {
     try {
-      const paymentSignature = await this.makePayment(stream, milestone.amount, milestoneId);
-      milestone.completed = true;
-      milestone.completedAt = Date.now();
-      this.emit("milestone_completed", {
-        streamId,
-        milestoneId,
-        signature: paymentSignature
-      });
+      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) {
-      this.emit("milestone_failed", {
-        streamId,
-        milestoneId,
-        error
-      });
-      throw error;
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.emit("error", new Error(`Webhook processing failed: ${errorMessage}`));
+      return {
+        success: false,
+        error: errorMessage
+      };
     }
   }
   /**
-   * Cleanup: Stop all streams and clear intervals
+   * Verify webhook signature
    */
-  cleanup() {
-    for (const streamId of this.intervals.keys()) {
-      this.stopStreamInterval(streamId);
+  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" };
     }
-    this.streams.clear();
-    this.intervals.clear();
-  }
-  // Private methods
-  generateStreamId(config) {
-    const timestamp = Date.now();
-    const hash = `${config.agentAddress}-${config.clientAddress}-${timestamp}`;
-    return Buffer.from(hash).toString("base64").slice(0, 16);
-  }
-  validateStreamConfig(config) {
-    if (config.totalAmount <= 0n) {
-      throw new Error("Total amount must be positive");
+    if (!timestamp) {
+      return { valid: false, error: "Missing timestamp header" };
     }
-    if (config.intervalMs <= 0) {
-      throw new Error("Interval must be positive");
+    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 (config.durationMs <= 0) {
-      throw new Error("Duration must be positive");
+    if (!this.options.webhookSecret) {
+      return { valid: false, error: "Webhook secret not configured" };
     }
-    if (config.amountPerInterval <= 0n) {
-      throw new Error("Amount per interval must be positive");
+    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" };
     }
-    const maxPayments = Math.ceil(config.durationMs / config.intervalMs);
-    const totalViaInterval = config.amountPerInterval * BigInt(maxPayments);
-    const milestoneTotal = config.milestones?.reduce((sum, m) => sum + m.amount, 0n) ?? 0n;
-    if (totalViaInterval + milestoneTotal > config.totalAmount * 110n / 100n) {
-      throw new Error("Payment schedule exceeds total amount (with 10% tolerance)");
+    if (!timingSafeEqual(signatureBuffer, expectedBuffer)) {
+      return { valid: false, error: "Invalid signature" };
     }
+    return { valid: true };
   }
-  startStreamInterval(stream) {
-    const interval = setInterval(async () => {
-      await this.processPayment(stream);
-    }, stream.config.intervalMs);
-    this.intervals.set(stream.id, interval);
+  /**
+   * 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
+    };
   }
-  stopStreamInterval(streamId) {
-    const interval = this.intervals.get(streamId);
-    if (interval) {
-      clearInterval(interval);
-      this.intervals.delete(streamId);
+  // =====================================================
+  // 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
+    };
   }
-  async processPayment(stream) {
-    if (stream.status !== "active") {
-      return;
-    }
-    if (stream.amountPaid >= stream.config.totalAmount) {
-      this.completeStream(stream);
-      return;
-    }
-    if (Date.now() >= stream.startedAt + stream.config.durationMs) {
-      this.completeStream(stream);
-      return;
+  /**
+   * 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 amount = stream.config.amountPerInterval;
-      const signature = await this.makePayment(stream, amount);
-      stream.lastPaymentAt = Date.now();
-      stream.nextPaymentAt = Date.now() + stream.config.intervalMs;
-      this.emit("payment_processed", {
-        streamId: stream.id,
-        amount,
-        signature
-      });
-    } catch (error) {
-      this.emit("payment_failed", {
-        streamId: stream.id,
-        error
-      });
-      if (stream.config.autoResume !== true) {
-        stream.status = "failed";
-        stream.error = error;
-        stream.endedAt = Date.now();
-        this.stopStreamInterval(stream.id);
+      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;
     }
   }
-  async makePayment(stream, amount, milestoneId) {
-    const paymentRequest = this.x402Client.createPaymentRequest({
-      amount,
-      token: stream.config.tokenMint,
-      description: milestoneId ? `Stream ${stream.id} - Milestone ${milestoneId}` : `Stream ${stream.id} - Interval payment`,
-      metadata: {
-        streamId: stream.id,
-        ...milestoneId && { milestoneId }
-      }
-    });
-    const receipt = await this.x402Client.pay(paymentRequest);
-    const payment = {
-      timestamp: Date.now(),
-      amount,
-      signature: receipt.signature,
-      milestoneId,
-      success: true
-    };
-    stream.payments.push(payment);
-    stream.amountPaid += amount;
-    return receipt.signature;
-  }
-  completeStream(stream) {
-    this.stopStreamInterval(stream.id);
-    stream.status = "completed";
-    stream.endedAt = Date.now();
-    this.emit("stream_completed", stream);
+  /**
+   * 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");
   }
 };
-var A2AClient = class extends EventEmitter {
-  rpc;
-  programId;
-  wallet;
-  constructor(options, wallet) {
+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.rpc = createSolanaRpc(options.rpcEndpoint);
-    this.programId = options.programId ?? GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS;
-    this.wallet = wallet;
+    this.config = {
+      marketplaceUrl: config.marketplaceUrl ?? DEFAULT_MARKETPLACE_URL,
+      apiKey: config.apiKey,
+      network: config.network ?? "solana",
+      timeout: config.timeout ?? 3e4
+    };
   }
+  // =====================================================
+  // PUBLIC METHODS
+  // =====================================================
   /**
-   * Create a new A2A communication session
-   *
-   * Establishes a secure communication channel between two agents.
+   * Register a GhostSpeak agent with PayAI marketplace
    *
-   * @param config - Session configuration
-   * @returns Session details including address
-   *
-   * @example
-   * ```typescript
-   * const session = await a2aClient.createSession({
-   *   responder: 'AgentBpubkey...',
-   *   sessionType: 'data_processing',
-   *   metadata: 'Processing financial data',
-   *   expiresIn: 7200 // 2 hours
-   * })
-   * console.log('Session created:', session.address)
-   * ```
+   * @param agent - Agent data from GhostSpeak
+   * @returns Registration result
    */
-  async createSession(config) {
+  async registerAgent(agent) {
     try {
-      const now = Math.floor(Date.now() / 1e3);
-      const expiresAt = now + (config.expiresIn ?? 3600);
-      const sessionId = BigInt(Date.now());
-      const instruction = await getCreateA2aSessionInstructionAsync({
-        creator: this.wallet,
-        sessionId,
-        initiator: this.wallet.address,
-        responder: config.responder,
-        sessionType: config.sessionType,
-        metadata: config.metadata ?? "",
-        expiresAt: BigInt(expiresAt)
-      }, { programAddress: this.programId });
-      const signature = await this.sendTransaction([instruction]);
-      const sessionAddress = instruction.accounts[0].address;
-      this.emit("session_created", {
-        type: "session_created",
-        timestamp: Date.now(),
-        data: { sessionAddress, signature }
+      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
       });
-      const session = await fetchA2ASession(this.rpc, sessionAddress);
       return {
-        ...session.data,
-        address: sessionAddress
+        success: true,
+        agentId: data.agentId,
+        marketplaceUrl: data.url
       };
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.emit("error", {
-        type: "error",
-        timestamp: Date.now(),
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      return {
+        success: false,
         error: errorMessage
-      });
-      throw new Error(`Failed to create A2A session: ${errorMessage}`);
+      };
     }
   }
   /**
-   * Send a message in an A2A session
-   *
-   * Sends structured messages between agents with automatic context management.
+   * Update an agent's registration on PayAI marketplace
    *
-   * @param params - Message parameters
-   * @returns Transaction signature
-   *
-   * @example
-   * ```typescript
-   * await a2aClient.sendMessage({
-   *   sessionAddress: session.address,
-   *   content: 'Processing complete. Results: {...}',
-   *   messageType: 'result'
-   * })
-   * ```
+   * @param agentId - PayAI agent ID
+   * @param agent - Updated agent data
+   * @returns Update result
    */
-  async sendMessage(params) {
+  async updateAgent(agentId, agent) {
     try {
-      const messageId = BigInt(Date.now());
-      const sessionId = BigInt(Date.now());
-      const timestamp = BigInt(Math.floor(Date.now() / 1e3));
-      const instruction = getSendA2aMessageInstruction({
-        message: await this.deriveMessageAddress(params.sessionAddress),
-        session: params.sessionAddress,
-        sender: this.wallet,
-        messageId,
-        sessionId,
-        senderArg: this.wallet.address,
-        content: params.content,
-        messageType: params.messageType ?? "text",
-        timestamp
-      }, { programAddress: this.programId });
-      const signature = await this.sendTransaction([instruction]);
-      this.emit("message_sent", {
-        type: "message_sent",
-        timestamp: Date.now(),
-        data: { signature, content: params.content }
+      const response = await this.makeRequest(`/merchants/${agentId}`, {
+        method: "PATCH",
+        body: JSON.stringify(agent)
       });
-      return signature;
+      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 : String(error);
-      this.emit("error", {
-        type: "error",
-        timestamp: Date.now(),
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      return {
+        success: false,
         error: errorMessage
-      });
-      throw new Error(`Failed to send A2A message: ${errorMessage}`);
+      };
     }
   }
   /**
-   * Update agent status
-   *
-   * Updates agent availability, capabilities, and status for discovery.
+   * Remove an agent from PayAI marketplace
    *
-   * @param update - Status update
-   * @returns Transaction signature
-   *
-   * @example
-   * ```typescript
-   * await a2aClient.updateStatus({
-   *   status: 'busy',
-   *   capabilities: ['nlp', 'translation'],
-   *   availability: false
-   * })
-   * ```
+   * @param agentId - PayAI agent ID
+   * @returns Removal result
    */
-  async updateStatus(update) {
+  async removeAgent(agentId) {
     try {
-      const statusAddress = await this.deriveStatusAddress();
-      const instruction = getUpdateA2aStatusInstruction({
-        status: statusAddress,
-        session: address("11111111111111111111111111111111"),
-        // Placeholder - need actual session
-        updater: this.wallet,
-        statusId: BigInt(Date.now()),
-        agent: this.wallet.address,
-        statusArg: update.status,
-        capabilities: update.capabilities ?? [],
-        availability: update.availability ?? true,
-        lastUpdated: BigInt(Math.floor(Date.now() / 1e3))
-      }, { programAddress: this.programId });
-      const signature = await this.sendTransaction([instruction]);
-      this.emit("status_updated", {
-        type: "status_updated",
-        timestamp: Date.now(),
-        data: { signature, status: update.status }
+      const response = await this.makeRequest(`/merchants/${agentId}`, {
+        method: "DELETE"
       });
-      return signature;
+      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 : String(error);
-      this.emit("error", {
-        type: "error",
-        timestamp: Date.now(),
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      return {
+        success: false,
         error: errorMessage
-      });
-      throw new Error(`Failed to update A2A status: ${errorMessage}`);
+      };
     }
   }
   /**
-   * Get session details
-   *
-   * Fetches current session state from on-chain.
+   * Check if an agent is registered on PayAI marketplace
    *
-   * @param sessionAddress - Session PDA address
-   * @returns Session details
+   * @param agentAddress - Agent's Solana address
+   * @returns Whether agent is registered
    */
-  async getSession(sessionAddress) {
+  async isAgentRegistered(agentAddress) {
     try {
-      const maybeSession = await fetchMaybeA2ASession(this.rpc, sessionAddress);
-      if (!maybeSession.exists) {
-        return null;
+      const response = await this.makeRequest(
+        `/merchants/check?address=${agentAddress}&network=${this.config.network}`
+      );
+      if (!response.ok) {
+        return false;
       }
-      return {
-        ...maybeSession.data,
-        address: sessionAddress
-      };
-    } catch (error) {
-      console.error("Failed to fetch A2A session:", error);
-      return null;
+      const data = await response.json();
+      return data.registered;
+    } catch {
+      return false;
     }
   }
   /**
-   * Get message by address
+   * Get agent's PayAI marketplace listing
    *
-   * @param messageAddress - Message PDA address
-   * @returns Message data
+   * @param agentAddress - Agent's Solana address
+   * @returns Agent listing or null
    */
-  async getMessage(messageAddress) {
+  async getAgentListing(agentAddress) {
     try {
-      const message = await fetchA2AMessage(this.rpc, messageAddress);
-      return message.data;
-    } catch (error) {
-      console.error("Failed to fetch A2A message:", error);
+      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;
     }
   }
   /**
-   * Get agent status
+   * Sync reputation score to PayAI marketplace
+   *
+   * Updates the agent's reputation score on PayAI based on
+   * GhostSpeak reputation calculations.
    *
-   * @param statusAddress - Status PDA address
-   * @returns Status data
+   * @param agentId - PayAI agent ID
+   * @param reputationScore - New reputation score (0-10000)
+   * @returns Update result
    */
-  async getStatus(statusAddress) {
+  async syncReputationScore(agentId, reputationScore) {
     try {
-      const status = await fetchA2AStatus(this.rpc, statusAddress);
-      return status.data;
+      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) {
-      console.error("Failed to fetch A2A status:", error);
-      return null;
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      return {
+        success: false,
+        error: errorMessage
+      };
     }
   }
   // =====================================================
-  // PRIVATE HELPER METHODS
+  // PRIVATE METHODS
   // =====================================================
-  async sendTransaction(instructions) {
-    try {
-      const { value: latestBlockhash } = await this.rpc.getLatestBlockhash().send();
-      let message = createTransactionMessage({ version: 0 });
-      message = setTransactionMessageFeePayer(this.wallet.address, message);
-      message = setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, message);
-      for (const ix of instructions) {
-        message = appendTransactionMessageInstruction(ix, message);
-      }
-      const signedTransaction = await signTransactionMessageWithSigners(message);
-      const signatures = Object.values(signedTransaction.signatures);
-      if (signatures.length === 0) {
-        throw new Error("Transaction has no signatures");
-      }
-      const signature = signatures[0];
-      const wireTransaction = getBase64EncodedWireTransaction(signedTransaction);
-      await this.rpc.sendTransaction(wireTransaction).send();
-      await this.confirmTransaction(signature);
-      return signature;
-    } catch (error) {
-      throw new Error(
-        `Transaction failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  async confirmTransaction(signature) {
-    for (let i = 0; i < 30; i++) {
-      const status = await this.rpc.getSignatureStatuses([signature]).send();
-      if (status.value[0]?.confirmationStatus === "confirmed" || status.value[0]?.confirmationStatus === "finalized") {
-        return;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-    }
-    throw new Error("Transaction confirmation timeout");
-  }
-  async deriveMessageAddress(sessionAddress) {
-    return address("11111111111111111111111111111111");
-  }
-  async deriveStatusAddress() {
-    return address("11111111111111111111111111111111");
-  }
-};
-function createA2AClient(options, wallet) {
-  return new A2AClient(options, wallet);
-}
-var H2AClient = class extends EventEmitter {
-  rpc;
-  programId;
-  wallet;
-  constructor(options, wallet) {
-    super();
-    this.rpc = createSolanaRpc(options.rpcEndpoint);
-    this.programId = options.programId ?? GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS;
-    this.wallet = wallet;
-  }
-  /**
-   * Create a new communication session with an agent
-   *
-   * Establishes a communication channel between a human and an agent.
-   *
-   * @param config - Session configuration
-   * @returns Session details including address
-   *
-   * @throws {Error} Currently not implemented - requires IDL regeneration
-   *
-   * @example
-   * ```typescript
-   * const session = await h2aClient.createSession({
-   *   agentAddress: 'Agent123...',
-   *   sessionType: 'content_writing',
-   *   metadata: 'Blog post about AI agents',
-   *   expiresIn: 7200 // 2 hours
-   * })
-   * ```
-   */
-  async createSession(config) {
-    const expiresAt = BigInt(Math.floor(Date.now() / 1e3) + (config.expiresIn ?? 3600));
-    const sessionId = BigInt(Date.now());
-    const initiator = this.wallet.address;
-    const [sessionAddress] = await getProgramDerivedAddress({
-      programAddress: this.programId,
-      seeds: [
-        getBytesEncoder().encode(new Uint8Array([99, 111, 109, 109, 95, 115, 101, 115, 115, 105, 111, 110])),
-        // 'comm_session'
-        getAddressEncoder().encode(initiator)
-      ]
-    });
-    const instruction = await getCreateCommunicationSessionInstructionAsync({
-      session: sessionAddress,
-      creator: this.wallet,
-      sessionId,
-      initiator,
-      initiatorType: 0 /* Human */,
-      responder: config.agentAddress,
-      responderType: 1 /* Agent */,
-      sessionType: config.sessionType,
-      metadata: config.metadata ?? "",
-      expiresAt
-    }, { programAddress: this.programId });
-    const signature = await this.sendTransaction([instruction]);
-    this.emit("session_created", {
-      type: "session_created",
-      timestamp: Date.now(),
-      data: {
-        address: sessionAddress,
-        signature,
-        agent: config.agentAddress
-      }
-    });
-    return { address: sessionAddress, signature };
-  }
-  /**
-   * Send a service request to an agent
-   *
-   * Sends a work request to an agent with optional payment commitment.
-   *
-   * @param request - Service request parameters
-   * @returns Transaction signature
-   *
-   * @example
-   * ```typescript
-   * await h2aClient.sendServiceRequest({
-   *   sessionAddress: session.address,
-   *   content: 'Generate 10 social media posts about web3',
-   *   messageType: 'service_request',
-   *   attachments: ['ipfs://QmBrandGuidelines'],
-   *   paymentAmount: 10_000_000n, // 10 USDC
-   *   deadline: Date.now() / 1000 + 172800 // 48 hours
-   * })
-   * ```
-   */
-  async sendServiceRequest(request) {
-    const messageId = BigInt(Date.now());
-    const messageIdBytes = new Uint8Array(8);
-    const view = new DataView(messageIdBytes.buffer);
-    view.setBigUint64(0, messageId, true);
-    const [messageAddress] = await getProgramDerivedAddress({
-      programAddress: this.programId,
-      seeds: [
-        getBytesEncoder().encode(new Uint8Array([99, 111, 109, 109, 95, 109, 101, 115, 115, 97, 103, 101])),
-        // 'comm_message'
-        getAddressEncoder().encode(request.sessionAddress),
-        getBytesEncoder().encode(messageIdBytes)
-      ]
-    });
-    const instruction = getSendCommunicationMessageInstruction({
-      message: messageAddress,
-      session: request.sessionAddress,
-      sender: this.wallet,
-      messageId,
-      senderType: 0 /* Human */,
-      content: request.content,
-      messageType: request.messageType ?? "service_request",
-      attachments: request.attachments ?? []
-    }, { programAddress: this.programId });
-    const signature = await this.sendTransaction([instruction]);
-    this.emit("service_requested", {
-      type: "service_requested",
-      timestamp: Date.now(),
-      data: {
-        messageAddress,
-        sessionAddress: request.sessionAddress,
-        signature
-      }
-    });
-    return signature;
-  }
   /**
-   * Send a message in an existing session
-   *
-   * Sends a message to an agent with support for file attachments.
-   *
-   * @param params - Message parameters
-   * @returns Transaction signature
+   * Convert GhostSpeak agent data to PayAI registration format
    */
-  async sendMessage(params) {
-    const messageId = BigInt(Date.now());
-    const messageIdBytes = new Uint8Array(8);
-    const view = new DataView(messageIdBytes.buffer);
-    view.setBigUint64(0, messageId, true);
-    const [messageAddress] = await getProgramDerivedAddress({
-      programAddress: this.programId,
-      seeds: [
-        getBytesEncoder().encode(new Uint8Array([99, 111, 109, 109, 95, 109, 101, 115, 115, 97, 103, 101])),
-        // 'comm_message'
-        getAddressEncoder().encode(params.sessionAddress),
-        getBytesEncoder().encode(messageIdBytes)
-      ]
-    });
-    const instruction = getSendCommunicationMessageInstruction({
-      message: messageAddress,
-      session: params.sessionAddress,
-      sender: this.wallet,
-      messageId,
-      senderType: 0 /* Human */,
-      content: params.content,
-      messageType: params.messageType ?? "text",
-      attachments: params.attachments ?? []
-    }, { programAddress: this.programId });
-    const signature = await this.sendTransaction([instruction]);
-    this.emit("message_sent", {
-      type: "message_sent",
-      timestamp: Date.now(),
-      data: {
-        messageAddress,
-        sessionAddress: params.sessionAddress,
-        signature
+  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
       }
-    });
-    return signature;
+    };
   }
   /**
-   * Get session details
-   *
-   * @param sessionAddress - Session PDA address
+   * Make an authenticated request to PayAI marketplace
    */
-  async getSession(sessionAddress) {
-    const accountInfo = await this.rpc.getAccountInfo(sessionAddress, { encoding: "base64" }).send();
-    if (!accountInfo.value) {
-      throw new Error(`Session account not found: ${sessionAddress}`);
+  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}`;
     }
-    const data = accountInfo.value.data;
-    return getCommunicationSessionDataDecoder().decode(
-      typeof data === "string" ? Uint8Array.from(Buffer.from(data, "base64")) : new Uint8Array(data)
-    );
-  }
-  // =====================================================
-  // PRIVATE HELPER METHODS
-  // =====================================================
-  async sendTransaction(instructions) {
     try {
-      const { value: latestBlockhash } = await this.rpc.getLatestBlockhash().send();
-      let message = createTransactionMessage({ version: 0 });
-      message = setTransactionMessageFeePayer(this.wallet.address, message);
-      message = setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, message);
-      for (const ix of instructions) {
-        message = appendTransactionMessageInstruction(ix, message);
-      }
-      const signedTransaction = await signTransactionMessageWithSigners(message);
-      const signatures = Object.values(signedTransaction.signatures);
-      if (signatures.length === 0) {
-        throw new Error("Transaction has no signatures");
-      }
-      const signature = signatures[0];
-      const wireTransaction = getBase64EncodedWireTransaction(signedTransaction);
-      await this.rpc.sendTransaction(wireTransaction).send();
-      await this.confirmTransaction(signature);
-      return signature;
-    } catch (error) {
-      throw new Error(
-        `Transaction failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  async confirmTransaction(signature) {
-    for (let i = 0; i < 30; i++) {
-      const status = await this.rpc.getSignatureStatuses([signature]).send();
-      if (status.value[0]?.confirmationStatus === "confirmed" || status.value[0]?.confirmationStatus === "finalized") {
-        return;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      const response = await fetch(`${this.config.marketplaceUrl}${path}`, {
+        ...options,
+        headers: {
+          ...headers,
+          ...options.headers
+        },
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
     }
-    throw new Error("Transaction confirmation timeout");
   }
 };
-function createH2AClient(options, wallet) {
-  return new H2AClient(options, wallet);
+function createPayAIAgentSync(config = {}) {
+  return new PayAIAgentSync(config);
 }
 
 // src/utils/test-ipfs-config.ts
@@ -3697,7 +766,7 @@ var IPFSOperationError = class extends Error {
     this.name = "IPFSOperationError";
   }
 };
-var DEFAULT_RETRY_CONFIG2 = {
+var DEFAULT_RETRY_CONFIG = {
   maxRetries: 3,
   baseDelay: 1e3,
   maxDelay: 3e4,
@@ -3758,7 +827,7 @@ var CircuitBreaker = class {
   }
 };
 var RetryHandler = class {
-  constructor(config = DEFAULT_RETRY_CONFIG2) {
+  constructor(config = DEFAULT_RETRY_CONFIG) {
     this.config = config;
     this.circuitBreaker = new CircuitBreaker();
   }
@@ -3883,7 +952,7 @@ var IPFSErrorHandler = class {
   retryHandler;
   fallbackHandler;
   constructor(retryConfig) {
-    this.retryHandler = new RetryHandler({ ...DEFAULT_RETRY_CONFIG2, ...retryConfig });
+    this.retryHandler = new RetryHandler({ ...DEFAULT_RETRY_CONFIG, ...retryConfig });
     this.fallbackHandler = new FallbackHandler();
   }
   async executeWithErrorHandling(operation, context, fallbackValue) {
@@ -4095,12 +1164,12 @@ function assembleStyles() {
         if (colorString.length === 3) {
           colorString = [...colorString].map((character) => character + character).join("");
         }
-        const integer7 = Number.parseInt(colorString, 16);
+        const integer = Number.parseInt(colorString, 16);
         return [
           /* eslint-disable no-bitwise */
-          integer7 >> 16 & 255,
-          integer7 >> 8 & 255,
-          integer7 & 255
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
           /* eslint-enable no-bitwise */
         ];
       },
@@ -4287,30 +1356,30 @@ var supports_color_default = supportsColor;
 
 // ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/utilities.js
 function stringReplaceAll(string, substring, replacer) {
-  let index7 = string.indexOf(substring);
-  if (index7 === -1) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
     return string;
   }
   const substringLength = substring.length;
   let endIndex = 0;
   let returnValue = "";
   do {
-    returnValue += string.slice(endIndex, index7) + substring + replacer;
-    endIndex = index7 + substringLength;
-    index7 = string.indexOf(substring, endIndex);
-  } while (index7 !== -1);
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
   returnValue += string.slice(endIndex);
   return returnValue;
 }
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index7) {
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
   let endIndex = 0;
   let returnValue = "";
   do {
-    const gotCR = string[index7 - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index7 - 1 : index7) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
-    endIndex = index7 + 1;
-    index7 = string.indexOf("\n", endIndex);
-  } while (index7 !== -1);
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
   returnValue += string.slice(endIndex);
   return returnValue;
 }
@@ -4875,7 +1944,7 @@ var IPFSProvider = class {
   client;
   isPrivateNetwork;
   constructor(options) {
-    const createClient2 = __require("kubo-rpc-client").create;
+    const createClient = __require("kubo-rpc-client").create;
     const ipfsNodeUrl = options?.ipfsNodeUrl || "http://localhost:5001";
     const headers = options?.headers || {};
     this.isPrivateNetwork = options?.usePrivateNetwork || false;
@@ -4890,7 +1959,7 @@ var IPFSProvider = class {
     if (typeof headers !== "object" || headers === null) {
       throw new Error("Headers must be a valid object");
     }
-    this.client = createClient2({
+    this.client = createClient({
       url: ipfsNodeUrl,
       headers
     });
@@ -4922,9 +1991,9 @@ var IPFSProvider = class {
    * This is not foolproof but can catch obvious cases
    */
   isDataUnencrypted(data) {
-    const text7 = new TextDecoder("utf-8", { fatal: false }).decode(data.slice(0, 100));
+    const text = new TextDecoder("utf-8", { fatal: false }).decode(data.slice(0, 100));
     const commonPatterns = ["{", "<", "BEGIN", "name", "address", "email", "password"];
-    return commonPatterns.some((pattern) => text7.toLowerCase().includes(pattern.toLowerCase()));
+    return commonPatterns.some((pattern) => text.toLowerCase().includes(pattern.toLowerCase()));
   }
   async retrieve(hash) {
     try {
@@ -5277,6 +2346,6 @@ function clearFeatureGateCache() {
   featureCache.clear();
 }
 
-export { A2AClient, AgentDiscoveryClient, CircuitBreaker, DEFAULT_RETRY_CONFIG2 as DEFAULT_RETRY_CONFIG, FEATURE_GATES, FallbackHandler, FetchWithPaymentClient, H2AClient, IPFSErrorHandler, IPFSOperationError, IPFSProvider, LocalStorageProvider, PaymentStreamingManager, PrivateDataQuery, PrivateMetadataStorage, RetryHandler, TEST_IPFS_CONFIG, WalletFundingService, X402AnalyticsTracker, X402Client, checkFeatureGate, clearFeatureGateCache, createA2AClient, createAgentDiscoveryClient, createH2AClient, createIPFSErrorHandler, createPrivacyManifest, createTestIPFSConfig, createX402AnalyticsTracker, createX402Client, createX402Middleware, defaultFundingService, ensureMinimumBalance, estimateStorageCost, fetchWithX402Payment, fundWallet, isIPFSError, withIPFSErrorHandling, withX402RateLimit, wrapFetchWithPayment, x402FastifyPlugin };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map