Enum EffectCommand 

pub enum EffectCommand {
    ChargeBudget {
        context: ContextId,
        authority: AuthorityId,
        peer: AuthorityId,
        amount: FlowCost,
    },
    AppendJournal {
        entry: JournalEntry,
    },
    RecordLeakage {
        bits: u32,
    },
    StoreMetadata {
        key: String,
        value: String,
    },
    SendEnvelope {
        to: NetworkAddress,
        peer_id: Option<Uuid>,
        envelope: Vec<u8>,
    },
    GenerateNonce {
        bytes: u32,
    },
}

Minimal, domain-agnostic effect commands

These are the primitive algebraic operations that guards can request. They represent what should happen, not how it happens.

Variants

ChargeBudget

Charge flow budget for spam/DoS protection

Fields

context: ContextId

Context being charged

authority: AuthorityId

Authority to charge

peer: AuthorityId

Peer being communicated with (if applicable)

amount: FlowCost

Amount to charge

AppendJournal

Append entry to the journal

Fields

entry: JournalEntry

Journal entry to append

RecordLeakage

Record metadata leakage for privacy analysis

Fields

bits: u32

Number of metadata bits revealed

StoreMetadata

Store metadata key-value pair

Fields

key: String

Storage key

value: String

Storage value

SendEnvelope

Send envelope to network address

Fields

to: NetworkAddress

Target address

peer_id: Option<Uuid>

Optional explicit peer ID (avoids address-derived IDs)

envelope: Vec<u8>

Envelope payload

GenerateNonce

Generate cryptographic nonce

Fields

bytes: u32

Number of random bytes needed

Trait Implementations

impl Clone for EffectCommand

fn clone(&self) -> EffectCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EffectCommand

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EffectCommand

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EffectCommand

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.