Enum WebSocketOperation 

pub enum WebSocketOperation {
    Connect {
        url: RexUrl,
        rex_id: RexId,
    },
    Read {
        connection_rex_id: RexId,
        mode: WebSocketReadMode,
    },
    Send {
        connection_rex_id: RexId,
        messages: Vec<RexValue>,
    },
    Close {
        connection_rex_id: RexId,
    },
}

WebSocket operation types for the WebSocket REX.

This enum defines the different operations that can be performed on WebSocket connections. All WebSocket operations are handled through a single TargetRexProgram::WebSocket variant.

Variants

• Connect - Establish a new WebSocket connection to an external server
• Read - Read the latest data from an existing WebSocket connection

Future Extensions

Additional operations like Send and Close may be added in the future.

Variants

Connect

Establish a new WebSocket connection.

When this operation is executed:

• A validator is randomly selected to handle the connection
• The TEE establishes the WebSocket connection to the specified URL
• On success, the connection is registered in the WebSocket Registry
• The assigned validator is recorded for future routing

Fields

url: RexUrl

WebSocket URL (typically wss://…)

rex_id: RexId

The RexId that represents this connection request

Read

Read data from an existing WebSocket connection.

When this operation is executed:

• The operation is automatically routed to the TEE holding the connection
• Returns messages from the connection’s buffer based on the read mode
• The referenced connection must exist and be active

Read Modes

• Latest (default): Returns only the most recent message
• All: Returns all accumulated messages in the buffer
• FromIndex(n): Returns all messages with index > n, with gap detection

Validation

The handler implementation must verify that:

• connection_rex_id references an existing Connect operation in the WebSocket Registry
• The connection is still active and hasn’t been closed
• The requesting validator has permission to read from this connection

Error Handling

If validation fails, the REX should return an appropriate error indicating:

• ConnectionNotFound - if the referenced REX ID doesn’t exist
• ConnectionClosed - if the connection has been terminated
• InvalidConnectionType - if the referenced REX is not a WebSocket Connect operation

Fields

connection_rex_id: RexId

References the RexId of the Connect operation that established the connection

mode: WebSocketReadMode

The read mode determining which messages to return (defaults to Latest for backward compatibility)

Send

Send messages to an existing WebSocket connection.

When this operation is executed:

• The operation is automatically routed to the TEE holding the connection
• Each RexValue in messages is sent as a separate WebSocket message
• The inner value is extracted: Plain(String) → sent as-is, Encrypted(String) → decrypted then sent
• Returns the number of messages successfully sent
• The referenced connection must exist and be active

Validation

The handler implementation must verify that:

• connection_rex_id references an existing Connect operation in the WebSocket Registry
• The connection is still active and hasn’t been closed
• The requesting validator has permission to send to this connection

Error Handling

If validation fails, the REX should return an appropriate error indicating:

• ConnectionNotFound - if the referenced REX ID doesn’t exist
• ConnectionClosed - if the connection has been terminated
• InvalidConnectionType - if the referenced REX is not a WebSocket Connect operation
• SecretDecryptionFailed - if an encrypted message cannot be decrypted

Fields

connection_rex_id: RexId

References the RexId of the Connect operation that established the connection

messages: Vec<RexValue>

Messages to send to the WebSocket connection Each RexValue will be sent as a separate WebSocket message

Close

Close an existing WebSocket connection.

When this operation is executed:

• The operation is automatically routed to the TEE holding the connection
• The WebSocket connection is gracefully closed
• The connection status in the WebSocket Registry is updated to Closed
• The referenced connection must exist and be active

Validation

The handler implementation must verify that:

• connection_rex_id references an existing Connect operation in the WebSocket Registry
• The requesting validator has permission to close this connection

Error Handling

If validation fails, the REX should return an appropriate error indicating:

• ConnectionNotFound - if the referenced REX ID doesn’t exist
• ConnectionAlreadyClosed - if the connection has already been terminated
• InvalidConnectionType - if the referenced REX is not a WebSocket Connect operation

Fields

connection_rex_id: RexId

References the RexId of the Connect operation to close

Implementations

impl WebSocketOperation

pub fn connect(url: impl Into<RexUrl>, rex_id: RexId) -> Self

Create a new Connect operation.

pub fn read(connection_rex_id: RexId) -> Self

Create a new Read operation with default Latest mode.

pub fn read_with_mode(connection_rex_id: RexId, mode: WebSocketReadMode) -> Self

Create a new Read operation with a specific mode.

pub fn send(connection_rex_id: RexId, messages: Vec<RexValue>) -> Self

Create a new Send operation.

pub fn close(connection_rex_id: RexId) -> Self

Create a new Close operation.

pub fn is_connect(&self) -> bool

Returns true if this is a Connect operation.

pub fn is_read(&self) -> bool

Returns true if this is a Read operation.

pub fn is_send(&self) -> bool

Returns true if this is a Send operation.

pub fn is_close(&self) -> bool

Returns true if this is a Close operation.

pub fn url(&self) -> Option<&RexUrl>

Returns the URL if this is a Connect operation, None otherwise.

pub fn rex_id(&self) -> Option<&RexId>

Returns the rex_id if this is a Connect operation, None otherwise.

pub fn connection_rex_id(&self) -> Option<&RexId>

Returns the connection_rex_id if this is a Read, Send, or Close operation, None otherwise.

pub fn read_mode(&self) -> Option<&WebSocketReadMode>

Returns the read mode if this is a Read operation, None otherwise.

pub fn messages(&self) -> Option<&[RexValue]>

Returns the messages if this is a Send operation, None otherwise.

Trait Implementations

impl BorshDeserialize for WebSocketOperation

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for WebSocketOperation

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl Clone for WebSocketOperation

fn clone(&self) -> WebSocketOperation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WebSocketOperation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WebSocketOperation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for WebSocketOperation

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

Formats the value using the given formatter.

impl EnumExt for WebSocketOperation

fn deserialize_variant<__R: Read>( reader: &mut __R, variant_tag: u8, ) -> Result<Self, Error>

Deserialises given variant of an enum from the reader.

impl Eq for WebSocketOperation

impl PartialEq for WebSocketOperation

fn eq(&self, other: &WebSocketOperation) -> 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 Serialize for WebSocketOperation

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 WebSocketOperation