PumpStream

// npm install @solana/web3.js axios bs58 tweetnacl ws

import fs from 'fs';
import path from 'path';
import axios from 'axios';
import { Keypair, VersionedTransaction } from '@solana/web3.js';
import bs58 from 'bs58';
import nacl from 'tweetnacl';
import WebSocket from 'ws';

const HTTP_API = "https://pumpstream.io/api/v1";
const WS_API = "wss://pumpstream.io/api/v1";
const DEPOSIT_AMOUNT = 0.001;
const PUBKEY = "YOUR_PUBKEY_HERE";

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

function loadKeypairFromFile(pubkeyStr) {
    const filePath = path.join('wallets', `${pubkeyStr}.json`);
    const fileContent = fs.readFileSync(filePath, 'utf-8');
    const keypairData = JSON.parse(fileContent);
    const secretKey = Uint8Array.from(keypairData);
    return Keypair.fromSecretKey(secretKey);
}

function getAuthSignature(keypair, message) {
    const messageBytes = new TextEncoder().encode(message);
    const signatureBytes = nacl.sign.detached(messageBytes, keypair.secretKey);
    return bs58.encode(signatureBytes);
}

function connectToStream(pubkey, signature) {
    const wsAuthUrl = `${WS_API}/stream?pubkey=${pubkey}&signed_message=${signature}`;
    console.log(`\n📡 Connecting to WebSocket stream...`);

    const ws = new WebSocket(wsAuthUrl);

    ws.on('open', () => {
        console.log("✅ WebSocket connected! Waiting for new token data...");
    });

    ws.on('message', (data) => {
        const messageStr = data.toString('utf-8');
        const transactions = JSON.parse(messageStr);
        for (const tx of transactions) {
            console.log(tx);
        }
    });

    ws.on('error', (err) => {
        console.error("WebSocket error:", err);
    });

    ws.on('close', (code, reason) => {
        console.log(`WebSocket closed. Code: ${code}, Reason: ${reason}`);
    });
}

async function main() {
    console.log("🔐 Loading keypair and creating authentication signature...");
    const walletKeypair = loadKeypairFromFile(PUBKEY);
    const authSignature = getAuthSignature(walletKeypair, PUBKEY);

    console.log("Checking account balance...");
    const balanceUrl = `${HTTP_API}/balance?pubkey=${PUBKEY}&signed_message=${authSignature}`;
    const balanceResponse = await axios.get(balanceUrl);
    const balanceData = balanceResponse.data;

    await sleep(1000);

    if (balanceData.data.expires_in_hours < 1) {
        console.log("Balance expiring soon. Initiating a deposit...");
        const genTxUrl = `${HTTP_API}/deposit/generate-transaction?pubkey=${PUBKEY}&amount=${DEPOSIT_AMOUNT}`;
        const genTxResponse = await axios.get(genTxUrl);
        const unsignedTxB58 = genTxResponse.data.data.unsigned_message;

        const txBuffer = Buffer.from(bs58.decode(unsignedTxB58));
        const transaction = VersionedTransaction.deserialize(txBuffer);
        transaction.sign([walletKeypair]);

        const signedTxB58 = bs58.encode(transaction.serialize());
        await sleep(1000);

        console.log("Submitting signed transaction...");
        const submitTxUrl = `${HTTP_API}/deposit/submit-transaction?pubkey=${PUBKEY}&signed_transaction=${signedTxB58}`;
        const depositResponse = await axios.get(submitTxUrl);
        console.log("✅ Deposit successful. New balance:", depositResponse.data);
        await sleep(1000);
    } else {
        console.log("Balance is sufficient. No deposit needed.", balanceData.data);
    }

    connectToStream(PUBKEY.to_string(), authSignature);
}

main();

use futures_util::StreamExt;
use reqwest::Client;
use serde::Deserialize;
use solana_sdk::{
    message::VersionedMessage,
    signature::{Keypair, Signer},
    transaction::VersionedTransaction,
};
use std::{path::Path, time::Duration};
use tokio_tungstenite::{connect_async, tungstenite::protocol::Message};

// --- Configuration ---
const HTTP_API: &str = "https://pumpstream.io/api/v1";
const WS_API: &str = "wss://pumpstream.io/api/v1";
const DEPOSIT_AMOUNT: f64 = 0.001; // in SOL
const PUBKEY: &str = "YOUR_PUBKEY_HERE";

#[derive(Deserialize, Debug)]
struct BalanceData {
    expires_in_hours: f64,
}

#[derive(Deserialize, Debug)]
struct BalanceResponse {
    data: BalanceData,
}

#[derive(Deserialize, Debug)]
struct GenTxData {
    unsigned_message: String,
}

#[derive(Deserialize, Debug)]
struct GenTxResponse {
    data: GenTxData,
}

#[derive(Deserialize, Debug)]
struct DepositResponse {
    data: serde_json::Value,
}

fn load_keypair_from_file(pubkey_str: &str) -> Result<Keypair, Box<dyn std::error::Error>> {
    let file_path = Path::new("wallets").join(format!("{}.json", pubkey_str));
    let file_content = std::fs::read_to_string(&file_path)?;
    let keypair_bytes: Vec<u8> = serde_json::from_str(&file_content)?;
    Keypair::from_bytes(&keypair_bytes).map_err(|e| e.into())
}

fn get_auth_signature(keypair: &Keypair, message: &str) -> String {
    let signature = keypair.sign_message(message.as_bytes());
    bs58::encode(signature).into_string()
}

async fn connect_to_stream(pubkey: String, signature: String) {
    let ws_auth_url = format!("{}/stream?pubkey={}&signed_message={}", WS_API, pubkey, signature);
    println!("\n📡 Connecting to WebSocket stream...");

    if let Ok((ws_stream, _)) = connect_async(&ws_auth_url).await {
        println!("✅ WebSocket connected! Waiting for new token data...");
        let (_write, mut read) = ws_stream.split();
        while let Some(Ok(msg)) = read.next().await {
            println!("{:?}", msg);
        }
    } else {
        eprintln!("WebSocket connection failed.");
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔐 Loading keypair and creating authentication signature...");
    let wallet_keypair = load_keypair_from_file(PUBKEY)?;
    let auth_signature = get_auth_signature(&wallet_keypair, PUBKEY);
    let http_client = Client::new();

    println!("Checking account balance...");
    let balance_url = format!("{}/balance?pubkey={}&signed_message={}", HTTP_API, PUBKEY, auth_signature);
    
    let response = http_client.get(&balance_url).send().await?;
    if response.status().is_success() {
        let balance_data = response.json::<BalanceResponse>().await?;
        tokio::time::sleep(Duration::from_secs(1)).await; 

        if balance_data.data.expires_in_hours < 1.0 {
            println!("Balance expiring soon. Initiating a deposit...");
            let gen_tx_url = format!("{}/deposit/generate-transaction?pubkey={}&amount={}", HTTP_API, PUBKEY, DEPOSIT_AMOUNT);
            let gen_tx_response = http_client.get(&gen_tx_url).send().await?.json::<GenTxResponse>().await?;
            let unsigned_tx_b58 = gen_tx_response.data.unsigned_message;

            let message_bytes = bs58::decode(&unsigned_tx_b58).into_vec()?;
            let message: VersionedMessage = bincode::deserialize(&message_bytes)?;
            let transaction = VersionedTransaction::try_new(message, &[&wallet_keypair])?;
            let signed_tx_b58 = bs58::encode(bincode::serialize(&transaction)?).into_string();

            tokio::time::sleep(Duration::from_secs(1)).await;

            println!("Submitting signed transaction...");
            let submit_tx_url = format!("{}/deposit/submit-transaction?pubkey={}&signed_transaction={}", HTTP_API, PUBKEY, signed_tx_b58);
            let deposit_response = http_client.get(&submit_tx_url).send().await?.json::<DepositResponse>().await?;
            println!("✅ Deposit successful. New balance: {:?}", deposit_response.data);
            tokio::time::sleep(Duration::from_secs(1)).await;
        } else {
            println!("Balance is sufficient. No deposit needed. {:?}", balance_data.data);
        }
    }
    
    connect_to_stream(PUBKEY.to_string(), auth_signature).await;
    Ok(())
}