Enum EntryKind 

pub enum EntryKind {
    StepResult {
        idempotency_key: IdempotencyKey,
        payload: Bytes,
        effect: EffectClass,
        payload_version: u8,
    },
    EffectIntent {
        idempotency_key: IdempotencyKey,
        effect: EffectClass,
        hmac: Option<[u8; 32]>,
    },
    PromiseCreated {
        promise_id: PromiseId,
        resolver_token_hash: [u8; 32],
        hmac: Option<[u8; 32]>,
    },
    PromiseResolved {
        promise_id: PromiseId,
        payload: Bytes,
    },
    TimerArmed {
        timer_id: TimerId,
        due_at_ms: i64,
        hmac: Option<[u8; 32]>,
    },
    TimerFired {
        timer_id: TimerId,
    },
    Checkpoint {
        up_to_step: u32,
        snapshot: Bytes,
    },
}

The kind of a single journal entry.

A closed enum: an exhaustive match over its variants is required, which guarantees every replay-relevant entry shape is handled. Only the variants that genuinely carry data (StepResult, PromiseResolved, Checkpoint) own a payload/snapshot field; the control entries hold identifiers and an optional row-level HMAC instead, so an illegal “control entry with payload” is unrepresentable.

Variants

StepResult

The committed result of a completed step. The payload is AEAD-sealed (nonce || ciphertext || tag).

Fields

idempotency_key: IdempotencyKey

Deduplication key for the step’s effect.

payload: Bytes

Sealed result bytes.

effect: EffectClass

How the step’s side effect behaves under replay.

payload_version: u8

Wire-format version discriminator for the sealed payload.

EffectIntent

An intent to run an exactly-once-guarded effect, journaled before the effect fires.

Fields

idempotency_key: IdempotencyKey

Deduplication key for the guarded effect.

effect: EffectClass

How the step’s side effect behaves under replay.

hmac: Option<[u8; 32]>

Row-level HMAC for shared-DB / Restate deployments; None for single-user SQLite.

PromiseCreated

Creation of an external-completion promise.

Fields

promise_id: PromiseId

The new promise’s identifier.

resolver_token_hash: [u8; 32]

BLAKE3 hash of the 32-byte resolver token (the token itself is never journaled).

hmac: Option<[u8; 32]>

Row-level HMAC for shared-DB / Restate deployments; None for single-user SQLite.

PromiseResolved

Resolution of a previously-created promise with its sealed result.

Fields

promise_id: PromiseId

The resolved promise’s identifier.

payload: Bytes

Sealed resolution bytes.

TimerArmed

A durable timer was armed to fire at a persisted instant.

Fields

timer_id: TimerId

The armed timer’s identifier.

due_at_ms: i64

Wake instant, as Unix epoch milliseconds.

hmac: Option<[u8; 32]>

Row-level HMAC for shared-DB / Restate deployments; None for single-user SQLite.

TimerFired

A previously-armed timer fired.

Fields

timer_id: TimerId

The fired timer’s identifier.

Checkpoint

A checkpoint fold that compacts the idempotent prefix up to a step.

Fields

up_to_step: u32

All steps strictly below this id are folded into the snapshot.

snapshot: Bytes

Sealed snapshot bytes.

Implementations

impl EntryKind

pub fn tag_enum(&self) -> EntryKindTag

Return the data-free EntryKindTag discriminator for this entry.

This is the bridge a backend uses to build the PayloadAad for an entry without exposing the payload to the cipher binding logic.

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

Return the canonical string used in the entry_kind column.

The step_result tag in particular is the predicate of the unique partial index that enforces “at most one committed result per step”. Delegates to EntryKindTag::as_str so the column strings have a single source of truth.

pub fn idempotency_key(&self) -> Option<IdempotencyKey>

Return the entry’s IdempotencyKey, for the two step-bearing kinds that carry one.

The replay-divergence guard (INV-3) compares the journaled key of a StepResult / EffectIntent against the key freshly derived from the replayed descriptor; control and promise/timer entries have no idempotency key and return None.

Trait Implementations

impl Clone for EntryKind

fn clone(&self) -> EntryKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EntryKind

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

Formats the value using the given formatter.

impl Eq for EntryKind

impl PartialEq for EntryKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for EntryKind