sequenceDiagram
    participant Customer
    participant App
    participant WebSocket
    participant RPC
    participant Database

    Customer->>App: Initiate payment
    App->>Customer: Return payment address
    Customer->>Solana: Send transaction
    WebSocket->>App: Transaction notification
    App->>RPC: getTransaction (verify)
    RPC->>App: Transaction details
    App->>RPC: getSignatureStatuses (confirmations)
    RPC->>App: Confirmation status
    alt Confirmed
        App->>Database: Mark payment complete
        App->>Customer: Order fulfilled
    else Failed/Reorg
        App->>Customer: Retry required
    end

import { Connection, PublicKey, Commitment } from '@solana/web3.js';

interface PaymentConfig {
  recipientAddress: string;
  expectedAmount: number;
  timeout: number; // milliseconds
  requiredConfirmations: number;
}

class PaymentProcessor {
  private connection: Connection;
  private wsConnection: Connection;

  constructor(rpcUrl: string, wsUrl: string) {
    this.connection = new Connection(rpcUrl, 'confirmed');
    this.wsConnection = new Connection(wsUrl, {
      commitment: 'confirmed',
      wsEndpoint: wsUrl,
    });
  }

  /**
   * Monitor and process a payment
   */
  async processPayment(config: PaymentConfig): Promise<PaymentResult> {
    const recipient = new PublicKey(config.recipientAddress);
    const startTime = Date.now();

    return new Promise((resolve, reject) => {
      let subscriptionId: number | null = null;
      let timeoutId: NodeJS.Timeout;

      // Set timeout
      timeoutId = setTimeout(() => {
        if (subscriptionId !== null) {
          this.wsConnection.removeAccountChangeListener(subscriptionId);
        }
        reject(new Error('Payment timeout exceeded'));
      }, config.timeout);

      // Subscribe to account changes
      subscriptionId = this.wsConnection.onAccountChange(
        recipient,
        async (accountInfo, context) => {
          try {
            console.log(`Account changed at slot ${context.slot}`);

            // Get recent signatures
            const signatures = await this.connection.getSignaturesForAddress(
              recipient,
              { limit: 10 },
              'confirmed'
            );

            // Process each signature
            for (const sigInfo of signatures) {
              if (sigInfo.err) continue;

              // Verify transaction
              const result = await this.verifyPaymentTransaction(
                sigInfo.signature,
                config
              );

              if (result.valid) {
                // Check confirmations
                const confirmed = await this.waitForConfirmations(
                  sigInfo.signature,
                  config.requiredConfirmations
                );

                if (confirmed) {
                  clearTimeout(timeoutId);
                  if (subscriptionId !== null) {
                    this.wsConnection.removeAccountChangeListener(subscriptionId);
                  }

                  resolve({
                    success: true,
                    signature: sigInfo.signature,
                    amount: result.amount,
                    timestamp: Date.now(),
                    confirmations: config.requiredConfirmations,
                  });
                  return;
                }
              }
            }
          } catch (error) {
            console.error('Error processing account change:', error);
          }
        },
        'confirmed'
      );

      console.log(`Monitoring payments to ${config.recipientAddress}`);
    });
  }

  /**
   * Verify a transaction matches payment criteria
   */
  private async verifyPaymentTransaction(
    signature: string,
    config: PaymentConfig
  ): Promise<{ valid: boolean; amount?: number }> {
    try {
      const tx = await this.connection.getTransaction(signature, {
        maxSupportedTransactionVersion: 0,
        commitment: 'confirmed',
      });

      if (!tx || tx.meta?.err) {
        return { valid: false };
      }

      const recipient = new PublicKey(config.recipientAddress);
      const recipientIndex = tx.transaction.message.staticAccountKeys.findIndex(
        key => key.equals(recipient)
      );

      if (recipientIndex === -1) {
        return { valid: false };
      }

      // Check balance change
      const preBalance = tx.meta.preBalances[recipientIndex];
      const postBalance = tx.meta.postBalances[recipientIndex];
      const amountReceived = (postBalance - preBalance) / 1e9; // Convert to SOL

      if (amountReceived >= config.expectedAmount) {
        return { valid: true, amount: amountReceived };
      }

      return { valid: false };
    } catch (error) {
      console.error('Error verifying transaction:', error);
      return { valid: false };
    }
  }

  /**
   * Wait for required confirmations
   */
  private async waitForConfirmations(
    signature: string,
    requiredConfirmations: number
  ): Promise<boolean> {
    const maxAttempts = 30;
    const delayMs = 2000;

    for (let i = 0; i < maxAttempts; i++) {
      try {
        const statuses = await this.connection.getSignatureStatuses([signature]);
        const status = statuses.value[0];

        if (!status) {
          await this.delay(delayMs);
          continue;
        }

        if (status.err) {
          console.error('Transaction failed:', status.err);
          return false;
        }

        const confirmations = status.confirmations || 0;
        console.log(`Confirmations: ${confirmations}/${requiredConfirmations}`);

        if (confirmations >= requiredConfirmations) {
          return true;
        }

        // Check if finalized
        if (status.confirmationStatus === 'finalized') {
          return true;
        }

        await this.delay(delayMs);
      } catch (error) {
        console.error('Error checking confirmations:', error);
        await this.delay(delayMs);
      }
    }

    return false;
  }

  /**
   * Handle reorg detection
   */
  async detectReorg(signature: string): Promise<boolean> {
    try {
      const statuses = await this.connection.getSignatureStatuses([signature]);
      const status = statuses.value[0];

      // If transaction no longer exists, possible reorg
      if (!status) {
        console.warn(`Transaction ${signature} not found - possible reorg`);
        return true;
      }

      return false;
    } catch (error) {
      console.error('Error detecting reorg:', error);
      return false;
    }
  }

  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

interface PaymentResult {
  success: boolean;
  signature: string;
  amount: number;
  timestamp: number;
  confirmations: number;
}

// Usage example
async function example() {
  const processor = new PaymentProcessor(
    'https://rpc.solana.com',
    'wss://rpc.solana.com'
  );

  try {
    const result = await processor.processPayment({
      recipientAddress: 'YourWalletAddressHere',
      expectedAmount: 0.1, // 0.1 SOL
      timeout: 300000, // 5 minutes
      requiredConfirmations: 15,
    });

    console.log('Payment processed:', result);
  } catch (error) {
    console.error('Payment processing failed:', error);
  }
}

class PaymentError extends Error {
  constructor(
    message: string,
    public code: PaymentErrorCode,
    public signature?: string
  ) {
    super(message);
    this.name = 'PaymentError';
  }
}

enum PaymentErrorCode {
  TIMEOUT = 'TIMEOUT',
  INSUFFICIENT_AMOUNT = 'INSUFFICIENT_AMOUNT',
  TRANSACTION_FAILED = 'TRANSACTION_FAILED',
  REORG_DETECTED = 'REORG_DETECTED',
  NETWORK_ERROR = 'NETWORK_ERROR',
}

// Enhanced error handling
async function processPaymentWithRetry(
  processor: PaymentProcessor,
  config: PaymentConfig,
  maxRetries: number = 3
): Promise<PaymentResult> {
  let lastError: Error | null = null;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await processor.processPayment(config);
    } catch (error) {
      lastError = error as Error;
      console.error(`Payment attempt ${attempt} failed:`, error);

      if (attempt < maxRetries) {
        const backoff = Math.pow(2, attempt) * 1000;
        console.log(`Retrying in ${backoff}ms...`);
        await new Promise(resolve => setTimeout(resolve, backoff));
      }
    }
  }

  throw new PaymentError(
    `Payment failed after ${maxRetries} attempts: ${lastError?.message}`,
    PaymentErrorCode.NETWORK_ERROR
  );
}

graph TB
    A[User Wallet] --> B[Get Token Accounts]
    B --> C[Filter NFTs]
    C --> D[Fetch Metadata]
    D --> E[Display Collection]

    F[Marketplace Program] --> G[Get Program Accounts]
    G --> H[Parse Listings]
    H --> I[Display Marketplace]

    J[WebSocket] --> K[Account Updates]
    K --> L[Sale Events]
    L --> M[UI Updates]

    E --> N[Combined View]
    I --> N
    M --> N

import { Connection, PublicKey, AccountInfo } from '@solana/web3.js';
import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
import axios from 'axios';

interface NFTMetadata {
  mint: string;
  name: string;
  symbol: string;
  uri: string;
  image?: string;
  attributes?: Array<{ trait_type: string; value: string }>;
}

interface MarketplaceListing {
  mint: string;
  seller: string;
  price: number;
  listingAccount: string;
}

class NFTMarketplace {
  private connection: Connection;
  private wsConnection: Connection;
  private marketplaceProgramId: PublicKey;

  constructor(rpcUrl: string, wsUrl: string, marketplaceProgramId: string) {
    this.connection = new Connection(rpcUrl, 'confirmed');
    this.wsConnection = new Connection(wsUrl, {
      commitment: 'confirmed',
      wsEndpoint: wsUrl,
    });
    this.marketplaceProgramId = new PublicKey(marketplaceProgramId);
  }

  /**
   * Get all NFTs owned by a wallet
   */
  async getUserNFTs(walletAddress: string): Promise<NFTMetadata[]> {
    const wallet = new PublicKey(walletAddress);

    console.log('Fetching token accounts...');
    const tokenAccounts = await this.connection.getTokenAccountsByOwner(
      wallet,
      { programId: TOKEN_PROGRAM_ID }
    );

    console.log(`Found ${tokenAccounts.value.length} token accounts`);

    // Filter for NFTs (amount = 1, decimals = 0)
    const nftMints: string[] = [];

    for (const { account } of tokenAccounts.value) {
      const data = account.data;
      // Parse token account data
      const amount = data.readBigUInt64LE(64);
      const decimals = data.readUInt8(44);

      if (amount === 1n && decimals === 0) {
        const mint = new PublicKey(data.slice(0, 32));
        nftMints.push(mint.toString());
      }
    }

    console.log(`Found ${nftMints.length} NFTs`);

    // Fetch metadata for all NFTs
    return await this.batchFetchMetadata(nftMints);
  }

  /**
   * Fetch metadata for multiple NFTs efficiently
   */
  private async batchFetchMetadata(mints: string[]): Promise<NFTMetadata[]> {
    const BATCH_SIZE = 10;
    const results: NFTMetadata[] = [];

    for (let i = 0; i < mints.length; i += BATCH_SIZE) {
      const batch = mints.slice(i, i + BATCH_SIZE);
      const batchResults = await Promise.allSettled(
        batch.map(mint => this.fetchNFTMetadata(mint))
      );

      for (const result of batchResults) {
        if (result.status === 'fulfilled' && result.value) {
          results.push(result.value);
        }
      }

      // Rate limiting
      if (i + BATCH_SIZE < mints.length) {
        await this.delay(100);
      }
    }

    return results;
  }

  /**
   * Fetch metadata for a single NFT using multiple methods
   */
  private async fetchNFTMetadata(mint: string): Promise<NFTMetadata | null> {
    try {
      // Method 1: Try Metaplex standard
      const metadata = await this.getMetaplexMetadata(mint);
      if (metadata) return metadata;

      // Method 2: Try direct URI from account data
      const directMetadata = await this.getDirectMetadata(mint);
      if (directMetadata) return directMetadata;

      // Method 3: Fallback to basic info
      return {
        mint,
        name: `NFT ${mint.slice(0, 8)}`,
        symbol: 'NFT',
        uri: '',
      };
    } catch (error) {
      console.error(`Error fetching metadata for ${mint}:`, error);
      return null;
    }
  }

  /**
   * Get metadata using Metaplex standard
   */
  private async getMetaplexMetadata(mint: string): Promise<NFTMetadata | null> {
    try {
      const METADATA_PROGRAM_ID = new PublicKey(
        'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s'
      );

      // Derive metadata PDA
      const [metadataPDA] = PublicKey.findProgramAddressSync(
        [
          Buffer.from('metadata'),
          METADATA_PROGRAM_ID.toBuffer(),
          new PublicKey(mint).toBuffer(),
        ],
        METADATA_PROGRAM_ID
      );

      const accountInfo = await this.connection.getAccountInfo(metadataPDA);
      if (!accountInfo) return null;

      // Parse Metaplex metadata (simplified)
      const data = accountInfo.data;

      // Skip header and read name
      let offset = 1 + 32 + 32; // key + update authority + mint
      const nameLength = data.readUInt32LE(offset);
      offset += 4;
      const name = data.slice(offset, offset + nameLength).toString('utf8').replace(/\0/g, '');
      offset += nameLength;

      const symbolLength = data.readUInt32LE(offset);
      offset += 4;
      const symbol = data.slice(offset, offset + symbolLength).toString('utf8').replace(/\0/g, '');
      offset += symbolLength;

      const uriLength = data.readUInt32LE(offset);
      offset += 4;
      const uri = data.slice(offset, offset + uriLength).toString('utf8').replace(/\0/g, '');

      // Fetch off-chain metadata
      let image: string | undefined;
      let attributes: Array<{ trait_type: string; value: string }> | undefined;

      if (uri) {
        try {
          const response = await axios.get(uri, { timeout: 5000 });
          image = response.data.image;
          attributes = response.data.attributes;
        } catch (error) {
          console.warn(`Failed to fetch off-chain metadata from ${uri}`);
        }
      }

      return { mint, name, symbol, uri, image, attributes };
    } catch (error) {
      return null;
    }
  }

  /**
   * Get metadata directly from mint account
   */
  private async getDirectMetadata(mint: string): Promise<NFTMetadata | null> {
    try {
      const mintPubkey = new PublicKey(mint);
      const accountInfo = await this.connection.getAccountInfo(mintPubkey);

      if (!accountInfo) return null;

      // Basic mint info
      return {
        mint,
        name: `Token ${mint.slice(0, 8)}`,
        symbol: 'TOKEN',
        uri: '',
      };
    } catch (error) {
      return null;
    }
  }

  /**
   * Get all marketplace listings
   */
  async getAllListings(): Promise<MarketplaceListing[]> {
    console.log('Fetching marketplace listings...');

    const accounts = await this.connection.getProgramAccounts(
      this.marketplaceProgramId,
      {
        filters: [
          { dataSize: 120 }, // Adjust based on your listing account size
        ],
      }
    );

    console.log(`Found ${accounts.length} listing accounts`);

    const listings: MarketplaceListing[] = [];

    for (const { pubkey, account } of accounts) {
      try {
        const listing = this.parseListingAccount(account.data, pubkey.toString());
        if (listing) {
          listings.push(listing);
        }
      } catch (error) {
        console.error(`Error parsing listing ${pubkey.toString()}:`, error);
      }
    }

    return listings;
  }

  /**
   * Parse listing account data
   */
  private parseListingAccount(data: Buffer, pubkey: string): MarketplaceListing | null {
    try {
      // Adjust parsing based on your marketplace program structure
      // This is a generic example

      const mint = new PublicKey(data.slice(0, 32)).toString();
      const seller = new PublicKey(data.slice(32, 64)).toString();
      const price = Number(data.readBigUInt64LE(64)) / 1e9; // Convert lamports to SOL

      return {
        mint,
        seller,
        price,
        listingAccount: pubkey,
      };
    } catch (error) {
      return null;
    }
  }

  /**
   * Monitor marketplace sales in real-time
   */
  async monitorSales(callback: (sale: SaleEvent) => void): Promise<number> {
    const subscriptionId = this.wsConnection.onProgramAccountChange(
      this.marketplaceProgramId,
      async (keyedAccountInfo) => {
        try {
          const { accountId, accountInfo } = keyedAccountInfo;

          // Check if account was closed (sale completed)
          if (accountInfo.lamports === 0) {
            const sale: SaleEvent = {
              listingAccount: accountId.toString(),
              timestamp: Date.now(),
              type: 'sale_completed',
            };

            callback(sale);
          } else {
            // Check for new listing
            const listing = this.parseListingAccount(
              accountInfo.data,
              accountId.toString()
            );

            if (listing) {
              const sale: SaleEvent = {
                listingAccount: accountId.toString(),
                timestamp: Date.now(),
                type: 'new_listing',
                listing,
              };

              callback(sale);
            }
          }
        } catch (error) {
          console.error('Error processing sale event:', error);
        }
      },
      'confirmed'
    );

    console.log('Monitoring marketplace sales...');
    return subscriptionId;
  }

  /**
   * Get marketplace stats
   */
  async getMarketplaceStats(): Promise<MarketplaceStats> {
    const listings = await this.getAllListings();

    const totalListings = listings.length;
    const floorPrice = Math.min(...listings.map(l => l.price));
    const averagePrice = listings.reduce((sum, l) => sum + l.price, 0) / totalListings;
    const totalVolume = listings.reduce((sum, l) => sum + l.price, 0);

    return {
      totalListings,
      floorPrice,
      averagePrice,
      totalVolume,
    };
  }

  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

interface SaleEvent {
  listingAccount: string;
  timestamp: number;
  type: 'sale_completed' | 'new_listing';
  listing?: MarketplaceListing;
}

interface MarketplaceStats {
  totalListings: number;
  floorPrice: number;
  averagePrice: number;
  totalVolume: number;
}

// Usage example
async function exampleNFTMarketplace() {
  const marketplace = new NFTMarketplace(
    'https://rpc.solana.com',
    'wss://rpc.solana.com',
    'YourMarketplaceProgramIdHere'
  );

  // Get user's NFTs
  const nfts = await marketplace.getUserNFTs('UserWalletAddressHere');
  console.log('User NFTs:', nfts);

  // Get all listings
  const listings = await marketplace.getAllListings();
  console.log('Marketplace listings:', listings);

  // Get stats
  const stats = await marketplace.getMarketplaceStats();
  console.log('Marketplace stats:', stats);

  // Monitor sales
  const subscriptionId = await marketplace.monitorSales((sale) => {
    console.log('Sale event:', sale);

    if (sale.type === 'sale_completed') {
      console.log('NFT sold!', sale.listingAccount);
    } else {
      console.log('New listing:', sale.listing);
    }
  });

  // Cleanup
  // marketplace.wsConnection.removeProgramAccountChangeListener(subscriptionId);
}

graph LR
    A[Dashboard] --> B[Vote Accounts]
    A --> C[Performance Samples]
    A --> D[Cluster Nodes]

    B --> E[Validator Stats]
    C --> E
    D --> E

    E --> F[Performance Trends]
    E --> G[Network Topology]
    E --> H[Alert System]

    H --> I[Email/SMS]
    H --> J[Webhook]

import { Connection, VoteAccountStatus, PerfSample, ContactInfo } from '@solana/web3.js';

interface ValidatorMetrics {
  identity: string;
  voteAccount: string;
  commission: number;
  activatedStake: number;
  lastVote: number;
  rootSlot: number;
  credits: number;
  epochCredits: number;
  skipRate: number;
  performance: number[];
}

interface AlertConfig {
  skipRateThreshold: number;
  performanceThreshold: number;
  delinquentAlert: boolean;
}

class ValidatorMonitor {
  private connection: Connection;
  private alertConfig: AlertConfig;
  private metrics: Map<string, ValidatorMetrics>;

  constructor(rpcUrl: string, alertConfig: AlertConfig) {
    this.connection = new Connection(rpcUrl, 'confirmed');
    this.alertConfig = alertConfig;
    this.metrics = new Map();
  }

  /**
   * Get complete validator information
   */
  async getValidatorInfo(voteAccount: string): Promise<ValidatorMetrics | null> {
    try {
      // Get vote accounts
      const voteAccounts = await this.connection.getVoteAccounts();

      // Find specific validator
      const validator = [...voteAccounts.current, ...voteAccounts.delinquent].find(
        v => v.votePubkey === voteAccount
      );

      if (!validator) {
        console.warn(`Validator ${voteAccount} not found`);
        return null;
      }

      // Get performance samples
      const perfSamples = await this.connection.getRecentPerformanceSamples(10);
      const avgPerformance = this.calculatePerformance(perfSamples);

      // Calculate skip rate
      const skipRate = this.calculateSkipRate(validator);

      const metrics: ValidatorMetrics = {
        identity: validator.nodePubkey,
        voteAccount: validator.votePubkey,
        commission: validator.commission,
        activatedStake: validator.activatedStake / 1e9, // Convert to SOL
        lastVote: validator.lastVote,
        rootSlot: validator.rootSlot,
        credits: validator.epochCredits.reduce((sum, [_, credits]) => sum + credits, 0),
        epochCredits: validator.epochCredits[0]?.[1] || 0,
        skipRate,
        performance: avgPerformance,
      };

      return metrics;
    } catch (error) {
      console.error('Error fetching validator info:', error);
      return null;
    }
  }

  /**
   * Get all validators with performance metrics
   */
  async getAllValidators(): Promise<ValidatorMetrics[]> {
    const voteAccounts = await this.connection.getVoteAccounts();
    const perfSamples = await this.connection.getRecentPerformanceSamples(10);
    const avgPerformance = this.calculatePerformance(perfSamples);

    const allValidators = [...voteAccounts.current, ...voteAccounts.delinquent];

    return allValidators.map(validator => ({
      identity: validator.nodePubkey,
      voteAccount: validator.votePubkey,
      commission: validator.commission,
      activatedStake: validator.activatedStake / 1e9,
      lastVote: validator.lastVote,
      rootSlot: validator.rootSlot,
      credits: validator.epochCredits.reduce((sum, [_, credits]) => sum + credits, 0),
      epochCredits: validator.epochCredits[0]?.[1] || 0,
      skipRate: this.calculateSkipRate(validator),
      performance: avgPerformance,
    }));
  }

  /**
   * Calculate skip rate for a validator
   */
  private calculateSkipRate(validator: any): number {
    const recentEpochs = validator.epochCredits.slice(0, 5);
    if (recentEpochs.length < 2) return 0;

    let totalSlots = 0;
    let totalCredits = 0;

    for (let i = 1; i < recentEpochs.length; i++) {
      const [epoch, credits, previousCredits] = recentEpochs[i];
      const [prevEpoch] = recentEpochs[i - 1];

      const creditsEarned = credits - previousCredits;
      const slotsInEpoch = 432000; // Approximate

      totalCredits += creditsEarned;
      totalSlots += slotsInEpoch;
    }

    const skipRate = ((totalSlots - totalCredits) / totalSlots) * 100;
    return Math.max(0, Math.min(100, skipRate));
  }

  /**
   * Calculate average performance from samples
   */
  private calculatePerformance(samples: PerfSample[]): number[] {
    return samples.map(sample => {
      const slotsPerSecond = sample.numSlots / sample.samplePeriodSecs;
      const transactionsPerSecond = sample.numTransactions / sample.samplePeriodSecs;
      return transactionsPerSecond;
    });
  }

  /**
   * Get network topology
   */
  async getNetworkTopology(): Promise<NetworkTopology> {
    const clusterNodes = await this.connection.getClusterNodes();

    const topology: NetworkTopology = {
      totalNodes: clusterNodes.length,
      nodesByVersion: {},
      nodesByRegion: {},
      nodes: clusterNodes.map(node => ({
        pubkey: node.pubkey,
        gossip: node.gossip,
        tpu: node.tpu,
        rpc: node.rpc || null,
        version: node.version || 'unknown',
      })),
    };

    // Group by version
    for (const node of clusterNodes) {
      const version = node.version || 'unknown';
      topology.nodesByVersion[version] = (topology.nodesByVersion[version] || 0) + 1;
    }

    return topology;
  }

  /**
   * Monitor validator and trigger alerts
   */
  async monitorValidator(
    voteAccount: string,
    callback: (alert: ValidatorAlert) => void
  ): Promise<void> {
    const checkInterval = 60000; // 1 minute

    const check = async () => {
      try {
        const metrics = await this.getValidatorInfo(voteAccount);

        if (!metrics) {
          callback({
            type: 'error',
            message: 'Failed to fetch validator metrics',
            timestamp: Date.now(),
            voteAccount,
          });
          return;
        }

        // Check skip rate
        if (metrics.skipRate > this.alertConfig.skipRateThreshold) {
          callback({
            type: 'skip_rate',
            message: `Skip rate ${metrics.skipRate.toFixed(2)}% exceeds threshold ${this.alertConfig.skipRateThreshold}%`,
            timestamp: Date.now(),
            voteAccount,
            metrics,
          });
        }

        // Check if delinquent
        const voteAccounts = await this.connection.getVoteAccounts();
        const isDelinquent = voteAccounts.delinquent.some(
          v => v.votePubkey === voteAccount
        );

        if (isDelinquent && this.alertConfig.delinquentAlert) {
          callback({
            type: 'delinquent',
            message: 'Validator is delinquent',
            timestamp: Date.now(),
            voteAccount,
            metrics,
          });
        }

        // Store metrics for trend analysis
        this.metrics.set(voteAccount, metrics);

      } catch (error) {
        console.error('Error monitoring validator:', error);
        callback({
          type: 'error',
          message: `Monitoring error: ${error}`,
          timestamp: Date.now(),
          voteAccount,
        });
      }
    };

    // Initial check
    await check();

    // Start monitoring
    setInterval(check, checkInterval);
  }

  /**
   * Generate performance report
   */
  async generateReport(voteAccount: string): Promise<ValidatorReport> {
    const metrics = await this.getValidatorInfo(voteAccount);
    if (!metrics) {
      throw new Error('Failed to fetch validator metrics');
    }

    const voteAccounts = await this.connection.getVoteAccounts();
    const allValidators = [...voteAccounts.current, ...voteAccounts.delinquent];

    // Calculate percentiles
    const skipRates = allValidators.map(v => this.calculateSkipRate(v));
    const stakes = allValidators.map(v => v.activatedStake);

    skipRates.sort((a, b) => a - b);
    stakes.sort((a, b) => a - b);

    const skipRatePercentile = this.getPercentile(skipRates, metrics.skipRate);
    const stakePercentile = this.getPercentile(stakes, metrics.activatedStake * 1e9);

    return {
      metrics,
      skipRatePercentile,
      stakePercentile,
      rank: this.calculateRank(metrics, allValidators),
      status: this.getValidatorStatus(metrics),
    };
  }

  private getPercentile(sortedArray: number[], value: number): number {
    const index = sortedArray.findIndex(v => v >= value);
    return (index / sortedArray.length) * 100;
  }

  private calculateRank(metrics: ValidatorMetrics, allValidators: any[]): number {
    const sorted = allValidators.sort((a, b) => b.activatedStake - a.activatedStake);
    return sorted.findIndex(v => v.votePubkey === metrics.voteAccount) + 1;
  }

  private getValidatorStatus(metrics: ValidatorMetrics): string {
    if (metrics.skipRate > 10) return 'poor';
    if (metrics.skipRate > 5) return 'fair';
    if (metrics.skipRate > 2) return 'good';
    return 'excellent';
  }
}

interface NetworkTopology {
  totalNodes: number;
  nodesByVersion: Record<string, number>;
  nodesByRegion: Record<string, number>;
  nodes: Array<{
    pubkey: string;
    gossip: string | null;
    tpu: string | null;
    rpc: string | null;
    version: string;
  }>;
}

interface ValidatorAlert {
  type: 'skip_rate' | 'delinquent' | 'performance' | 'error';
  message: string;
  timestamp: number;
  voteAccount: string;
  metrics?: ValidatorMetrics;
}

interface ValidatorReport {
  metrics: ValidatorMetrics;
  skipRatePercentile: number;
  stakePercentile: number;
  rank: number;
  status: string;
}

// Usage example
async function exampleValidatorMonitoring() {
  const monitor = new ValidatorMonitor(
    'https://rpc.solana.com',
    {
      skipRateThreshold: 5,
      performanceThreshold: 0.8,
      delinquentAlert: true,
    }
  );

  // Get validator info
  const info = await monitor.getValidatorInfo('VoteAccountAddressHere');
  console.log('Validator info:', info);

  // Get all validators
  const allValidators = await monitor.getAllValidators();
  console.log(`Total validators: ${allValidators.length}`);

  // Get network topology
  const topology = await monitor.getNetworkTopology();
  console.log('Network topology:', topology);

  // Monitor with alerts
  await monitor.monitorValidator('VoteAccountAddressHere', (alert) => {
    console.log('ALERT:', alert);

    // Send notification (email, webhook, etc.)
    if (alert.type === 'delinquent') {
      // Send urgent alert
      sendUrgentNotification(alert);
    }
  });

  // Generate report
  const report = await monitor.generateReport('VoteAccountAddressHere');
  console.log('Validator report:', report);
}

function sendUrgentNotification(alert: ValidatorAlert): void {
  // Implement notification logic
  console.log('URGENT:', alert.message);
}

graph TB
    A[Wallet] --> B[Protocol 1]
    A --> C[Protocol 2]
    A --> D[Protocol 3]

    B --> E[Get Program Accounts]
    C --> E
    D --> E

    E --> F[Parse Positions]
    F --> G[Fetch Token Prices]
    G --> H[Calculate USD Values]

    H --> I[Portfolio Dashboard]

    J[WebSocket] --> K[Position Updates]
    K --> L[Rebalance Alerts]

import { Connection, PublicKey } from '@solana/web3.js';
import axios from 'axios';

interface Position {
  protocol: string;
  type: 'lending' | 'liquidity' | 'staking' | 'vault';
  asset: string;
  amount: number;
  usdValue: number;
  apy?: number;
  health?: number;
}

interface ProtocolConfig {
  name: string;
  programId: string;
  parser: (data: Buffer) => any;
}

class DeFiPositionTracker {
  private connection: Connection;
  private wsConnection: Connection;
  private protocols: ProtocolConfig[];
  private priceCache: Map<string, { price: number; timestamp: number }>;

  constructor(rpcUrl: string, wsUrl: string) {
    this.connection = new Connection(rpcUrl, 'confirmed');
    this.wsConnection = new Connection(wsUrl, {
      commitment: 'confirmed',
      wsEndpoint: wsUrl,
    });
    this.protocols = this.initializeProtocols();
    this.priceCache = new Map();
  }

  /**
   * Initialize supported protocols
   */
  private initializeProtocols(): ProtocolConfig[] {
    return [
      {
        name: 'Marinade',
        programId: 'MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD',
        parser: this.parseMarinadePosition,
      },
      {
        name: 'Orca',
        programId: 'whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc',
        parser: this.parseOrcaPosition,
      },
      // Add more protocols
    ];
  }

  /**
   * Get all positions for a wallet
   */
  async getAllPositions(walletAddress: string): Promise<Position[]> {
    const wallet = new PublicKey(walletAddress);
    const allPositions: Position[] = [];

    console.log('Fetching positions across all protocols...');

    for (const protocol of this.protocols) {
      try {
        const positions = await this.getProtocolPositions(wallet, protocol);
        allPositions.push(...positions);
      } catch (error) {
        console.error(`Error fetching ${protocol.name} positions:`, error);
      }
    }

    // Calculate USD values
    await this.enrichWithPrices(allPositions);

    return allPositions;
  }

  /**
   * Get positions for a specific protocol
   */
  private async getProtocolPositions(
    wallet: PublicKey,
    protocol: ProtocolConfig
  ): Promise<Position[]> {
    const programId = new PublicKey(protocol.programId);

    // Get all program accounts for this wallet
    const accounts = await this.connection.getProgramAccounts(programId, {
      filters: [
        {
          memcmp: {
            offset: 8, // Skip discriminator
            bytes: wallet.toBase58(),
          },
        },
      ],
    });

    console.log(`Found ${accounts.length} ${protocol.name} accounts`);

    const positions: Position[] = [];

    for (const { account } of accounts) {
      try {
        const parsed = protocol.parser(account.data);
        if (parsed) {
          positions.push({
            protocol: protocol.name,
            ...parsed,
            usdValue: 0, // Will be calculated later
          });
        }
      } catch (error) {
        console.error(`Error parsing ${protocol.name} account:`, error);
      }
    }

    return positions;
  }

  /**
   * Parse Marinade stake position
   */
  private parseMarinadePosition(data: Buffer): Partial<Position> | null {
    try {
      // Simplified parsing - adjust based on actual program structure
      const amount = Number(data.readBigUInt64LE(40)) / 1e9;

      return {
        type: 'staking',
        asset: 'mSOL',
        amount,
        apy: 7.5, // Would fetch from API
      };
    } catch (error) {
      return null;
    }
  }

  /**
   * Parse Orca liquidity position
   */
  private parseOrcaPosition(data: Buffer): Partial<Position> | null {
    try {
      // Simplified parsing
      const liquidity = Number(data.readBigUInt64LE(65));

      return {
        type: 'liquidity',
        asset: 'LP-Token',
        amount: liquidity / 1e9,
        apy: 15.2, // Would fetch from API
      };
    } catch (error) {
      return null;
    }
  }

  /**
   * Enrich positions with USD prices
   */
  private async enrichWithPrices(positions: Position[]): Promise<void> {
    const uniqueAssets = [...new Set(positions.map(p => p.asset))];

    // Fetch prices for all unique assets
    const prices = await this.fetchPrices(uniqueAssets);

    // Update positions with USD values
    for (const position of positions) {
      const price = prices.get(position.asset) || 0;
      position.usdValue = position.amount * price;
    }
  }

  /**
   * Fetch token prices from Jupiter or CoinGecko
   */
  private async fetchPrices(assets: string[]): Promise<Map<string, number>> {
    const prices = new Map<string, number>();
    const CACHE_DURATION = 60000; // 1 minute

    for (const asset of assets) {
      // Check cache
      const cached = this.priceCache.get(asset);
      if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
        prices.set(asset, cached.price);
        continue;
      }

      try {
        // Fetch from Jupiter Price API
        const response = await axios.get(
          `https://price.jup.ag/v4/price?ids=${asset}`,
          { timeout: 5000 }
        );

        const price = response.data.data[asset]?.price || 0;
        prices.set(asset, price);

        // Cache price
        this.priceCache.set(asset, { price, timestamp: Date.now() });
      } catch (error) {
        console.error(`Error fetching price for ${asset}:`, error);
        prices.set(asset, 0);
      }
    }

    return prices;
  }

  /**
   * Calculate portfolio summary
   */
  calculatePortfolioSummary(positions: Position[]): PortfolioSummary {
    const totalValue = positions.reduce((sum, p) => sum + p.usdValue, 0);

    const byProtocol: Record<string, number> = {};
    const byType: Record<string, number> = {};

    for (const position of positions) {
      byProtocol[position.protocol] = (byProtocol[position.protocol] || 0) + position.usdValue;
      byType[position.type] = (byType[position.type] || 0) + position.usdValue;
    }

    // Calculate weighted average APY
    const totalApy = positions
      .filter(p => p.apy)
      .reduce((sum, p) => sum + (p.apy! * p.usdValue), 0);
    const weightedApy = totalValue > 0 ? totalApy / totalValue : 0;

    return {
      totalValue,
      byProtocol,
      byType,
      weightedApy,
      positions: positions.length,
    };
  }

  /**
   * Monitor positions and trigger alerts
   */
  async monitorPositions(
    walletAddress: string,
    alertConfig: AlertConfig,
    callback: (alert: PositionAlert) => void
  ): Promise<void> {
    const wallet = new PublicKey(walletAddress);
    const subscriptions: number[] = [];

    for (const protocol of this.protocols) {
      const programId = new PublicKey(protocol.programId);

      const subscriptionId = this.wsConnection.onProgramAccountChange(
        programId,
        async (keyedAccountInfo) => {
          try {
            const { accountId, accountInfo } = keyedAccountInfo;

            // Check if account belongs to our wallet
            const accountData = accountInfo.data;
            // Simplified check - adjust based on program structure
            const ownerPubkey = new PublicKey(accountData.slice(8, 40));

            if (!ownerPubkey.equals(wallet)) return;

            // Parse position
            const parsed = protocol.parser(accountData);
            if (!parsed) return;

            const position: Position = {
              protocol: protocol.name,
              ...parsed,
              usdValue: 0,
            };

            // Enrich with price
            await this.enrichWithPrices([position]);

            // Check alerts
            this.checkAlerts(position, alertConfig, callback);

          } catch (error) {
            console.error('Error monitoring position:', error);
          }
        },
        'confirmed',
        [
          {
            memcmp: {
              offset: 8,
              bytes: wallet.toBase58(),
            },
          },
        ]
      );

      subscriptions.push(subscriptionId);
    }

    console.log(`Monitoring ${subscriptions.length} protocols for position changes...`);
  }

  /**
   * Check if position triggers any alerts
   */
  private checkAlerts(
    position: Position,
    config: AlertConfig,
    callback: (alert: PositionAlert) => void
  ): void {
    // Health factor alert (for lending positions)
    if (position.health && position.health < config.healthFactorThreshold) {
      callback({
        type: 'health_factor',
        message: `Health factor ${position.health.toFixed(2)} below threshold`,
        position,
        timestamp: Date.now(),
      });
    }

    // Large value change alert
    // Would need to track previous values for this

    // Rebalancing opportunity
    if (position.apy && position.apy > config.rebalanceApyThreshold) {
      callback({
        type: 'rebalance_opportunity',
        message: `High APY opportunity: ${position.apy.toFixed(2)}%`,
        position,
        timestamp: Date.now(),
      });
    }
  }

  /**
   * Export positions to CSV
   */
  exportToCSV(positions: Position[]): string {
    const headers = ['Protocol', 'Type', 'Asset', 'Amount', 'USD Value', 'APY', 'Health'];
    const rows = positions.map(p => [
      p.protocol,
      p.type,
      p.asset,
      p.amount.toFixed(6),
      p.usdValue.toFixed(2),
      p.apy?.toFixed(2) || '',
      p.health?.toFixed(2) || '',
    ]);

    return [headers, ...rows].map(row => row.join(',')).join('\n');
  }
}

interface PortfolioSummary {
  totalValue: number;
  byProtocol: Record<string, number>;
  byType: Record<string, number>;
  weightedApy: number;
  positions: number;
}

interface AlertConfig {
  healthFactorThreshold: number;
  rebalanceApyThreshold: number;
  valueChangeThreshold: number;
}

interface PositionAlert {
  type: 'health_factor' | 'value_change' | 'rebalance_opportunity';
  message: string;
  position: Position;
  timestamp: number;
}

// Usage example
async function exampleDeFiTracking() {
  const tracker = new DeFiPositionTracker(
    'https://rpc.solana.com',
    'wss://rpc.solana.com'
  );

  // Get all positions
  const positions = await tracker.getAllPositions('WalletAddressHere');
  console.log('All positions:', positions);

  // Calculate summary
  const summary = tracker.calculatePortfolioSummary(positions);
  console.log('Portfolio summary:', summary);
  console.log(`Total value: $${summary.totalValue.toFixed(2)}`);
  console.log(`Weighted APY: ${summary.weightedApy.toFixed(2)}%`);

  // Export to CSV
  const csv = tracker.exportToCSV(positions);
  console.log('CSV export:', csv);

  // Monitor positions
  await tracker.monitorPositions(
    'WalletAddressHere',
    {
      healthFactorThreshold: 1.5,
      rebalanceApyThreshold: 20,
      valueChangeThreshold: 1000,
    },
    (alert) => {
      console.log('POSITION ALERT:', alert);
    }
  );
}

graph LR
    A[Wallet Address] --> B[getSignaturesForAddress]
    B --> C[Paginate Results]
    C --> D[Batch getTransaction]
    D --> E[Parse & Categorize]
    E --> F[Export CSV/JSON]

    G[Progress Tracking] --> C
    H[Error Handling] --> D
    I[Rate Limiting] --> D

import { Connection, PublicKey, ParsedTransactionWithMeta } from '@solana/web3.js';
import * as fs from 'fs';

interface TransactionRecord {
  signature: string;
  timestamp: number;
  type: string;
  from: string;
  to: string;
  amount: number;
  fee: number;
  status: 'success' | 'failed';
  memo?: string;
}

interface ExportOptions {
  startTime?: number;
  endTime?: number;
  format: 'csv' | 'json';
  outputPath: string;
  batchSize: number;
  includeFailedTx: boolean;
}

class TransactionHistoryExporter {
  private connection: Connection;

  constructor(rpcUrl: string) {
    this.connection = new Connection(rpcUrl, 'confirmed');
  }

  /**
   * Export complete transaction history
   */
  async exportHistory(
    walletAddress: string,
    options: ExportOptions
  ): Promise<ExportResult> {
    const wallet = new PublicKey(walletAddress);
    const startTime = Date.now();

    console.log('Starting transaction history export...');
    console.log('Options:', options);

    // Step 1: Get all signatures with pagination
    const signatures = await this.getAllSignatures(wallet, options);
    console.log(`Found ${signatures.length} transactions`);

    // Step 2: Fetch transaction details in batches
    const transactions = await this.batchFetchTransactions(signatures, options.batchSize);
    console.log(`Fetched ${transactions.length} transaction details`);

    // Step 3: Parse and categorize transactions
    const records = this.parseTransactions(transactions, walletAddress);
    console.log(`Parsed ${records.length} transaction records`);

    // Step 4: Filter by time range
    const filtered = this.filterByTimeRange(records, options);
    console.log(`After filtering: ${filtered.length} records`);

    // Step 5: Export to file
    await this.exportToFile(filtered, options);

    const duration = Date.now() - startTime;

    return {
      totalTransactions: filtered.length,
      successfulTx: filtered.filter(r => r.status === 'success').length,
      failedTx: filtered.filter(r => r.status === 'failed').length,
      totalFees: filtered.reduce((sum, r) => sum + r.fee, 0),
      duration,
      outputPath: options.outputPath,
    };
  }

  /**
   * Get all signatures with pagination
   */
  private async getAllSignatures(
    wallet: PublicKey,
    options: ExportOptions
  ): Promise<string[]> {
    const allSignatures: string[] = [];
    let before: string | undefined;
    let hasMore = true;

    while (hasMore) {
      try {
        const signatures = await this.connection.getSignaturesForAddress(
          wallet,
          { before, limit: 1000 },
          'confirmed'
        );

        if (signatures.length === 0) {
          hasMore = false;
          break;
        }

        // Filter by time if specified
        for (const sig of signatures) {
          if (options.startTime && sig.blockTime && sig.blockTime < options.startTime) {
            hasMore = false;
            break;
          }

          // Skip failed transactions if not requested
          if (!options.includeFailedTx && sig.err) {
            continue;
          }

          allSignatures.push(sig.signature);
        }

        before = signatures[signatures.length - 1].signature;

        console.log(`Fetched ${allSignatures.length} signatures so far...`);

        // Rate limiting
        await this.delay(100);

      } catch (error) {
        console.error('Error fetching signatures:', error);
        break;
      }
    }

    return allSignatures;
  }

  /**
   * Batch fetch transaction details
   */
  private async batchFetchTransactions(
    signatures: string[],
    batchSize: number
  ): Promise<(ParsedTransactionWithMeta | null)[]> {
    const transactions: (ParsedTransactionWithMeta | null)[] = [];

    for (let i = 0; i < signatures.length; i += batchSize) {
      const batch = signatures.slice(i, i + batchSize);

      console.log(`Fetching batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(signatures.length / batchSize)}`);

      try {
        // Fetch transactions concurrently within batch
        const batchPromises = batch.map(sig =>
          this.connection.getParsedTransaction(sig, {
            maxSupportedTransactionVersion: 0,
            commitment: 'confirmed',
          })
        );

        const batchResults = await Promise.allSettled(batchPromises);

        for (const result of batchResults) {
          if (result.status === 'fulfilled') {
            transactions.push(result.value);
          } else {
            console.error('Failed to fetch transaction:', result.reason);
            transactions.push(null);
          }
        }

        // Rate limiting between batches
        if (i + batchSize < signatures.length) {
          await this.delay(500);
        }

      } catch (error) {
        console.error('Error in batch fetch:', error);
      }
    }

    return transactions;
  }

  /**
   * Parse transactions into structured records
   */
  private parseTransactions(
    transactions: (ParsedTransactionWithMeta | null)[],
    walletAddress: string
  ): TransactionRecord[] {
    const records: TransactionRecord[] = [];

    for (const tx of transactions) {
      if (!tx) continue;

      try {
        const record = this.parseTransaction(tx, walletAddress);
        if (record) {
          records.push(record);
        }
      } catch (error) {
        console.error('Error parsing transaction:', error);
      }
    }

    return records;
  }

  /**
   * Parse a single transaction
   */
  private parseTransaction(
    tx: ParsedTransactionWithMeta,
    walletAddress: string
  ): TransactionRecord | null {
    const signature = tx.transaction.signatures[0];
    const timestamp = tx.blockTime || 0;
    const status = tx.meta?.err ? 'failed' : 'success';
    const fee = (tx.meta?.fee || 0) / 1e9;

    // Determine transaction type
    let type = 'unknown';
    let from = '';
    let to = '';
    let amount = 0;
    let memo: string | undefined;

    // Check for SPL token transfers
    if (tx.meta?.postTokenBalances && tx.meta?.preTokenBalances) {
      const postBalances = tx.meta.postTokenBalances;
      const preBalances = tx.meta.preTokenBalances;

      for (const postBalance of postBalances) {
        const preBalance = preBalances.find(
          pb => pb.accountIndex === postBalance.accountIndex
        );

        if (preBalance && postBalance.uiTokenAmount.uiAmount !== preBalance.uiTokenAmount.uiAmount) {
          type = 'token_transfer';
          amount = Math.abs(
            (postBalance.uiTokenAmount.uiAmount || 0) - (preBalance.uiTokenAmount.uiAmount || 0)
          );
          break;
        }
      }
    }

    // Check for SOL transfers
    if (type === 'unknown' && tx.meta?.postBalances && tx.meta?.preBalances) {
      const accountKeys = tx.transaction.message.accountKeys;

      for (let i = 0; i < accountKeys.length; i++) {
        const preBalance = tx.meta.preBalances[i];
        const postBalance = tx.meta.postBalances[i];
        const change = (postBalance - preBalance) / 1e9;

        if (Math.abs(change) > 0.000001) {
          const account = accountKeys[i].pubkey.toString();

          if (change < 0) {
            from = account;
            amount = Math.abs(change);
          } else if (change > 0 && account !== walletAddress) {
            to = account;
          }

          type = 'sol_transfer';
        }
      }
    }

    // Check for program interactions
    if (type === 'unknown') {
      const instructions = tx.transaction.message.instructions;
      if (instructions.length > 0) {
        // Simplified - would need more sophisticated parsing
        type = 'program_interaction';
      }
    }

    // Extract memo if present
    const logMessages = tx.meta?.logMessages || [];
    for (const log of logMessages) {
      if (log.includes('Memo')) {
        memo = log;
        break;
      }
    }

    return {
      signature,
      timestamp,
      type,
      from,
      to,
      amount,
      fee,
      status: status as 'success' | 'failed',
      memo,
    };
  }

  /**
   * Filter records by time range
   */
  private filterByTimeRange(
    records: TransactionRecord[],
    options: ExportOptions
  ): TransactionRecord[] {
    return records.filter(record => {
      if (options.startTime && record.timestamp < options.startTime) {
        return false;
      }
      if (options.endTime && record.timestamp > options.endTime) {
        return false;
      }
      return true;
    });
  }

  /**
   * Export records to file
   */
  private async exportToFile(
    records: TransactionRecord[],
    options: ExportOptions
  ): Promise<void> {
    if (options.format === 'csv') {
      await this.exportToCSV(records, options.outputPath);
    } else {
      await this.exportToJSON(records, options.outputPath);
    }

    console.log(`Exported to ${options.outputPath}`);
  }

  /**
   * Export to CSV format
   */
  private async exportToCSV(records: TransactionRecord[], outputPath: string): Promise<void> {
    const headers = ['Signature', 'Date', 'Type', 'From', 'To', 'Amount', 'Fee', 'Status', 'Memo'];

    const rows = records.map(record => [
      record.signature,
      new Date(record.timestamp * 1000).toISOString(),
      record.type,
      record.from,
      record.to,
      record.amount.toFixed(9),
      record.fee.toFixed(9),
      record.status,
      record.memo || '',
    ]);

    const csv = [headers, ...rows]
      .map(row => row.map(cell => `"${cell}"`).join(','))
      .join('\n');

    fs.writeFileSync(outputPath, csv);
  }

  /**
   * Export to JSON format
   */
  private async exportToJSON(records: TransactionRecord[], outputPath: string): Promise<void> {
    const json = JSON.stringify(records, null, 2);
    fs.writeFileSync(outputPath, json);
  }

  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

interface ExportResult {
  totalTransactions: number;
  successfulTx: number;
  failedTx: number;
  totalFees: number;
  duration: number;
  outputPath: string;
}

// Usage example
async function exampleExport() {
  const exporter = new TransactionHistoryExporter('https://rpc.solana.com');

  try {
    const result = await exporter.exportHistory('WalletAddressHere', {
      format: 'csv',
      outputPath: '/tmp/transaction_history.csv',
      batchSize: 10,
      includeFailedTx: true,
      // Optional time range (Unix timestamps)
      // startTime: 1640000000,
      // endTime: 1672535999,
    });

    console.log('Export complete!');
    console.log(`Total transactions: ${result.totalTransactions}`);
    console.log(`Successful: ${result.successfulTx}`);
    console.log(`Failed: ${result.failedTx}`);
    console.log(`Total fees: ${result.totalFees.toFixed(9)} SOL`);
    console.log(`Duration: ${result.duration}ms`);
    console.log(`Output: ${result.outputPath}`);
  } catch (error) {
    console.error('Export failed:', error);
  }
}