Enum CrdtType 

pub enum CrdtType {
    LwwRegister {
        inner_type: String,
    },
    GCounter,
    PnCounter,
    Rga,
    UnorderedMap {
        key_type: String,
        value_type: String,
    },
    UnorderedSet {
        element_type: String,
    },
    Vector {
        element_type: String,
    },
    UserStorage,
    FrozenStorage,
    Custom(String),
}

CRDT type indicator for merge semantics.

Identifies the conflict resolution strategy used when merging replicated data. This enum is used both by the storage layer (for persistence metadata) and the sync protocol (for wire-format entity classification).

Merge Semantics

Each variant defines specific merge behavior:

• Registers: LwwRegister (timestamp-based)
• Counters: GCounter (grow-only), PnCounter (increment/decrement)
• Collections: Rga, UnorderedMap, UnorderedSet, Vector
• Special: UserStorage, FrozenStorage, Custom

Variants

LwwRegister

Last-Writer-Wins Register.

Wraps primitive types with timestamp-based conflict resolution. Merge: Higher HLC timestamp wins, with node ID as tie-breaker.

The inner type name enables proper deserialization during merge.

Fields

inner_type: String

Inner type name (e.g., “String”, “u64”, “MyStruct”)

GCounter

Grow-only Counter.

Supports only increment operations; value can never decrease. Internally tracks increments per executor. Merge: Take maximum of each executor’s count.

PnCounter

Positive-Negative Counter.

Supports both increment and decrement operations. Internally uses two maps: positive and negative counts per executor. Merge: Union of positive maps, union of negative maps, then compute difference.

Rga

Replicated Growable Array.

CRDT for collaborative text editing and ordered sequences. Supports concurrent insertions and deletions with causal ordering. Merge: Interleave elements by (timestamp, node_id) ordering.

UnorderedMap

Unordered Map.

Key-value store with add-wins semantics for keys. Keys are never lost once added (tombstoned but retained). Values are merged recursively if they implement Mergeable. Merge: Union of keys, recursive merge of values.

Fields

key_type: String

Key type name

value_type: String

Value type name (may be a nested CRDT)

UnorderedSet

Unordered Set.

Collection of unique values with add-wins semantics. Elements are never lost once added. Merge: Union of all elements from both sets.

Fields

element_type: String

Element type name

Vector

Vector (ordered collection).

Ordered list with append operations. Elements are identified by index + timestamp for ordering. Merge: Element-wise merge by index with timestamp ordering.

Fields

element_type: String

Element type name (may be a nested CRDT)

UserStorage

User Storage.

Per-user data storage with signature-based access control. Only the owning user (identified by executor ID) can modify their data. Merge: Latest update per user based on nonce/timestamp.

FrozenStorage

Frozen Storage.

Write-once storage for immutable data. Data can be written once and never modified or deleted. Merge: First-write-wins (subsequent writes are no-ops).

Custom(String)

Custom CRDT with app-defined merge.

For types annotated with #[derive(CrdtState)] that define custom merge logic. The string identifies the custom type name within the application. Merge: Dispatched to WASM runtime to call the app’s merge function.

Implementations

impl CrdtType

pub fn lww_register(inner_type: impl Into<String>) -> CrdtType

Create an LwwRegister with a known inner type.

pub fn unordered_map( key_type: impl Into<String>, value_type: impl Into<String>, ) -> CrdtType

Create an UnorderedMap with known key and value types.

pub fn unordered_set(element_type: impl Into<String>) -> CrdtType

Create an UnorderedSet with a known element type.

pub fn vector(element_type: impl Into<String>) -> CrdtType

Create a Vector with a known element type.

pub const fn is_counter(&self) -> bool

Returns true if this is a counter type (GCounter or PnCounter).

pub const fn is_set(&self) -> bool

Returns true if this is a set type.

pub const fn is_collection(&self) -> bool

Returns true if this is a collection type (map, set, vector, or array).

pub const fn is_custom(&self) -> bool

Returns true if this is a custom CRDT type.

pub const fn is_special_storage(&self) -> bool

Returns true if this type requires special storage handling.

Trait Implementations

impl BorshDeserialize for CrdtType

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

where __R: Read,

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 CrdtType

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

where __W: Write,

impl Clone for CrdtType

fn clone(&self) -> CrdtType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CrdtType

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

Formats the value using the given formatter.

impl Default for CrdtType

fn default() -> CrdtType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CrdtType

fn deserialize<__D>( __deserializer: __D, ) -> Result<CrdtType, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EnumExt for CrdtType

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

where __R: Read,

Deserialises given variant of an enum from the reader.

impl Ord for CrdtType

fn cmp(&self, other: &CrdtType) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for CrdtType

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

fn partial_cmp(&self, other: &CrdtType) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for CrdtType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CrdtType

impl StructuralPartialEq for CrdtType