Struct FlashbotsClient 

pub struct FlashbotsClient { /* private fields */ }

Main client for interacting with Flashbots relay

Implementations

impl FlashbotsClient

pub fn new(config: FlashbotsClientConfig) -> Self

Creates a new Flashbots client with custom configuration

pub fn new_mainnet() -> Self

Creates a new client configured for Mainnet

pub fn new_sepolia() -> Self

Creates a new client configured for Sepolia testnet

pub fn with_max_retries(self, max_retries: u32) -> Self

Sets maximum retry attempts for operations

pub fn with_timeout(self, timeout_seconds: u64) -> Self

Sets request timeout in seconds

pub async fn send_bundle( &self, bundle: Bundle, ) -> FlashbotsResult<SendBundleResponse>

Sends a bundle to Flashbots relay

Example

use flashbots_rs::{FlashbotsClient, Bundle};

let client = FlashbotsClient::new_mainnet();
let bundle = Bundle::default(); // Your bundle construction
let response = client.send_bundle(bundle).await?;
println!("Bundle sent with hash: {:?}", response.bundle_hash);

pub async fn send_bundle_with_retry( &self, bundle: Bundle, ) -> FlashbotsResult<SendBundleResponse>

Sends a bundle with automatic retry logic

pub async fn simulate_bundle( &self, simulation: SimulateBundleRequest, ) -> FlashbotsResult<SimulateBundleResponse>

Simulates bundle execution without submitting to the network

Example

use flashbots_rs::{FlashbotsClient, SimulateBundleRequest};

let client = FlashbotsClient::new_mainnet();
let simulation = SimulateBundleRequest::default(); // Your simulation parameters
let result = client.simulate_bundle(simulation).await?;
println!("Simulation success: {}, Gas used: {}", result.success, result.gas_used);

pub async fn simulate_bundle_with_retry( &self, simulation: SimulateBundleRequest, ) -> FlashbotsResult<SimulateBundleResponse>

Simulates bundle with automatic retry logic

pub async fn get_bundle_stats( &self, bundle_hash: H256, block_number: U64, ) -> FlashbotsResult<BundleStats>

Gets bundle statistics for a specific block

pub async fn get_bundle_receipt( &self, bundle_hash: H256, ) -> FlashbotsResult<BundleReceipt>

Gets bundle receipt by hash

pub async fn get_user_stats( &self, address: Address, block_number: U64, ) -> FlashbotsResult<UserStats>

Gets user statistics for a specific address and block

pub async fn get_health(&self) -> FlashbotsResult<bool>

Checks relay health status

Example

use flashbots_rs::FlashbotsClient;

let client = FlashbotsClient::new_mainnet();
let is_healthy = client.get_health().await?;
println!("Relay is healthy: {}", is_healthy);

pub async fn get_bundle_price( &self, block_number: U64, ) -> FlashbotsResult<BundlePriceResponse>

Gets bundle price for a specific block

pub async fn wait_for_bundle_inclusion( &self, bundle_hash: H256, timeout_blocks: u64, ) -> FlashbotsResult<Option<BundleReceipt>>

Waits for bundle to be included in a block

Example

use flashbots_rs::FlashbotsClient;
use ethers::types::H256;

let client = FlashbotsClient::new_mainnet();
let bundle_hash = H256::zero(); // Your actual bundle hash
let receipt = client.wait_for_bundle_inclusion(bundle_hash, 10).await?;
match receipt {
    Some(receipt) => println!("Bundle included: {:?}", receipt),
    None => println!("Bundle not included within timeout"),
}

pub async fn send_and_wait_for_bundle( &self, bundle: Bundle, timeout_blocks: u64, ) -> FlashbotsResult<Option<BundleReceipt>>

Sends bundle and waits for inclusion

Example

use flashbots_rs::{FlashbotsClient, Bundle};

let client = FlashbotsClient::new_mainnet();
let bundle = Bundle::default(); // Your bundle construction
let receipt = client.send_and_wait_for_bundle(bundle, 10).await?;
match receipt {
    Some(receipt) => println!("Bundle successfully included: {:?}", receipt),
    None => println!("Bundle not included within timeout"),
}

pub async fn simulate_and_send_bundle( &self, bundle: Bundle, simulation_params: SimulateBundleRequest, ) -> FlashbotsResult<Option<SendBundleResponse>>

Simulates bundle and sends it if simulation is successful

pub async fn send_bundles( &self, bundles: Vec<Bundle>, ) -> FlashbotsResult<Vec<FlashbotsResult<SendBundleResponse>>>

Sends multiple bundles in sequence

pub fn config(&self) -> &FlashbotsClientConfig

Returns current client configuration

pub fn with_config(&self, config: FlashbotsClientConfig) -> Self

Creates a new client instance with different configuration

pub async fn send_raw_bundle( &self, raw_bundle: Value, ) -> FlashbotsResult<SendBundleResponse>

Send the raw transaction packet (low-level API)

pub async fn cancel_bundles( &self, bundle_hashes: Vec<H256>, ) -> FlashbotsResult<CancelBundlesResponse>

Cancel submitted transaction package

Example

let client = FlashbotsClient::new_mainnet();
let bundle_hashes = vec![H256::zero()]; // Transaction package hash
let result = client.cancel_bundles(bundle_hashes).await?;
println!("Cancel result: {}", result.success);

pub async fn get_bundle_by_hash( &self, bundle_hash: H256, ) -> FlashbotsResult<BundleByHashResponse>

Retrieve transaction package details and receipts using transaction package hash.

pub async fn get_block( &self, block_number: U64, ) -> FlashbotsResult<BlockResponse>

Get detailed information of a specified block

Example

let client = FlashbotsClient::new_mainnet();
let block_number = U64::from(17000000u64);
let block_info = client.get_block(block_number).await?;
println!("Block miner: {:?}", block_info.miner);

pub async fn get_latest_block(&self) -> FlashbotsResult<BlockResponse>

Get the latest block information

pub async fn get_user_status( &self, address: Address, ) -> FlashbotsResult<UserStatus>

Obtain user status information (without relying on specific blocks)

Example

let client = FlashbotsClient::new_mainnet();
let address = Address::zero(); // real address
let user_status = client.get_user_status(address).await?;
println!("User reputation: {:?}", user_status.reputation);

pub async fn get_gas_price(&self) -> FlashbotsResult<GasPriceResponse>

Get recommended gas prices

Example

let client = FlashbotsClient::new_mainnet();
let gas_prices = client.get_gas_price().await?;
println!("Fast gas price: {}", gas_prices.fast_gas_price);

pub async fn get_supported_endpoints(&self) -> FlashbotsResult<Vec<String>>

Get the list of API endpoints supported by the repeater.

pub async fn get_relay_info(&self) -> FlashbotsResult<RelayInfo>

Get repeater information

Example

use flashbots_rs::FlashbotsClient;

let client = FlashbotsClient::new_mainnet();
let relay_info = client.get_relay_info().await?;
println!("Relay: {} v{}", relay_info.name, relay_info.version);

pub async fn get_bundle_receipts( &self, bundle_hashes: Vec<H256>, ) -> FlashbotsResult<Vec<BundleReceipt>>

Batch Transaction Package Receipts

pub async fn check_bundle_inclusions( &self, bundle_hashes: Vec<H256>, ) -> FlashbotsResult<Vec<(H256, bool)>>

Check if multiple transaction packages have been included.

pub async fn send_bundle_and_get_receipt( &self, bundle: Bundle, timeout_blocks: u64, ) -> FlashbotsResult<BundleReceipt>

Send transaction package and get receipt (simplified version)

pub async fn validate_bundle(&self, bundle: &Bundle) -> FlashbotsResult<bool>

Verify transaction package format

pub async fn get_relay_stats(&self) -> FlashbotsResult<Value>

Obtain repeater performance statistics

pub async fn get_builder_info(&self) -> FlashbotsResult<Value>

Get Builder Information

pub async fn simulate_bundles( &self, simulations: Vec<SimulateBundleRequest>, ) -> FlashbotsResult<Vec<FlashbotsResult<SimulateBundleResponse>>>

Batch simulated trading package

pub async fn send_and_cancel_bundle( &self, bundle: Bundle, ) -> FlashbotsResult<bool>

Send the transaction package and cancel it immediately (for testing purposes).

pub async fn get_network_info(&self) -> FlashbotsResult<Value>

Get network information

pub async fn is_blacklisted(&self, address: Address) -> FlashbotsResult<bool>

Check if the address is blacklisted.

pub async fn get_version(&self) -> FlashbotsResult<String>

Get repeater version

impl FlashbotsClient

pub fn new_production() -> Self

Creates a production-ready client (Mainnet, high retry count)

pub fn new_development() -> Self

Creates a development client (testnet, fast failure)

Trait Implementations

impl Clone for FlashbotsClient

fn clone(&self) -> FlashbotsClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FlashbotsClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.