maili_protocol/batch/tx_data/
eip7702.rs

//! This module contains the eip7702 transaction data type for a span batch.

use crate::{SpanBatchError, SpanDecodingError};
use alloc::vec::Vec;
use alloy_consensus::{SignableTransaction, Signed, TxEip7702};
use alloy_eips::{eip2930::AccessList, eip7702::SignedAuthorization};
use alloy_primitives::{Address, PrimitiveSignature as Signature, U256};
use alloy_rlp::{Bytes, RlpDecodable, RlpEncodable};

/// The transaction data for an EIP-7702 transaction within a span batch.
#[derive(Debug, Clone, PartialEq, Eq, RlpEncodable, RlpDecodable)]
pub struct SpanBatchEip7702TransactionData {
    /// The ETH value of the transaction.
    pub value: U256,
    /// Maximum priority fee per gas.
    pub max_priority_fee_per_gas: U256,
    /// Maximum fee per gas.
    pub max_fee_per_gas: U256,
    /// Transaction calldata.
    pub data: Bytes,
    /// Access list, used to pre-warm storage slots through static declaration.
    pub access_list: AccessList,
    /// Authorization list, used to allow a signer to delegate code to a contract
    pub authorization_list: Vec<SignedAuthorization>,
}

impl SpanBatchEip7702TransactionData {
    /// Converts [SpanBatchEip7702TransactionData] into a signed [`TxEip7702`].
    pub fn to_signed_tx(
        &self,
        nonce: u64,
        gas: u64,
        to: Address,
        chain_id: u64,
        signature: Signature,
    ) -> Result<Signed<TxEip7702>, SpanBatchError> {
        let eip7702_tx = TxEip7702 {
            chain_id,
            nonce,
            max_fee_per_gas: u128::from_be_bytes(
                self.max_fee_per_gas.to_be_bytes::<32>()[16..].try_into().map_err(|_| {
                    SpanBatchError::Decoding(SpanDecodingError::InvalidTransactionData)
                })?,
            ),
            max_priority_fee_per_gas: u128::from_be_bytes(
                self.max_priority_fee_per_gas.to_be_bytes::<32>()[16..].try_into().map_err(
                    |_| SpanBatchError::Decoding(SpanDecodingError::InvalidTransactionData),
                )?,
            ),
            gas_limit: gas,
            to,
            value: self.value,
            input: self.data.clone().into(),
            access_list: self.access_list.clone(),
            authorization_list: self.authorization_list.clone(),
        };
        let signature_hash = eip7702_tx.signature_hash();
        Ok(Signed::new_unchecked(eip7702_tx, signature, signature_hash))
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::SpanBatchTransactionData;
    use alloc::vec::Vec;
    use alloy_rlp::{Decodable, Encodable};
    use revm::primitives::Authorization;

    #[test]
    fn encode_eip7702_tx_data_roundtrip() {
        let authorization = Authorization {
            chain_id: U256::from(0x01),
            address: Address::left_padding_from(&[0x01, 0x02, 0x03]),
            nonce: 2,
        };
        let signature = Signature::test_signature();
        let arb_authorization: SignedAuthorization = authorization.into_signed(signature);

        let variable_fee_tx = SpanBatchEip7702TransactionData {
            value: U256::from(0xFF),
            max_fee_per_gas: U256::from(0xEE),
            max_priority_fee_per_gas: U256::from(0xDD),
            data: Bytes::from(alloc::vec![0x01, 0x02, 0x03]),
            access_list: AccessList::default(),
            authorization_list: vec![arb_authorization],
        };

        let mut encoded_buf = Vec::new();
        SpanBatchTransactionData::Eip7702(variable_fee_tx.clone()).encode(&mut encoded_buf);

        let decoded = SpanBatchTransactionData::decode(&mut encoded_buf.as_slice()).unwrap();
        let SpanBatchTransactionData::Eip7702(variable_fee_decoded) = decoded else {
            panic!("Expected SpanBatchEip7702TransactionData, got {:?}", decoded);
        };

        assert_eq!(variable_fee_tx, variable_fee_decoded);
    }
}
maili_protocol/batch/tx_data/eip7702.rs

maili_protocol/batch/tx_data/
eip7702.rs
