txboost-rs 0.1.0

Txboost middleware for ethers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use crate::{
    bundle::{SendBundleRequest, SimulateBundleRequest, StateBlockNumber},
    relay::{Relay, RelayError},
};
use ethers::{
    core::types::U64,
    providers::{Middleware, MiddlewareError},
    signers::Signer,
};
use serde::{de, Deserialize, Deserializer, Serialize};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum TxBoostMiddlewareError<M: Middleware> {
    /// The relay responded with an error.
    #[error(transparent)]
    RelayError(#[from] RelayError),
    #[error("{0}")]
    MiddlewareError(M::Error),
    #[error("Failed to simulate bundle")]
    BundleSimError,
}

impl<M: Middleware> MiddlewareError for TxBoostMiddlewareError<M> {
    type Inner = M::Error;

    fn from_err(src: M::Error) -> TxBoostMiddlewareError<M> {
        TxBoostMiddlewareError::MiddlewareError(src)
    }

    fn as_inner(&self) -> Option<&Self::Inner> {
        match self {
            TxBoostMiddlewareError::MiddlewareError(e) => Some(e),
            _ => None,
        }
    }
}

#[derive(Debug)]
pub struct TxBoostMiddleware<M, S> {
    inner: M,
    relay: Relay<S>,
    simulation_relay: Option<Relay<S>>,
}

impl<M: Middleware, S: Signer> TxBoostMiddleware<M, S> {
    pub fn new(inner: M, relay: Relay<S>, simulation_relay: Option<Relay<S>>) -> Self {
        Self {
            inner,
            relay,
            simulation_relay,
        }
    }

    pub fn relay(&self) -> &Relay<S> {
        &self.relay
    }

    pub fn simulation_relay(&self) -> Option<&Relay<S>> {
        self.simulation_relay.as_ref()
    }

    pub fn into_inner(self) -> M {
        self.inner
    }

    pub async fn simulate_bundle(
        &self,
        bundle: &SimulateBundleRequest,
    ) -> Result<SimulatedBundleResponse, TxBoostMiddlewareError<M>> {
        self.simulation_relay
            .as_ref()
            .unwrap_or(&self.relay)
            .request("eth_callBundle", [bundle])
            .await
            .map_err(TxBoostMiddlewareError::RelayError)?
            .ok_or(TxBoostMiddlewareError::BundleSimError)
    }

    pub async fn send_bundle(
        &self,
        bundle: &SendBundleRequest,
    ) -> Result<SendBundleResponse, TxBoostMiddlewareError<M>> {
        self.relay
            .request("eth_sendBundle", [bundle])
            .await
            .map_err(TxBoostMiddlewareError::RelayError)?
            .ok_or(TxBoostMiddlewareError::BundleSimError)
    }
}

fn de_from_str<'de, D>(deserializer: D) -> Result<U64, D::Error>
where
    D: Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;

    U64::from_str_radix(&s, 16).map_err(de::Error::custom)
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SimulatedBundleResponse {
    txs: Vec<String>,
    #[serde(deserialize_with = "de_from_str")]
    block_number: U64,
    state_block_number: StateBlockNumber,
    #[serde(skip_serializing_if = "Option::is_none")]
    timestamp: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SendBundleResponse {
    pub bundle_gas_price: String,
    pub bundle_hash: String,
    pub coinbase_diff: String,
    pub eth_sent_to_coinbase: String,
    pub gas_fees: String,
    pub results: Vec<SendBundleResult>,
    pub state_block_number: u64,
    pub total_gas_used: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SendBundleResult {
    pub bundle_hash: String,
    pub coinbase_diff: String,
    pub eth_sent_to_coinbase: String,
    pub gas_fees: String,
    pub state_block_number: u64,
    pub total_gas_used: u64,
}