ethers-flashbots

The BroadcasterMiddleware is designed to send the same bundle to multiple relay URLs simultaneously. This is useful for increasing the chances of your bundle being picked up by different builders.

Important: Like FlashbotsMiddleware, this does NOT sign transactions. You must use a signer middleware first.

When using Middleware::send_transaction, it defaults to targeting the next block and does not perform simulation.

use ethers::prelude::*;
use std::convert::TryFrom;
use ethers_flashbots::BroadcasterMiddleware;
use url::Url;

// ... setup provider, signer, and wallet ...

let mut client = SignerMiddleware::new(
    BroadcasterMiddleware::new(
        provider,
        vec![Url::parse("https://rpc.titanbuilder.xyz")?, Url::parse("https://relay.flashbots.net")?],
        Url::parse("https://relay.flashbots.net")?, // simulation relay
        signer
    ),
    wallet
);

let tx = TransactionRequest::pay("vitalik.eth", 100);
let pending_tx = client.send_transaction(tx, None).await?;

The FlashbotsMiddleware allows you to send custom bundles or standard transactions to a single Flashbots relay.

Important: This middleware does NOT sign your transactions. You must wrap the FlashbotsMiddleware in a SignerMiddleware (or similar) to ensure transactions are signed before they reach the Flashbots layer. The relay_signer provided during initialization is used specifically for signing requests to the Flashbots relay (your searcher identity).

When using Middleware::send_transaction, the middleware automatically constructs a bundle with these defaults:

• The transaction is assumed not to revert.
• No minimum or maximum timestamp is set.
• The target block is the next block (latest_block + 1).
• No bundle simulation is performed before sending.

use ethers::prelude::*;
use std::convert::TryFrom;
use ethers_flashbots::FlashbotsMiddleware;
use url::Url;

// ... setup provider, signer (searcher identity), and wallet (transaction signer) ...

// Note: The order is important! The signer middleware must sign transactions 
// BEFORE they are sent to the Flashbots middleware.
let mut client = SignerMiddleware::new(
    FlashbotsMiddleware::new(
        provider,
        Url::parse("https://relay.flashbots.net")?,
        signer
    ),
    wallet
);

// This transaction will now be sent as a Flashbots bundle!
let tx = TransactionRequest::pay("vitalik.eth", 100);
let pending_tx = client.send_transaction(tx, None).await?;

You can send transactions as Flashbots bundles by wrapping an ethers Provider with FlashbotsMiddleware and then wrapping that in a SignerMiddleware.

To do this, you need:

1. A Provider (e.g., Provider<Http>) connected to a network.
2. A bundle_signer (a LocalWallet) used to sign the bundle itself.
3. A wallet (a LocalWallet) used to sign the actual transactions within the bundle.
4. The Flashbots relay URL (e.g., https://relay.flashbots.net).

Once configured, you can use client.send_transaction(tx, None) to submit the transaction as part of a bundle.

use eyre::Result;
use ethers::core::rand::thread_rng;
use ethers::prelude::*;
use ethers_flashbots::*;
use std::convert::TryFrom;
use url::Url;

#[tokio::main]
async fn main() -> Result<()> {
    // Connect to the network
    let provider = Provider::<Http>::try_from("https://mainnet.eth.aragon.network")?;

    // This is your searcher identity
    let bundle_signer = LocalWallet::new(&mut thread_rng());
    // This signs transactions
    let wallet = LocalWallet::new(&mut thread_rng());

    // Add signer and Flashbots middleware
    let client = SignerMiddleware::new(
        FlashbotsMiddleware::new(
            provider,
            Url::parse("https://relay.flashbots.net")?,
            bundle_signer,
        ),
        wallet,
    );

    // Pay Vitalik using a Flashbots bundle!
    let tx = TransactionRequest::pay("vitalik.eth", 100);
    let pending_tx = client.send_transaction(tx, None).await?;

    // Get the receipt
    let receipt = pending_tx
        .await?
        .ok_or_else(|| eyre::format_err!("tx not included"))?;
    let tx = client.get_transaction(receipt.transaction_hash).await?;

    println!("Sent transaction: $\\n", serde_json::to_string(&tx)?);
    println!("Receipt: $\\n", serde_json::to_string(&receipt)?);

    Ok(())
}