Enum OpenStreamFrame 

pub enum OpenStreamFrame {
    Start {
        content_type: Option<String>,
    },
    Accept,
    Chunk {
        chunk_index: u64,
        data: String,
    },
    Ping {
        nonce: String,
    },
    Pong {
        nonce: String,
    },
    Close {
        last_chunk_index: Option<u64>,
    },
    Abort {
        reason: Option<String>,
    },
}

A CEP-41 open-stream frame (the cvm object).

Internally tagged on frameType. The constant cvm.type ("open-stream") is handled separately by to_cvm_value / from_cvm_value rather than encoded as an enum field, exactly mirroring CEP-22’s oversized_transfer/frame.rs.

Variants

Start

Opens a stream. Carries only optional application-defined advisory metadata; receivers MUST NOT depend on it for stream correctness.

Fields

content_type: Option<String>

Optional advisory content type (writer-settable, receiver-ignored).

Accept

Reader handshake acknowledgement, sent only in reply to an inbound start.

Chunk

One ordered payload fragment of the stream.

Fields

chunk_index: u64

Contiguous-from-0 chunk index used for completeness/ordering.

data: String

The chunk payload (an arbitrary UTF-8 string).

Ping

Keepalive probe; the peer must echo the nonce in a pong.

Fields

nonce: String

Opaque probe nonce echoed back by the peer.

Pong

Keepalive response echoing a prior ping nonce.

Fields

nonce: String

The nonce of the ping being acknowledged.

Close

Closes the stream gracefully (terminal). Declares the final chunk index when any chunks were emitted, so the reader can verify completeness.

Fields

last_chunk_index: Option<u64>

The highest chunkIndex emitted, or None for a zero-chunk stream.

Abort

Terminates the stream early (terminal).

Fields

reason: Option<String>

Optional advisory reason.

Implementations

impl OpenStreamFrame

pub fn frame_type(&self) -> &'static str

Returns the frameType discriminator string for this frame.

pub fn to_cvm_value(&self) -> Result<Value, Error>

Serialize this frame into a cvm object Value, injecting the constant type discriminator ("open-stream").

pub fn from_cvm_value(value: &Value) -> Option<Self>

Parse a cvm object Value into a typed frame, verifying the type discriminator. Returns None when value is not an open-stream frame or fails to parse.

pub fn is_frame_value(value: &Value) -> bool

Returns true when value structurally looks like an open-stream frame (type == "open-stream" and a string frameType).

Mirrors the TS isOpenStreamFrame structural narrowing.

pub fn into_progress_notification( &self, progress_token: &str, progress: u64, message: Option<&str>, ) -> Result<JsonRpcNotification, Error>

Wrap this frame in a notifications/progress JsonRpcNotification.

Builds the outer params with progressToken, progress, an optional human-readable message (non-normative UX), and the cvm frame. The token is always emitted as a JSON string, even when the originating request carried a numeric one (matching the TS SDK’s String(progressToken)); see progress_token_string.

Trait Implementations

impl Clone for OpenStreamFrame

fn clone(&self) -> OpenStreamFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OpenStreamFrame

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OpenStreamFrame

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for OpenStreamFrame

impl PartialEq for OpenStreamFrame

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for OpenStreamFrame

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OpenStreamFrame