Enum IngressEvent 

pub enum IngressEvent {
    EnvelopeFrom {
        src_peer: PeerId,
        envelope: WireEnvelope,
        src_observed_address: Option<Address>,
    },
    AppEvent {
        module_name: String,
        input_name: String,
        value_bytes: Vec<u8>,
    },
    TimerMatured {
        at_ns: u64,
    },
    Invoke {
        module_name: String,
        inputs: Vec<(String, Vec<u8>)>,
        exec_id: ExecId,
    },
    Completion {
        cmd_id: CommandId,
        results: Vec<Vec<u8>>,
    },
    CompletionFailed {
        cmd_id: CommandId,
        detail: String,
    },
    SendFailed {
        wire_req_id: u64,
        peer: Vec<u8>,
        reason: &'static str,
    },
    AppIngressError {
        source: AppIngressSource,
        byte_count: usize,
        kind: AppIngressErrorKind,
    },
}

External-event variants pushed to the ingress queue per docs/ENGINE.md §6 entry points.

Variants

EnvelopeFrom

Inbound wire envelope from the transport layer, attributed to a source peer. The engine calls PeerGovernor::check_inbound(src_peer) on ingress; blocked or non-allowlisted peers are dropped before any slot is written, surfacing as EngineStep::PeerBlocked.

Fields

src_peer: PeerId

Peer the envelope arrived from.

envelope: WireEnvelope

The envelope payload.

src_observed_address: Option<Address>

Transport-observed source address, when the adapter can supply it (e.g. NAT-translated remote endpoint, dialer’s observed multiaddr). The receiver merges this into its AddressBook entry for src_peer so reflexive-address discovery composes with the sender-claimed envelope.src_peer_addresses list. None means the transport didn’t surface an observed address.

AppEvent

Host pushed an app event onto a Module input.

Fields

module_name: String

Target Module’s name.

input_name: String

Module input port name.

value_bytes: Vec<u8>

Encoded value payload.

TimerMatured

External timer maturity signal (used when an off-thread scheduler drives the engine).

Fields

at_ns: u64

Maturity timestamp (nanoseconds).

Invoke

Explicit Module invocation from host.

Fields

module_name: String

Target Module’s name.

inputs: Vec<(String, Vec<u8>)>

(input_name, value_bytes) pairs.

exec_id: ExecId

ExecId allocated by Node::invoke so the host can correlate EngineStep::AppEvent / OpCompleted / AsyncSuspended outputs back to the originating call.

Completion

External (off-thread) async completion landing back at the engine.

Fields

cmd_id: CommandId

The CommandId being fulfilled.

results: Vec<Vec<u8>>

Encoded output payloads.

CompletionFailed

Async completion FAILURE landing back at the engine. Distinct from Completion: CompletionSink::fail mints this variant directly so handle_completion_failed can route to the typed OpFailed surface — the host sees a real error, not a success-bytes masquerade.

Fields

cmd_id: CommandId

The CommandId whose await failed.

detail: String

Human-readable failure detail; the runtime wraps it into bus::OpError on the engine side.

SendFailed

Transport-side send-outcome failure surfaced by an adapter (libp2p, sim, etc.) when the network NAKed an outbound envelope or its delivery deadline elapsed without an ACK. Distinct from CompletionFailed (which covers off-thread compute completion); this variant covers transport-layer delivery failure.

Fields

wire_req_id: u64

The wire request id of the failed outbound envelope.

peer: Vec<u8>

The destination peer that NAKed or timed out (raw multihash bytes so the engine can reconstruct PeerId::from_bytes(&peer)).

reason: &'static str

Stable diagnostic label (e.g. "nak", "timeout", "network_unreachable"). Adapters pick from a fixed vocabulary so consumers can match on the label.

AppIngressError

Off-thread application-ingress failure (currently only CompletionSink::complete exceeding the per-completion result cap). The engine drains this variant and publishes a matching InfraEvent::AppIngressError on the bus so subscribers see the rejection. The synchronous Node::deliver_event / Node::invoke path publishes directly with &mut bus access; this variant is the cross-thread bridge for sinks that don’t hold a bus reference. The Component observes an async-op timeout in place of the dropped completion.

Fields

source: AppIngressSource

Which application-side entry point raised the failure.

byte_count: usize

Bytes the boundary was asked to admit.

kind: AppIngressErrorKind

Which failure mode fired.

Implementations

impl IngressEvent

pub fn from_in_process(src_peer: PeerId, envelope: WireEnvelope) -> Self

Construct an EnvelopeFrom for the in-process router common case where the transport carries no NAT and the observed address is the sender’s PeerId-tagged multiaddr. Test buses and the in-process router call this so observed-address propagation exercises the same merge path as a real transport’s reflexive surface.

Trait Implementations

impl Debug for IngressEvent

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

Formats the value using the given formatter.