Skip to main content

Relayer/TPU Quickstart

⚡ Integrate with AI
I'm building a Blockspace Relayer/TPU integration — a gRPC Block Engine that receives pending Solana transactions from the Blockspace relayer.

Product: Blockspace Relayer/TPU — push service for Solana MEV searchers. Blockspace's relayer pushes pending TPU transactions from Everstake validators to a gRPC Block Engine endpoint I operate. Wire shape mirrors Jito Relayer ↔ Block Engine.
Edge: ~250ms TPU window per leader slot. Pay-on-profit.
Auth: Token + signing-pubkey allowlist. Application-reviewed — contact support-blockspace@everstake.one.
Blockspace relayer key (Solana identity our relayer uses for auth): EsSaJ9ZZd59QAQYF38nnXGEDFpJSdRVhzpoN1rdNvJRG
Reference implementations:
  - Minimal Block Engine: https://github.com/jito-labs/block_engine_simple
  - Jito Relayer: https://github.com/jito-foundation/jito-relayer
Full reference: https://docs.blockspace.everstake.one/llms-full.txt

My stack: Rust (preferred) or TypeScript.
What I need:
1. A minimal gRPC server implementing the Block Engine interface (using block_engine_simple as the template).
2. Auth service that accepts only the Blockspace relayer key (EsSaJ9ZZd59QAQYF38nnXGEDFpJSdRVhzpoN1rdNvJRG).
3. Handler for the PendingTransaction stream that prints transaction signatures as they arrive.

Generate the minimal working skeleton. Include: dependency list (Cargo.toml or package.json), proto imports, server startup, auth check, and the stream handler. Note which fields in PendingTransaction are most useful for arb signal extraction.
Open in Claude →Open in ChatGPT →Open in Perplexity →

Relayer/TPU is a push service: you operate a gRPC Block Engine-style endpoint, and our validator pushes transactions to it. The architecture mirrors Jito Relayer ↔ Block Engine.

1. Build (or fork) a Block Engine​

There's no turn-key public software for this. You build a gRPC server that accepts a stream of transactions from our relayer.

Reference implementation: jito-labs/block_engine_simple — the minimal example showing the wire shape your software must implement.

At a minimum, your endpoint:

  • Accepts inbound gRPC connections from the Blockspace relayer.
  • Authenticates the connection (the auth endpoint can be the same gRPC service or a separate one).
  • Receives a stream of PendingTransaction messages and processes them.

2. Provide your endpoint(s)​

In the dashboard → Relayer/TPU → Subscribe, give us:

  • Block Engine gRPC URL — where to send transactions.
  • Auth URL (optional) — separate endpoint if your auth service is split out.

Examples:

https://be.example.com/                       (combined: BE + auth)
https://be.example.com/    https://auth.be.example.com/    (split)
https://be.example.net/
https://203.0.113.3:10000
http://203.0.113.4:10001

Both HTTPS and HTTP (with explicit port) are accepted.

3. Allowlist the relayer key​

If your endpoint operates with an allowlist, allow the Blockspace relayer key:

EsSaJ9ZZd59QAQYF38nnXGEDFpJSdRVhzpoN1rdNvJRG

This is the Solana identity our relayer uses to authenticate against Block Engines. Configure your auth service to accept it as authorized.

4. Verify​

Once the connection is established, you should see PendingTransaction messages flowing into your Block Engine. If the stream is silent:

  • Confirm the relayer key is allowlisted.
  • Confirm the endpoint URL is reachable from our network.
  • Check the dashboard for connection status — there's usually an indicator if our relayer can't connect.

What to do with the transactions​

What you do with the inbound stream is your own application logic. Common patterns:

  • Arb signal extraction — scan transaction contents for opportunities.
  • Sandwich detection — match incoming txs to known liquidity pools.
  • Internal mempool aggregation — fan out to multiple downstream consumers.

Next​