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

use ethers_core::types::{transaction::eip2718::TypedTransaction, BlockId};
use ethers_providers::{Middleware, MiddlewareError, PendingTransaction};

use async_trait::async_trait;
use std::fmt::Debug;
use thiserror::Error;

/// Basic trait to ensure that transactions about to be sent follow certain rules.
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
pub trait Policy: Sync + Send + Debug {
    type Error: Sync + Send + Debug;

    /// Evaluates the transactions.
    ///
    /// Returns Ok with the `tx` or an Err otherwise.
    async fn ensure_can_send(&self, tx: TypedTransaction) -> Result<TypedTransaction, Self::Error>;
}

/// A policy that does not restrict anything.
#[derive(Debug, Clone, Copy)]
pub struct AllowEverything;

#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
impl Policy for AllowEverything {
    type Error = ();

    async fn ensure_can_send(&self, tx: TypedTransaction) -> Result<TypedTransaction, Self::Error> {
        Ok(tx)
    }
}

/// A policy that rejects all transactions.
#[derive(Debug, Clone, Copy)]
pub struct RejectEverything;

#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
impl Policy for RejectEverything {
    type Error = ();

    async fn ensure_can_send(&self, _: TypedTransaction) -> Result<TypedTransaction, Self::Error> {
        Err(())
    }
}

/// Middleware used to enforce certain policies for transactions.
#[derive(Clone, Debug)]
pub struct PolicyMiddleware<M, P> {
    pub(crate) inner: M,
    pub(crate) policy: P,
}

impl<M, P> PolicyMiddleware<M, P>
where
    M: Middleware,
    P: Policy,
{
    /// Creates a new client from the provider and policy.
    pub fn new(inner: M, policy: P) -> Self {
        Self { inner, policy }
    }
}

#[derive(Error, Debug)]
/// Error thrown when the client interacts with the policy middleware.
pub enum PolicyMiddlewareError<M: Middleware, P: Policy> {
    /// Thrown when the internal policy errors
    #[error("{0:?}")]
    PolicyError(P::Error),
    /// Thrown when an internal middleware errors
    #[error(transparent)]
    MiddlewareError(M::Error),
}

impl<M: Middleware, P: Policy> MiddlewareError for PolicyMiddlewareError<M, P> {
    type Inner = M::Error;

    fn from_err(src: M::Error) -> Self {
        PolicyMiddlewareError::MiddlewareError(src)
    }

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

#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
impl<M, P> Middleware for PolicyMiddleware<M, P>
where
    M: Middleware,
    P: Policy,
{
    type Error = PolicyMiddlewareError<M, P>;
    type Provider = M::Provider;
    type Inner = M;

    fn inner(&self) -> &M {
        &self.inner
    }

    /// This ensures the tx complies with the registered policy.
    /// If so then this simply delegates the transaction to the inner middleware
    async fn send_transaction<T: Into<TypedTransaction> + Send + Sync>(
        &self,
        tx: T,
        block: Option<BlockId>,
    ) -> Result<PendingTransaction<'_, Self::Provider>, Self::Error> {
        let tx = self
            .policy
            .ensure_can_send(tx.into())
            .await
            .map_err(PolicyMiddlewareError::PolicyError)?;
        self.inner.send_transaction(tx, block).await.map_err(PolicyMiddlewareError::MiddlewareError)
    }
}