
$GRT news
Every $GRT story, instantly, with how the price moved after each one.
Top stories
Latest
- Building social for the long haul means making hard calls, learning the hard way, and still showing up. @LC is coming to @monad with years of those lessons behind it. Growing, adapting, still shipping. Onward with social 🤝 Mask Network (mask.io)
- How BAM Schedules Transactions From the TPU to the leader, one 20 ms round at a time We get asked constantly: how exactly does BAM decide what goes into a block, and in what order? It’s not magic, but there is a lot of machinery under the hood. This post traces a transaction's exact path: how it hits a BAM Node, how we filter out the noise, how everything gets scored, how auction rounds freeze the state, and how our execution engine (Wavefront) rips through that ordering to build a block. If you just want the actionable alpha on how to land your transactions more reliably, skip straight to the TL;DR at the bottom. 1. The TPU Pipeline When a validator is hooked up to BAM, it gossips its BAM Node's TPU address. That means anything sent "direct to the leader"—whether from RPCs, wallets, or bots—hits the BAM Node first. If the validator disconnects or the BAM node goes unhealthy, it just reverts the gossip entry and takes its TPU back. The BAM Node runs the same QUIC-based TPU as Agave, enforcing the exact same stake-weighted quality of service (SWQoS): Stake belongs to the sender, not the leader. When you connect, the node checks the stake of the identity on your QUIC cert. More stake equals more connections and concurrent streams. Unstaked senders still get a seat at the table, but their share is fixed and smaller. Under heavy load, unstaked traffic gets throttled to its floor first, then we hold staked peers to their proportional quotas. The forward port is strictly for the staked. It’s just there so staked validators can forward traffic they caught while not leading. One recommendation if you actually care about your TPU landing rate, is to route through a staked connection using a service like Jito’s FullSend (or an RPC with solid SWQoS). Don’t just fire from an unstaked client and hope for the best. Once a packet gets in the door, it hits a ruthless "cheap-first" pipeline before the scheduler even looks at it: Deduplication: A single thread merges TPU and Block Engine traffic, nuking exact duplicates using a bloom filter (which resets on a short timer). Cheap Rejects: Ed25519 signature verification is painfully expensive. If a packet's signature was already processed, or its blockhash or nonce is already dead, BAM drops it before sigverify to save the CPU. Sigverify: The survivors hit a pool of worker threads pinned to dedicated cores. Buffer & Score: Finally, the clean transactions are sanitized, lookup tables resolved, locks and compute limits validated, scored (more on this in Section 3), and tossed into a bounded priority queue. Every step is connected by bounded channels. If a stage falls behind, it drops packets instead of blocking. A spam burst at step 1 won't choke out step 4. 2. Bundles: The First-Pass Filter Bundles hit a BAM Node either from the Block Engine or straight over Direct Bundle Ingest (DBI). If you're routing through the Block Engine, you can target specific regions (e.g., hitting LON or DUB when targeting AMS or FRA leaders). Keep in mind, any bundle sent through Jito needs a minimum 1,000 lamport tip. To see who's running what, check the BAM validator API. Before a bundle can compete, it has to pass sigverify and the bundle filter. This filter is a restrictive first gate, by design. BAM sees a ton of hopeless traffic: bundles for slots where no BAM leader is up, stale bundles, guaranteed reverts. The goal is to trash the garbage as cheaply as possible so BAM spends real compute on the valuable ones. Checks run from cheapest to heaviest: Is a BAM leader actually up? If not, bundles get dropped immediately. BAM only buffers bundles right before a BAM leader slot. Shape check: Bundles must contain 1 to 5 transactions. Per-tx validation: BAM sanitizes, checks for known-bad blockhashes, resolves LUTs, validates locks, and ensures you aren't touching validator accounts (a strict no-go). It stops at the first failure. Front-running protection: The node strictly enforces the jitodontfront rule for direct arrivals (the Block Engine already handles this for routed bundles). Bank checks: BAM looks at transaction age, status, and whether the fee payer for the first txn actually has the funds. Simulation: The survivors get simulated against current state, top priority first. If any transaction in a bundle fails here, the whole bundle is dropped. The auction only looks at bundles that will execute cleanly. If a bundle survives all this, it joins the bundle priority queue to be scored. 3. Sorting: The Universal Score Transactions and bundles all compete on one critical metric: validator revenue per unit of estimated cost. priority = reward × 1,000,000 / (cost + 1) (The 1,000,000 multiplier just stops integer division from rounding small scores to zero, and the +1 prevents division by zero. Simple math). The Numerator (Reward) An important note on tips: BAM ranks everything before execution. BAM can only count tips if it can read them directly from the transaction. If you try to tip via CPI or TransferWithSeed, the leader still gets the money if you land, but it won't help you win the auction. Standalone transactions compete solely on priority fees; bundles compete on fees plus explicit tips. The Denominator (Estimated Cost) Cost is a static estimate generated the moment the transaction arrives, not a simulation result. It has five parts: Execution usually has the highest weight. The key rule is simple: every unit of compute you request but don't use actively tanks your score. A Quick Example Imagine a 1-sig transaction with 2 writable accounts and ~100 bytes of data. It pays a 5,000-lamport base fee (2,500 goes to the validator) and a 2,000-lamport priority fee. Total reward: 4,500 lamports. Same transaction, same money spent, but dialing in the limits boosts the score by 3.5x. Now wrap two of those optimized transactions into a bundle and add a 50,000-lamport tip. The reward jumps to 59,000, cost is 122,818, and your score rockets to 480,381. That tip is what lets bundles get ahead of standard transactions. How BAM Picks: get_next_pop Transactions and bundles sit in separate min-max heaps. When the auction is filling a block, it just asks one question over and over: Does the top transaction score higher than the top bundle? If yes, take the txn. If no, take the bundle. Ties go to bundles. If one queue is empty, drain the other. Arrival time doesn't matter. Within a queue, equal scores have no strict order. The only exceptions are the round's clock transaction (which advances the Market Tick program) and Maker Priority Plugin updates, both of which are drained first. 4. Auction Rounds & Frozen Inside One BAM schedules in frequent batch auctions (FBA). It doesn't sequence transactions the millisecond they arrive, but instead groups them into short rounds and ranks the batch. If two transactions arrive 1ms apart in the same round, they're treated as simultaneous and sorted purely by score. So, for senders, it’s less important to try to be microseconds faster, they just need to be in the right round. Round Lengths Round length is derived directly from slot length (a tenth of the slot). Because of Solana’s SIMD-0525 slot-time reductions, BAM’s rounds have shrunk organically: (Note: The Block Engine’s own auction runs on a fixed 50ms tick, completely independent of this). Freezing the Competing Set Each round is a fast state machine. The phase dictates how BAM handles fresh arrivals: At the start, it pulls a capped batch of new arrivals into the priority queues. While the round is active, new arrivals are sidelined in a holding lane. The fill loop only pulls from the priority queues. The competing set is frozen. When the round ends, the holding lane flushes into the priority queues to compete in the next round alongside the losers from the previous one. Pacing the Slot Winning a round only matters if there’s block capacity left. BAM releases the block compute limit and the per-account write limit linearly across the slot, cutting off slightly early so it has time to actually reach the leader. The per-account limit is the real bottleneck for most searchers. If everyone is hammering the same oracle or liquidity pool, they’re all fighting for the same per-slot budget, and fees dictate who wins. If large bundles start dragging the committed block cost behind the linear schedule, the scheduler temporarily pauses bundles and fills with plain transactions until we catch back up. 5. Wavefront: From Ordered to Executed Ranking transactions and bundles is only one part of the equation. The scheduler has to execute the work speculatively to ensure it actually fits before committing to the leader. It has to do this in order, respect account conflicts, and move fast enough to keep a 20ms round fed. Here’s where Wavefront comes in. Since August 2026, this dataflow scheduler has been BAM’s sole execution engine. Why We Built It BAM’s old engine kept a priority graph of account locks on the auction thread. It would drain ready work to simulation workers, wait for results, commit them, and unblock the next items. The graph was fast, but the round trips increased latency. On mainnet, a 40-deep chain of trades on a single hot pool spent milliseconds just waiting in transit between the auction thread and the workers. How Wavefront Fixes It Think of Wavefront like a CPU's Tomasulo algorithm applied to Solana: The Graph: Built in priority order. Each item gets a node, with edges pointing to earlier conflicting items (write-after-write, write-after-read, read-after-write). The Ready Heap: Each node tracks its unfinished predecessors. When that hits zero, it drops into a priority-ordered ready heap. Worker Autonomy: This is where the magic happens. A worker grabs a batch of ready items, checks the budget, executes them against a speculative bank, and commits them. Then the worker decrements the predecessor counts of dependent items itself. Unblocking the next trade is a single atomic operation—no round trips required. Continuations: If finishing an item unblocks a higher-priority dependent, the worker just grabs it immediately, bypassing the heap entirely. A long ladder of trades on a single pool now rips back-to-back on a single core. The result? Zero lock tables, zero deferred work, and parallel execution for unrelated accounts. Wavefront has been one of BAM’s most important scheduler upgrades, and responsible for its increase in performance across all relevant block packing metrics 6. Making It Fast A few of the heavy-lifting optimizations powering the current scheduler: Cheap work first: Known-bad txs die before sigverify. DBI credentials get checked before request bodies are read. Bundles are filtered before simulation. Zero-copy: Transactions are parsed in place as views and passed by handle. Hot-path allocations dropped by over 50%. Worker-owned cascades: One dependency hop in Wavefront is just an atomic decrement and a heap push. In microbenchmarks, that hop costs ~60 nanoseconds. Disjoint batching: Up to eight non-conflicting items share an execution call to amortize SVM fixed costs. (Bundles always run solo). Spin, then park: Idle workers spin with exponential backoff before sleeping, cutting wake-up latency in half. Cache-conscious: Graph nodes live inline in an arena, aligned to cache lines. Shrinking work items from 2.8 KB to 630 bytes made graph filling ~40% faster. Lock-free reads: The speculative bank reads block-cost totals from atomics, dropping snapshot times from 700ns to 70ns. Background reaping: Dropping a slot's speculative state happens on a background thread now, saving tens of milliseconds. Today, Wavefront workers spend 80–90% of their time actually executing transactions inside the SVM. The scheduling overhead is essentially gone. What This Means For BAM Senders (The TL;DR) Right-size your compute. Set SetComputeUnitLimit accurately, and dial back your loaded-account-data limit. Over-requesting directly penalizes your priority score. Tip properly. Use a top-level System Program transfer. CPI tips do not count toward BAM’s auction ranking. (And remember the 1,000 lamport minimum). Target your geography. If you're allowlisted for DBI, use it. Otherwise, route bundles through the optimal Block Engine region (e.g., LON/DUB for AMS/FRA leaders). Pay both a tip and a priority fee on bundles. Standard leaders rank on tips alone; BAM leaders count both. Play the round, not the microsecond. Being 200 µs faster inside a 20ms round does nothing. Missing the round costs everything. Stop spamming duplicates. We deduplicate across multiple layers. Spamming doesn't help you land. Beware the per-account limit. On hot accounts, the budget is capped. Optimize your compute footprint so more of your transactions fit, because throwing more money at it won't increase the cap. Stake your TPU connection. If you rely on the TPU path, send over staked connections. Unstaked traffic gets throttled the second load spikes. Jito
- 📺 Graph Office Hours #283 is up. Catch what you missed: What we covered: • REO Step 4 (from November 17): required qualifying Subgraphs = the greater of 10, or total stake ÷ 4M GRT, rounded up. Indexers above 40M GRT total stake: work out your number now. Later steps are projected through March 2027, with a holiday freeze from late December to early January • Studio to Network, Phase 2: Base is next. Indexers: plan Base infrastructure now and loop in the Foundation before you scale up. Developers get the announcement on November 17, and the publish deadline for Studio-only Base Subgraphs is December 1 • Chain updates: Elysium, Kinetiq's Layer 2 for Hyperliquid, is live on Substreams and Firehose from block 0 • Multi-Gateway Subgraph Service: the Foundation's gateway approach, three tiers of external gateway support, and next steps with two design partners • Adjacent ecosystems: Polygon Uburu, Base Denim, Polymarket Protocol V2, Stellar Protocol 30, BNB Chain Jenner on December 8, and new Firehose and Substreams releases • Graph Node and Substreams: PR queue cleanup on Graph Node, and SQL sink improvements merged in Substreams • Foundation initiatives: Liquid Staking, Indexing Payments (broader rollout likely early January), and Studio pricing Read more: REO dashboard: Studio to Network, Phase 1 recap: Full recap on the Forum: Questions or feedback? Drop them in the thread. Next call is Tuesday at 17:00 UTC on the Discord stage. The Graph
Loading the $GRT page…