Historical evm events

packages/ciphernode/aggregator/src/plaintext_aggregator.rs

@@ -236,7 +236,7 @@ impl FromSnapshotWithParams for PlaintextAggregator {
 }
 
 impl Checkpoint for PlaintextAggregator {
-    fn repository(&self) -> Repository<PlaintextAggregatorState> {
-        self.store.clone()
+    fn repository(&self) -> &Repository<PlaintextAggregatorState> {
+        &self.store
     }
 }

packages/ciphernode/aggregator/src/publickey_aggregator.rs

@@ -261,7 +261,7 @@ impl FromSnapshotWithParams for PublicKeyAggregator {
 }
 
 impl Checkpoint for PublicKeyAggregator {
-    fn repository(&self) -> Repository<PublicKeyAggregatorState> {
-        self.store.clone()
+    fn repository(&self) -> &Repository<PublicKeyAggregatorState> {
+        &self.store
     }
 }

packages/ciphernode/config/src/app_config.rs

@@ -10,11 +10,39 @@ use std::{
     path::{Path, PathBuf},
 };
 
+#[derive(Debug, Deserialize, Serialize, PartialEq)]
+#[serde(untagged)]
+pub enum Contract {
+    Full {
+        address: String,
+        deploy_block: Option<u64>,
+    },
+    AddressOnly(String),
+}
+
+impl Contract {
+    pub fn address(&self) -> &String {
+        use Contract::*;
+        match self {
+            Full { address, .. } => address,
+            AddressOnly(v) => v,
+        }
+    }
+
+    pub fn deploy_block(&self) -> Option<u64> {
+        use Contract::*;
+        match self {
+            Full { deploy_block, .. } => deploy_block.clone(),
+            AddressOnly(_) => None,
+        }
+    }
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 pub struct ContractAddresses {
-    pub enclave: String,
-    pub ciphernode_registry: String,
-    pub filter_registry: String,
+    pub enclave: Contract,
+    pub ciphernode_registry: Contract,
+    pub filter_registry: Contract,
 }
 
 #[derive(Debug, Deserialize, Serialize)]

packages/ciphernode/core/src/events.rs

@@ -552,6 +552,7 @@ impl Display for Shutdown {
 #[rtype(result = "()")]
 pub struct TestEvent {
     pub msg: String,
+    pub entropy: u64,
 }
 
 #[cfg(test)]

packages/ciphernode/data/src/snapshot.rs

@@ -20,7 +20,7 @@ where
 /// This trait enables the self type to checkpoint its state
 pub trait Checkpoint: Snapshot {
     /// Declare the DataStore instance available on the object
-    fn repository(&self) -> Repository<Self::Snapshot>;
+    fn repository(&self) -> &Repository<Self::Snapshot>;
 
     /// Write the current snapshot to the `Repository` provided by `repository()`
     fn checkpoint(&self) {

packages/ciphernode/enclave_node/src/aggregator.rs

@@ -49,16 +49,25 @@ pub async fn setup_aggregator(
         let read_provider = create_readonly_provider(&ensure_ws_rpc(rpc_url)).await?;
         let write_provider =
             create_provider_with_signer(&ensure_http_rpc(rpc_url), &signer).await?;
+
         EnclaveSol::attach(
             &bus,
             &read_provider,
             &write_provider,
-            &chain.contracts.enclave,
+            &chain.contracts.enclave.address(),
+            &repositories.enclave_sol_reader(read_provider.get_chain_id()),
+            chain.contracts.enclave.deploy_block(),
+        )
+        .await?;
+        RegistryFilterSol::attach(&bus, &write_provider, &chain.contracts.filter_registry.address()).await?;
+        CiphernodeRegistrySol::attach(
+            &bus,
+            &read_provider,
+            &chain.contracts.ciphernode_registry.address(),
+            &repositories.ciphernode_registry_reader(read_provider.get_chain_id()),
+            chain.contracts.ciphernode_registry.deploy_block(),
         )
         .await?;
-        RegistryFilterSol::attach(&bus, &write_provider, &chain.contracts.filter_registry).await?;
-        CiphernodeRegistrySol::attach(&bus, &read_provider, &chain.contracts.ciphernode_registry)
-            .await?;
     }
 
     E3RequestRouter::builder(&bus, store)

packages/ciphernode/enclave_node/src/ciphernode.rs

@@ -3,7 +3,6 @@ use alloy::primitives::Address;
 use anyhow::Result;
 use cipher::Cipher;
 use config::AppConfig;
-use data::{DataStore, InMemStore, SledStore};
 use enclave_core::EventBus;
 use evm::{
     helpers::{create_readonly_provider, ensure_ws_rpc},
@@ -46,9 +45,22 @@ pub async fn setup_ciphernode(
         let rpc_url = &chain.rpc_url;
 
         let read_provider = create_readonly_provider(&ensure_ws_rpc(rpc_url)).await?;
-        EnclaveSolReader::attach(&bus, &read_provider, &chain.contracts.enclave).await?;
-        CiphernodeRegistrySol::attach(&bus, &read_provider, &chain.contracts.ciphernode_registry)
-            .await?;
+        EnclaveSolReader::attach(
+            &bus,
+            &read_provider,
+            &chain.contracts.enclave.address(),
+            &repositories.enclave_sol_reader(read_provider.get_chain_id()),
+            chain.contracts.enclave.deploy_block(),
+        )
+        .await?;
+        CiphernodeRegistrySol::attach(
+            &bus,
+            &read_provider,
+            &chain.contracts.ciphernode_registry.address(),
+            &repositories.ciphernode_registry_reader(read_provider.get_chain_id()),
+            chain.contracts.ciphernode_registry.deploy_block()
+        )
+        .await?;
     }
 
     E3RequestRouter::builder(&bus, store.clone())

packages/ciphernode/enclave_node/src/datastore.rs

@@ -1,15 +1,25 @@
+use std::path::PathBuf;
+
 use actix::{Actor, Addr};
 use anyhow::Result;
 use config::AppConfig;
 use data::{DataStore, InMemStore, SledStore};
 use enclave_core::EventBus;
 use router::{Repositories, RepositoriesFactory};
 
+pub fn get_sled_store(bus: &Addr<EventBus>, db_file: &PathBuf) -> Result<DataStore> {
+    Ok((&SledStore::new(bus, db_file)?.start()).into())
+}
+
+pub fn get_in_mem_store() -> DataStore {
+    (&InMemStore::new(true).start()).into()
+}
+
 pub fn setup_datastore(config: &AppConfig, bus: &Addr<EventBus>) -> Result<DataStore> {
     let store: DataStore = if !config.use_in_mem_store() {
-        (&SledStore::new(&bus, &config.db_file())?.start()).into()
+        get_sled_store(&bus, &config.db_file())?
     } else {
-        (&InMemStore::new(true).start()).into()
+        get_in_mem_store()
     };
     Ok(store)
 }

packages/ciphernode/evm/Cargo.toml

@@ -8,11 +8,17 @@ actix = { workspace = true }
 alloy = { workspace = true }
 alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
+async-trait = { workspace = true }
 enclave-core = { path = "../core" }
 data = { path = "../data" }
 futures-util = { workspace = true }
 sortition = { path = "../sortition" }
 cipher = { path = "../cipher" }
 tokio = { workspace = true }
 tracing = { workspace = true }
+serde = { workspace = true }
 zeroize = { workspace = true }
+
+[dev-dependencies]
+enclave_node = { path = "../enclave_node" }
+

packages/ciphernode/evm/src/ciphernode_registry_sol.rs

@@ -1,16 +1,18 @@
 use crate::{
+    event_reader::EvmEventReaderState,
     helpers::{ReadonlyProvider, WithChainId},
     EvmEventReader,
 };
-use actix::Addr;
+use actix::{Actor, Addr};
 use alloy::{
     primitives::{LogData, B256},
     sol,
     sol_types::SolEvent,
 };
 use anyhow::Result;
+use data::Repository;
 use enclave_core::{EnclaveEvent, EventBus};
-use tracing::{error, trace};
+use tracing::{error, info, trace};
 
 sol!(
     #[sol(rpc)]
@@ -102,20 +104,41 @@ impl CiphernodeRegistrySolReader {
         bus: &Addr<EventBus>,
         provider: &WithChainId<ReadonlyProvider>,
         contract_address: &str,
+        repository: &Repository<EvmEventReaderState>,
+        start_block: Option<u64>
     ) -> Result<Addr<EvmEventReader<ReadonlyProvider>>> {
-        let addr = EvmEventReader::attach(bus, provider, extractor, contract_address).await?;
+        let addr = EvmEventReader::attach(
+            provider,
+            extractor,
+            contract_address,
+            start_block,
+            &bus.clone().into(),
+            repository,
+        )
+        .await?;
+
+        info!(address=%contract_address, "EnclaveSolReader is listening to address");
+
         Ok(addr)
     }
 }
 
+impl Actor for CiphernodeRegistrySolReader {
+    type Context = actix::Context<Self>;
+}
+
+/// Eventual wrapper for both a reader and a writer
 pub struct CiphernodeRegistrySol;
 impl CiphernodeRegistrySol {
     pub async fn attach(
         bus: &Addr<EventBus>,
         provider: &WithChainId<ReadonlyProvider>,
         contract_address: &str,
+        repository: &Repository<EvmEventReaderState>,
+        start_block: Option<u64>
     ) -> Result<()> {
-        CiphernodeRegistrySolReader::attach(bus, provider, contract_address).await?;
+        CiphernodeRegistrySolReader::attach(bus, provider, contract_address, repository, start_block).await?;
+        // TODO: Writer if needed
         Ok(())
     }
 }

packages/ciphernode/evm/src/enclave_sol.rs

@@ -1,10 +1,12 @@
 use crate::{
     enclave_sol_reader::EnclaveSolReader,
     enclave_sol_writer::EnclaveSolWriter,
+    event_reader::EvmEventReaderState,
     helpers::{ReadonlyProvider, SignerProvider, WithChainId},
 };
 use actix::Addr;
 use anyhow::Result;
+use data::Repository;
 use enclave_core::EventBus;
 
 pub struct EnclaveSol;
@@ -14,8 +16,10 @@ impl EnclaveSol {
         read_provider: &WithChainId<ReadonlyProvider>,
         write_provider: &WithChainId<SignerProvider>,
         contract_address: &str,
+        repository: &Repository<EvmEventReaderState>,
+        start_block: Option<u64>
     ) -> Result<()> {
-        EnclaveSolReader::attach(bus, read_provider, contract_address).await?;
+        EnclaveSolReader::attach(bus, read_provider, contract_address, repository, start_block).await?;
         EnclaveSolWriter::attach(bus, write_provider, contract_address).await?;
         Ok(())
     }

packages/ciphernode/evm/src/enclave_sol_reader.rs

@@ -1,12 +1,14 @@
+use crate::event_reader::EvmEventReaderState;
 use crate::helpers::{ReadonlyProvider, WithChainId};
 use crate::EvmEventReader;
 use actix::Addr;
 use alloy::primitives::{LogData, B256};
 use alloy::transports::BoxTransport;
 use alloy::{sol, sol_types::SolEvent};
 use anyhow::Result;
+use data::Repository;
 use enclave_core::{EnclaveEvent, EventBus};
-use tracing::{error, trace};
+use tracing::{error, info, trace};
 
 sol!(
     #[sol(rpc)]
@@ -86,8 +88,21 @@ impl EnclaveSolReader {
         bus: &Addr<EventBus>,
         provider: &WithChainId<ReadonlyProvider, BoxTransport>,
         contract_address: &str,
+        repository: &Repository<EvmEventReaderState>,
+        start_block: Option<u64>
     ) -> Result<Addr<EvmEventReader<ReadonlyProvider>>> {
-        let addr = EvmEventReader::attach(bus, provider, extractor, contract_address).await?;
+        let addr = EvmEventReader::attach(
+            provider,
+            extractor,
+            contract_address,
+            start_block,
+            &bus.clone(),
+            repository,
+        )
+        .await?;
+
+        info!(address=%contract_address, "EnclaveSolReader is listening to address");
+
         Ok(addr)
     }
 }