Struct FrameTransaction 

pub struct FrameTransaction {
    pub chain_id: u64,
    pub nonce: u64,
    pub sender: Address,
    pub frames: Vec<Frame>,
    pub signatures: Vec<FrameSignature>,
    pub max_priority_fee_per_gas: u64,
    pub max_fee_per_gas: u64,
    pub max_fee_per_blob_gas: U256,
    pub blob_versioned_hashes: Vec<H256>,
    pub inner_hash: OnceCell<H256>,
    pub cached_canonical: OnceCell<Vec<u8>>,
}

EIP-8141 Frame Transaction A transaction whose validity and gas payment are defined abstractly via frames. No ECDSA signature — sender is explicit. Authentication happens via APPROVE opcode.

Fields

chain_id: u64

nonce: u64

sender: Address

frames: Vec<Frame>

signatures: Vec<FrameSignature>

EIP-8141 outer signature list (spec commit fe0940cae2). Validated before any frame executes; referenced by VERIFY frames and SIGPARAM.

max_priority_fee_per_gas: u64

max_fee_per_gas: u64

max_fee_per_blob_gas: U256

blob_versioned_hashes: Vec<H256>

inner_hash: OnceCell<H256>

cached_canonical: OnceCell<Vec<u8>>

Implementations

impl FrameTransaction

pub fn compute_sig_hash(&self) -> H256

Canonical signature hash (EIP-8141, spec commit fe0940cae2): the raw signature bytes of every signature with empty msg are elided (a signature over this hash cannot commit to its own bytes). Frame data is NO LONGER elided — it is fully covered. Signatures with an explicit 32-byte msg keep their bytes (they sign that digest, not this hash).

pub fn signature_verification_cost(&self) -> u64

Per EIP-8141 (spec commit fe0940cae2): 2800 gas per SECP256K1 signature, 6700 per P256. Unknown schemes are rejected by static validation, so they are treated as 0 here (validation runs first).

pub fn total_gas_limit(&self) -> u64

Compute total gas limit: intrinsic + calldata cost (frames + signatures)

• signature verification cost + sum of frame gas limits.

pub fn expiry_deadline(&self) -> Option<u64>

The expiry deadline (8-byte big-endian) of this transaction’s expiry verifier frame, if one exists with well-formed data.

pub fn validate_static_constraints(&self) -> Result<(), String>

Validate static constraints per EIP-8141 spec. Returns an error string if the transaction is invalid.

pub fn validation_prefix( &self, ) -> Result<ValidationPrefix, FrameValidationError>

Identify and return the validation prefix of this frame transaction.

The validation prefix is the minimal leading subsequence of frames (ignoring expiry-verifier frames) that establishes who pays for the transaction. Four shapes are recognized (per EIP-8141 §Mempool):

• SelfVerify: one VERIFY frame targeting tx.sender with scope APPROVE_EXECUTION_AND_PAYMENT.
• DeploySelfVerify: one DEFAULT frame (deploy) then one VERIFY frame as above.
• OnlyVerifyPay: one VERIFY frame (only_verify, scope APPROVE_EXECUTION) + one VERIFY frame (pay, scope APPROVE_PAYMENT).
• DeployOnlyVerifyPay: DEFAULT deploy frame + OnlyVerifyPay pair.

Expiry-verifier frames (see Frame::is_expiry_verifier) are transparent; they are skipped during shape matching but their indices are NOT included in frame_indices (which holds only the semantically meaningful prefix frames).

pub fn validate_prefix_structure( &self, prefix: &ValidationPrefix, ) -> Result<(), FrameValidationError>

Validate structural rules for the identified validation prefix.

Checks:

• Deploy frame (if any) is at index 0 and uses DEFAULT execution mode.
• At most one deploy frame exists in the prefix.
• self_verify / only_verify / pay frames use VERIFY execution mode.
• Resolved target of each VERIFY frame matches tx.sender (target == None means sender; a non-None target must equal sender).
• Scope restriction matches the frame’s role: self_verify → APPROVE_EXECUTION_AND_PAYMENT, only_verify → APPROVE_EXECUTION, pay → APPROVE_PAYMENT.
• No frame in the prefix has the atomic-batch flag set.
• Total gas budget: Σ(prefix frame gas_limits) + signature_verification_cost() ≤ MAX_VERIFY_GAS.

Trait Implementations

impl Archive for FrameTransaction

where u64: Archive, H160Wrapper: ArchiveWith<Address>, Vec<Frame>: Archive, Vec<FrameSignature>: Archive, U256Wrapper: ArchiveWith<U256>, Map<H256Wrapper>: ArchiveWith<Vec<H256>>, Skip: ArchiveWith<OnceCell<H256>> + ArchiveWith<OnceCell<Vec<u8>>>,

type Archived = ArchivedFrameTransaction

The archived representation of this type.

type Resolver = FrameTransactionResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for FrameTransaction

fn clone(&self) -> FrameTransaction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FrameTransaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FrameTransaction

fn default() -> FrameTransaction

Returns the “default value” for a type.

impl<__D: Fallible + ?Sized> Deserialize<FrameTransaction, __D> for Archived<FrameTransaction>

where u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>, H160Wrapper: ArchiveWith<Address> + DeserializeWith<<H160Wrapper as ArchiveWith<Address>>::Archived, Address, __D>, Vec<Frame>: Archive, <Vec<Frame> as Archive>::Archived: Deserialize<Vec<Frame>, __D>, Vec<FrameSignature>: Archive, <Vec<FrameSignature> as Archive>::Archived: Deserialize<Vec<FrameSignature>, __D>, U256Wrapper: ArchiveWith<U256> + DeserializeWith<<U256Wrapper as ArchiveWith<U256>>::Archived, U256, __D>, Map<H256Wrapper>: ArchiveWith<Vec<H256>> + DeserializeWith<<Map<H256Wrapper> as ArchiveWith<Vec<H256>>>::Archived, Vec<H256>, __D>, Skip: ArchiveWith<OnceCell<H256>> + DeserializeWith<<Skip as ArchiveWith<OnceCell<H256>>>::Archived, OnceCell<H256>, __D> + ArchiveWith<OnceCell<Vec<u8>>> + DeserializeWith<<Skip as ArchiveWith<OnceCell<Vec<u8>>>>::Archived, OnceCell<Vec<u8>>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<FrameTransaction, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Eq for FrameTransaction

impl From<FrameTransaction> for GenericTransaction

fn from(value: FrameTransaction) -> Self

Converts to this type from the input type.

impl PartialEq for FrameTransaction

fn eq(&self, other: &FrameTransaction) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PayloadRLPEncode for FrameTransaction

fn encode_payload(&self, buf: &mut dyn BufMut)

fn encode_payload_to_vec(&self) -> Vec<u8>

impl RLPDecode for FrameTransaction

fn decode_unfinished( rlp: &[u8], ) -> Result<(FrameTransaction, &[u8]), RLPDecodeError>

fn decode(rlp: &[u8]) -> Result<Self, RLPDecodeError>

impl RLPEncode for FrameTransaction

fn encode(&self, buf: &mut dyn BufMut)

fn length(&self) -> usize

fn encode_to_vec(&self) -> Vec<u8>

impl Serialize for FrameTransaction

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for FrameTransaction

where u64: Serialize<__S>, H160Wrapper: SerializeWith<Address, __S>, Vec<Frame>: Serialize<__S>, Vec<FrameSignature>: Serialize<__S>, U256Wrapper: SerializeWith<U256, __S>, Map<H256Wrapper>: SerializeWith<Vec<H256>, __S>, Skip: SerializeWith<OnceCell<H256>, __S> + SerializeWith<OnceCell<Vec<u8>>, __S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for FrameTransaction