Legal
Company
Privacy Policy
Terms and Conditions
Metrics Hub
About
Career
Recources
Your Place to Share and Learn
Join our Discord community, where we share updates, exchange ideas, and support each other’s growth.
Join Us
Our Partners and Supporters
Driving network growth and decentralization with robust, high-performance infrastructure.
Solana Foundation
Boosting MEV rewards and network efficiency with advanced validator strategies.
Jito
Empowering next-gen DeFi protocols through reliable validator and RPC solutions.
Kolibrio



The LumLabs Edge
Assets Staked with LumLabs
$40M+
By Network Performance
Top 10%
Commission, Always
0%
MEV Back to Stakers
100%
Get Started
TxnEngine
SWQoS-powered Solana sending that lands fast—even under congestion.
connection pooling for high throughput.
Parallelized pipelines
included to compete for block space.
Jito auction path
connections for prioritized bandwidth.
SWQoS staked
Validator Success Toolkit
Go to Stake Advisor
Solana Pool Adviser
See how much stake you can win - and the effort it will take.
Stake Potential
estimate stake you can attract across pools.
Effort Score
tasks, proof, and time required.
Smart Targeting
prioritize pools with the best stake-per-effort.
Go to resources
Build & Learn Hub
Step-by-step guides and resources to launch and scale your validator flow.
collaborate, share, and grow together.
Community Support
learn directly from top validators.
Best Practices
from setup to scaling your node.
Step-by-Step Guides
Solana’s Learning Hub Empowering Builders
Run Validators nodes easier, learn how to attract stake, and use landing infrastructure for your very first Solana project.
Join Us
Metrics Hub
Recources
Career
About
Stake with Us
Step Into the Lab
Hop into our Discord to get updates, share ideas, and grow with fellow builders.

Join Us
Partners & Supporters
Driving network growth and decentralization with secure, high-performance infrastructure and tools.
Solana Foundation
MEV-enabled infrastructure that improves execution and increases validator rewards across Solana.
Jito
Orderflow RPC API to block toxic MEV, monetize transactions, and optimize on-chain execution.
Kolibrio



Inside the LumLabs Validator
Assets Staked with LumLabs
$40M+
Network Performance
Top 10%
Commission
Policy
0%
MEV Back to Stakers
100%
Enterprise-Grade
Validators for Your Business
White-Label Validator Solutions.
Who It’s For
Exchanges with native staking.
Wallets with built-in staking features.
DeFi protocols that leverage stake weight.
Growing Solana startups.
Features
Enterprise-grade infrastructure.
External stake acquisition support.
Custom commission models & terms.
Fast auto-failover and seamless updates.
24/7 validator health monitoring.
Dedicated support and guidance.
Get Your Validator
Enterprise-Grade
Validators for Your Business
White-Label Validator Solutions.
Who It’s For
Exchanges with native staking.
Wallets with built-in staking features.
DeFi protocols that leverage stake weight.
Growing Solana startups.
Features
Enterprise-grade infrastructure.
External stake acquisition support.
Custom commission models & terms.
Fast auto-failover and seamless updates.
24/7 validator health monitoring.
Dedicated support and guidance.
Get Your Validator
TxEngine
SWQoS-powered Solana transactions that land fast, even under congestion.
connection pooling for high throughput.
Parallelized pipelines
routes transactions to compete for block space.
Jito auction path
prioritized bandwidth for your traffic end to end.
SWQoS-staked
Validator Lab Kit
Go to landing TXN
Solana Pool Advisor
Estimate how much stake you can win and the effort required.
Stake Potential
projected stake you can attract across pools.
Effort Score
required tasks, proof, and time commitment per pool.
Smart Targeting
prioritize pools with the best stake-per-effort.
Go To Pools.map()
Go to resources
Build & Learn Hub
Step-by-step guides and resources to launch and scale your validator.
collaborate, share, and grow together in our Discord.
Community Support
proven methods from top validators on Solana.
Best Practices
clear tutorials from first setup to confidently scaling your validator.
Step-by-Step Guides
Solana’s Learning Hub Empowering Validators
Operate your node, attract stake, and launch with proven infrastructure for Solana builders.
Join Discord

Metrics Hub
Resources
Careers
About
Stake with Us
Legal
Privacy Policy
Terms and Conditions
Products & Tools
Pools.map()
TxEngine
Metrics Hub
White-Label Validators
Company
About
Careers
Resources
© 2025 LumLabs
Stake with Us
Metrics Hub
Resources
Careers
About
TxEngine — Free Priority Sending for Solana
Stake-weighted transaction delivery with optional Jito routing. Point high-priority transactions to TxEngine and keep confirmations steady during congestion.
Get API Key in Telegram
Instant. Free. Up to 1 tx/sec.
Priority sending with SWQoS + optional Jito routing. No tips to LumLabs required.

What TxEngine Does?
Use your own or a public RPC to fetch a recent blockhash and compute priority fees. If you want quota from
LumLabs RPC, email: info@lumlabs.io.
Free tier: 1 transaction per second per token during early access.
Simple sender flow: build & sign locally, then POST the base64 tx to TxEngine.
Optional Jito routing: add jito=1 to your request; include your own Jito tips in the transaction.
Priority pathing (SWQoS): stake-weighted fast lane that bypasses public RPC queues.
Key Benefits
Zero cost at 1 TPS — perfect for bots, infra keep-alives, and critical paths.
Deterministic performance — priority enforcement keeps throughput steady even at peak.
Global gateways — geo-distributed ingress for low latency.
Fair-use limits — sensible throttling to protect the lane.
Jito-ready — opt-in via jito=1; you supply tips directly in the transaction.
How It Works
Basic counters and status via the Telegram bot — coming soon. (Higher-throughput tiers may arrive later.)
Observe & iterate
TxEngine applies stake-weighted prioritization and submits through our protected path for predictable confirms.
Fast-lane execution
POST the base64 transaction to the Sender endpoint with your token. Add jito=1 to enable Jito routing; omit to use the default path or use just SWQoS.
Send to TxEngine
Use your own or public RPC to fetch a recent blockhash, set a priority fee, and (optionally) add a Jito tip instruction. Sign and serialize to base64. Or contact us for LumLabs RPC quota: info@lumlabs.io.
Build & sign locally
01
02
03
04

Integration Notes
No default RPC: we don’t calculate priority fees or recent blockhash. Use your own or public RPC, or email: info@lumlabs.io for LumLabs RPC quota.
Jito: append &jito=1 to the Sender URL. You must include your own Jito tip in the transaction; TxEngine doesn’t add or redirect tips, and no tips go to any LumLabs wallet.
Body: { "transactions": ["BASE64_TX", "..."] } (array of base64-serialized txs).
Auth & Endpoint: get both in the Telegram bot.
Query auth param: token=
JavaScript (Node, @solana/web3.js)
import {
Connection,
Keypair,
PublicKey,
SystemProgram,
Transaction,
ComputeBudgetProgram,
} from "@solana/web3.js";
import bs58 from "bs58";
import fetch from "node-fetch";
// 1) Build & sign locally using YOUR or PUBLIC RPC
const RPC_URL = process.env.SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
const payer = Keypair.fromSecretKey(bs58.decode(process.env.SECRET_KEY)); // base58-encoded 64-byte secret key
const connection = new Connection(RPC_URL, "confirmed");
const recipient = new PublicKey("ReplaceWithRecipientPubkey");
// priority fee (micro-lamports per compute unit). Tune to network conditions.
const MICRO_LAMPORTS_PER_CU = 1_000;
const { blockhash } = await connection.getLatestBlockhash("finalized");
const tx = new Transaction({ recentBlockhash: blockhash, feePayer: payer.publicKey });
// Add compute budget for priority fees (optional)
tx.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: MICRO_LAMPORTS_PER_CU }));
// Your core instruction(s)
tx.add(SystemProgram.transfer({
fromPubkey: payer.publicKey,
toPubkey: recipient,
lamports: 1_000, // example
}));
// OPTIONAL: add your own Jito tip instruction (transfer to the Jito tip account) before signing
// tx.add(SystemProgram.transfer({ fromPubkey: payer.publicKey, toPubkey: JITO_TIP_ACCOUNT, lamports: YOUR_TIP }));
tx.sign(payer);
const base64Tx = tx.serialize().toString("base64");
// 2) Send via TxEngine Sender
const host = process.env.TXENGINE_HOST; // from Telegram bot
const token = process.env.TXENGINE_TOKEN; // from Telegram bot
const jitoQS = process.env.JITO ==="1" ? "&jito=1" : "";
const url = `https://${host}/v0/transactions?token=${token}${jitoQS}`;
const res = await fetch(url, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ transactions: [base64Tx] }),
});
if (!res.ok) throw new Error(await res.text());
console.log("TxEngine response:", await res.json());
import os, base64, requests
from solana.rpc.api import Client
from solana.transaction import Transaction
from solana.system_program import TransferParams, transfer
from solana.keypair import Keypair
from solders.pubkey import Pubkey
from solders.compute_budget import set_compute_unit_price
from base58 import b58decode
# 1) Build & sign with YOUR or PUBLIC RPC
rpc_url = os.getenv("SOLANA_RPC_URL", "https://api.mainnet-beta.solana.com")
rpc = Client(rpc_url)
# Load keypair (base58-encoded 64-byte secret key recommended)
secret_b58 = os.environ["SECRET_KEY"]
payer = Keypair.from_secret_key(b58decode(secret_b58))
recent = rpc.get_latest_blockhash().value.blockhash
tx = Transaction(recent_blockhash=recent, fee_payer=payer.public_key)
# priority fee (optional)
tx.add(set_compute_unit_price(1000)) # micro-lamports per CU
# your instruction(s)
tx.add(transfer(TransferParams(
from_pubkey=payer.public_key,
to_pubkey=Pubkey.from_string("ReplaceWithRecipientPubkey"),
lamports=1000
)))
# OPTIONAL: add your own Jito tip instruction here
tx.sign(payer)
b64 = base64.b64encode(bytes(tx.serialize())).decode("utf-8")
# 2) Send to TxEngine
host = os.environ["TXENGINE_HOST"] # from Telegram bot
token = os.environ["TXENGINE_TOKEN"] # from Telegram bot
jito = os.getenv("JITO", "0") # "1" to enable
url = f"https://{host}/v0/transactions?token={token}&jito={jito}"
resp = requests.post(url, json={"transactions":[b64]}, timeout=30)
resp.raise_for_status()
print(resp.json())
export async function sendViaTxEngine(
base64Tx: string,
{ token, host, jito = false }: { token: string; host: string; jito?: boolean }
) {
// host & token are provided by the Telegram bot
const url = `https://${host}/v0/transactions?token=${encodeURIComponent(token)}${jito ? "&jito=1" : ""}`;
const res = await fetch(url, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ transactions: [base64Tx] }),
});
if (!res.ok) throw new Error(await res.text());
return res.json();
}
TXENGINE_HOST="your.txengine.host" # from Telegram bot
TOKEN="YOUR_TXENGINE_TOKEN" # from Telegram bot
JITO="0" # set to 1 to enable Jito routing
curl -sS -X POST "https://${TXENGINE_HOST}/v0/transactions?token=${TOKEN}&jito=${JITO}" -H 'Content-Type: application/json' -d '{"transactions":["BASE64_SERIALIZED_TX_HERE"]}'
Python (solana-py + solders)
TypeScript (browser) — minimal POST
cURL — send a signed base64 transaction
Integration Notes
Is TxEngine really free?
How do I enable Jito routing?
Do you calculate priority fees or blockhash for me?
Legal
Contact
Products & Tools
Company
© 2025 LumLabs
Privacy Policy
Terms and Conditions
Resources
Careers
About
Pools.map()
TxEngine
Metrics Hub
White-Label Validators
info@lumlabs.io