fix: Resolve merge conflicts

Signed-off-by: William Hankins <[email protected]>

Author: whankinsiv

Cargo.lock

@@ -4,6 +4,7 @@
 #![allow(dead_code)]
 
 use crate::ledger_state::SPOState;
+use crate::queries::parameters::{ParametersStateQuery, ParametersStateQueryResponse};
 use crate::queries::{
     accounts::{AccountsStateQuery, AccountsStateQueryResponse},
     addresses::{AddressStateQuery, AddressStateQueryResponse},
@@ -168,6 +169,15 @@ pub struct SPOStakeDistributionMessage {
     pub spos: Vec<(KeyHash, DelegatedStake)>,
 }
 
+#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
+pub struct SPORewardsMessage {
+    /// Epoch which has ended
+    pub epoch: u64,
+
+    /// SPO rewards by operator ID (total rewards before distribution, pool operator's rewards)
+    pub spos: Vec<(KeyHash, SPORewards)>,
+}
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ProtocolParamsMessage {
     pub params: ProtocolParams,
@@ -224,6 +234,7 @@ pub enum CardanoMessage {
     // Stake distribution info
     DRepStakeDistribution(DRepStakeDistributionMessage), // Info about drep stake
     SPOStakeDistribution(SPOStakeDistributionMessage),   // SPO delegation distribution (SPDD)
+    SPORewards(SPORewardsMessage),                       // SPO rewards distribution (SPRD)
     StakeAddressDeltas(StakeAddressDeltasMessage),       // Stake part of address deltas
 }
 
@@ -315,6 +326,7 @@ pub enum StateQuery {
     Pools(PoolsStateQuery),
     Scripts(ScriptsStateQuery),
     Transactions(TransactionsStateQuery),
+    Parameters(ParametersStateQuery),
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -332,4 +344,5 @@ pub enum StateQueryResponse {
     Pools(PoolsStateQueryResponse),
     Scripts(ScriptsStateQueryResponse),
     Transactions(TransactionsStateQueryResponse),
+    Parameters(ParametersStateQueryResponse),
 }

common/src/messages.rs

@@ -1,5 +1,8 @@
 use crate::{messages::EpochActivityMessage, KeyHash, ProtocolParams};
 
+pub const DEFAULT_EPOCHS_QUERY_TOPIC: (&str, &str) =
+    ("epochs-state-query-topic", "cardano.query.epochs");
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum EpochsStateQuery {
     GetLatestEpoch,

common/src/queries/epochs.rs

@@ -12,6 +12,7 @@ pub mod ledger;
 pub mod mempool;
 pub mod metadata;
 pub mod network;
+pub mod parameters;
 pub mod pools;
 pub mod scripts;
 pub mod transactions;

common/src/queries/mod.rs

@@ -0,0 +1,22 @@
+use crate::ProtocolParams;
+
+pub const DEFAULT_PARAMETERS_QUERY_TOPIC: (&str, &str) =
+    ("parameters-state-query-topic", "cardano.query.parameters");
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub enum ParametersStateQuery {
+    GetLatestParameters,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub enum ParametersStateQueryResponse {
+    LatestParameters(LatestParameters),
+
+    NotFound,
+    Error(String),
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct LatestParameters {
+    pub parameters: ProtocolParams,
+}

common/src/queries/parameters.rs

@@ -1,4 +1,7 @@
-use crate::PoolRegistration;
+use crate::{KeyHash, PoolEpochState, PoolRegistration, PoolRetirement};
+
+pub const DEFAULT_POOLS_QUERY_TOPIC: (&str, &str) =
+    ("pools-state-query-topic", "cardano.query.pools");
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum PoolsStateQuery {
@@ -62,19 +65,24 @@ pub enum PoolsStateQueryResponse {
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PoolsList {
-    pub pool_operators: Vec<Vec<u8>>,
+    pub pool_operators: Vec<KeyHash>,
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PoolsListWithInfo {
-    pub pools: Vec<(Vec<u8>, PoolRegistration)>,
+    pub pools: Vec<(KeyHash, PoolRegistration)>,
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct PoolsRetiredList {}
+pub struct PoolsRetiredList {
+    pub retired_pools: Vec<PoolRetirement>,
+}
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct PoolsRetiringList {}
+pub struct PoolsRetiringList {
+    // pool id, retiring epoch
+    pub retiring_pools: Vec<PoolRetirement>,
+}
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PoolsActiveStakes {
@@ -94,7 +102,9 @@ pub struct PoolsTotalBlocksMinted {
 pub struct PoolInfo {}
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct PoolHistory {}
+pub struct PoolHistory {
+    pub history: Vec<PoolEpochState>,
+}
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PoolMetadata {}

common/src/queries/pools.rs

@@ -2,14 +2,20 @@
 //! Keeps per-block state for rollbacks or per-epoch state for historical lookups
 //! Use imbl collections in the state to avoid memory explosion!
 
-use crate::params::SECURITY_PARAMETER_K;
 use std::collections::VecDeque;
-
 use tracing::info;
 
-pub enum HistoryKind {
-    BlockState, // Used for rollbacks, bounded at k
-    EpochState, // Used for historical lookups, unbounded
+use crate::params::SECURITY_PARAMETER_K;
+
+pub enum StateHistoryStore {
+    Bounded(u64), // Used for rollbacks, bounded at k
+    Unbounded,    // Used for historical lookups, unbounded
+}
+
+impl StateHistoryStore {
+    pub fn default_block_store() -> Self {
+        Self::Bounded(SECURITY_PARAMETER_K)
+    }
 }
 
 struct HistoryEntry<S> {
@@ -25,17 +31,16 @@ pub struct StateHistory<S> {
     /// Module name
     module: String,
 
-    // Block or Epoch based history
-    kind: HistoryKind,
+    store: StateHistoryStore,
 }
 
 impl<S: Clone + Default> StateHistory<S> {
     /// Construct
-    pub fn new(module: &str, kind: HistoryKind) -> Self {
+    pub fn new(module: &str, store: StateHistoryStore) -> Self {
         Self {
             history: VecDeque::new(),
             module: module.to_string(),
-            kind: kind,
+            store,
         }
     }
 
@@ -50,38 +55,25 @@ impl<S: Clone + Default> StateHistory<S> {
         self.history.back().map(|entry| entry.state.clone()).unwrap_or_default()
     }
 
+    /// Get all the states references in the history
+    pub fn values(&self) -> Vec<&S> {
+        self.history.iter().map(|entry| &entry.state).collect()
+    }
+
     /// Get the previous state for the given block, handling rollbacks if required
     /// State returned is cloned ready for modification - call commit() when done
     pub fn get_rolled_back_state(&mut self, index: u64) -> S {
-        match self.kind {
-            HistoryKind::BlockState => {
-                while let Some(entry) = self.history.back() {
-                    if entry.index >= index {
-                        info!(
-                            "{} rolling back state to {} removing block {}",
-                            self.module, index, entry.index
-                        );
-                        self.history.pop_back();
-                    } else {
-                        break;
-                    }
-                }
-            }
-            HistoryKind::EpochState => {
-                while let Some(entry) = self.history.back() {
-                    if entry.index >= index {
-                        info!(
-                            "{} rolling back epoch state to {} removing epoch {}",
-                            self.module, index, entry.index
-                        );
-                        self.history.pop_back();
-                    } else {
-                        break;
-                    }
-                }
+        while let Some(entry) = self.history.back() {
+            if entry.index >= index {
+                info!(
+                    "{} rolling back state to {} removing block {}",
+                    self.module, index, entry.index
+                );
+                self.history.pop_back();
+            } else {
+                break;
             }
         }
-
         self.get_current_state()
     }
 
@@ -90,20 +82,36 @@ impl<S: Clone + Default> StateHistory<S> {
         self.history.iter().find(|entry| entry.index == index).map(|entry| &entry.state)
     }
 
+    /// Return a reference to the state at the given block number, if it exists
+    pub fn get_by_index_reverse(&self, index: u64) -> Option<&S> {
+        self.history.iter().rev().find(|entry| entry.index == index).map(|entry| &entry.state)
+    }
+
+    /// Get state history's size
     pub fn len(&self) -> usize {
         self.history.len()
     }
 
+    /// Commit new state without checking the block number
+    /// TODO: enhance block number logic to commit state without check (for bootstrapping)
+    pub fn commit_forced(&mut self, state: S) {
+        self.history.push_back(HistoryEntry { index: 0, state });
+    }
+
     /// Commit the new state
     pub fn commit(&mut self, index: u64, state: S) {
-        match self.kind {
-            HistoryKind::BlockState => {
-                while self.history.len() >= SECURITY_PARAMETER_K as usize {
-                    self.history.pop_front();
+        match self.store {
+            StateHistoryStore::Bounded(k) => {
+                while let Some(entry) = self.history.front() {
+                    if (index - entry.index) > k {
+                        self.history.pop_front();
+                    } else {
+                        break;
+                    }
                 }
                 self.history.push_back(HistoryEntry { index, state });
             }
-            HistoryKind::EpochState => {
+            StateHistoryStore::Unbounded => {
                 self.history.push_back(HistoryEntry { index, state });
             }
         }
@@ -122,4 +130,9 @@ impl<S: Clone> StateHistory<S> {
             init()
         }
     }
+
+    /// Clear the history
+    pub fn clear(&mut self) {
+        self.history.clear();
+    }
 }

common/src/state_history.rs

@@ -495,6 +495,18 @@ pub struct PoolRetirement {
     pub epoch: u64,
 }
 
+/// Pool Epoch History Data
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct PoolEpochState {
+    pub epoch: u64,
+    pub blocks_minted: u64,
+    pub active_stake: u64,
+    pub active_size: RationalNumber,
+    pub delegators_count: u64,
+    pub pool_reward: u64,
+    pub spo_reward: u64,
+}
+
 /// Stake delegation data
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct StakeDelegation {
@@ -511,10 +523,23 @@ pub struct DelegatedStake {
     /// Active stake - UTXO values only (used for reward calcs)
     pub active: Lovelace,
 
+    /// Active delegators count - delegators making active stakes (used for pool history)
+    pub active_delegators_count: u64,
+
     /// Total 'live' stake - UTXO values and rewards (used for VRF)
     pub live: Lovelace,
 }
 
+/// SPO rewards data (for SPORewardsMessage)
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct SPORewards {
+    /// Total rewards before distribution
+    pub total_rewards: Lovelace,
+
+    /// Pool operator's rewards
+    pub operator_rewards: Lovelace,
+}
+
 /// Genesis key delegation
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct GenesisKeyDelegation {