Ethers Flashbots

https://docs.rs/ethers-flashbots/latest/
Admin
Ethers Flashbots provides an ethers compatible middleware for submitting Flashbots bundles, allowing...
Tokens:60,860
Snippets:301
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Flashbots Middleware Integration Example

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

This example shows how to set up and use the FlashbotsMiddleware with ethers-rs. It demonstrates initializing an HTTP provider, defining wallets for signing relay requests and transactions, and chaining them with SignerMiddleware to send transactions as Flashbots bundles.

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

# async fn foo() -> Result<(), Box<dyn std::error::Error>> {
let provider = Provider::<Http>::try_from("http://localhost:8545")
    .expect("Could not instantiate HTTP provider");

// Used to sign Flashbots relay requests - this is your searcher identity
let signer: LocalWallet = "380eb0f3d505f087e438eca80bc4df9a7faa24f868e69fc0440261a0fc0567dc"
    .parse()?;

// Used to sign transactions
let wallet: LocalWallet = "380eb0f3d505f087e438eca80bc4df9a7faa24f868e69fc0440261a0fc0567dc"
    .parse()?;

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

// This transaction will now be send as a Flashbots bundle!
let tx = TransactionRequest::pay("vitalik.eth", 100);
# Ok(())
# }
```

--------------------------------

### Rustdoc Keyboard Shortcuts

Source: https://docs.rs/ethers-flashbots/latest/help

Provides a list of keyboard shortcuts for navigating and interacting with rustdoc generated documentation. These shortcuts enhance the efficiency of browsing API references and code examples.

```APIDOC
`?`: Show this help dialog
`S` / `/`: Focus the search field
`↑`: Move up in search results
`↓`: Move down in search results
`←` / `→`: Switch result tab (when results focused)
`⏎`: Go to active search result
`+`: Expand all sections
`-`: Collapse all sections
```

--------------------------------

### Send Transaction with ethers-flashbots Middleware

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Demonstrates how to use the `BroadcasterMiddleware` from `ethers-flashbots` to send transactions. It outlines the default assumptions made when `Middleware::send_transaction` is used, such as disallowing reverts, not setting timestamps, targeting the next block, and skipping simulation. The example shows the setup of the middleware with a provider, a wallet for signing transactions, and multiple Flashbots relay URLs.

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

# async fn foo() -> Result<(), Box<dyn std::error::Error>> {
let provider = Provider::<Http>::try_from("http://localhost:8545")
    .expect("Could not instantiate HTTP provider");

// Used to sign Flashbots relay requests - this is your searcher identity
let signer: LocalWallet = "380eb0f3d505f087e438eca80bc4df9a7faa24f868e69fc0440261a0fc0567dc"
    .parse()?;

// Used to sign transactions
let wallet: LocalWallet = "380eb0f3d505f087e438eca80bc4df9a7faa24f868e69fc0440261a0fc0567dc"
    .parse()?;

// Note: The order is important! You want the signer
// middleware to sign your transactions *before* they
// are sent to your Flashbots middleware.
let mut client = SignerMiddleware::new(
    BroadcasterMiddleware::new(
        provider,
        vec![Url::parse("https://rpc.titanbuilder.xyz")?, Url::parse("https://relay.flashbots.net")?],
    ),
    wallet
);
# Ok(())
# }
```

--------------------------------

### Get Simulation Relay Client - ethers-flashbots

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Retrieves the specific relay client used for simulating bundles. This allows for testing bundle execution before broadcasting.

```rust
pub fn simulation_relay(&self) -> &Relay<S> {
    &self.simulation_relay
}
```

--------------------------------

### Send Transaction via Flashbots

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Example of sending a transaction using the BroadcasterMiddleware. After initializing the middleware, a transaction request can be created and sent using the `send_transaction` method. The transaction will be routed through the configured Flashbots relays.

```rust
/// ```rust
/// use ethers::prelude::*; 
/// use ethers_flashbots::FlashbotsMiddleware;
/// use url::Url;
///
/// async fn example<M: Middleware, S: Signer + 'static>(
///     client: SignerMiddleware<M, S>,
/// ) -> Result<(), Box<dyn std::error::Error>> {
///     let signer = client.signer();
///     let mut client = FlashbotsMiddleware::new(client, Url::parse("https://relay.flashbots.net")?, signer);
///
///     // 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?;
///     # Ok(())
/// # }
/// ```
```

--------------------------------

### Get Bundle Transaction Hashes

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Generates a vector of transaction hashes for all transactions within the bundle. It handles both signed and raw transactions, calculating their respective hashes.

```rust
pub fn transaction_hashes(&self) -> Vec<TxHash> {
    self.transactions
        .iter()
        .map(|tx| match tx {
            BundleTransaction::Signed(inner) => keccak256(inner.rlp()).into(),
            BundleTransaction::Raw(inner) => keccak256(inner).into(),
        })
        .collect()
}
```

--------------------------------

### FlashbotsMiddleware Initialization and Access

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Demonstrates how to create and manage the FlashbotsMiddleware. It covers initializing the middleware with a relay URL and signer, retrieving the primary relay, accessing the simulation relay, and setting a separate relay for bundle simulations.

```rust
pub struct FlashbotsMiddleware<M, S> {
    inner: M,
    relay: Relay<S>,
    simulation_relay: Option<Relay<S>>,
}

impl<M: Middleware, S: Signer> FlashbotsMiddleware<M, S> {
    /// Initialize a new Flashbots middleware.
    ///
    /// The signer is used to sign requests to the relay.
    pub fn new(inner: M, relay_url: impl Into<Url>, relay_signer: S) -> Self {
        Self {
            inner,
            relay: Relay::new(relay_url, Some(relay_signer)),
            simulation_relay: None,
        }
    }

    /// Get the relay client used by the middleware.
    pub fn relay(&self) -> &Relay<S> {
        &self.relay
    }

    /// Get the relay client used by the middleware to simulate
    /// bundles if set.
    pub fn simulation_relay(&self) -> Option<&Relay<S>> {
        self.simulation_relay.as_ref()
    }

    /// Set a separate relay to use for simulating bundles.
    ///
    /// This can either be a full Flashbots relay or a node that implements
    /// the `eth_callBundle` remote procedure call.
    pub fn set_simulation_relay(&mut self, relay_url: impl Into<Url>) {
        self.simulation_relay = Some(Relay::new(relay_url, None));
    }
}
```

--------------------------------

### Get Target Block

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Retrieves the target block number for the bundle, if specified. This indicates the block in which the bundle is intended to be included.

```rust
pub fn block(&self) -> Option<U64> {
    self.target_block
}
```

--------------------------------

### Relay Client Initialization and Usage

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/relay

Provides an overview of the `Relay` client's purpose and its recommended usage. It highlights that while this client allows direct relay interaction, the `FlashbotsMiddleware` is generally preferred for most applications.

```APIDOC
Relay Client:
  Purpose: Facilitates direct interaction with Flashbots relays.
  Initialization: Requires a signer for authentication and a relay URL.
  Usage Note: Recommended for advanced users or specific direct interaction needs. For most use cases, consider using `FlashbotsMiddleware`.
  Dependencies: `reqwest` for HTTP requests, `ethers` for signing and types, `serde` for serialization/deserialization.
```

--------------------------------

### ethers-flashbots Files

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/lib

Lists the source files within the ethers-flashbots crate, providing direct links to their content on docs.rs.

```rust
bundle.rs
jsonrpc.rs
lib.rs
middleware.rs
pending_bundle.rs
relay.rs
user.rs
utils.rs
```

--------------------------------

### ABI Type Information

Source: https://docs.rs/ethers-flashbots/latest/ethers_flashbots/type

Provides methods to get the native ABI type and a hint of the minimum byte size for a given type.

```rust
fn param_type() -> ParamType
// The native ABI type this type represents.

fn minimum_size() -> usize
// A hint of the minimum number of bytes this type takes up in the ABI.
```

--------------------------------

### Get Simulation Timestamp

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Retrieves the UNIX timestamp used for bundle simulation. This can be used to simulate time-sensitive operations within a bundle.

```rust
/// Get the UNIX timestamp used for bundle simulation (if any).
///
/// See [`eth_callBundle`][fb_call_bundle] in the Flashbots documentation
/// for more information on bundle simulations.
///
/// [fb_call_bundle]: https://docs.flashbots.net/flashbots-auction/searchers/advanced/rpc-endpoint#eth_callbundle
pub fn simulation_timestamp(&self) -> Option<u64> {
    self.simulation_timestamp
}
```

--------------------------------

### ethers-flashbots Source Files

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/user

Lists the source files available in the ethers-flashbots crate, providing links to their respective documentation.

```rust
bundle.rs
jsonrpc.rs
lib.rs
middleware.rs
pending_bundle.rs
relay.rs
user.rs
utils.rs
```

--------------------------------

### Get Bundle UUID

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Retrieves the optional UUID associated with the bundle. This UUID is used for bundle replacements or cancellations via eth_cancelBundle.

```rust
pub fn uuid(&self) -> &Option<Uuid> {
    &self.uuid
}
```

--------------------------------

### ethers-flashbots Crate Overview

Source: https://docs.rs/ethers-flashbots/latest/ethers_flashbots/all

Provides an overview of the ethers-flashbots crate, its version, license, dependencies, and documentation status. It lists the main structs available for Flashbots integration.

```rust
// Crate: ethers-flashbots
// Version: 0.15.0
// License: MIT
// Dependencies:
// - async-trait ^0.1.58
// - chrono ^0.4.22
// - ethers ^2.0.0
// - futures-core ^0.3
// - futures-util ^0.3
// - pin-project ^1
// - reqwest ^0.11
// - serde ^1
// - serde_json ^1
// - thiserror ^1.0.37
// - url ^2.3.1
// - uuid ^1.5

// Structs available:
// - BroadcasterMiddleware
// - BundleRequest
// - BundleStats
// - FlashbotsMiddleware
// - PendingBundle
// - Relay
// - SimulatedBundle
// - SimulatedTransaction
// - UserStats
```

--------------------------------

### Get Relay Client - ethers-flashbots

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Retrieves the vector of relay clients used by the middleware. These clients are responsible for communicating with Flashbots relays.

```rust
pub fn relay(&self) -> &Vec<Relay<S>> {
    &self.relays
}
```

--------------------------------

### SimulatedBundle Fields

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Details the fields for a simulated bundle, including its hash, coinbase difference, tips, gas price, and total gas used.

```rust
pub struct SimulatedBundle {
    /// The bundle's hash.
    #[serde(rename = "bundleHash")]
    pub hash: BundleHash,
    /// The difference in coinbase's balance due to this bundle.
    /// This includes total gas fees and coinbase tips.
    #[serde(rename = "coinbaseDiff")]
    #[serde(deserialize_with = "deserialize_u256")]
    pub coinbase_diff: U256,
    /// The amount of Eth sent to coinbase in this bundle.
    #[serde(rename = "ethSentToCoinbase")]
    #[serde(deserialize_with = "deserialize_u256")]
    pub coinbase_tip: U256,
    /// The gas price of the bundle.
    #[serde(rename = "bundleGasPrice")]
    #[serde(deserialize_with = "deserialize_u256")]
    pub gas_price: U256,
    /// The total amount of gas used in this bundle.
    #[serde(rename = "totalGasUsed")]
    #[serde(deserialize_with = "deserialize_u256")]
    pub total_gas_used: U256
}
```

--------------------------------

### ethers-flashbots Source Files

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/jsonrpc

Lists the source files available within the ethers-flashbots crate, including bundle.rs, jsonrpc.rs, lib.rs, middleware.rs, pending_bundle.rs, relay.rs, user.rs, and utils.rs.

```rust
ethers_flashbots/bundle.rs
ethers_flashbots/jsonrpc.rs
ethers_flashbots/lib.rs
ethers_flashbots/middleware.rs
ethers_flashbots/pending_bundle.rs
ethers_flashbots/relay.rs
ethers_flashbots/user.rs
ethers_flashbots/utils.rs
```

--------------------------------

### Get Bundle Transactions

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Provides a reference to the vector of BundleTransaction objects contained within the bundle. This allows inspection of the transactions included in the bundle request.

```rust
pub fn transactions(&self) -> &Vec<BundleTransaction> {
    &self.transactions
}
```

--------------------------------

### Get Simulation Block Number

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Retrieves the block number used for simulating bundle execution. This allows for testing bundles against a specific blockchain state.

```rust
/// Get the block that determines the state for bundle simulation (if any).
///
/// See [`eth_callBundle`][fb_call_bundle] in the Flashbots documentation
/// for more information on bundle simulations.
///
/// [fb_call_bundle]: https://docs.flashbots.net/flashbots-auction/searchers/advanced/rpc-endpoint#eth_callbundle
pub fn simulation_block(&self) -> Option<U64> {
    self.simulation_block
}
```

--------------------------------

### ethers-flashbots Crate Overview

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/jsonrpc

Provides an overview of the ethers-flashbots crate, its version, license, source code links, and dependencies. It highlights that 91.3% of the crate is documented.

```rust
crate: ethers-flashbots
version: 0.15.0
license: MIT
dependencies:
  - async-trait ^0.1.58
  - chrono ^0.4.22
  - ethers ^2.0.0
  - futures-core ^0.3
  - futures-util ^0.3
  - pin-project ^1
  - reqwest ^0.11
  - serde ^1
  - serde_json ^1
  - thiserror ^1.0.37
  - url ^2.3.1
  - uuid ^1.5
```

--------------------------------

### ethers-flashbots Crate Information

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/lib

Provides metadata and links for the ethers-flashbots crate version 0.15.0. Includes links to documentation, source code, license, and related crates.

```rust
crate: ethers-flashbots version: 0.15.0
license: MIT
source: https://github.com/onbjerg/ethers-flashbots
crates.io: https://crates.io/crates/ethers-flashbots
docs.rs: https://docs.rs/ethers-flashbots/latest
```

--------------------------------

### ethers-flashbots Crate Information

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/utils

Provides metadata and links for the ethers-flashbots crate, including version, license, source code repository, and dependencies.

```Rust
Crate: ethers-flashbots
Version: 0.15.0
License: MIT
Repository: https://github.com/onbjerg/ethers-flashbots
Dependencies:
  - async-trait ^0.1.58
  - chrono ^0.4.22
  - ethers ^2.0.0
  - futures-core ^0.3
  - futures-util ^0.3
  - pin-project ^1
  - reqwest ^0.11
  - serde ^1
  - serde_json ^1
  - thiserror ^1.0.37
  - url ^2.3.1
  - uuid ^1.5
```

--------------------------------

### Deserialize Simulated Transaction from JSON

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

This snippet shows how to deserialize a `SimulatedTransaction` object from a JSON string using `serde_json`. It includes example JSON data with fields like `coinbaseDiff`, `ethSentToCoinbase`, and `fromAddress`.

```rust
let tx: SimulatedTransaction = serde_json::from_str(
            r#"{{
        "coinbaseDiff": "10000000000063000",
        "ethSentToCoinbase": "10000000000000000",
        "fromAddress": "0x02A727155aeF8609c9f7F2179b2a1f560B39F5A0"
    }}"#
        ).unwrap();
```

--------------------------------

### ethers-flashbots Crate Information

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Provides metadata and links for the ethers-flashbots crate version 0.15.0. Includes information about its license, source code repository, and dependencies.

```rust
Crate: ethers-flashbots
Version: 0.15.0
License: MIT
Repository: https://github.com/onbjerg/ethers-flashbots
Dependencies:
  - async-trait ^0.1.58
  - chrono ^0.4.22
  - ethers ^2.0.0
  - futures-core ^0.3
  - futures-util ^0.3
  - pin-project ^1
  - reqwest ^0.11
  - serde ^1
  - serde_json ^1
  - thiserror ^1.0.37
  - url ^2.3.1
  - uuid ^1.5
Documentation Coverage: 91.3%
```

--------------------------------

### ethers-flashbots Source Files

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/utils

Lists the source files available within the ethers-flashbots crate, allowing users to browse the codebase.

```Rust
Source Files:
- bundle.rs
- jsonrpc.rs
- lib.rs
- middleware.rs
- pending_bundle.rs
- relay.rs
- user.rs
- utils.rs
```

--------------------------------

### Get User Stats with ethers-flashbots

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Retrieves user statistics from the Flashbots relay. This method uses the signer identity configured with the middleware to fetch stats. It requires the latest block number to be fetched first.

```rust
pub async fn get_user_stats(&self) -> Result<UserStats, FlashbotsMiddlewareError<M, S>> {
    let latest_block = self
        .inner
        .get_block_number()
        .await
        .map_err(FlashbotsMiddlewareError::MiddlewareError)?;

    self.relay
        .request(
            "flashbots_getUserStatsV2",
            [GetUserStatsParams {
                block_number: latest_block,
            }],
        )
        .await
        .map_err(FlashbotsMiddlewareError::RelayError)?
        .ok_or(FlashbotsMiddlewareError::UserStatsError)
}
```

--------------------------------

### Flashbots Bundle RPC Methods

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Provides documentation for the Flashbots RPC methods used by the ethers-flashbots middleware.

```APIDOC
eth_callBundle:
  Description: Simulates a bundle of transactions without including it in a block.
  Parameters:
    - bundle: A `BundleRequest` object containing the transactions and simulation parameters.
  Returns:
    - `SimulatedBundle`: An object containing the simulation results, including logs and state changes.
  Reference: https://docs.flashbots.net/flashbots-auction/searchers/advanced/rpc-endpoint#eth_callbundle

eth_sendBundle:
  Description: Submits a bundle of transactions to the Flashbots relayer for inclusion in a block.
  Parameters:
    - bundle: A `BundleRequest` object containing the transactions, target block, and other relevant parameters.
  Returns:
    - `PendingBundle`: A handle to the submitted bundle, allowing tracking of its status.
  Reference: https://docs.flashbots.net/flashbots-auction/searchers/advanced/rpc-endpoint#eth_sendbundle

BundleRequest:
  Fields:
    - block: The target block number for the bundle.
    - simulation_block: Optional block number for simulation.
    - simulation_timestamp: Optional timestamp for simulation.
    - transactions: A list of signed Ethereum transactions.
    - block_number: The block number to which the bundle should be applied.
    - timestamp: The timestamp to which the bundle should be applied.
    - revert_reason: The revert reason for the bundle.
    - gas_price: The gas price for the bundle.
    - coinbase_transfer: The coinbase transfer amount.
    - state_block_number: The state block number for the bundle.
    - calldata: The calldata for the bundle.
    - logs: The logs for the bundle.
    - revert_block_number: The revert block number for the bundle.
    - revert_timestamp: The revert timestamp for the bundle.
    - revert_calldata: The revert calldata for the bundle.
    - revert_logs: The revert logs for the bundle.
    - revert_gas_price: The revert gas price for the bundle.
    - revert_coinbase_transfer: The revert coinbase transfer amount.
    - revert_state_block_number: The revert state block number for the bundle.

SimulatedBundle:
  Fields:
    - block_number: The block number of the simulation.
    - timestamp: The timestamp of the simulation.
    - revert_reason: The revert reason if the bundle reverted.
    - gas_used: The gas used by the bundle.
    - logs: The logs generated by the bundle.
    - state_changes: Any state changes resulting from the bundle.

PendingBundle:
  Fields:
    - bundle_hash: The hash of the submitted bundle.
    - block_number: The block number the bundle was submitted for.
    - status: The current status of the bundle (e.g., pending, included, reverted).
```

--------------------------------

### BundleRequest Structure and Serialization

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Defines the `BundleRequest` struct used to represent a Flashbots bundle. It includes fields for transactions, revertible transactions, block numbers, timestamps, and simulation parameters. The example demonstrates how to construct a `BundleRequest` and serialize it into JSON format.

```rust
/// A list of times at which builders selected the bundle to be included in the target block.
#[serde(default = "Vec::new")]
pub considered_by_builders_at: Vec<BuilderEntry>,
/// A list of times at which builders sealed a block containing the bundle.
#[serde(default = "Vec::new")]
pub sealed_by_builders_at: Vec<BuilderEntry>}

/// A builder log entry is a pairing of a builder's public key and a timestamp at which they
/// performed some operation on a bundle.
#[derive(Deserialize, Debug)]
pub struct BuilderEntry {
    /// The public key of the builder.
    pub pubkey: Bytes,
    /// The timestamp of this log entry.
    pub timestamp: Option<DateTime<Utc>>,
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::str::FromStr;
    use uuid::uuid;

    #[test]
    fn bundle_serialize() {
        let bundle = BundleRequest::new()
            .push_transaction(Bytes::from(vec![0x1]))
            .push_revertible_transaction(Bytes::from(vec![0x2]))
            .set_block(2.into())
            .set_min_timestamp(1000)
            .set_max_timestamp(2000)
            .set_simulation_timestamp(1000)
            .set_simulation_block(1.into())
            .set_simulation_basefee(333333);

        assert_eq!(
            &serde_json::to_string(&bundle).unwrap(),
            r#"{"txs":["0x01","0x02"],"revertingTxHashes":["0xf2ee15ea639b73fa3db9b34a245bdfa015c260c598b211bf05a1ecc4b3e3b4f2"],"blockNumber":"0x2","minTimestamp":1000,"maxTimestamp":2000,"stateBlockNumber":"0x1","timestamp":1000,"baseFee":333333}""#
        );
    }
}
```

--------------------------------

### ethers-flashbots Crate Information

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/pending_bundle

Provides an overview of the ethers-flashbots crate, including its version, license, source code links, and dependencies. It highlights the percentage of documented code and available feature flags.

```rust
Crate: ethers-flashbots
Version: 0.15.0
License: MIT
Dependencies:
  - async-trait ^0.1.58
  - chrono ^0.4.22
  - ethers ^2.0.0
  - futures-core ^0.3
  - futures-util ^0.3
  - pin-project ^1
  - reqwest ^0.11
  - serde ^1
  - serde_json ^1
  - thiserror ^1.0.37
  - url ^2.3.1
  - uuid ^1.5
Documentation: 91.3% documented
Source Code: https://github.com/onbjerg/ethers-flashbots
Features: See available feature flags
```

--------------------------------

### Simulate Bundle Creation and Assertions

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

This snippet demonstrates the creation of a simulated bundle and asserts various properties of the bundle, such as coinbase diff, tip, gas price, gas used, gas fees, simulation block number, and transaction details. It verifies the number of transactions and specific attributes like transaction value and error messages.

```rust
let simulated_bundle = SimulatedBundle {
            coinbase_diff: H160::from_str("0x0000000000000000000000000000000000000000").unwrap(),
            coinbase_tip: U256::from(20000000000000000u64),
            gas_price: U256::from(476190476193u64),
            gas_used: U256::from(42000),
            gas_fees: U256::from(126000),
            simulation_block: U64::from(5221585),
            transactions: vec![
                SimulatedTransaction {
                    value: Some(Bytes::from(vec![])), 
                    error: Some("execution reverted".into()),
                    ..Default::default()
                },
                SimulatedTransaction {
                    value: Some(Bytes::from(vec![0x1])),
                    error: None,
                    ..Default::default()
                },
                SimulatedTransaction {
                    to: None,
                    ..Default::default()
                }
            ]
        };

        assert_eq!(
            simulated_bundle.coinbase_diff,
            U256::from(20000000000126000u64)
        );
        assert_eq!(
            simulated_bundle.coinbase_tip,
            U256::from(20000000000000000u64)
        );
        assert_eq!(simulated_bundle.gas_price, U256::from(476190476193u64));
        assert_eq!(simulated_bundle.gas_used, U256::from(42000));
        assert_eq!(simulated_bundle.gas_fees, U256::from(126000));
        assert_eq!(simulated_bundle.simulation_block, U64::from(5221585));
        assert_eq!(simulated_bundle.transactions.len(), 3);
        assert_eq!(
            simulated_bundle.transactions[0].value,
            Some(Bytes::from(vec![]))
        );
        assert_eq!(
            simulated_bundle.transactions[0].error,
            Some("execution reverted".into())
        );
        assert_eq!(simulated_bundle.transactions[1].error, None);
        assert_eq!(
            simulated_bundle.transactions[1].value,
            Some(Bytes::from(vec![0x1]))
        );
        assert_eq!(simulated_bundle.transactions[2].to, None);
```

--------------------------------

### Relay Client Initialization and Request Sending

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/relay

Demonstrates how to create a new `Relay` client and send JSON-RPC requests to the Flashbots relay. It covers initializing the client with a URL and an optional signer, and making requests with specified methods and parameters.

```rust
impl<S: Signer> Relay<S> {
    /// Initializes a new relay client.
    pub fn new(url: impl Into<Url>, signer: Option<S>) -> Self {
        Self {
            id: AtomicU64::new(0),
            client: Client::new(),
            url: url.into(),
            signer,
        }
    }

    /// Sends a request with the provided method to the relay, with the
    /// parameters serialized as JSON.
    pub async fn request<T: Serialize + Send + Sync, R: DeserializeOwned>(
        &self,
        method: &str,
        params: T,
    ) -> Result<Option<R>, RelayError<S>> {
        let next_id = self.id.load(Ordering::SeqCst) + 1;
        self.id.store(next_id, Ordering::SeqCst);

        let payload = Request::new(next_id, method, params);

        let mut req = self.client.post(self.url.as_ref());

        if let Some(signer) = &self.signer {
            let signature = signer
                .sign_message(format!("0x{:x}",

```

--------------------------------

### ethers-flashbots Dependencies

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Lists the dependencies required for the ethers-flashbots crate, including version constraints for normal and development dependencies.

```rust
async-trait ^0.1.58
chrono ^0.4.22
ethers ^2.0.0
futures-core ^0.3
futures-util ^0.3
pin-project ^1
reqwest ^0.11
serde ^1
serde_json ^1
thiserror ^1.0.37
url ^2.3.1
uuid ^1.5
ethers ^2.0.0 (dev)
eyre ^0.6 (dev)
tokio ^1.21.2 (dev)
```

--------------------------------

### ethers-flashbots Dependencies

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/user

Lists the dependencies for the ethers-flashbots crate, including version constraints for normal and development dependencies.

```rust
async-trait ^0.1.58
chrono ^0.4.22
ethers ^2.0.0
futures-core ^0.3
futures-util ^0.3
pin-project ^1
reqwest ^0.11
serde ^1
serde_json ^1
thiserror ^1.0.37
url ^2.3.1
uuid ^1.5
ethers ^2.0.0 (dev)
eyre ^0.6 (dev)
tokio ^1.21.2 (dev)
```

--------------------------------

### ethers-flashbots Crate Information

Source: https://docs.rs/ethers-flashbots/latest/ethers_flashbots/index

Provides an overview of the ethers-flashbots crate, including its version, license, source code links, and dependencies. This information is useful for understanding the project's ecosystem and integration points.

```rust
Crate: ethers-flashbots
Version: 0.15.0
License: MIT
Dependencies:
  - async-trait ^0.1.58
  - chrono ^0.4.22
  - ethers ^2.0.0
  - futures-core ^0.3
  - futures-util ^0.3
  - pin-project ^1
  - reqwest ^0.11
  - serde ^1
  - serde_json ^1
  - thiserror ^1.0.37
  - url ^2.3.1
  - uuid ^1.5

Source: https://github.com/onbjerg/ethers-flashbots
Documentation: https://docs.rs/ethers-flashbots/latest/ethers_flashbots/
```

--------------------------------

### ethers-flashbots Dependencies

Source: https://docs.rs/ethers-flashbots/latest/settings

Lists the direct and development dependencies for the ethers-flashbots crate. These include libraries for asynchronous operations, date/time handling, Ethereum interaction, futures, serialization, error handling, URLs, and UUIDs.

```Rust
async-trait ^0.1.58
chrono ^0.4.22
ethers ^2.0.0
futures-core ^0.3
futures-util ^0.3
pin-project ^1
reqwest ^0.11
serde ^1
serde_json ^1
thiserror ^1.0.37
url ^2.3.1
uuid ^1.5
ethers ^2.0.0 (dev)
eyre ^0.6 (dev)
tokio ^1.21.2 (dev)
```

--------------------------------

### H256 Initialization Methods

Source: https://docs.rs/ethers-flashbots/latest/ethers_flashbots/type

Provides methods to create new H256 instances, including zero-initialized and byte-repeated hashes.

```rust
pub const fn zero() -> H256
// Returns a new zero-initialized fixed hash.
```

```rust
pub const fn repeat_byte(byte: u8) -> H256
// Returns a new fixed hash where all bits are set to the given byte.
```

--------------------------------

### ethers-flashbots Source Files

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Lists the source files available within the ethers-flashbots crate, indicating the modular structure of the library.

```rust
Source Files:
- bundle.rs
- jsonrpc.rs
- lib.rs
- middleware.rs
- pending_bundle.rs
- relay.rs
- user.rs
- utils.rs
```

--------------------------------

### ethers-flashbots Source Files

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

Lists the source files within the ethers-flashbots crate, indicating the modules and their respective locations.

```rust
bundle.rs
jsonrpc.rs
lib.rs
middleware.rs
pending_bundle.rs
relay.rs
user.rs
utils.rs
```

--------------------------------

### ethers-flashbots Crate Information

Source: https://docs.rs/ethers-flashbots/latest/ethers_flashbots

Provides metadata and links for the ethers-flashbots Rust crate. Includes version, license, source code repository, and dependencies.

```rust
Crate: ethers-flashbots
Version: 0.15.0
License: MIT
Dependencies:
  - async-trait ^0.1.58
  - chrono ^0.4.22
  - ethers ^2.0.0
  - futures-core ^0.3
  - futures-util ^0.3
  - pin-project ^1
  - reqwest ^0.11
  - serde ^1
  - serde_json ^1
  - thiserror ^1.0.37
  - url ^2.3.1
  - uuid ^1.5
Source: https://github.com/onbjerg/ethers-flashbots
Documentation: https://docs.rs/ethers-flashbots/latest/ethers_flashbots/
```

--------------------------------

### Initialize BroadcasterMiddleware

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/middleware

Creates a new instance of BroadcasterMiddleware. This middleware is used to send transactions via Flashbots relays. It requires an inner middleware, a list of relay URLs, a simulation relay URL, and a signer for authentication.

```rust
impl<M: Middleware, S: Signer> BroadcasterMiddleware<M, S> {
    /// Initialize a new Flashbots middleware.
    ///
    /// The signer is used to sign requests to the relay.
    pub fn new(
        inner: M,
        relay_urls: Vec<Url>,
        simulation_relay: impl Into<Url>,
        relay_signer: S,
    ) -> Self
    where
        S: Clone,
    {
        Self {
            inner,
            relays: relay_urls
                .into_iter()
                .map(|r| Relay::new(r, Some(relay_signer.clone())))
                .collect(),
            simulation_relay: Relay::new(simulation_relay, Some(relay_signer)),
        }
    }
}
```

--------------------------------

### Flashbots Bundle API

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/bundle

This section details the API for creating and managing Flashbots bundles using the `ethers-flashbots` crate. It covers the `BundleRequest` structure and its methods for adding transactions, setting block and timestamp constraints, and specifying simulation parameters.

```APIDOC
BundleRequest:
  __new__() -> BundleRequest
    Creates a new, empty `BundleRequest`.

  push_transaction(tx: Bytes) -> BundleRequest
    Adds a transaction to the bundle. Transactions are ordered by their inclusion in the bundle.
    Parameters:
      tx: The transaction data as `Bytes`.

  push_revertible_transaction(tx: Bytes) -> BundleRequest
    Adds a revertible transaction to the bundle. These transactions are executed only if the entire bundle succeeds.
    Parameters:
      tx: The revertible transaction data as `Bytes`.

  set_block(block_number: U256) -> BundleRequest
    Sets the target block number for the bundle.
    Parameters:
      block_number: The target block number as `U256`.

  set_min_timestamp(timestamp: u64) -> BundleRequest
    Sets the minimum timestamp (in seconds) at which the bundle can be included in a block.
    Parameters:
      timestamp: The minimum timestamp.

  set_max_timestamp(timestamp: u64) -> BundleRequest
    Sets the maximum timestamp (in seconds) at which the bundle can be included in a block.
    Parameters:
      timestamp: The maximum timestamp.

  set_simulation_timestamp(timestamp: u64) -> BundleRequest
    Sets the timestamp for simulation purposes. This might be used for gas estimation or other simulation-specific logic.
    Parameters:
      timestamp: The simulation timestamp.

  set_simulation_block(block_number: U256) -> BundleRequest
    Sets the block number for simulation purposes.
    Parameters:
      block_number: The simulation block number as `U256`.

  set_simulation_basefee(basefee_gwei: u64) -> BundleRequest
    Sets the base fee for simulation purposes, typically in Gwei.
    Parameters:
      basefee_gwei: The simulation base fee.

BuilderEntry:
  pubkey: Bytes
    The public key of the builder.
  timestamp: Option<DateTime<Utc>>
    The timestamp associated with the builder's action.
```

--------------------------------

### ethers-flashbots Crate Information

Source: https://docs.rs/ethers-flashbots/latest/index

Provides metadata and links for the ethers-flashbots Rust crate. Includes version, license, source code repository, and dependencies.

```rust
Crate: ethers-flashbots
Version: 0.15.0
License: MIT
Dependencies:
  - async-trait ^0.1.58
  - chrono ^0.4.22
  - ethers ^2.0.0
  - futures-core ^0.3
  - futures-util ^0.3
  - pin-project ^1
  - reqwest ^0.11
  - serde ^1
  - serde_json ^1
  - thiserror ^1.0.37
  - url ^2.3.1
  - uuid ^1.5
Source: https://github.com/onbjerg/ethers-flashbots
Documentation: https://docs.rs/ethers-flashbots/latest/ethers_flashbots/
```

--------------------------------

### ethers-flashbots Dev Dependencies

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/lib

Lists the development dependencies for the ethers-flashbots crate. These are used for testing, building, and other development-related tasks.

```rust
ethers: ^2.0.0
eyre: ^0.6
tokio: ^1.21.2
```

--------------------------------

### ethers-flashbots Dependencies

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/lib

Lists the direct dependencies for the ethers-flashbots crate, including version requirements. This helps in understanding the ecosystem and potential compatibility.

```rust
async-trait: ^0.1.58
chrono: ^0.4.22
ethers: ^2.0.0
futures-core: ^0.3
futures-util: ^0.3
pin-project: ^1
reqwest: ^0.11
serde: ^1
serde_json: ^1
thiserror: ^1.0.37
url: ^2.3.1
uuid: ^1.5
```

--------------------------------

### ethers-flashbots Crate Overview

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/relay

Provides an overview of the ethers-flashbots crate, its version, license, dependencies, and documentation status. It highlights the crate's purpose as Flashbots middleware for ethers-rs.

```rust
crate: ethers-flashbots
version: 0.15.0
license: MIT
dependencies:
  - async-trait ^0.1.58
  - chrono ^0.4.22
  - ethers ^2.0.0
  - futures-core ^0.3
  - futures-util ^0.3
  - pin-project ^1
  - reqwest ^0.11
  - serde ^1
  - serde_json ^1
  - thiserror ^1.0.37
  - url ^2.3.1
  - uuid ^1.5
documentation_coverage: 91.3%
```

--------------------------------

### ethers-flashbots File Structure

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/pending_bundle

Lists the source files within the ethers-flashbots crate, indicating the modular structure of the project. This helps in understanding the organization of the codebase.

```rust
Files:
  bundle.rs
  jsonrpc.rs
  lib.rs
  middleware.rs
  pending_bundle.rs
  relay.rs
  user.rs
  utils.rs
```

--------------------------------

### PendingBundle Constructor and Methods (Rust)

Source: https://docs.rs/ethers-flashbots/latest/src/ethers_flashbots/pending_bundle

Defines the PendingBundle struct, its constructor `new`, and the `bundle_hash` getter method. The constructor initializes a PendingBundle with a bundle hash, block number, transaction hashes, and a JSON RPC provider.

```rust
impl<'a, P: JsonRpcClient> PendingBundle<'a, P> {
    pub fn new(
        bundle_hash: Option<BundleHash>,
        block: U64,
        transactions: Vec<TxHash>,
        provider: &'a Provider<P>,
    ) -> Self {
        Self {
            bundle_hash,
            block,
            transactions,
            provider,
            state: PendingBundleState::PausedGettingBlock,
            interval: Box::new(interval(DEFAULT_POLL_INTERVAL)),
        }
    }

    /// Get the bundle hash for this pending bundle.
    #[deprecated(note = "use the bundle_hash field instead")]
    pub fn bundle_hash(&self) -> Option<BundleHash> {
        self.bundle_hash
    }
}
```

--------------------------------

### Rust TryFrom and TryInto Conversions

Source: https://docs.rs/ethers-flashbots/latest/ethers_flashbots/enum

Provides documentation for the `try_from` and `try_into` methods, which are part of the `TryFrom` and `TryInto` traits in Rust. These methods facilitate fallible type conversions, returning a `Result` to indicate success or failure.

```rust
/// fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
/// Performs the conversion.
///
/// ### impl<T, U> TryInto<U> for T
/// where U: TryFrom<T>,
/// 
/// #### type Error = <U as TryFrom<T>>::Error
/// The type returned in the event of a conversion error.
/// 
/// #### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
/// Performs the conversion.
```

--------------------------------

### Relay Struct and Methods

Source: https://docs.rs/ethers-flashbots/latest/ethers_flashbots/struct

Documentation for the `Relay` struct in ethers-flashbots, which acts as a client for Flashbots relays. It includes methods for initialization and sending requests.

```rust
pub struct Relay<S> { /* private fields */ }

impl<S: Signer> Relay<S> {
    pub fn new(url: impl Into<Url>, signer: Option<S>) -> Self

    pub async fn request<T: Serialize + Send + Sync, R: DeserializeOwned>( &self, method: &str, params: T, ) -> Result<Option<R>, RelayError<S>>
}
```

```APIDOC
Relay struct:
  A Flashbots relay client that automatically signs requests and sets the Flashbots authorization header.
  Note: This is generally not recommended for direct use; prefer FlashbotsMiddleware.

  Methods:
    new(url: impl Into<Url>, signer: Option<S>) -> Self
      Initializes a new relay client.

    request<T: Serialize + Send + Sync, R: DeserializeOwned>( &self, method: &str, params: T ) -> Result<Option<R>, RelayError<S>>
      Sends a request with the provided method to the relay, with the parameters serialized as JSON.
      Parameters:
        method: The RPC method to call.
        params: The parameters for the RPC method, serialized as JSON.
      Returns:
        A Result containing an Option of the deserialized response or a RelayError.
```
Tokens:
Raw