Struct SingletonAgent

pub struct SingletonAgent<R, A: Agent + RecordedAgent<R>> { /* private fields */ }

Implementation of agent set for a single agent

Convenience implementation of the AgentSet trait for a set containing a single agent

Examples

use rand::RngCore;
use alloy_primitives::Address;
use verbs_rs::{DB, env::{Env, Validator}};
use verbs_rs::agent::{Agent, RecordedAgent, SingletonAgent, AgentSet};
use verbs_rs::contract::Transaction;

struct DummyAgent{}

impl Agent for DummyAgent {
    fn update<D: DB, V: Validator, R: RngCore>(
        &mut self, rng: &mut R, network: &mut Env<D, V>
    ) -> Vec<Transaction> {
        Vec::default()
    }

    fn get_address(&self) -> Address {
        Address::ZERO
    }
}

impl RecordedAgent<bool> for DummyAgent {
    fn record<D: DB, V: Validator>(&mut self, _env: &mut Env<D, V>) -> bool {
        true
    }
}

let singleton_agent = SingletonAgent::<bool, DummyAgent>::from(
    DummyAgent{}
);

let addresses = singleton_agent.get_addresses();

Implementations

impl<R, A: Agent + RecordedAgent<R>> SingletonAgent<R, A>

pub fn from(agent: A) -> Self

Initialise an from an existing agents.

Arguments

• agent - Agent controlled by the agent-set

pub fn get_records(&self) -> &Vec<R>

Get the recorded history of the agent.

pub fn take_records(&mut self) -> Vec<R>

Take ownership of recorded data of the agent.

Trait Implementations

impl<R: 'static, A: Agent + RecordedAgent<R> + 'static> AgentSet for SingletonAgent<R, A>

Implementations of agent updates and recording.

fn call<D: DB, V: Validator, RG: RngCore>( &mut self, rng: &mut RG, env: &mut Env<D, V>, ) -> Vec<Transaction>

Call the agent and optionally return EVM call

This is called during the simulation, updating the state of the agents, and collecting any submitted transactions into a single vector.

Arguments

• rng - Random generator
• network - Protocol deployment(s)

fn record<D: DB, V: Validator>(&mut self, env: &mut Env<D, V>)

Record the current state of the agent

fn get_addresses(&self) -> Vec<Address>

Get the address of the agent as a vector

impl<R, A: Agent + RecordedAgent<R>> RecordedAgentSet<R> for SingletonAgent<R, A>

fn take_records(&mut self) -> Vec<Vec<R>>