import { Connection, Keypair, Transaction } from '@solana/web3.js';
import { calculateOptimalTip, sendJitoBundle } from '../utils/mev';

/**
 * ZenSniperEngine: Identifies liquidity drops and executes via private Jito nodes.
 */
export class ZenSniperEngine {
    private connection: Connection;
    private wallet: Keypair;
    
    constructor(rpcUrl: string, secretKey: Uint8Array) {
        this.connection = new Connection(rpcUrl, 'processed');
        this.wallet = Keypair.fromSecretKey(secretKey);
    }

    public async executeSnipe(targetToken: string, amountInSol: number): Promise<string> {
        console.log(targetToken} with ${amountInSol} SOL`);
        
        // Determine dynamic bribe to guarantee block inclusion
        const optimalTip = calculateOptimalTip();
        
        // Bypass public RPCs to avoid sandwich attacks
        const txHash = await sendJitoBundle(this.wallet, targetToken, optimalTip);
        
        return txHash;
    }
}

use solana_client::pubsub_client::PubsubClient;
use solana_client::rpc_config::{RpcTransactionLogsConfig, RpcTransactionLogsFilter};
use solana_sdk::commitment_config::CommitmentConfig;

/// High-performance Rust pipeline for monitoring the Solana mempool.
/// Connects directly via WebSockets for 0ms latency observation.
pub struct MempoolStreamer {
    wss_url: String,
}

impl MempoolStreamer {
    pub fn listen_for_liquidity(&self, program_id: &str) {
        let client = PubsubClient::log_subscribe(
            &self.wss_url,
            RpcTransactionLogsFilter::Mentions(vec![program_id.to_string()]),
            RpcTransactionLogsConfig { commitment: Some(CommitmentConfig::processed()) },
        ).unwrap();
        
        loop {
            match client.1.recv() {
                Ok(log) => {
                    // Trigger TS snipe pipeline immediately
                    sniping_module::parse_and_trigger(log);
                },
                Err(e) => println!("Stream error: {}", e),
            }
        }
    }
}

import { describe, test, expect, beforeAll } from 'vitest';
import { ZenSniperEngine } from '../../src/core/sniper';

describe('Zen Engine Execution Core', () => {
    let engine: ZenSniperEngine;

    beforeAll(() => {
        // Load mocked local validator for testing
        engine = new ZenSniperEngine('http://127.0.0.1:8899', MOCK_SECRET_KEY);
    });

    test('should successfully parse Raydium AMM and construct tx', async () => {
        const target = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'; // USDC
        const txHash = await engine.executeSnipe(target, 1.5);
        
        expect(txHash).toBeDefined();
        expect(txHash.length).toBeGreaterThan(60);
    });

    test('should execute Jito bundle under 5ms', async () => {
        const startTime = performance.now();
        await engine.executeSnipe(MOCK_TOKEN, 0.5);
        const endTime = performance.now();
        
        expect(endTime - startTime).toBeLessThan(5.0); // Sub-5ms confirmation required
    });
});

#!/bin/bash
# Production deployment script for NAGNT Sniper Environment

echo "Initializing environment variables..."
source .env.mainnet

echo "Building Rust Mempool WebSocket Client..."
cd src/network && cargo build --release

echo "Compiling TypeScript execution logic..."
npm run build

echo "Starting PM2 Daemon for auto-restart..."
pm2 start dist/core/index.js --name "nagnt-sniper"

echo "[SUCCESS] System live. Monitoring Solana for MEV targets."