Struct Frame

pub struct Frame {
    pub id: ChannelId,
    pub number: u16,
    pub data: Vec<u8>,
    pub is_last: bool,
}

A channel frame representing a segment of channel data for transmission.

Frames are the atomic units of data transmission in the OP Stack derivation pipeline. Large channel data is split into multiple frames to fit within L1 transaction size constraints while maintaining the ability to reassemble the original data.

Binary Encoding Format

The frame is encoded as a concatenated byte sequence:

frame = channel_id ++ frame_number ++ frame_data_length ++ frame_data ++ is_last

Field Specifications

• channel_id (16 bytes): Unique identifier linking this frame to its parent channel
• frame_number (2 bytes, uint16): Sequence number for proper reassembly ordering
• frame_data_length (4 bytes, uint32): Length of the frame_data field in bytes
• frame_data (variable): The actual payload data for this frame segment
• is_last (1 byte, bool): Flag indicating if this is the final frame in the sequence

Total Overhead

Each frame has a fixed overhead of 23 bytes (16 + 2 + 4 + 1) plus the variable data payload.

Frame Sequencing

Frames within a channel must be:

1. Sequentially numbered: Starting from 0 and incrementing by 1
2. Properly terminated: Exactly one frame marked with is_last = true
3. Complete: All frame numbers from 0 to the last frame must be present

Reassembly Process

Channel reassembly involves:

1. Collection: Gather all frames with the same channel ID
2. Sorting: Order frames by their frame number
3. Validation: Verify sequential numbering and last frame flag
4. Concatenation: Combine frame data in order to reconstruct channel

Error Conditions

Frame processing can fail due to:

• Missing frames in the sequence
• Duplicate frame numbers
• Multiple frames marked as last
• Frame data exceeding size limits
• Invalid encoding or corruption

Fields

id: ChannelId

Unique identifier linking this frame to its parent channel.

All frames belonging to the same channel share this identifier, enabling proper grouping during the reassembly process. The channel ID is typically derived from the first frame’s metadata.

number: u16

Sequence number for frame ordering within the channel.

Frame numbers start at 0 and increment sequentially. This field is critical for proper reassembly ordering and detecting missing or duplicate frames during channel reconstruction.

data: Vec<u8>

Payload data carried by this frame.

Contains a segment of the original channel data. When all frames in a channel are reassembled, concatenating this data in frame number order reconstructs the complete channel payload.

is_last: bool

Flag indicating whether this is the final frame in the channel sequence.

Exactly one frame per channel should have this flag set to true. This enables detection of complete channel reception and validation that no frames are missing from the end of the sequence.

Implementations

impl Frame

pub const fn new( id: ChannelId, number: u16, data: Vec<u8>, is_last: bool, ) -> Self

Creates a new Frame.

pub fn encode(&self) -> Vec<u8>

Encode the frame into a byte vector.

pub fn decode(encoded: &[u8]) -> Result<(usize, Self), FrameDecodingError>

Decode a frame from a byte vector.

pub fn parse_frame( data: &[u8], start: usize, ) -> Result<(usize, Self), FrameDecodingError>

Parses a single frame from the given data at the given starting position, returning the frame and the number of bytes consumed.

pub fn parse_frames(encoded: &[u8]) -> Result<Vec<Self>, FrameParseError>

Parse the on chain serialization of frame(s) in an L1 transaction. Currently only version 0 of the serialization format is supported. All frames must be parsed without error and there must not be any left over data and there must be at least one frame.

Frames are stored in L1 transactions with the following format:

• data = DerivationVersion0 ++ Frame(s) Where there is one or more frames concatenated together.

pub fn size(&self) -> usize

Calculates the size of the frame + overhead for storing the frame. The sum of the frame size of each frame in a channel determines the channel’s size. The sum of the channel sizes is used for pruning & compared against the max channel bank size.

Trait Implementations

impl Clone for Frame

fn clone(&self) -> Frame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Frame

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

Formats the value using the given formatter.

impl Default for Frame

fn default() -> Frame

Returns the “default value” for a type.

impl PartialEq for Frame

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Frame

impl StructuralPartialEq for Frame