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. 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): 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: 100 gas per ARBITRARY signature, 2800 per SECP256K1, 6700 per P256. Unknown schemes are rejected by static validation, so they are treated as 0 here (validation runs first).

pub fn data_cost(&self) -> u64

EIP-7623 calldata cost over the frame and signature data: 4 gas per zero byte, 16 per non-zero byte.

pub fn calldata_tokens(&self) -> u64

EIP-7623 token count over the frame and signature data, used for the calldata floor. Frame transactions exist only from Hegota onward, which is after Amsterdam, so EIP-7976’s unweighted count (every byte costs STANDARD_TOKEN_COST) always applies.

pub fn calldata_floor_gas(&self) -> u64

The EIP-7623 calldata floor: the least the frame and signature data may cost, whatever execution actually consumes.

pub fn mandatory_gas(&self) -> u64

The mandatory costs, always charged in full: the intrinsic cost, the per-frame cost, and signature verification.

pub fn standard_gas_limit(&self) -> u64

EIP-8141 standard_gas_limit: mandatory costs + data cost + sum of frame gas limits.

pub fn calldata_floor_total(&self) -> u64

EIP-8141 calldata_floor_gas: the mandatory costs plus the EIP-7623 floor over every byte this transaction carries. The mandatory costs are always charged, so they sit on both sides of the max_gas comparison.

pub fn max_gas(&self) -> u64

EIP-8141 max_gas = max(standard_gas_limit, calldata_floor_gas): the gas reserved from the block pool before execution and the quantity max_cost is charged over. A transaction whose data floor exceeds what it declared for execution reserves the floor rather than being rejected.

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) -> Self

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() -> Self

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: &Self) -> 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