export abstract class BaseExecutor {
  protected config: ExecutorConfig;
  protected metrics: MetricsCollector;
  protected logger: Logger;

  constructor(config: ExecutorConfig, logger?: Logger) {
    this.config = config;
    this.logger = logger || pino({ name: this.name() });
    this.metrics = new MetricsCollector(this.name());
  }

  // Abstract methods (must implement)
  abstract name(): string;
  abstract execute(request: ExecutionRequest): Promise<ExecutionResult>;

  // Template methods (can override)
  protected abstract buildTransaction(request: ExecutionRequest): Promise<VersionedTransaction>;
  protected abstract submitTransaction(tx: VersionedTransaction): Promise<string>;
  protected abstract confirmTransaction(signature: string, timeout: number): Promise<boolean>;

  // Helper methods (built-in)
  protected async signTransaction(
    tx: VersionedTransaction,
    signers: KeyPairSigner[]
  ): Promise<VersionedTransaction> {
    for (const signer of signers) {
      await tx.sign([signer]);
    }
    return tx;
  }

  protected async validateTransaction(tx: VersionedTransaction): Promise<void> {
    const serialized = tx.serialize();
    if (serialized.length > 1232) {
      throw new Error(`Transaction too large: ${serialized.length} bytes`);
    }
  }

  protected async handleExecutionError(error: Error, request: ExecutionRequest): Promise<void> {
    this.logger.error({ error, opportunity: request.opportunity.id }, 'Execution failed');
    this.metrics.incrementExecutionErrors(error.message);
  }

  // Retry logic
  protected async executeWithRetry<T>(
    fn: () => Promise<T>,
    maxRetries: number = 3
  ): Promise<T> {
    let lastError: Error;

    for (let i = 0; i < maxRetries; i++) {
      try {
        return await fn();
      } catch (error) {
        lastError = error as Error;
        const delay = Math.pow(2, i) * 1000; // Exponential backoff
        await sleep(delay);
      }
    }

    throw lastError!;
  }
}

export interface ExecutorConfig {
  name: string;
  enabled: boolean;

  // RPC configuration
  rpcEndpoint: string;
  rpcBackups: string[];

  // Jito configuration
  jitoBlockEngineUrl?: string;
  jitoUuid?: string;
  jitoTipBase?: number;
  jitoTipStep?: number;

  // TPU configuration
  tpuTimeout?: number;
  tpuRetryCount?: number;
  tpuFanoutSlots?: number;

  // Flash loan configuration
  kaminoMarketAddress?: string;

  // Transaction building
  computeUnitLimit: number;
  computeUnitPrice: number;

  // Confirmation
  confirmationTimeout: number;
  confirmationCommitment: 'processed' | 'confirmed' | 'finalized';

  // Error handling
  maxRetries: number;
  retryDelayMs: number;

  // Metrics
  metricsEnabled: boolean;
}

export interface ExecutionRequest {
  opportunity: TradeOpportunity;
  wallet: KeyPairSigner;
  timeout: number;
}

export interface ExecutionResult {
  opportunityId: string;
  status: 'success' | 'failed';
  signature?: string;
  error?: string;
  expectedProfit?: number;
  actualProfit?: number;
  latency: number;
  timestamp: number;
  metadata?: Record<string, unknown>;
}

export class TransactionBuilder {
  private instructions: TransactionInstruction[] = [];
  private signers: KeyPairSigner[] = [];
  private feePayer: Address | null = null;
  private recentBlockhash: string | null = null;
  private addressLookupTables: AddressLookupTableAccount[] = [];

  addInstruction(ix: TransactionInstruction): this {
    this.instructions.push(ix);
    return this;
  }

  addInstructions(ixs: TransactionInstruction[]): this {
    this.instructions.push(...ixs);
    return this;
  }

  addComputeBudget(opts: { units: number; microLamports: number }): this {
    this.instructions.unshift(
      ComputeBudgetProgram.setComputeUnitLimit({ units: opts.units }),
      ComputeBudgetProgram.setComputeUnitPrice({ microLamports: opts.microLamports })
    );
    return this;
  }

  setFeePayer(feePayer: Address): this {
    this.feePayer = feePayer;
    return this;
  }

  setRecentBlockhash(blockhash: string): this {
    this.recentBlockhash = blockhash;
    return this;
  }

  addAddressLookupTable(alt: AddressLookupTableAccount): this {
    this.addressLookupTables.push(alt);
    return this;
  }

  async build(): Promise<VersionedTransaction> {
    if (!this.feePayer) throw new Error('Fee payer not set');
    if (!this.recentBlockhash) throw new Error('Recent blockhash not set');

    const message = MessageV0.compile({
      payerKey: this.feePayer,
      instructions: this.instructions,
      recentBlockhash: this.recentBlockhash,
      addressLookupTableAccounts: this.addressLookupTables
    });

    return new VersionedTransaction(message);
  }
}

// Build arbitrage transaction
const builder = new TransactionBuilder();

// Add compute budget (MUST be first)
builder.addComputeBudget({
  units: 400_000,
  microLamports: 1_000_000 // 1000 lamports priority fee
});

// Add swap instructions
for (const hop of opportunity.path) {
  const swapIxs = await buildSwapInstructions(hop, wallet);
  builder.addInstructions(swapIxs);
}

// Add Jito tip (if using Jito)
if (executionMethod === 'jito_bundle') {
  builder.addInstruction(
    SystemProgram.transfer({
      fromPubkey: wallet.address,
      toPubkey: jitoTipAccount,
      lamports: 10_000n // 0.00001 SOL tip
    })
  );
}

// Set transaction metadata
const blockhash = await connection.getLatestBlockhash();
builder.setFeePayer(wallet.address);
builder.setRecentBlockhash(blockhash.blockhash);

// Compress with ALT (optional, if transaction > 1232 bytes)
if (needsCompression) {
  builder.addAddressLookupTable(altAccount);
}

// Build transaction
const tx = await builder.build();

// Sign transaction
await tx.sign([wallet]);

// Validate size
const serialized = tx.serialize();
console.log(`Transaction size: ${serialized.length} bytes`); // Must be <= 1232

export class JitoExecutor extends BaseExecutor {
  name = 'jito';

  private jitoClient: JitoJsonRpcClient;
  private tipAccounts: string[];

  constructor(config: ExecutorConfig, logger?: Logger) {
    super(config, logger);
    this.jitoClient = new JitoJsonRpcClient(
      config.jitoBlockEngineUrl!,
      config.jitoUuid!
    );
    this.tipAccounts = JITO_TIP_ACCOUNTS;
  }

  async execute(request: ExecutionRequest): Promise<ExecutionResult> {
    const startTime = Date.now();
    const tracer = trace.getTracer('executor-framework');

    return await tracer.startActiveSpan('jito_execution', async (span) => {
      try {
        // 1. Build transaction
        span.addEvent('building_transaction');
        const tx = await this.buildTransaction(request);

        // 2. Add tip instruction
        const tipAccount = this.selectTipAccount();
        const tipAmount = this.calculateTip(request.opportunity);
        await this.addTipInstruction(tx, tipAccount, tipAmount);

        // 3. Sign transaction
        span.addEvent('signing_transaction');
        const signed = await this.signTransaction(tx, [request.wallet]);

        // 4. Validate
        await this.validateTransaction(signed);

        // 5. Submit bundle
        span.addEvent('submitting_bundle');
        const bundleId = await this.submitTransaction(signed);

        // 6. Monitor confirmation
        span.addEvent('monitoring_confirmation');
        const confirmed = await this.confirmTransaction(bundleId, request.timeout);

        if (!confirmed) {
          throw new Error('Bundle confirmation timeout');
        }

        // 7. Parse results
        const actualProfit = await this.parseProfit(bundleId);

        span.setStatus({ code: SpanStatusCode.OK });

        return {
          opportunityId: request.opportunity.id,
          status: 'success',
          signature: bundleId,
          expectedProfit: request.opportunity.expectedProfitUsd,
          actualProfit,
          latency: Date.now() - startTime,
          timestamp: Date.now(),
          metadata: {
            executor: 'jito',
            tipAmount,
            tipAccount
          }
        };
      } catch (error) {
        span.recordException(error as Error);
        span.setStatus({ code: SpanStatusCode.ERROR, message: (error as Error).message });

        return {
          opportunityId: request.opportunity.id,
          status: 'failed',
          error: (error as Error).message,
          latency: Date.now() - startTime,
          timestamp: Date.now(),
          metadata: { executor: 'jito' }
        };
      } finally {
        span.end();
      }
    });
  }

  protected async buildTransaction(request: ExecutionRequest): Promise<VersionedTransaction> {
    const builder = new TransactionBuilder();

    // Add swap instructions based on opportunity routes
    for (const route of request.opportunity.routes) {
      const instructions = await this.buildSwapInstructions(route, request.wallet);
      builder.addInstructions(instructions);
    }

    // Add compute budget
    builder.addComputeBudget({
      units: 400_000,
      microLamports: 1_000_000 // 1000 lamports
    });

    // Set fee payer and blockhash
    const blockhash = await this.getRecentBlockhash();
    builder.setFeePayer(request.wallet.address);
    builder.setRecentBlockhash(blockhash);

    // Compress with ALT if needed
    const tx = await builder.build();
    return await this.compressWithALT(tx);
  }

  protected async submitTransaction(tx: VersionedTransaction): Promise<string> {
    const bundleId = await this.jitoClient.sendBundle([tx], {
      skipPreflight: false
    });

    this.logger.info({ bundleId }, 'Bundle submitted');
    return bundleId;
  }

  protected async confirmTransaction(bundleId: string, timeout: number): Promise<boolean> {
    const startTime = Date.now();

    while (Date.now() - startTime < timeout) {
      const status = await this.jitoClient.getBundleStatuses([bundleId]);

      if (status.value[0]?.confirmation_status === 'confirmed') {
        return true;
      }

      await sleep(2000); // Poll every 2 seconds
    }

    return false;
  }

  private selectTipAccount(): string {
    // Random selection or round-robin
    return this.tipAccounts[Math.floor(Math.random() * this.tipAccounts.length)];
  }

  private calculateTip(opportunity: TradeOpportunity): number {
    // Dynamic tip based on profit
    const baseTip = this.config.jitoTipBase || 5000;
    const profitBasedTip = Math.floor(opportunity.expectedProfitUsd * 0.01); // 1% of profit
    return Math.max(baseTip, profitBasedTip);
  }
}

const JITO_TIP_ACCOUNTS = [
  '96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5',
  'HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe',
  'Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY',
  'ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49',
  'DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh'
];

export class TPUExecutor extends BaseExecutor {
  name = 'tpu';

  private tpuClient: QUICTPUClient;

  constructor(config: ExecutorConfig) {
    super(config);
    this.tpuClient = new QUICTPUClient({
      timeout: 5000,
      retryCount: 2,
      fanoutSlots: 4
    });
  }

  async execute(request: ExecutionRequest): Promise<ExecutionResult> {
    // Build and sign (same as Jito)
    const tx = await this.buildTransaction(request);
    const signed = await this.signTransaction(tx, [request.wallet]);
    await this.validateTransaction(signed);

    // Submit via TPU
    const signature = await this.submitTransaction(signed);

    // Confirm via RPC
    const confirmed = await this.confirmTransaction(signature, request.timeout);

    if (!confirmed) {
      throw new Error('Transaction confirmation timeout');
    }

    return {
      opportunityId: request.opportunity.id,
      status: 'success',
      signature,
      latency: Date.now() - startTime,
      timestamp: Date.now(),
      metadata: { executor: 'tpu' }
    };
  }

  protected async submitTransaction(tx: VersionedTransaction): Promise<string> {
    const serialized = tx.serialize();
    const signature = await this.tpuClient.send(serialized);

    this.logger.info({ signature }, 'Transaction submitted via TPU');
    return signature;
  }

  protected async confirmTransaction(signature: string, timeout: number): Promise<boolean> {
    const connection = new Connection(this.config.rpcEndpoint);

    try {
      const result = await connection.confirmTransaction(signature, 'confirmed', timeout);
      return !result.value.err;
    } catch {
      return false;
    }
  }
}

export class FlashLoanExecutor extends BaseExecutor {
  name = 'flash-loan';

  private kaminoMarket: KaminoMarket;
  private baseExecutor: BaseExecutor;

  constructor(config: ExecutorConfig, baseExecutor: BaseExecutor) {
    super(config);
    this.baseExecutor = baseExecutor;
    this.kaminoMarket = new KaminoMarket(
      config.kaminoMarketAddress!,
      new Connection(config.rpcEndpoint)
    );
  }

  async execute(request: ExecutionRequest): Promise<ExecutionResult> {
    // Build flash loan transaction
    const tx = await this.buildFlashLoanTransaction(request);
    const signed = await this.signTransaction(tx, [request.wallet]);
    await this.validateTransaction(signed);

    // Submit via base executor
    const signature = await this.baseExecutor.submitTransaction(signed);
    const confirmed = await this.baseExecutor.confirmTransaction(signature, request.timeout);

    if (!confirmed) {
      throw new Error('Flash loan transaction timeout');
    }

    return {
      opportunityId: request.opportunity.id,
      status: 'success',
      signature,
      latency: Date.now() - startTime,
      timestamp: Date.now(),
      metadata: {
        executor: 'flash-loan',
        baseExecutor: this.baseExecutor.name()
      }
    };
  }

  protected async buildFlashLoanTransaction(request: ExecutionRequest): Promise<VersionedTransaction> {
    const builder = new TransactionBuilder();

    // 1. Flash loan borrow
    const borrowAmount = BigInt(request.opportunity.amount);
    const borrowIx = await this.kaminoMarket.getBorrowInstruction({
      owner: request.wallet.address,
      reserve: this.getReserveForToken(request.opportunity.tokenA),
      amount: borrowAmount
    });
    builder.addInstruction(borrowIx);

    // 2. Swap instructions
    for (const route of request.opportunity.routes) {
      const swapIxs = await this.buildSwapInstructions(route, request.wallet);
      builder.addInstructions(swapIxs);
    }

    // 3. Flash loan repay
    const repayIx = await this.kaminoMarket.getRepayInstruction({
      owner: request.wallet.address,
      reserve: this.getReserveForToken(request.opportunity.tokenA),
      amount: borrowAmount
    });
    builder.addInstruction(repayIx);

    // 4. Set transaction metadata
    const blockhash = await this.getRecentBlockhash();
    builder.setFeePayer(request.wallet.address);
    builder.setRecentBlockhash(blockhash);

    // 5. Add compute budget (flash loans need more CU)
    builder.addComputeBudget({
      units: 600_000, // Flash loans are more expensive
      microLamports: 2_000_000 // Higher priority
    });

    return await builder.build();
  }

  private getReserveForToken(tokenMint: string): string {
    // Map token mint to Kamino reserve address
    const RESERVES = {
      'So11111111111111111111111111111111111111112': 'SOL_RESERVE_ADDRESS',
      'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v': 'USDC_RESERVE_ADDRESS'
    };
    return RESERVES[tokenMint] || '';
  }
}

export class WalletManager {
  private wallets: KeyPairSigner[] = [];
  private walletStates: Map<string, WalletState> = new Map();
  private currentIndex = 0;

  constructor(private config: WalletConfig) {}

  async initialize(): Promise<void> {
    // Load wallets from configuration
    for (const privateKey of this.config.privateKeys) {
      const wallet = await this.loadWallet(privateKey);
      this.wallets.push(wallet);
      this.walletStates.set(wallet.address, {
        balance: 0,
        inFlight: 0,
        lastUsed: 0,
        errors: 0
      });
    }

    // Fetch initial balances
    await this.refreshBalances();
  }

  /**
   * Get next available wallet (round-robin with health checks)
   */
  getNextWallet(): KeyPairSigner {
    const maxAttempts = this.wallets.length;
    let attempts = 0;

    while (attempts < maxAttempts) {
      const wallet = this.wallets[this.currentIndex];
      const state = this.walletStates.get(wallet.address)!;

      // Advance index
      this.currentIndex = (this.currentIndex + 1) % this.wallets.length;
      attempts++;

      // Check wallet health
      if (this.isWalletHealthy(state)) {
        return wallet;
      }
    }

    throw new Error('No healthy wallets available');
  }

  /**
   * Get wallet with sufficient balance
   */
  getWalletWithBalance(minBalance: number): KeyPairSigner | null {
    for (const wallet of this.wallets) {
      const state = this.walletStates.get(wallet.address)!;
      if (state.balance >= minBalance && this.isWalletHealthy(state)) {
        return wallet;
      }
    }
    return null;
  }

  /**
   * Mark wallet as in-flight (transaction pending)
   */
  markInFlight(wallet: KeyPairSigner): void {
    const state = this.walletStates.get(wallet.address)!;
    state.inFlight++;
    state.lastUsed = Date.now();
  }

  /**
   * Mark wallet as completed (transaction confirmed)
   */
  markCompleted(wallet: KeyPairSigner, success: boolean): void {
    const state = this.walletStates.get(wallet.address)!;
    state.inFlight = Math.max(0, state.inFlight - 1);

    if (!success) {
      state.errors++;
    } else {
      state.errors = 0; // Reset error counter on success
    }
  }

  /**
   * Check wallet health
   */
  private isWalletHealthy(state: WalletState): boolean {
    // Too many errors
    if (state.errors >= 5) return false;

    // Too many in-flight transactions
    if (state.inFlight >= 3) return false;

    // Low balance
    if (state.balance < 0.1) return false;

    return true;
  }

  /**
   * Refresh wallet balances
   */
  async refreshBalances(): Promise<void> {
    const connection = new Connection(this.config.rpcEndpoint);

    const promises = this.wallets.map(async (wallet) => {
      const balance = await connection.getBalance(wallet.address);
      const state = this.walletStates.get(wallet.address)!;
      state.balance = balance / 1e9; // lamports to SOL
    });

    await Promise.all(promises);
  }

  /**
   * Get wallet statistics
   */
  getStats(): WalletStats {
    const stats: WalletStats = {
      total: this.wallets.length,
      healthy: 0,
      lowBalance: 0,
      highInFlight: 0,
      errored: 0
    };

    for (const state of this.walletStates.values()) {
      if (this.isWalletHealthy(state)) stats.healthy++;
      if (state.balance < 0.1) stats.lowBalance++;
      if (state.inFlight >= 3) stats.highInFlight++;
      if (state.errors >= 5) stats.errored++;
    }

    return stats;
  }
}

interface WalletState {
  balance: number;
  inFlight: number;
  lastUsed: number;
  errors: number;
}

interface WalletStats {
  total: number;
  healthy: number;
  lowBalance: number;
  highInFlight: number;
  errored: number;
}

// Initialize wallet manager
const walletManager = new WalletManager({
  privateKeys: [
    process.env.WALLET_1!,
    process.env.WALLET_2!,
    process.env.WALLET_3!,
    process.env.WALLET_4!,
    process.env.WALLET_5!
  ],
  rpcEndpoint: 'https://api.mainnet-beta.solana.com'
});

await walletManager.initialize();

// Get next wallet for execution
const wallet = walletManager.getNextWallet();

// Execute trade
walletManager.markInFlight(wallet);
try {
  await executor.execute({ opportunity, wallet, timeout: 10000 });
  walletManager.markCompleted(wallet, true);
} catch (error) {
  walletManager.markCompleted(wallet, false);
}

// Monitor wallet health
setInterval(async () => {
  await walletManager.refreshBalances();
  const stats = walletManager.getStats();
  console.log('Wallet stats:', stats);
}, 30000); // Every 30 seconds

interface ExecutionPlanEvent {
  planId: string;
  opportunityId: string;
  strategy: 'arbitrage' | 'triangular' | 'market_making';
  executionMethod: 'jito_bundle' | 'tpu_direct' | 'rpc';

  // Transaction details
  routes: SwapRoute[];
  inputToken: string;
  outputToken: string;
  inputAmount: number;
  expectedProfit: number;

  // Validation results
  simulationSuccess: boolean;
  gasEstimate: number;
  slippage: number;

  // Execution constraints
  maxLatency: number;
  deadline: number;
  priorityFee: number;

  // Flash loan (optional)
  flashLoan?: {
    provider: 'kamino';
    amount: number;
    reserve: string;
  };

  timestamp: number;
}

interface ExecutionResultEvent {
  executionId: string;
  planId: string;
  opportunityId: string;
  status: 'success' | 'failed' | 'timeout';

  // Transaction results
  signature?: string;
  blockSlot?: number;
  confirmationTime?: number;

  // Financial results
  expectedProfit: number;
  actualProfit?: number;
  executionCost: number;
  netProfit?: number;

  // Performance metrics
  latency: number;
  executionMethod: string;

  // Error details (if failed)
  error?: string;
  errorCode?: string;

  timestamp: number;
}

import { connect, JSONCodec } from 'nats';

export class ExecutorService {
  private nc: NatsConnection;
  private js: JetStreamClient;
  private executor: BaseExecutor;
  private walletManager: WalletManager;

  async start(): Promise<void> {
    // Connect to NATS
    this.nc = await connect({ servers: 'nats://localhost:4222' });
    this.js = this.nc.jetstream();

    // Subscribe to PLANNED stream
    const sub = await this.js.subscribe('execution.planned.*', {
      stream: 'PLANNED',
      durable: 'executor-consumer',
      ack_policy: 'explicit'
    });

    // Subscribe to SYSTEM stream (kill switch)
    const systemSub = await this.js.subscribe('system.killswitch', {
      stream: 'SYSTEM'
    });

    // Process execution plans
    (async () => {
      for await (const msg of sub) {
        await this.handleExecutionPlan(msg);
      }
    })();

    // Monitor kill switch
    (async () => {
      for await (const msg of systemSub) {
        await this.handleKillSwitch(msg);
      }
    })();

    this.logger.info('Executor service started');
  }

  private async handleExecutionPlan(msg: JsMsg): Promise<void> {
    const jc = JSONCodec<ExecutionPlanEvent>();
    const plan = jc.decode(msg.data);

    try {
      // Select wallet
      const wallet = this.walletManager.getNextWallet();

      // Execute
      const result = await this.executor.execute({
        opportunity: plan,
        wallet,
        timeout: plan.maxLatency
      });

      // Publish result
      await this.publishResult(result);

      // Ack message
      msg.ack();
    } catch (error) {
      this.logger.error({ error, plan }, 'Execution failed');

      // Publish failure
      await this.publishResult({
        executionId: crypto.randomUUID(),
        planId: plan.planId,
        opportunityId: plan.opportunityId,
        status: 'failed',
        error: error.message,
        latency: 0,
        timestamp: Date.now()
      });

      // Ack message (don't reprocess)
      msg.ack();
    }
  }

  private async publishResult(result: ExecutionResultEvent): Promise<void> {
    const jc = JSONCodec<ExecutionResultEvent>();

    await this.js.publish(
      `executed.${result.status}.${result.opportunityId}`,
      jc.encode(result)
    );
  }

  private async handleKillSwitch(msg: JsMsg): Promise<void> {
    this.logger.error('Kill switch triggered, stopping executor');

    // Stop processing new messages
    await this.stop();

    // Publish shutdown metric
    await this.js.publish('metrics.executor.stopped', JSONCodec().encode({
      reason: 'killswitch',
      timestamp: Date.now()
    }));
  }

  async stop(): Promise<void> {
    await this.nc.drain();
    await this.nc.close();
    this.logger.info('Executor service stopped');
  }
}

export class BlockhashCache {
  private cachedBlockhash: { blockhash: string; lastValidBlockHeight: number } | null = null;
  private lastFetch = 0;

  async getBlockhash(connection: Connection): Promise<string> {
    const now = Date.now();

    // Refresh every 30 seconds (blockhash valid for 150 seconds)
    if (!this.cachedBlockhash || now - this.lastFetch > 30_000) {
      this.cachedBlockhash = await connection.getLatestBlockhash();
      this.lastFetch = now;
    }

    return this.cachedBlockhash.blockhash;
  }
}

// ❌ Sequential (slow)
const balance = await connection.getBalance(wallet);
const tokenAccounts = await connection.getTokenAccountsByOwner(wallet, { programId: TOKEN_PROGRAM_ID });

// ✅ Parallel (2x faster)
const [balance, tokenAccounts] = await Promise.all([
  connection.getBalance(wallet),
  connection.getTokenAccountsByOwner(wallet, { programId: TOKEN_PROGRAM_ID })
]);

export class RPCConnectionPool {
  private connections: Connection[] = [];

  constructor(endpoints: string[]) {
    // Create connection pool
    this.connections = endpoints.map(url => new Connection(url, {
      commitment: 'confirmed',
      wsEndpoint: url.replace('https', 'wss')
    }));

    // Pre-warm connections
    this.warmup();
  }

  private async warmup(): Promise<void> {
    await Promise.all(
      this.connections.map(conn => conn.getSlot())
    );
  }

  getConnection(): Connection {
    // Round-robin selection
    return this.connections[Math.floor(Math.random() * this.connections.length)];
  }
}

// Use Address Lookup Tables (ALT) to compress transactions
export async function compressWithALT(
  tx: VersionedTransaction,
  alt: AddressLookupTableAccount
): Promise<VersionedTransaction> {
  const message = MessageV0.compile({
    payerKey: tx.message.staticAccountKeys[0],
    instructions: TransactionMessage.decompile(tx.message).instructions,
    recentBlockhash: tx.message.recentBlockhash,
    addressLookupTableAccounts: [alt]
  });

  return new VersionedTransaction(message);
}

export async function calculatePriorityFee(
  opportunity: TradeOpportunity,
  congestion: 'low' | 'medium' | 'high'
): Promise<number> {
  // Base fee
  let microLamports = 1_000_000; // 1000 lamports

  // Adjust for congestion
  if (congestion === 'medium') microLamports *= 2;
  if (congestion === 'high') microLamports *= 5;

  // Adjust for opportunity value
  const profitBased = Math.floor(opportunity.expectedProfitUsd * 1_000_000);
  microLamports = Math.max(microLamports, profitBased);

  return microLamports;
}

try {
  const result = await executor.execute(request);
} catch (error) {
  if (error instanceof InsufficientFundsError) {
    // Wallet balance too low
    await walletManager.markCompleted(wallet, false);
    await fundWallet(wallet);
  } else if (error instanceof TransactionExpiredError) {
    // Blockhash expired, retry with fresh blockhash
    request.blockhash = await getLatestBlockhash();
    await executor.execute(request);
  } else if (error instanceof SimulationFailedError) {
    // Don't retry, opportunity is stale
    logger.warn('Simulation failed, skipping opportunity');
  } else {
    // Unknown error, log and skip
    logger.error({ error }, 'Unknown execution error');
  }
}

export class CircuitBreaker {
  private failures = 0;
  private lastFailure = 0;
  private state: 'closed' | 'open' | 'half-open' = 'closed';

  async execute<T>(fn: () => Promise<T>): Promise<T> {
    if (this.state === 'open') {
      // Check if we should try half-open
      if (Date.now() - this.lastFailure > 60_000) {
        this.state = 'half-open';
      } else {
        throw new Error('Circuit breaker is open');
      }
    }

    try {
      const result = await fn();

      // Success, reset
      this.failures = 0;
      this.state = 'closed';

      return result;
    } catch (error) {
      this.failures++;
      this.lastFailure = Date.now();

      // Open circuit after 5 failures
      if (this.failures >= 5) {
        this.state = 'open';
        logger.error('Circuit breaker opened after 5 failures');
      }

      throw error;
    }
  }
}

export class RateLimiter {
  private requests: number[] = [];

  async acquire(maxPerSecond: number): Promise<void> {
    const now = Date.now();

    // Remove requests older than 1 second
    this.requests = this.requests.filter(ts => now - ts < 1000);

    // Check rate limit
    if (this.requests.length >= maxPerSecond) {
      const oldestRequest = this.requests[0];
      const waitTime = 1000 - (now - oldestRequest);
      await sleep(waitTime);
      return this.acquire(maxPerSecond);
    }

    this.requests.push(now);
  }
}

export class ExecutorMetrics {
  private registry = new Registry();

  executionsTotal = new Counter({
    name: 'executor_executions_total',
    help: 'Total number of executions',
    labelNames: ['status', 'method'],
    registers: [this.registry]
  });

  executionDuration = new Histogram({
    name: 'executor_execution_duration_ms',
    help: 'Execution duration in milliseconds',
    labelNames: ['method'],
    buckets: [10, 50, 100, 200, 500, 1000, 2000, 5000],
    registers: [this.registry]
  });

  profitTotal = new Counter({
    name: 'executor_profit_usd_total',
    help: 'Total profit in USD',
    labelNames: ['method'],
    registers: [this.registry]
  });

  recordExecution(result: ExecutionResult): void {
    this.executionsTotal.inc({
      status: result.status,
      method: result.metadata?.executor
    });

    this.executionDuration.observe(
      { method: result.metadata?.executor },
      result.latency
    );

    if (result.actualProfit) {
      this.profitTotal.inc(
        { method: result.metadata?.executor },
        result.actualProfit
      );
    }
  }
}