Run every lane at once.
Gallop turns multi-step Solana workflows into dependency graphs, reads the accounts each transaction locks, and hands every independent lane to its own rider. Nothing waits that does not have to.
Solana executes in parallel. Most bots still send one transaction at a time.
The runtime can process transactions side by side when they do not lock the same accounts. Scripts rarely take advantage of it: they await each confirmation in turn, pay everything from one wallet and bundle by hand.
One wallet, one queue
Six transactions, six round trips. Every transaction write-locks the same fee payer, so even unrelated steps cannot run together, and one failure stalls the rest of the queue.
Gallop
rider-1 swap ──► deposit bundle rider-2 buy-1 ─── buy-2 bundle · pool:sol-bonk rider-3 pay solo rider-4 stake solo
Gallop reads dependencies and account locks. Steps that must stay together are bundled; everything else gets its own rider and lands in the same window.
Graph. Lock. Simulate. Gallop.
You describe the steps and the accounts they touch. Gallop works out which steps can move at the same time and how each lane should land.
Graph
Declare each transaction as a unit, with the steps it depends on.
Lock
Gallop compares writable and read-only accounts and finds every lock conflict.
Simulate
Each unit is simulated to check errors, measure compute and size the CU limit.
Gallop
Independent lanes get their own rider. Linked steps travel as one Jito-sized bundle.
Parallelism is decided by accounts, not by order.
Two transactions can run side by side only if neither writes an account the other touches. Hover a unit to see who it collides with. The matrix is computed by the same engine the Playground uses.
The fee payer is write-locked by every transaction it pays for. Pay six independent transactions from one wallet and they serialize on that single account. That is why Gallop assigns one rider per lane. Riders and fee payers →
Every unit, from simulated to finalized.
Units move through Solana's commitment levels and every transition is emitted as an event. A bundle is all-or-nothing: fail one unit and watch its bundle drop while the other lanes carry on.
Pay for the compute you request. Not a lamport more.
The priority fee is charged on the compute unit limit a transaction asks for, not on what it uses. Gallop sets each limit from simulation plus a margin, prices it, and adds a tip only where a lane travels as a bundle.
- Base fee: 5,000 lamports per signature
- Priority fee: CU limit × price in micro-lamports ÷ 1,000,000
- Up to 5 transactions per Jito bundle, landed in order or not at all
- Transactions above 1,232 bytes are flagged before they are signed
Know before you sign.
Gallop simulates every unit against the cluster before anything is signed, decodes program errors and logs, and uses the measured compute to size each transaction.
- Catch instruction errors with the program logs that explain them
- Measure compute per unit and set limits from real numbers
- Flag oversized transactions and suggest address lookup tables
- Detect lock conflicts and dependency cycles before sending
import { Gallop } from "@gallop/sdk";
const gallop = new Gallop({ cluster: "mainnet-beta", rpc: RPC_URL });
const graph = gallop.graph({ name: "desk-run" });
graph.add("swap-usdc", swapIx, { writable: [opsSol, opsUsdc, pool] });
graph.add("deposit-usdc", depositIx, { writable: [opsUsdc, vault] });
// deposit-usdc must land after swap-usdc
graph.dependsOn("deposit-usdc", "swap-usdc");
const plan = await graph.plan({ riders: "per-lane" });
console.log(plan.lanes); // [{ id: "A", strategy: "BUNDLE", ... }]Describe the work. Gallop finds the lanes.
Add units with their instructions and the accounts they lock, declare what depends on what, and ask for a plan. Lanes, riders, bundles and compute limits come back as plain data you can inspect before anything is signed.
Start from a workflow you already run.
Each template is a predefined graph with its accounts. Open one in the Playground to see how its locks shape the lanes.
Parallel Swaps
Four swaps in four pools from four wallets: four lanes, one landing window.
rider-1 ── SOL → USDC rider-2 ── SOL → JUP rider-3 ── SOL → BONK rider-4 ── SOL → WIFOpen in Playground →
Launch Bundle
Create the token, then four wallets buy in the same block. Exactly one bundle.
create-mint ├─► buy-w1 ├─► buy-w2 ├─► buy-w3 └─► buy-w4 5/5 txsOpen in Playground →
Multi-wallet Buy
Six wallets, one curve. The curve account is written by all of them, so they share a lane.
curve:token (writable) ├── w1 … w5 bundle 1 └── w6 bundle 2Open in Playground →
Airdrop
Eight transfers from one token account. Every one writes the source, so they chain.
treasury:ata ├── 5 transfers bundle 1 └── 3 transfers bundle 2Open in Playground →
Split Airdrop
Same eight transfers from four source accounts. The chain breaks into four lanes.
src-1 ── 2 transfers src-2 ── 2 transfers src-3 ── 2 transfers src-4 ── 2 transfersOpen in Playground →
Multi-hop
A strict chain: each hop spends what the previous one produced.
SOL ↓ USDC ↓ JUP ── stakeOpen in Playground →
Plan offchain. Land onchain.
Graph analysis does not need a program. Planning offchain is cheaper, faster to change and easier to inspect. The cluster does what it is good at: executing, ordering and finalizing.
$GALLOP
$GALLOP is the community token of the Gallop project on Solana.
It is not required to use the software. The engine, SDK and CLI work without it, and the token has no function inside the Gallop codebase today. Nothing here is financial advice.
TBA
- Ticker
- $GALLOP
- Network
- Solana
- Pair
- TBA
