ethers_middleware/
policy.rs

1use ethers_core::types::{transaction::eip2718::TypedTransaction, BlockId};
2use ethers_providers::{Middleware, MiddlewareError, PendingTransaction};
3
4use async_trait::async_trait;
5use std::fmt::Debug;
6use thiserror::Error;
7
8/// Basic trait to ensure that transactions about to be sent follow certain rules.
9#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
10#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
11pub trait Policy: Sync + Send + Debug {
12    type Error: Sync + Send + Debug;
13
14    /// Evaluates the transactions.
15    ///
16    /// Returns Ok with the `tx` or an Err otherwise.
17    async fn ensure_can_send(&self, tx: TypedTransaction) -> Result<TypedTransaction, Self::Error>;
18}
19
20/// A policy that does not restrict anything.
21#[derive(Debug, Clone, Copy)]
22pub struct AllowEverything;
23
24#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
25#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
26impl Policy for AllowEverything {
27    type Error = ();
28
29    async fn ensure_can_send(&self, tx: TypedTransaction) -> Result<TypedTransaction, Self::Error> {
30        Ok(tx)
31    }
32}
33
34/// A policy that rejects all transactions.
35#[derive(Debug, Clone, Copy)]
36pub struct RejectEverything;
37
38#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
39#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
40impl Policy for RejectEverything {
41    type Error = ();
42
43    async fn ensure_can_send(&self, _: TypedTransaction) -> Result<TypedTransaction, Self::Error> {
44        Err(())
45    }
46}
47
48/// Middleware used to enforce certain policies for transactions.
49#[derive(Clone, Debug)]
50pub struct PolicyMiddleware<M, P> {
51    pub(crate) inner: M,
52    pub(crate) policy: P,
53}
54
55impl<M, P> PolicyMiddleware<M, P>
56where
57    M: Middleware,
58    P: Policy,
59{
60    /// Creates a new client from the provider and policy.
61    pub fn new(inner: M, policy: P) -> Self {
62        Self { inner, policy }
63    }
64}
65
66#[derive(Error, Debug)]
67/// Error thrown when the client interacts with the policy middleware.
68pub enum PolicyMiddlewareError<M: Middleware, P: Policy> {
69    /// Thrown when the internal policy errors
70    #[error("{0:?}")]
71    PolicyError(P::Error),
72    /// Thrown when an internal middleware errors
73    #[error(transparent)]
74    MiddlewareError(M::Error),
75}
76
77impl<M: Middleware, P: Policy> MiddlewareError for PolicyMiddlewareError<M, P> {
78    type Inner = M::Error;
79
80    fn from_err(src: M::Error) -> Self {
81        PolicyMiddlewareError::MiddlewareError(src)
82    }
83
84    fn as_inner(&self) -> Option<&Self::Inner> {
85        match self {
86            PolicyMiddlewareError::MiddlewareError(e) => Some(e),
87            _ => None,
88        }
89    }
90}
91
92#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
93#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
94impl<M, P> Middleware for PolicyMiddleware<M, P>
95where
96    M: Middleware,
97    P: Policy,
98{
99    type Error = PolicyMiddlewareError<M, P>;
100    type Provider = M::Provider;
101    type Inner = M;
102
103    fn inner(&self) -> &M {
104        &self.inner
105    }
106
107    /// This ensures the tx complies with the registered policy.
108    /// If so then this simply delegates the transaction to the inner middleware
109    async fn send_transaction<T: Into<TypedTransaction> + Send + Sync>(
110        &self,
111        tx: T,
112        block: Option<BlockId>,
113    ) -> Result<PendingTransaction<'_, Self::Provider>, Self::Error> {
114        let tx = self
115            .policy
116            .ensure_can_send(tx.into())
117            .await
118            .map_err(PolicyMiddlewareError::PolicyError)?;
119        self.inner.send_transaction(tx, block).await.map_err(PolicyMiddlewareError::MiddlewareError)
120    }
121}
ethers_middleware/policy.rs

ethers_middleware/
policy.rs
