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

//! ZKsync-specific transaction data filler.

use alloy::{
    network::TransactionBuilder,
    primitives::U256,
    providers::{
        fillers::{FillerControlFlow, TxFiller},
        Provider, SendableTx,
    },
    transports::TransportResult,
};

use crate::network::{transaction_request::TransactionRequest, Zksync};

use super::{Eip712Fee, ZksyncProvider};

/// [Filler](https://docs.rs/alloy/latest/alloy/providers/fillers/trait.TxFiller.html) for EIP-712 transaction type.
///
/// Can fill fields such as `gas_limit`, `max_fee_per_gas`, `max_priority_fee_per_gas`, and `gas_per_pubdata`.
#[derive(Debug, Clone, Copy, Default)]
#[non_exhaustive]
pub struct Eip712FeeFiller {}

impl TxFiller<Zksync> for Eip712FeeFiller {
    type Fillable = Eip712Fee;

    fn status(&self, tx: &TransactionRequest) -> FillerControlFlow {
        if tx.gas_per_pubdata().unwrap_or_default() > U256::ZERO  // TODO: Should be `is_none()` once `gas_per_pubdata` in TransactionRequest is `Option`
            && tx.gas_limit().is_some()
            && tx.max_fee_per_gas().is_some()
            && tx.max_priority_fee_per_gas().is_some()
        {
            return FillerControlFlow::Finished;
        }
        if tx.from().is_none() {
            return FillerControlFlow::missing("Eip712FeeFiller", vec!["from"]);
        }
        FillerControlFlow::Ready
    }

    fn fill_sync(&self, _tx: &mut SendableTx<Zksync>) {}

    async fn prepare<P>(
        &self,
        provider: &P,
        tx: &TransactionRequest,
    ) -> TransportResult<Self::Fillable>
    where
        P: Provider<Zksync>,
    {
        let fee = provider.estimate_fee(tx.clone()).await?;
        Ok(fee)
    }

    async fn fill(
        &self,
        fee: Self::Fillable,
        mut tx: SendableTx<Zksync>,
    ) -> TransportResult<SendableTx<Zksync>> {
        if let Some(builder) = tx.as_mut_builder() {
            // Only set fields that are missing to prevent accidental overrides.
            if builder.gas_limit().is_none() {
                builder.set_gas_limit(fee.gas_limit);
            }
            if builder.max_fee_per_gas().is_none() {
                builder.set_max_fee_per_gas(fee.max_fee_per_gas);
            }
            if builder.max_priority_fee_per_gas().is_none() {
                builder.set_max_priority_fee_per_gas(fee.max_priority_fee_per_gas);
            }
            // TODO: Should be `is_none()` once `gas_per_pubdata` in TransactionRequest is `Option`
            if builder.gas_per_pubdata().unwrap_or_default() == U256::ZERO {
                builder.set_gas_per_pubdata(fee.gas_per_pubdata_limit);
            }
        }
        Ok(tx)
    }
}