Flashbots

https://docs.flashbots.net
Admin
Flashbots is a research and development organization dedicated to mitigating the negative...
Tokens:126,575
Snippets:726
Trust Score:9.4
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install MEV-Boost from Source using go install

Source: https://docs.flashbots.net/flashbots-mev-boost/getting-started/installation

Installs the latest version of MEV-Boost using the `go install` command. This method places the executable in your `$GOPATH/bin` directory. You can also specify a version using the `@VERSION` syntax.

```bash
go install github.com/flashbots/mev-boost@latest
mev-boost -help
```

```bash
go install github.com/flashbots/mev-boost@VERSION
mev-boost -help
```

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

### Install Portable MEV-Boost with go install

Source: https://docs.flashbots.net/flashbots-mev-boost/getting-started/installation

Installs a portable version of MEV-Boost using `go install` by setting specific CGO flags. This is recommended for systems where the default build might cause 'SIGILL: illegal instruction' errors.

```bash
CGO_CFLAGS="-O -D__BLST_PORTABLE__" go install github.com/flashbots/mev-boost@latest
```

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

### Configure Flashbots Provider with web3.py

Source: https://docs.flashbots.net/flashbots-auction/quick-start

This example demonstrates how to configure a web3.py provider for interacting with the Flashbots network. It involves setting up a Web3 instance with a JSON RPC provider and an Ethereum account for signing payloads, which is used for identity and reputation.

```python
import os

from eth_account.account import Account
from eth_account.signers.local import LocalAccount
from flashbots import flashbot

from web3 import Web3, HTTPProvider


# Create a web3 object with a standard json rpc provider, such as Infura, Alchemy, or your own node.
w3 = Web3(HTTPProvider("http://localhost:8545"))

# ETH_ACCOUNT_SIGNATURE is an Ethereum private key that does NOT store funds and is NOT your bot's primary key.
# This is an identifying key for signing payloads to establish reputation and whitelisting
ETH_ACCOUNT_SIGNATURE: LocalAccount = Account.from_key(os.environ.get("ETH_SIGNATURE_KEY"))


```

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

### Web3.py Flashbots Integration

Source: https://docs.flashbots.net/flashbots-auction/quick-start

Illustrates how to integrate Flashbots with web3.py, including setting up the web3 object and authentication signer.

```APIDOC
## Web3.py Flashbots Integration

This example demonstrates how to initialize a web3.py instance and configure an authentication account for interacting with the Flashbots network.

### Parameters
*   `w3` (Web3) - A web3.py instance connected to an Ethereum node.
*   `ETH_ACCOUNT_SIGNATURE` (LocalAccount) - An `eth_account` LocalAccount object created from a private key. This key is used for signing payloads to establish identity and reputation.

### Request Example
```python
import os

from eth_account.account import Account
from eth_account.signers.local import LocalAccount
from flashbots import flashbot

from web3 import Web3, HTTPProvider


# Create a web3 object with a standard json rpc provider, such as Infura, Alchemy, or your own node.
w3 = Web3(HTTPProvider("http://localhost:8545"))

# ETH_ACCOUNT_SIGNATURE is an Ethereum private key that does NOT store funds and is NOT your bot's primary key.
# This is an identifying key for signing payloads to establish reputation and whitelisting
ETH_ACCOUNT_SIGNATURE: LocalAccount = Account.from_key(os.environ.get("ETH_SIGNATURE_KEY"))
```
```

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

### Ethers.js Flashbots Provider Configuration

Source: https://docs.flashbots.net/flashbots-auction/quick-start

Demonstrates how to configure the Flashbots Bundle Provider using ethers.js.

```APIDOC
## Ethers.js Flashbots Provider Configuration

This example shows how to set up an ethers.js provider and connect it to the Flashbots network using a dedicated authentication signer.

### Method
`FlashbotsBundleProvider.create()`

### Parameters
*   `provider` (ethers.providers.JsonRpcProvider) - An ethers.js JSON RPC provider instance.
*   `authSigner` (ethers.Wallet) - An Ethereum wallet instance used for signing payloads. This key is for identification and reputation, not for fund management.

### Request Example
```javascript
const { ethers } = require("ethers");
const { FlashbotsBundleProvider } = require("@flashbots/ethers-provider-bundle");

// Standard json rpc provider directly from ethers.js. You can use Infura, Alchemy, or your own node.
const provider = new ethers.providers.JsonRpcProvider({
  url: ETHEREUM_RPC_URL,
});

// `authSigner` is an Ethereum private key that does NOT store funds and is NOT your bot's primary key.
// This is an identifying key for signing payloads to establish reputation and whitelisting
const authSigner = new ethers.Wallet(
  "0x0000000000000000000000000000000000000000000000000000000000000000"
);

// Flashbots provider requires passing in a standard provider and an auth signer
const flashbotsProvider = await FlashbotsBundleProvider.create(
  provider,
  authSigner
);
```
```

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

### Import and Initialize MEV-Share Client (TypeScript)

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/getting-started

Demonstrates how to import necessary components from 'ethers' and '@flashbots/mev-share-client' and initialize the MEV-Share client for connecting to Ethereum mainnet. Requires RPC_URL and FB_REPUTATION_PRIVATE_KEY.

```typescript
import {Wallet, JsonRpcProvider} from 'ethers';
import MevShareClient,
  {
    BundleParams,
    IPendingBundle,
    IPendingTransaction,
    TransactionOptions,
  } from '@flashbots/mev-share-client';

const provider = new JsonRpcProvider(RPC_URL);
const authSigner = new Wallet(FB_REPUTATION_PRIVATE_KEY, provider);
const mevShareClient = MevShareClient.useEthereumMainnet(authSigner);
```

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

### Install and Run MEV-Boost using Docker

Source: https://docs.flashbots.net/flashbots-mev-boost/getting-started/installation

Provides commands to pull the latest MEV-Boost Docker image (standard or portable) and run it. This is a convenient way to deploy MEV-Boost without local compilation, ensuring consistent environments.

```bash
docker pull flashbots/mev-boost:latest
```

```bash
docker pull flashbots/mev-boost:latest-portable
```

```bash
docker run flashbots/mev-boost -help
```

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

### Install MEV-Share Client Library (TypeScript)

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/getting-started

Adds the @flashbots/mev-share-client library to your project using yarn. This is the first step to integrating MEV-Share functionality into your TypeScript application.

```bash
yarn add @flashbots/mev-share-client
```

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

### Build MEV-Boost from Source by Cloning Repository

Source: https://docs.flashbots.net/flashbots-mev-boost/getting-started/installation

This method involves cloning the MEV-Boost repository, optionally checking out a specific tag, and then building the software using `make`. It offers a direct way to compile the project. The `make build-portable` option is available for troubleshooting specific instruction errors.

```bash
git clone https://github.com/flashbots/mev-boost.git
cd mev-boost
```

```bash
git checkout tags/YOUR_VERSION
```

```bash
make build
```

```bash
make build-portable
```

```bash
./mev-boost -help
```

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

### Docusaurus Frontmatter: Full Example

Source: https://docs.flashbots.net/contribution-guide

A comprehensive example of Docusaurus frontmatter, showcasing various metadata options like 'id', 'title', 'hide_title', 'hide_table_of_contents', 'sidebar_label', 'custom_edit_url', 'description', 'keywords', 'image', and 'slug'.

```yaml
---
id: not-three-cats
title: Three Cats
hide_title: false
hide_table_of_contents: false
sidebar_label: Still not three cats
custom_edit_url: https://github.com/flashbots/docs/edit/main/docs/three-cats.md
description: Three cats are not unlike four cats like three cats
keywords:
  - cats
  - three
image: ./assets/img/logo.png
slug: /myDoc
---
My Document Markdown content

```

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

### Simple Limit Order Bot Tutorial

Source: https://docs.flashbots.net/flashbots-mev-share/release-notes/2023-07

New tutorial for searching on MEV-Share, using a simple limit order bot as an example, with step-by-step instructions and full code examples.

```APIDOC
## Simple Limit Order Bot Tutorial

### Description
Step-by-step tutorial for searching on MEV-Share using a simple limit order bot, including full code examples and an open-source bot repository.

### Method
N/A (Tutorial content)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Flashbots Integration with ethers-rs (Rust)

Source: https://docs.flashbots.net/flashbots-auction/quick-start

Shows how to set up a Flashbots provider using the ethers-rs library in Rust. This involves connecting to an Ethereum network, creating a wallet for transaction signing, and initializing the Flashbots middleware.

```rust
use ethers::core::rand::thread_rng;
use ethers::prelude::*;
use ethers_flashbots::*;
use std::convert::TryFrom;
use url::Url;

#[tokio::main]
async fn main() {
    // Connect to the network
    let provider = Provider::<Http>::try_from("https://www.ankr.com/rpc/eth/").unwrap();

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

    // This signs transactions and is randomly generated in this example
    let wallet = LocalWallet::new(&mut thread_rng());

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

```

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

### Flashbots Authentication and Bundle Sending (Go)

Source: https://docs.flashbots.net/flashbots-auction/quick-start

Demonstrates how to create an authenticated HTTP request to the Flashbots relay using Go. It includes setting up an HTTP client, preparing an RPC request payload, signing the payload with a private key, and sending the request with the necessary headers.

```go
package main

import (
	"bytes"
	"crypto/ecdsa"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"time"

	"github.com/ethereum/go-ethereum/accounts"
	"github.com/ethereum/go-ethereum/common/hexutil"
	"github.com/ethereum/go-ethereum/crypto"
)

const (
	flashbotURL     = "https://relay.flashbots.net"
	flashbotXHeader = "X-Flashbots-Signature"
)

var (
	// authSigner is an Ethereum private key that does NOT store funds and is NOT your bot's primary key.
	// This is an identifying key for signing payloads to establish reputation and whitelisting
	privateKey, _ = crypto.HexToECDSA(
		"2e19800fcbbf0abb7cf6d72ee7171f08943bc8e5c3568d1d7420e52136898154",
	)
)

func flashbotHeader(signature []byte, privateKey *ecdsa.PrivateKey) string {
	return crypto.PubkeyToAddress(privateKey.PublicKey).Hex() +
		":" + hexutil.Encode(signature)
}

func main() {
	// Example: create a Flashbots authenticated request
	mevHTTPClient := &http.Client{
		Timeout: time.Second * 3,
	}

	// Prepare your RPC request (e.g., eth_sendBundle, eth_callBundle, etc.)
	params := map[string]interface{}{
		"jsonrpc": "2.0",
		"id":      1,
		"method":  "eth_sendBundle", // or other Flashbots RPC methods
		"params":  []interface{}{ /* your bundle params */ },
	}

	payload, _ := json.Marshal(params)
	req, _ := http.NewRequest("POST", flashbotURL, bytes.NewBuffer(payload))

	// Sign the payload for Flashbots authentication
	headerReady, _ := crypto.Sign(
		accounts.TextHash([]byte(hexutil.Encode(crypto.Keccak256(payload)))),
		privateKey,
	)

	req.Header.Add("content-type", "application/json")
	req.Header.Add("Accept", "application/json")
	req.Header.Add(flashbotXHeader, flashbotHeader(headerReady, privateKey))

	resp, _ := mevHTTPClient.Do(req)
	res, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(res))
}

```

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

### Docusaurus Frontmatter: Basic Example

Source: https://docs.flashbots.net/contribution-guide

An example of basic Docusaurus frontmatter for a document. It includes a 'title' key which will be rendered as a heading on the page.

```yaml
---
title: Example Doc
---

```

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

### Flashbots Bundle Relay URLs

Source: https://docs.flashbots.net/flashbots-auction/quick-start

Provides the mainnet and Sepolia relay URLs for sending Flashbots bundles.

```APIDOC
## Flashbots Bundle Relay URLs

This table lists the available URLs for the Flashbots bundle relay on different Ethereum networks.

### Network
Mainnet
Sepolia

### URL
`https://relay.flashbots.net`
`https://relay-sepolia.flashbots.net`
```

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

### Flashbots Bundle Creation and Sending (ethers.js)

Source: https://docs.flashbots.net/flashbots-auction/quick-start

Illustrates how to create and send a transaction bundle to the Flashbots network using ethers.js. It covers initializing the provider, creating an authentication signer, and using the FlashbotsBundleProvider to sign and send the bundle.

```javascript
const { ethers } = require("ethers");
const {
  FlashbotsBundleProvider,
} = require("@flashbots/ethers-provider-bundle");
const provider = new ethers.providers.JsonRpcProvider({
  url: ETHEREUM_RPC_URL,
});

const authSigner = new ethers.Wallet(
  "0x2000000000000000000000000000000000000000000000000000000000000000"
);
const flashbotsProvider = await FlashbotsBundleProvider.create(
  provider,
  authSigner
);

const signedBundle = await flashbotsProvider.signBundle([
  {
    signer: SOME_SIGNER_TO_SEND_FROM,
    transaction: SOME_TRANSACTION_TO_SEND,
  },
]);

const bundleReceipt = await flashbotsProvider.sendRawBundle(
  signedBundle,
  TARGET_BLOCK_NUMBER
);

```

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

### Initialize MEV-Share Client with Custom Network Parameters (TypeScript)

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/getting-started

Shows how to instantiate a MevShareClient directly with custom network configurations, including chainId, streamUrl, and apiUrl. This provides flexibility for connecting to different networks or specific MEV-Share relay endpoints.

```typescript
// connect to MEV-Share on mainnet
const mevShareClient = new MevShareClient(authSigner, {
  name: 'mainnet',
  chainId: 1,
  streamUrl: 'https://mev-share.flashbots.net',
  apiUrl: 'https://relay.flashbots.net',
});
```

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

### Debugging Guide

Source: https://docs.flashbots.net/flashbots-mev-share/release-notes/2023-07

Follow this guide for debugging bundles as a searcher on MEV-Share.

```APIDOC
## Debugging Guide

### Description
Follow this guide for debugging bundles as a searcher on MEV-Share.

### Method
N/A (Informational guide)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Compile and Deploy Contracts with Foundry

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/tutorials/flash-loan-arbitrage/simple-blind-arbitrage

Instructions for compiling smart contracts using Foundry's 'forge build' command, and deploying contracts locally using 'forge create'. This includes setting up environment variables for private keys, RPC URLs, and contract constructor arguments. It also shows how to start a local Ethereum fork with 'anvil'.

```bash
# compile contracts  
forge build  
  
# to test with a local fork:  
anvil -f $MAINNET_RPC_URL --chain-id 1 &  
  
# these vars are set to deploy on local fork; change as/if needed  
export PRIVATE_KEY="0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"  
export WETH_ADDRESS="0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"  
export RPC_URL="http://localhost:8545"  
  
# deploy flashloan arb contract  
forge create -r $RPC_URL --private-key $PRIVATE_KEY BlindBackrunFlashLoan --constructor-args $WETH_ADDRESS  
  
# or deploy capital-intensive contract  
forge create -r $RPC_URL --private-key $PRIVATE_KEY BlindBackrun --constructor-args $WETH_ADDRESS  
```

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

### MEV-Share Bundle Composition with tx_hash Hint

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/understanding-bundles

This example demonstrates how to send a bundle to MEV-Share with the `tx_hash` hint enabled, allowing other searchers to backrun your transactions and earn you additional MEV.

```APIDOC
## POST /mev_sendBundle (with privacy parameter)

### Description
Sends a bundle to the MEV-Share network. The `privacy` parameter, specifically the `txHash` hint, allows other searchers to view transaction hashes, enabling them to create backrunning bundles and share profits with the original sender.

### Method
POST

### Endpoint
`/mev_sendBundle`

### Parameters
#### Request Body
- **inclusion** (object) - Required - Specifies inclusion criteria for the bundle.
  - **block** (number) - Required - The target block number for inclusion.
  - **maxBlock** (number) - Optional - The maximum block number for inclusion.
- **body** (array) - Required - An array of transactions to include in the bundle.
  - **tx** (string) - Required - The signed transaction hash or data.
  - **canRevert** (boolean) - Required - Indicates if the transaction is allowed to revert.
- **privacy** (object) - Optional - Configuration for privacy and data sharing.
  - **hints** (object) - Optional - Hints to share with other searchers.
    - **txHash** (boolean) - Optional - If true, transaction hashes are shared.

### Request Example
```json
{
  "inclusion": {
    "block": 17539448,
    "maxBlock": 17539458
  },
  "body": [
    {"tx": "0x02...", "canRevert": false},
    {"tx": "0x02...", "canRevert": false}
  ],
  "privacy": {
    "hints": {
      "txHash": true
    }
  }
}
```

### Response
#### Success Response (200)
- **bundle_hash** (string) - The hash of the successfully submitted bundle.

#### Response Example
```json
{
  "bundle_hash": "0xabc123..."
}
```

### Notes
- Only original signed transactions are supported when the `privacy` parameter is used.
- Bundles using transactions specified by `{hash}` are not allowed to use the privacy parameter.
```

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

### Docusaurus Image Embedding Example

Source: https://docs.flashbots.net/contribution-guide

This snippet demonstrates how to embed an image in Docusaurus documentation using the require syntax. It specifies the image source and provides alternative text for accessibility.

```javascript
<img
  src={require('../static/img/example-banner.png').default}
  alt="Example banner"
/>

```

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

### Get Historical Hint Data

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/event-stream

Retrieve historical hint data from a specific block range. This endpoint allows you to query event history within a defined start and end block.

```APIDOC
## GET /api/v1/history

### Description
Retrieves historical hint data from a specific block range.

### Method
GET

### Endpoint
/api/v1/history

### Parameters
#### Query Parameters
- **blockStart** (integer) - Required - The starting block number for the query.
- **blockEnd** (integer) - Optional - The ending block number for the query. If not provided, it defaults to the current block.
- **limit** (integer) - Optional - The maximum number of results to return. Defaults to a system-defined limit (e.g., 500).
- **offset** (integer) - Optional - The number of results to skip. Used for pagination.

### Request Example
```bash
curl 'https://mev-share-goerli.flashbots.net/api/v1/history?blockStart=9091377&blockEnd=9091379'
```

### Response
#### Success Response (200)
- **block** (integer) - The block number.
- **timestamp** (integer) - The block timestamp.
- **hint** (object) - An object containing hint data.
  - **txs** (array) - An array of transaction objects within the hint, or null if none.
    - **to** (string) - The recipient address of the transaction.
    - **callData** (string) - The call data of the transaction.
    - **functionSelector** (string) - The function selector of the transaction.
  - **hash** (string) - The hash of the block.
  - **logs** (array) - An array of logs, or null.
  - **gasUsed** (string) - The amount of gas used, represented as a hexadecimal string.
  - **mevGasPrice** (string) - The MEV gas price, represented as a hexadecimal string.

#### Response Example
```json
[
  {
    "block": 9091377,
    "timestamp": 1685452445,
    "hint": {
      "txs": [
        {
          "to": "0x8d460b72eaf3d63830e16c22d1fc6908d0834abe",
          "callData": "0x",
          "functionSelector": "0x00000000"
        }
      ],
      "hash": "0x50df4922dd5f9adee91d44119132da85b50fe61f0c77556b039261f7828e1794",
      "logs": null,
      "gasUsed": "0x5208",
      "mevGasPrice": "0x3b9aca00"
    }
  }
]
```
```

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

### Initialize MEV-Share Client and Ethers Providers

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/tutorials/limit-order/setup

This snippet initializes the MEV-Share client and Ethers.js provider and wallets. It uses environment variables for RPC URL and private keys, falling back to defaults. It demonstrates connecting to both Goerli testnet and Ethereum mainnet via the MevShareClient.

```typescript
import MevShareClient, {IPendingTransaction} from '@flashbots/mev-share-client'
import { Contract, JsonRpcProvider, Wallet } from 'ethers'
import { UNISWAP_V2_ABI, UNISWAP_FACTORY_ABI, ERC20_ABI } from './abi' // <-- new import
import dotenv from "dotenv"
dotenv.config()

const RPC_URL = process.env.RPC_URL || 'http://127.0.0.1:8545'
const EXECUTOR_KEY = process.env.EXECUTOR_KEY || Wallet.createRandom().privateKey
const FB_REPUTATION_PRIVATE_KEY = process.env.FB_REPUTATION_KEY || Wallet.createRandom().privateKey

// create web3 provider & wallets, connect to mev-share
const provider = new JsonRpcProvider(RPC_URL)
const executorWallet = new Wallet(EXECUTOR_KEY, provider)
const authSigner = new Wallet(FB_REPUTATION_PRIVATE_KEY, provider)
const mevshare = MevShareClient.useEthereumGoerli(authSigner)
// if you want to connect to mainnet instead:
// const mevshare = MevShareClient.useEthereumMainnet(authSigner)

```

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

### Configure Flashbots Provider with Ethers.js

Source: https://docs.flashbots.net/flashbots-auction/quick-start

This snippet shows how to set up an Ethers.js provider to communicate with the Flashbots network. It requires a standard JSON RPC provider and an authentication signer key for identity verification and reputation building.

```javascript
const { ethers } = require("ethers");
const {
  FlashbotsBundleProvider,
} = require("@flashbots/ethers-provider-bundle");

// Standard json rpc provider directly from ethers.js. You can use Infura, Alchemy, or your own node.
const provider = new ethers.providers.JsonRpcProvider({
  url: ETHEREUM_RPC_URL,
});

// `authSigner` is an Ethereum private key that does NOT store funds and is NOT your bot's primary key.
// This is an identifying key for signing payloads to establish reputation and whitelisting
const authSigner = new ethers.Wallet(
  "0x0000000000000000000000000000000000000000000000000000000000000000"
);

// Flashbots provider requires passing in a standard provider and an auth signer
const flashbotsProvider = await FlashbotsBundleProvider.create(
  provider,
  authSigner
);

```

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

### Initialize and Configure Typescript Project for Flashbots

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/tutorials/limit-order/setup

Commands to create a new project directory, initialize it with yarn, and install essential development and runtime dependencies for a Flashbots bot. This includes packages for Typescript, linting, environment variable management, and the ethers and mev-share client libraries.

```bash
mkdir simple-limit-order-bot && cd simple-limit-order-bot
yarn init
# install typescript & eslint dev dependencies
yarn add -D @types/node @typescript-eslint/eslint-plugin @typescript-eslint/parser dotenv eslint eslint-plugin-tsdoc ts-node typescript
# install ethers & mev-share client
yarn add ethers @flashbots/mev-share-client
```

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

### Transaction Sending and Receipt Retrieval (ethers-rs, Rust)

Source: https://docs.flashbots.net/flashbots-auction/quick-start

Demonstrates sending a transaction using the ethers-rs library in Rust and retrieving its receipt. This snippet shows how to construct a transaction, send it, wait for inclusion, and fetch the transaction details and receipt.

```rust
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)?);

```

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

### Flash Loan Arbitrage with makeFlashLoan

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/tutorials/flash-loan-arbitrage/bot

This section details how to use the `makeFlashLoan` function to execute a flash loan arbitrage. A backrun bundle consists of the user's transaction and subsequent backrun transactions. The `makeFlashLoan` function initiates the process by requesting a flash loan, after which the arbitrage contract attempts to profit from the borrowed assets.

```APIDOC
## POST /submit_backrun_bundle

### Description
Submits a backrun bundle to the Flashbots network for inclusion in a block. The bundle typically includes the user's original transaction and one or more backrun transactions designed to profit from the state changes induced by the user's transaction.

### Method
POST

### Endpoint
`/submit_backrun_bundle`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **userTransaction** (object) - Required - The user's original transaction details.
- **backrunTxs** (array) - Required - An array of backrun transactions. Each transaction should be ABI-encoded and may include calls to functions like `makeFlashLoan`.
  - **tokenAddresses** (array[address]) - Required - An array of token addresses for the flash loan.
  - **amounts** (array[uint256]) - Required - An array of amounts corresponding to the tokens for the flash loan.
  - **userData** (bytes) - Required - ABI-encoded data for the arbitrage execution, typically arguments for the `_executeArbitrage` function.

### Request Example
```json
{
  "userTransaction": { ... },
  "backrunTxs": [
    {
      "to": "0xContractAddress",
      "functionSignature": "0x...",
      "args": {
        "tokens": ["0xTokenA", "0xTokenB"],
        "amounts": ["1000000000000000000", "500000000000000000"],
        "userData": "0x..."
      }
    }
  ]
}
```

### Response
#### Success Response (200)
- **bundleHash** (string) - The unique hash of the submitted bundle.
- **simulated** (object) - Simulation results of the bundle execution.
  - **gasUsed** (uint256) - Total gas used by the bundle.
  - **ethSent** (string) - Amount of ETH sent to the builder.
  - **logs** (array) - Logs generated during simulation.

#### Response Example
```json
{
  "bundleHash": "0xabc123...",
  "simulated": {
    "gasUsed": 100000,
    "ethSent": "0.1",
    "logs": []
  }
}
```

## Contract Function: makeFlashLoan

### Description
This function is part of the arbitrage contract and is used to initiate a flash loan. It takes the desired tokens, their amounts, and user-defined data for the arbitrage execution. The contract will attempt to perform an arbitrage with the borrowed assets and return any profit after repaying the loan and paying the builder.

### Method
N/A (This is a contract function call within a transaction)

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body (Conceptual - this is an argument to a contract call)
- **tokens** (IERC20[] memory) - Required - An array of `IERC20` token contract instances to borrow.
- **amounts** (uint256[] memory) - Required - An array of the amounts to borrow for each corresponding token in the `tokens` array.
- **userData** (bytes memory) - Required - ABI-encoded data containing the arguments required for the `_executeArbitrage` function.

### Request Example (Illustrative - as part of a transaction payload)
```json
{
  "to": "0xArbitrageContractAddress",
  "data": "0x...makeFlashLoan(address[],uint256[],bytes)..."
}
```

### Response (Conceptual - this is the result of the contract execution)
#### Success Response
- The transaction will succeed if the arbitrage is profitable and all conditions are met. The profit will be distributed after loan repayment and builder fees.

#### Response Example
N/A (This is a contract execution, not an API response)
```

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

### Configure MEV-Boost as a Systemd Service

Source: https://docs.flashbots.net/flashbots-mev-boost/getting-started/installation

Defines a systemd service file for MEV-Boost to ensure it runs as a background service. This configuration includes parameters for description, network targets, user, working directory, restart policies, and the executable path with mainnet and relay options.

```ini
[Unit]
Description=mev-boost
Wants=network-online.target
After=network-online.target

[Service]
User=mev-boost
Group=mev-boost
WorkingDirectory=/home/mev-boost
Type=simple
Restart=always
RestartSec=5
ExecStart=/home/mev-boost/bin/mev-boost \
-mainnet \
-relay-check \
-relays YOUR_RELAY_CHOICE

[Install]
WantedBy=multi-user.target
```

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

### Swap Functions in Solidity

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/tutorials/limit-order/setup

These Solidity functions facilitate token swaps. `swapETHForExactTokens` allows swapping a specific amount of ETH for an exact amount of tokens, while `swapExactETHForTokens` swaps a variable amount of ETH for at least a minimum amount of tokens. Both require a path for token conversion and a deadline.

```Solidity
function swapETHForExactTokens(
    uint256 amountOut,
    address[] calldata path,
    address to,
    uint256 deadline
) external payable returns (uint256[] memory amounts);

function swapExactETHForTokens(
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
) external payable returns (uint256[] memory amounts);
```

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

### RPC with Custom Hints

Source: https://docs.flashbots.net/flashbots-protect/settings-guide

Configure what transaction data is visible to MEV-Share searchers using the `hint` query parameter. Multiple hints can be specified to customize data sharing.

```APIDOC
## GET /?hint=<hint1>&hint=<hint2>...

### Description
Allows customization of transaction data shared with MEV-Share searchers via the `hint` query parameter. If one or more hints are provided, any hint not included is disabled. The `hash` hint is always shared if other hints are present. Full privacy mode is achieved by sharing only the `hash` hint.

### Method
GET

### Endpoint
https://rpc.flashbots.net/

### Query Parameters
- **hint** (string) - Required - Specifies the type of transaction data to share with MEV-Share searchers. Multiple `hint` parameters can be used.
  - `calldata`: Share data sent to the smart contract. Also shares function selector and contract address.
  - `logs`: Share logs emitted by the transaction.
  - `default_logs`: Share a specific subset of logs related to DeFi swaps (e.g., pool ID, swap indication for Curve, Balancer, Uniswap V2/V3).
  - `function_selector`: Share the 4-byte function identifier. Also shares contract address.
  - `contract_address`: Share the recipient contract address.
  - `hash`: Share the transaction hash (or bundle hash). If other hints are shared, this is always included.
  - `tx_hash`: Share individual transaction hashes within a bundle.
  - `full`: Share all fields of individual transactions except signatures.

### Request Body
None

### Response
#### Success Response (200)
Returns a success status for RPC calls with custom hints applied.

#### Response Example
```
https://rpc.flashbots.net?hint=contract_address&hint=logs
```
This example shares the contract address and logs, but not the calldata or function selector.
```

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

### Fetch MEV-Share Event Stream using curl

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/event-stream

This example demonstrates how to access the MEV-Share event stream using the `curl` command-line tool. By making an HTTP GET request to the specified endpoint, `curl` will subscribe to the stream and display incoming events. The stream will remain active, printing events as they are received, until manually interrupted (e.g., with CTRL-C).

```bash
curl https://mev-share-goerli.flashbots.net

```

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

### Signature Generation Examples

Source: https://docs.flashbots.net/flashbots-auction/advanced/rpc-endpoint

Examples of how to generate the EIP-191 signature using different libraries.

```APIDOC
### Signature Generation

The signature is calculated by taking the EIP-191 hash of the JSON body encoded as UTF-8 bytes.

#### ethers.js
```javascript
import { Wallet, id } from 'ethers';

const privateKey = '0x1234'; // Replace with your actual private key
const wallet = new Wallet(privateKey);
const body = '{"jsonrpc":"2.0","method":"eth_sendBundle","params":[{see above}],"id":1}'; // Replace with your actual JSON payload
const signature = wallet.address + ':' + wallet.signMessage(id(body));

console.log('X-Flashbots-Signature:', signature);
```

#### web3.py
```python
from web3 import Web3
from eth_account import Account, messages

private_key = '0x1234' # Replace with your actual private key
body = '{"jsonrpc":"2.0","method":"eth_sendBundle","params":[{see above}],"id":1}' # Replace with your actual JSON payload
message = messages.encode_defunct(text=Web3.keccak(text=body).hex())
signature = Account.from_key(private_key).address + ':' + Account.sign_message(message, private_key).signature.hex()

print('X-Flashbots-Signature:', signature)
```

#### go
```go
import (
	"crypto/ecdsa"
	"encoding/hex"
	"math/big"

	"github.com/ethereum/go-ethereum/accounts"
	"github.com/ethereum/go-ethereum/common/hexutil"
	"github.com/ethereum/go-ethereum/crypto"
)

// Assume privKey is your *ecdsa.PrivateKey and body is your JSON payload string
// Example placeholder for privKey and body:
var privKey *ecdsa.PrivateKey
var body string = `{"jsonrpc":"2.0","method":"eth_sendBundle","params":[{see above}],"id":1}`

hashedBody := crypto.Keccak256Hash([]byte(body)).Hex()
sig, err := crypto.Sign(accounts.TextHash([]byte(hashedBody)), privKey)
if err != nil {
	// Handle error
}
signature := crypto.PubkeyToAddress(privKey.PublicKey).Hex() + ":" + hexutil.Encode(sig)

// The 'signature' variable now holds the X-Flashbots-Signature value
// fmt.Println("X-Flashbots-Signature:", signature)
```
```

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

### Generate Vanity Ethereum Address with Cast

Source: https://docs.flashbots.net/flashbots-mev-share/searchers/tutorials/limit-order/setup

Demonstrates how to use the 'cast wallet vanity' command to generate a private key for an Ethereum address that starts with a specific prefix. This is useful for creating memorable or designated addresses.

```bash
cast wallet vanity --starts-with babe
```
Tokens:
Raw