Struct TapNode

pub struct TapNode { /* private fields */ }

The TAP Node

The TAP Node is the core component responsible for coordinating message processing, routing, and delivery to TAP Agents. It serves as a central hub for all TAP communications and transaction coordination.

Core Responsibilities

• Agent Management: Registration and deregistration of TAP Agents
• Message Processing: Processing incoming and outgoing messages through middleware chains
• Message Routing: Determining the appropriate recipient for each message
• Event Publishing: Broadcasting node events to subscribers
• Scalability: Managing concurrent message processing through worker pools

Lifecycle

1. Create a node with appropriate configuration
2. Register one or more agents with the node
3. Start the processor pool (if high throughput is required)
4. Process incoming/outgoing messages
5. Publish and respond to events

Thread Safety

The TapNode is designed to be thread-safe and can be shared across multiple threads using an Arc<TapNode>. All internal mutability is handled through appropriate synchronization primitives.

Implementations

impl TapNode

pub fn new(config: NodeConfig) -> Self

Create a new TAP node with the given configuration

pub async fn start(&mut self, config: ProcessorPoolConfig) -> Result<()>

Start the node

pub async fn receive_message(&self, message: Message) -> Result<()>

Receive and process an incoming message

This method handles the complete lifecycle of an incoming message:

1. Processing the message through all registered processors
2. Routing the message to determine the appropriate target agent
3. Dispatching the message to the target agent

The processing pipeline may transform or even drop the message based on validation rules or other processing logic. If a message is dropped during processing, this method will return Ok(()) without an error.

Parameters

• message - The DIDComm message to be processed

Returns

• Ok(()) if the message was successfully processed and dispatched (or intentionally dropped)
• Err(Error) if there was an error during processing, routing, or dispatching

Errors

This method can return errors for several reasons:

• Processing errors from message processors
• Routing errors if no target agent can be determined
• Dispatch errors if the target agent cannot be found or fails to process the message

Example

// Process an incoming message
node.receive_message(message).await?;

pub async fn dispatch_message( &self, target_did: String, message: Message, ) -> Result<()>

Dispatch a message to an agent by DID

pub async fn send_message( &self, from_did: &str, to_did: &str, message: Message, ) -> Result<String>

Send a message from one agent to another

This method handles the processing, routing, and delivery of a message from one agent to another. It returns the packed message.

pub async fn register_agent(&self, agent: Arc<DefaultAgent>) -> Result<()>

Register a new agent with the node

pub async fn unregister_agent(&self, did: &str) -> Result<()>

Unregister an agent from the node

pub fn get_all_agent_dids(&self) -> Vec<String>

Get all registered agent DIDs

pub fn get_event_bus(&self) -> Arc<EventBus>

Get the event bus

pub fn get_resolver(&self) -> Arc<NodeResolver>

Get the resolver

pub fn config(&self) -> &NodeConfig

Get the node config

pub fn agents(&self) -> &AgentRegistry

Get the agent registry

Trait Implementations

impl Clone for TapNode

fn clone(&self) -> TapNode

Returns a copy of the value.

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

Performs copy-assignment from source.