Enum RexValue 

pub enum RexValue {
    Plain(Vec<u8>),
    Encrypted(Vec<u8>),
}

Represents a value that can be either plain text or encrypted.

This enum is used to handle REX data that may contain sensitive information that needs to be encrypted when transmitted or stored, while also supporting plain text values for non-sensitive data.

Both variants accept JSON strings or byte arrays during deserialization. Serialization always outputs the canonical byte-array format.

Variants

• Plain(Vec<u8>) - A plain text value that is not encrypted. Accepts a JSON string (e.g., {"Plain": "hello"}) or byte array.
• Encrypted(Vec<u8>) - Encrypted ciphertext. When passed as a JSON string, the value should be base64-encoded ciphertext for TEE decryption. No base64 validation is performed at deserialization time.

Variants

Plain(Vec<u8>)

Encrypted(Vec<u8>)

Implementations

impl RexValue

pub fn plain(data: Vec<u8>) -> Self

Create a plain value from raw bytes.

pub fn plain_string(s: impl Into<String>) -> Self

Create a plain value from a string (convenience method).

This is the preferred way to create an RexValue from string data after the migration from string-based RexValue.

pub fn encrypted(ciphertext: Vec<u8>) -> Self

Create an encrypted value from raw ciphertext bytes.

pub fn as_string(&self) -> Option<&str>

Get the inner data as a string slice, if it’s valid UTF-8.

Returns Some(&str) if the data is valid UTF-8, None otherwise. Only works on Plain variants; Encrypted always returns None.

pub fn as_bytes(&self) -> &[u8]

Get the inner data as a byte slice.

Works on both Plain and Encrypted variants.

pub fn is_plain(&self) -> bool

Returns true if this is a Plain variant.

pub fn is_encrypted(&self) -> bool

Returns true if this is an Encrypted variant.

Trait Implementations

impl BorshDeserialize for RexValue

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 RexValue

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

impl Clone for RexValue

fn clone(&self) -> RexValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RexValue

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

Formats the value using the given formatter.

impl Default for RexValue

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RexValue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EnumExt for RexValue

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 RexValue

impl From<RexValue> for RexUrl

fn from(value: RexValue) -> Self

Converts to this type from the input type.

impl FromStr for RexValue

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for RexValue

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

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 RexValue