Struct SideEffectStore 

pub struct SideEffectStore { /* private fields */ }

Store the mapping from (LyquidID, ChainPos, SideEffectKind) to slot execution side-effects.

Implementations

impl SideEffectStore

pub fn new(store: Arc<dyn KVStore>, cache_size: usize) -> Self

Create a side-effect store backed by the given key-value store.

cache_size controls the in-memory LRU cache used for output payload reads.

pub fn write_outputs( &self, changes: HashMap<SideEffectKey, EventOutputs>, ) -> Result<(), SideEffectStoreError>

Persist slot side-effect payloads.

Semantics:

• Insert-only writes: this API persists slot outputs, and does not support deletion/tombstones.
• Replay idempotency: writing the same key with the same payload is accepted.
• Conflict protection: writing the same key with a different payload returns ConflictingReplay.

Concurrency model:

• Designed for a single writer per backing keyspace, with multiple concurrent readers.
• Cache lock scope is intentionally short:
  1. classify keys by cache hit/miss,
  2. perform store I/O without holding the cache lock,
  3. update cache after successful persistence.

pub fn upsert_inter_call_output( &self, key: InterCallOutputKey, output: CallEventOutput, ) -> Result<(), SideEffectStoreError>

Persist the single output for one injected inter-call slot.

The key identifies one (callee, pos, inter_call_seq) slot. Replaying the same output is accepted; attempting to overwrite an existing output with a different value returns ConflictingCallOutputReplay.

pub fn read_inter_call_output( &self, key: InterCallOutputKey, ) -> Result<Option<CallEventOutput>, SideEffectStoreError>

Read the stored output for one injected inter-call slot.

Returns:

• None if the slot has no persisted side effects yet
• Some(None) if the slot completed without an output payload
• Some(Some(bytes)) if the slot produced output bytes

pub fn append_inbound_inter_calls<I>( &self, inbound_calls: I, ) -> Result<(), SideEffectStoreError>

where I: IntoIterator<Item = InboundInterCall>,

Append multiple observed inbound inter-call records.

Records are grouped by callee, validated, merged idempotently, and stored in order_key order for each callee.

pub fn read_inbound_inter_calls( &self, lyquid: LyquidID, from_exclusive: Option<CallOrderKey>, until_exclusive: ChainPos, limit: usize, ) -> Result<Vec<InboundInterCall>, SideEffectStoreError>

Read inbound inter-call records for one callee in ascending order_key order.

Only records with from_exclusive < order_key and call.pos < until_exclusive are returned, up to limit entries.