Struct EventEmitter 

pub struct EventEmitter { /* private fields */ }

Event publisher that manages event listeners and middleware.

Events flow through three phases:

1. Internal listeners see raw events (SDK components like ClientSyncListener)
2. Middleware chain can transform or suppress events
3. External listeners see processed events (client event handlers)

Implementations

impl EventEmitter

pub fn new(has_real_time_sync: bool) -> Self

Create a new event emitter

pub async fn add_external_listener( &self, listener: Box<dyn EventListener>, ) -> String

Add an external listener to receive events

Arguments

• listener - The listener to add

Returns

A unique identifier for the listener, which can be used to remove it later

pub async fn remove_external_listener(&self, id: &str) -> bool

Remove an external listener by its ID

Arguments

• id - The ID returned from add_listener

Returns

true if the listener was found and removed, false otherwise

pub async fn clear_external_listeners(&self)

Remove all external listeners.

Listeners are owned by the emitter, so a listener that references the SDK pins the whole instance; dropping them here on disconnect makes the instance releasable regardless of what listeners capture.

pub async fn add_internal_listener( &self, listener: Box<dyn EventListener>, ) -> String

Add an internal listener that sees all raw events before middleware processing.

Used by SDK components (e.g., ClientSyncListener) that need to observe events that middleware may suppress.

pub async fn remove_internal_listener(&self, id: &str) -> bool

Remove an internal listener by its ID

pub async fn add_middleware(&self, middleware: Box<dyn EventMiddleware>)

Add middleware to the event processing chain.

Middleware can transform or suppress events before they reach external listeners.

Middleware is owned by the emitter for its whole lifetime, so it must not hold a reference back to the emitter (directly or transitively), or the SDK object graph can never be dropped. Code that needs to emit must receive the emitter from its caller instead (see RuntimeEventHandler and TokenConverter::convert).

pub async fn emit(&self, event: &SdkEvent)

Emit an event through the three-phase pipeline:

1. Internal listeners see the raw event
2. Middleware chain can transform or suppress
3. External listeners see the processed event

pub async fn emit_synced(&self, synced: &InternalSyncedEvent)

pub async fn notify_rtsync_failed(&self)

Notify that real-time sync has failed. If the first synced event is still buffered and the wallet has already synced, release it immediately instead of waiting for a remote pull that may never arrive.

Trait Implementations

impl Default for EventEmitter

fn default() -> Self

Returns the “default value” for a type.