Struct EventGraph 

pub struct EventGraph {

    p2p: P2pPtr,
    dag_store: RwLock<DAGStore>,
    static_dag: Tree,
    datastore: PathBuf,
    replay_mode: bool,
    broadcasted_ids: RwLock<HashSet<Hash>>,
    pub prune_task: OnceCell<StoppableTaskPtr>,
    pub event_pub: PublisherPtr<Event>,
    pub static_pub: PublisherPtr<Event>,
    pub current_genesis: RwLock<Event>,
    hours_rotation: u64,
    pub synced: RwLock<bool>,
    pub deg_enabled: RwLock<bool>,
    deg_publisher: PublisherPtr<DegEvent>,
    fast_mode: bool,
    sled_db: Db,
    pub rln_identity_tree: RwLock<SmtMemoryFp>,
}

An Event Graph instance

Fields

p2p: P2pPtr

Pointer to the P2P network instance

dag_store: RwLock<DAGStore>

Sled tree containing the headers

static_dag: Tree

Static DAG

datastore: PathBuf

Replay logs path.

replay_mode: bool

Run in replay_mode where if set we log Sled DB instructions into datastore, useful to reacreate a faulty DAG to debug.

broadcasted_ids: RwLock<HashSet<Hash>>

A HashSet containg event IDs and their 1-level parents. These come from the events we’ve sent out using EventPut. They are used with EventReq to decide if we should reply or not. Additionally it is also used when we broadcast the TipRep message telling peers about our unreferenced tips.

prune_task: OnceCell<StoppableTaskPtr>

DAG Pruning Task

event_pub: PublisherPtr<Event>

Event publisher, this notifies whenever an event is inserted into the DAG

static_pub: PublisherPtr<Event>

Static Event publisher, this notifies whenever a static event is inserted into the static DAG

current_genesis: RwLock<Event>

Current genesis event

hours_rotation: u64

Currently configured DAG rotation, in hours

synced: RwLock<bool>

Flag signalling DAG has finished initial sync

deg_enabled: RwLock<bool>

Enable graph debugging

deg_publisher: PublisherPtr<DegEvent>

The publisher for which we can give deg info over

fast_mode: bool

Run in fast mode where if set we sync only headers.

sled_db: Db

sled DB

rln_identity_tree: RwLock<SmtMemoryFp>

RLN identity storage

Implementations

impl EventGraph

pub async fn new( p2p: P2pPtr, sled_db: Db, datastore: PathBuf, replay_mode: bool, fast_mode: bool, hours_rotation: u64, ex: Arc<Executor<'_>>, ) -> Result<EventGraphPtr>

Create a new EventGraph instance, creates a new Genesis event and checks if it is containd in DAG, if not prunes DAG, may also start a pruning task based on hours_rotation, and return an atomic instance of Self

• p2p atomic pointer to p2p.
• sled_db sled DB instance.
• datastore path where we should log db instrucion if run in replay mode.
• replay_mode set the flag to keep a log of db instructions.
• hours_rotation marks the lifetime of the DAG before it’s pruned.

pub fn hours_rotation(&self) -> u64

pub async fn dag_sync(&self, dag: Tree, fast_mode: bool) -> Result<()>

Sync the DAG from connected peers

pub async fn sync_selected(&self, count: usize, fast_mode: bool) -> Result<()>

Choose how many dags to sync

async fn dag_prune(&self, genesis_event: Event) -> Result<()>

Atomically prune the DAG and insert the given event as genesis.

async fn dag_prune_task(self: Arc<Self>, hours_rotation: u64) -> Result<()>

Background task periodically pruning the DAG.

pub async fn dag_insert( &self, events: &[Event], dag_name: &str, ) -> Result<Vec<Hash>>

Atomically insert given events into the DAG and return the event IDs. All provided events must be valid. An overlay is used over the DAG tree, temporary writting each event in order. After all events have been validated and inserted successfully, we write the overlay to sled. This will append the new events into the unreferenced tips set, and remove the events’ parents from it. It will also append the events’ level-1 parents to the broadcasted_ids set, so the P2P protocol knows that any requests for them are actually legitimate. TODO: The broadcasted_ids set should periodically be pruned, when some sensible time has passed after broadcasting the event.

pub async fn header_dag_insert( &self, headers: Vec<Header>, dag_name: &str, ) -> Result<()>

pub async fn fetch_event_from_dags( &self, event_id: &Hash, ) -> Result<Option<Event>>

Search and fetch an event through all DAGs

async fn get_next_layer_with_parents(&self, dag_name: &u64) -> (u64, [Hash; 5])

Get next layer along with its N_EVENT_PARENTS from the unreferenced tips of the DAG. Since tips are mapped by their layer, we go backwards until we fill the vector, ensuring we always use latest layers tips as parents.

async fn find_unreferenced_tips_static(&self, dag: &Tree) -> LayerUTips

Find the unreferenced tips in the current DAG state, mapped by their layers.

async fn get_next_layer_with_parents_static(&self) -> (u64, [Hash; 5])

async fn get_unreferenced_tips_sorted(&self) -> Vec<[Hash; 5]>

Internal function used for DAG sorting.

pub async fn order_events(&self) -> Vec<Event>

Perform a topological sort of the DAG.

async fn dfs_topological_sort( &self, event: Event, visited: &mut HashSet<Hash>, ) -> VecDeque<(u64, Event)>

We do a non-recursive DFS (https://en.wikipedia.org/wiki/Depth-first_search), and additionally we consider the timestamps.

pub async fn deg_enable(&self)

Enable graph debugging

pub async fn deg_disable(&self)

Disable graph debugging

pub async fn deg_subscribe(&self) -> Subscription<DegEvent>

Subscribe to deg events

pub async fn deg_notify(&self, event: DegEvent)

Send a deg notification over the publisher

pub async fn eventgraph_info(&self, id: u16, _params: JsonValue) -> JsonResult

pub async fn fetch_headers_with_tips( &self, dag_name: &str, tips: &LayerUTips, ) -> Result<Vec<Header>>

Fetch all events that are not ancestors of the tips

async fn get_ancestors( &self, visited: &mut HashSet<Hash>, header: Header, tree: &Tree, ) -> Result<()>

Finds all the ancestors of an event

pub async fn fetch_successors_of(&self, tips: LayerUTips) -> Result<Vec<Event>>

Fetch all the events that are on a higher layers than the provided ones.

pub async fn static_new(sled_db: &Db) -> Result<Tree>

pub async fn static_sync(&self) -> Result<()>

pub async fn static_broadcast(&self, event: Event, blob: Vec<u8>) -> Result<()>

pub async fn static_insert(&self, event: &Event) -> Result<()>

pub async fn static_fetch(&self, event_id: &Hash) -> Result<Option<Event>>

pub async fn static_fetch_all(&self) -> Result<Vec<Event>>

pub async fn static_unreferenced_tips(&self) -> LayerUTips