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)]
@@ -297,7 +325,9 @@ chains:
     rpc_url: "ws://localhost:8545"
     contracts:
       enclave: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0"
-      ciphernode_registry: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9"
+      ciphernode_registry:
+        address: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9"
+        deploy_block: 1764352873645
       filter_registry: "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"
 "#,
             )?;
@@ -308,10 +338,18 @@ chains:
             assert_eq!(chain.name, "hardhat");
             assert_eq!(chain.rpc_url, "ws://localhost:8545");
             assert_eq!(
-                chain.contracts.enclave,
+                chain.contracts.enclave.address(),
                 "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0"
             );
-
+            assert_eq!(
+                chain.contracts.ciphernode_registry.address(),
+                "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9"
+            );
+            assert_eq!(chain.contracts.enclave.deploy_block(), None);
+            assert_eq!(
+                chain.contracts.ciphernode_registry.deploy_block(),
+                Some(1764352873645)
+            );
             Ok(())
         });
     }

packages/ciphernode/core/src/events.rs

@@ -56,7 +56,7 @@ impl TryFrom<E3id> for U256 {
 pub struct EventId(pub [u8; 32]);
 
 impl EventId {
-    fn from<T: Hash>(value: T) -> Self {
+    pub fn hash<T: Hash>(value: T) -> Self {
         let mut hasher = Sha256::new();
         let mut std_hasher = DefaultHasher::new();
         value.hash(&mut std_hasher);
@@ -224,7 +224,7 @@ pub trait FromError {
 impl From<KeyshareCreated> for EnclaveEvent {
     fn from(data: KeyshareCreated) -> Self {
         EnclaveEvent::KeyshareCreated {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -233,7 +233,7 @@ impl From<KeyshareCreated> for EnclaveEvent {
 impl From<E3Requested> for EnclaveEvent {
     fn from(data: E3Requested) -> Self {
         EnclaveEvent::E3Requested {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -242,7 +242,7 @@ impl From<E3Requested> for EnclaveEvent {
 impl From<PublicKeyAggregated> for EnclaveEvent {
     fn from(data: PublicKeyAggregated) -> Self {
         EnclaveEvent::PublicKeyAggregated {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -251,7 +251,7 @@ impl From<PublicKeyAggregated> for EnclaveEvent {
 impl From<CiphertextOutputPublished> for EnclaveEvent {
     fn from(data: CiphertextOutputPublished) -> Self {
         EnclaveEvent::CiphertextOutputPublished {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -260,7 +260,7 @@ impl From<CiphertextOutputPublished> for EnclaveEvent {
 impl From<DecryptionshareCreated> for EnclaveEvent {
     fn from(data: DecryptionshareCreated) -> Self {
         EnclaveEvent::DecryptionshareCreated {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -269,7 +269,7 @@ impl From<DecryptionshareCreated> for EnclaveEvent {
 impl From<PlaintextAggregated> for EnclaveEvent {
     fn from(data: PlaintextAggregated) -> Self {
         EnclaveEvent::PlaintextAggregated {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -278,7 +278,7 @@ impl From<PlaintextAggregated> for EnclaveEvent {
 impl From<E3RequestComplete> for EnclaveEvent {
     fn from(data: E3RequestComplete) -> Self {
         EnclaveEvent::E3RequestComplete {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -287,7 +287,7 @@ impl From<E3RequestComplete> for EnclaveEvent {
 impl From<CiphernodeSelected> for EnclaveEvent {
     fn from(data: CiphernodeSelected) -> Self {
         EnclaveEvent::CiphernodeSelected {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -296,7 +296,7 @@ impl From<CiphernodeSelected> for EnclaveEvent {
 impl From<CiphernodeAdded> for EnclaveEvent {
     fn from(data: CiphernodeAdded) -> Self {
         EnclaveEvent::CiphernodeAdded {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -305,7 +305,7 @@ impl From<CiphernodeAdded> for EnclaveEvent {
 impl From<CiphernodeRemoved> for EnclaveEvent {
     fn from(data: CiphernodeRemoved) -> Self {
         EnclaveEvent::CiphernodeRemoved {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -314,7 +314,7 @@ impl From<CiphernodeRemoved> for EnclaveEvent {
 impl From<EnclaveError> for EnclaveEvent {
     fn from(data: EnclaveError) -> Self {
         EnclaveEvent::EnclaveError {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -323,7 +323,7 @@ impl From<EnclaveError> for EnclaveEvent {
 impl From<Shutdown> for EnclaveEvent {
     fn from(data: Shutdown) -> Self {
         EnclaveEvent::Shutdown {
-            id: EventId::from(data.clone()),
+            id: EventId::hash(data.clone()),
             data: data.clone(),
         }
     }
@@ -332,7 +332,7 @@ impl From<Shutdown> for EnclaveEvent {
 impl From<TestEvent> for EnclaveEvent {
     fn from(value: TestEvent) -> Self {
         EnclaveEvent::TestEvent {
-            id: EventId::from(value.clone()),
+            id: EventId::hash(value.clone()),
             data: value.clone(),
         }
     }
@@ -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/src/commands/aggregator/mod.rs

@@ -3,7 +3,7 @@ use anyhow::*;
 use clap::Subcommand;
 use config::AppConfig;
 
-#[derive(Subcommand)]
+#[derive(Subcommand, Debug)]
 pub enum AggregatorCommands {
     /// Start the application as an aggregator
     Start {
@@ -17,7 +17,7 @@ pub enum AggregatorCommands {
     },
 }
 
-pub async fn execute(command: AggregatorCommands, config: AppConfig) -> Result<()> {
+pub async fn execute(command: AggregatorCommands, config: AppConfig, id: &str) -> Result<()> {
     match command {
         AggregatorCommands::Start {
             pubkey_write_path,
@@ -27,6 +27,7 @@ pub async fn execute(command: AggregatorCommands, config: AppConfig) -> Result<(
                 config,
                 pubkey_write_path.as_deref(),
                 plaintext_write_path.as_deref(),
+                id
             )
             .await?
         }

packages/ciphernode/enclave/src/commands/aggregator/start.rs

@@ -9,13 +9,14 @@ pub async fn execute(
     config: AppConfig,
     pubkey_write_path: Option<&str>,
     plaintext_write_path: Option<&str>,
+    id: &str
 ) -> Result<()> {
     owo();
 
-    info!("LAUNCHING AGGREGATOR");
-
-    let (bus, handle) = setup_aggregator(config, pubkey_write_path, plaintext_write_path).await?;
+    let (bus, handle, peer_id) =
+        setup_aggregator(config, pubkey_write_path, plaintext_write_path, id).await?;
 
+    info!("LAUNCHING AGGREGATOR {}", peer_id);
     tokio::spawn(listen_for_shutdown(bus.into(), handle));
 
     std::future::pending::<()>().await;

packages/ciphernode/enclave/src/commands/mod.rs

@@ -8,7 +8,7 @@ use aggregator::AggregatorCommands;
 use clap::Subcommand;
 use wallet::WalletCommands;
 
-#[derive(Subcommand)]
+#[derive(Subcommand, Debug)]
 pub enum Commands {
     /// Start the application
     Start,

packages/ciphernode/enclave/src/commands/password/mod.rs

@@ -5,7 +5,7 @@ use anyhow::*;
 use clap::Subcommand;
 use config::AppConfig;
 
-#[derive(Subcommand)]
+#[derive(Subcommand, Debug)]
 pub enum PasswordCommands {
     /// Create a new password
     Create {
@@ -25,7 +25,7 @@ pub enum PasswordCommands {
     },
 }
 
-pub async fn execute(command: PasswordCommands, config: AppConfig) -> Result<()> {
+pub async fn execute(command: PasswordCommands, config: AppConfig, id: &str) -> Result<()> {
     match command {
         PasswordCommands::Create { password } => create::execute(&config, password).await?,
         PasswordCommands::Delete => delete::execute(&config).await?,

packages/ciphernode/enclave/src/commands/start.rs

@@ -5,17 +5,16 @@ use tracing::info;
 
 use crate::owo;
 
-pub async fn execute(config: AppConfig) -> Result<()> {
+pub async fn execute(config: AppConfig, id: &str) -> Result<()> {
     owo();
 
     // let address = Address::parse_checksummed(&config.address(), None).context("Invalid address")?;
     let Some(address) = config.address() else {
         return Err(anyhow!("You must provide an address"));
     };
 
-    info!("LAUNCHING CIPHERNODE: ({})", address);
-
-    let (bus, handle) = setup_ciphernode(config, address).await?;
+    let (bus, handle, peer_id) = setup_ciphernode(config, address, id).await?;
+    info!("LAUNCHING CIPHERNODE: ({}/{})", address, peer_id);
 
     tokio::spawn(listen_for_shutdown(bus.into(), handle));
 

packages/ciphernode/enclave/src/commands/wallet/mod.rs

@@ -3,7 +3,7 @@ use anyhow::*;
 use clap::Subcommand;
 use config::AppConfig;
 
-#[derive(Subcommand)]
+#[derive(Subcommand, Debug)]
 pub enum WalletCommands {
     /// Set a new Wallet Private Key
     Set {
@@ -22,7 +22,7 @@ fn ensure_hex(s: &str) -> Result<String> {
     Ok(s.to_string())
 }
 
-pub async fn execute(command: WalletCommands, config: AppConfig) -> Result<()> {
+pub async fn execute(command: WalletCommands, config: AppConfig, id: &str) -> Result<()> {
     match command {
         WalletCommands::Set { private_key } => set::execute(&config, private_key).await?,
     };