Struct World 

pub struct World {
    pub id: String,
    pub agents: Option<HashMap<String, Agent>>,
    pub environment: Option<Environment>,
    pub messager: Messager,
}

A world is a collection of agents that use the same type of provider, e.g., operate on the same blockchain or same Environment. The world is responsible for managing the agents and their state transitions.

How it works

The World holds on to a collection of Agents and can run them all concurrently when the [run] method is called. The World takes in AgentBuilders and when it does so, it creates Agents that are now connected to the world via a client (Arc<RevmMiddleware>) and a messager (Messager).

Fields

id: String

The identifier of the world.

agents: Option<HashMap<String, Agent>>

The agents in the world.

environment: Option<Environment>

The environment for the world.

messager: Messager

The messaging layer for the world.

Implementations

impl World

pub fn new(id: &str) -> Self

Creates a new World with the given identifier and provider.

pub fn from_config<C: CreateStateMachine + Serialize + DeserializeOwned + Debug>( config_path: &str, ) -> Result<Self, ArbiterEngineError>

Builds and adds agents to the world from a configuration file.

This method reads a configuration file specified by config_path, which should be a TOML file containing the definitions of agents and their behaviors. Each agent is identified by a unique string key, and associated with a list of behaviors. These behaviors are deserialized into instances that implement the CreateStateMachine trait, allowing them to be converted into state machines that define the agent’s behavior within the world.

Type Parameters

• C: The type of the behavior component that each agent will be associated with. This type must implement the CreateStateMachine, Serialize, DeserializeOwned, and Debug traits.

Arguments

• config_path: A string slice that holds the path to the configuration file relative to the current working directory.

Panics

This method will panic if:

• The current working directory cannot be determined.
• The configuration file specified by config_path cannot be opened.
• The configuration file cannot be read into a string.
• The contents of the configuration file cannot be deserialized into the expected HashMap<String, Vec<C>> format.

Examples

Assuming a TOML file named agents_config.toml exists in the current working directory with the following content:

[[agent1]]
BehaviorTypeA = { ... } ,
[[agent1]]
BehaviorTypeB = { ... }

[agent2]
BehaviorTypeC = { ... }

pub fn add_agent(&mut self, agent_builder: AgentBuilder)

Adds an agent, constructed from the provided AgentBuilder, to the world.

This method takes an AgentBuilder instance, extracts its identifier, and uses it to create both a RevmMiddleware client and a Messager specific to the agent. It then builds the Agent from the AgentBuilder using these components. Finally, the newly created Agent is inserted into the world’s internal collection of agents.

Panics

This method will panic if:

• It fails to create a RevmMiddleware client for the agent.
• The AgentBuilder fails to build the Agent.
• The world’s internal collection of agents is not initialized.

Examples

Assuming you have an AgentBuilder instance named agent_builder:

world.add_agent(agent_builder);

This will add the agent defined by agent_builder to the world.

pub async fn run(&mut self) -> Result<ArbiterDB, ArbiterEngineError>

Executes all agents and their behaviors concurrently within the world.

This method takes all the agents registered in the world and runs their associated behaviors in parallel. Each agent’s behaviors are executed with their respective messaging and client context. This method ensures that all agents and their behaviors are started simultaneously, leveraging asynchronous execution to manage concurrent operations.

Errors

Returns an error if no agents are found in the world, possibly indicating that the world has already been run or that no agents were added prior to execution.

Trait Implementations

impl Debug for World

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

Formats the value using the given formatter.