The fast path, documented.

npm install @solana/web3.js@1

landing.mjs

// Save as landing.mjs. Send one JSON line per transaction on stdin.
import { readFileSync } from "node:fs";
import { createInterface } from "node:readline";
import {
  ComputeBudgetProgram, Keypair, PublicKey, SystemProgram,
  TransactionMessage, VersionedTransaction
} from "@solana/web3.js";

const region = process.env.SLOTBOLT_REGION;
if (!["fra", "ams", "ny", "tokyo"].includes(region)) throw new Error("Invalid region");
const key = process.env.SLOTBOLT_API_KEY;
const keypairFile = process.env.SLOTBOLT_KEYPAIR_FILE;
if (!key || !keypairFile) throw new Error("Set SLOTBOLT_API_KEY and SLOTBOLT_KEYPAIR_FILE");
const payer = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(readFileSync(keypairFile, "utf8"))));
const tipAccounts = [
  "5kw4XdUjk7k9rPH8cTNFqgtpnwhWekVAXEKB2medmoq",
  "4tgpD2mKc6ojaGdJhxvjvo4fRDRJCQUimcvt9SX842Qt",
  "GN1BZUWcoGLStou1M9RD98c9b7JdoXZoTTZR9a6WkdaT",
  "3uANArQUJDsaBqFVNCP9C5HZV9YSU7b2upRH3d9pNHtM",
  "4A68gTsn6pExwmEAn9CVdJxFvVxLdYertG83SR2BYmtD",
  "CinsfRDHjvyfKJjwp8R9TJRCkoP6SGM2eHKJiWyehpP7",
  "EKb54KnRaXxQaaDLqDSvGvRL76whuf5CKtum1qSCSMnk",
  "AsMLHiUCZoojNF1b6sDRPKrbc6RkeDHPZyGPa5hK5ToY",
  "GnPxqoD63TXYrTsXZNsxyt2iZaperxTUz344KUHgBJLJ",
  "HiKfsAEYBL21cZSmhLjV5VEcgjFH5yzGGXXDQcVTztKS",
  "4TTTLWoJNMAHWyFVUDfXasZLfXTt54h4zVpE6wYXa2fH",
  "J8PJG3HQfwxw9yG5w7DzuwnfadAfaikyGyDSLkt2cpGi",
  "8qKJzmNeckLTEHnNdmN198quQ1omU2FshgSLYQeB3oww",
  "7yQ4me6yFn6LDX9jAZ4Sy3jdg6m15uJM15tB1EBC3Jbz",
  "9qc8oYmvSyxaruvnqReY8WXk1ua9r4gRvqKQpEGEVaWc",
  "HPbzYkQ8pkC9UyBEWMtLopQGLxUzpzboXRbrqn9Ue9kg",
  "GQVb9JkQGzQfkXZAbMS66p7dUs7BKbJRD5soSX8m66MW",
  "3jShf4bRzuXPsHtkAAwwvAPCt4H4sEcncKPjo1jZGdWg",
  "F2378NNuCQMng3kDU4exgDoZ6LCSfHS2o2pRH2jXYWjE",
  "82yeCQBs34DJDfj3ybwrbfUDmpdHQpxMNvoRdnhRmw7E"
].map((address) => new PublicKey(address));
let nextTipIndex = payer.publicKey.toBytes()[0] % tipAccounts.length;
const base = "http://" + region + ".slotbolt.trade:1234";
const query = new URLSearchParams({ api_key: key });

async function ping() {
  const response = await fetch(base + "/ping?" + query);
  if (!response.ok) throw new Error("Ping failed: HTTP " + response.status);
}
setInterval(() => { ping().catch(console.error); }, 30_000);

const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
for await (const line of lines) {
  if (!line.trim()) continue;
  const { recipient, lamports, recentBlockhash } = JSON.parse(line);
  if (!Number.isSafeInteger(lamports) || lamports <= 0) throw new Error("Invalid lamports");
  // Select one Tip Account for this input line; submit one transaction below.
  const tipAccount = tipAccounts[nextTipIndex];
  nextTipIndex = (nextTipIndex + 1) % tipAccounts.length;
  const message = new TransactionMessage({
    payerKey: payer.publicKey,
    recentBlockhash,
    instructions: [
      ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
      ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 60_000_000 }),
      SystemProgram.transfer({ fromPubkey: payer.publicKey, toPubkey: new PublicKey(recipient), lamports }),
      SystemProgram.transfer({ fromPubkey: payer.publicKey, toPubkey: tipAccount, lamports: 110_000_000 })
    ]
  }).compileToV0Message();
  const tx = new VersionedTransaction(message);
  tx.sign([payer]);
  const signedTx = Buffer.from(tx.serialize()).toString("base64");
  const response = await fetch(base + "/submit?" + query, {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0", id: 1, method: "sendTransaction",
      params: [signedTx, { encoding: "base64" }]
    })
  });
  const reply = await response.json().catch(() => null);
  if (reply?.error) throw new Error("SlotBolt JSON-RPC " + reply.error.code + ": " + reply.error.message);
  if (!response.ok) throw new Error("Submit failed: HTTP " + response.status);
  if (!reply) throw new Error("Submit returned no JSON-RPC body");
  console.log("Accepted by SlotBolt API:", reply.result);
}

Cargo.toml

[dependencies]
tokio = { version = "1.45.1", features = ["macros", "rt-multi-thread", "time", "io-std", "io-util"] }
reqwest = { version = "0.11.27", default-features = false, features = ["json", "rustls-tls"] }
serde_json = "1.0.140"
solana-sdk = "=2.2.1"
base64 = "0.22.1"
bincode = "1.3.3"

src/main.rs

use std::{env, str::FromStr, time::Duration};
use base64::{engine::general_purpose::STANDARD, Engine as _};
use serde_json::{json, Value};
use solana_sdk::{
    compute_budget::ComputeBudgetInstruction,
    hash::Hash,
    message::{v0, VersionedMessage},
    pubkey::Pubkey,
    signature::{read_keypair_file, Signer},
    system_instruction,
    transaction::VersionedTransaction,
};
use tokio::io::{self, AsyncBufReadExt, BufReader};

const TIP_ACCOUNTS: [&str; 20] = [
    "5kw4XdUjk7k9rPH8cTNFqgtpnwhWekVAXEKB2medmoq",
    "4tgpD2mKc6ojaGdJhxvjvo4fRDRJCQUimcvt9SX842Qt",
    "GN1BZUWcoGLStou1M9RD98c9b7JdoXZoTTZR9a6WkdaT",
    "3uANArQUJDsaBqFVNCP9C5HZV9YSU7b2upRH3d9pNHtM",
    "4A68gTsn6pExwmEAn9CVdJxFvVxLdYertG83SR2BYmtD",
    "CinsfRDHjvyfKJjwp8R9TJRCkoP6SGM2eHKJiWyehpP7",
    "EKb54KnRaXxQaaDLqDSvGvRL76whuf5CKtum1qSCSMnk",
    "AsMLHiUCZoojNF1b6sDRPKrbc6RkeDHPZyGPa5hK5ToY",
    "GnPxqoD63TXYrTsXZNsxyt2iZaperxTUz344KUHgBJLJ",
    "HiKfsAEYBL21cZSmhLjV5VEcgjFH5yzGGXXDQcVTztKS",
    "4TTTLWoJNMAHWyFVUDfXasZLfXTt54h4zVpE6wYXa2fH",
    "J8PJG3HQfwxw9yG5w7DzuwnfadAfaikyGyDSLkt2cpGi",
    "8qKJzmNeckLTEHnNdmN198quQ1omU2FshgSLYQeB3oww",
    "7yQ4me6yFn6LDX9jAZ4Sy3jdg6m15uJM15tB1EBC3Jbz",
    "9qc8oYmvSyxaruvnqReY8WXk1ua9r4gRvqKQpEGEVaWc",
    "HPbzYkQ8pkC9UyBEWMtLopQGLxUzpzboXRbrqn9Ue9kg",
    "GQVb9JkQGzQfkXZAbMS66p7dUs7BKbJRD5soSX8m66MW",
    "3jShf4bRzuXPsHtkAAwwvAPCt4H4sEcncKPjo1jZGdWg",
    "F2378NNuCQMng3kDU4exgDoZ6LCSfHS2o2pRH2jXYWjE",
    "82yeCQBs34DJDfj3ybwrbfUDmpdHQpxMNvoRdnhRmw7E"
];

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let region = env::var("SLOTBOLT_REGION")?;
    if !matches!(region.as_str(), "fra" | "ams" | "ny" | "tokyo") {
        return Err("invalid region".into());
    }
    let key = env::var("SLOTBOLT_API_KEY")?;
    let payer = read_keypair_file(env::var("SLOTBOLT_KEYPAIR_FILE")?)?;
    let mut next_tip_index = payer.pubkey().to_bytes()[0] as usize % TIP_ACCOUNTS.len();
    let base = format!("http://{region}.slotbolt.trade:1234");
    let client = reqwest::Client::builder().timeout(Duration::from_secs(5)).build()?;
    let ping_client = client.clone();
    let ping_key = key.clone();
    let ping_url = format!("{base}/ping");
    tokio::spawn(async move {
        let mut cadence = tokio::time::interval(Duration::from_secs(30));
        cadence.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
        loop {
            cadence.tick().await;
            match ping_client.get(&ping_url).query(&[("api_key", &ping_key)]).send().await {
                Ok(response) if response.status().is_success() => {}
                Ok(response) => eprintln!("Ping failed: HTTP {}", response.status()),
                Err(error) => eprintln!("Ping failed: {error}"),
            }
        }
    });

    let mut lines = BufReader::new(io::stdin()).lines();
    while let Some(line) = lines.next_line().await? {
        if line.trim().is_empty() { continue; }
        let trade: Value = serde_json::from_str(&line)?;
        let recipient = Pubkey::from_str(trade["recipient"].as_str().ok_or("missing recipient")?)?;
        let lamports = trade["lamports"].as_u64().filter(|value| *value > 0).ok_or("invalid lamports")?;
        let blockhash = Hash::from_str(trade["recentBlockhash"].as_str().ok_or("missing recentBlockhash")?)?;
        // Select one Tip Account for this input line; submit one transaction below.
        let tip = Pubkey::from_str(TIP_ACCOUNTS[next_tip_index])?;
        next_tip_index = (next_tip_index + 1) % TIP_ACCOUNTS.len();
        let instructions = vec![
            ComputeBudgetInstruction::set_compute_unit_limit(200_000),
            ComputeBudgetInstruction::set_compute_unit_price(60_000_000),
            system_instruction::transfer(&payer.pubkey(), &recipient, lamports),
            system_instruction::transfer(&payer.pubkey(), &tip, 110_000_000),
        ];
        let message = v0::Message::try_compile(&payer.pubkey(), &instructions, &[], blockhash)?;
        let tx = VersionedTransaction::try_new(VersionedMessage::V0(message), &[&payer])?;
        let signed_tx = STANDARD.encode(bincode::serialize(&tx)?);
        let response = client.post(format!("{base}/submit"))
            .query(&[("api_key", &key)])
            .json(&json!({
                "jsonrpc": "2.0", "id": 1, "method": "sendTransaction",
                "params": [signed_tx, { "encoding": "base64" }]
            }))
            .send().await?;
        let status = response.status();
        let reply: Value = response.json().await?;
        if let Some(error) = reply.get("error") {
            return Err(format!("SlotBolt JSON-RPC error: {error}").into());
        }
        if !status.is_success() { return Err(format!("Submit failed: HTTP {status}").into()); }
        println!("Accepted by SlotBolt API: {}", reply["result"]);
    }
    Ok(())
}