Relayer mvp

fuel-core-bft/src/service.rs

@@ -7,7 +7,6 @@ use fuel_core_interfaces::{
     },
     block_producer::BlockProducer,
     p2p::P2pRequestEvent,
-    relayer,
 };
 use parking_lot::Mutex;
 use std::sync::Arc;
@@ -35,7 +34,6 @@ impl Service {
 
     pub async fn start(
         &self,
-        _relayer: relayer::Sender,
         _p2p_consensus: mpsc::Sender<P2pRequestEvent>,
         _block_producer: Arc<dyn BlockProducer>,
         _block_importer_sender: mpsc::Sender<ImportBlockMpsc>,

fuel-core-interfaces/src/relayer.rs

@@ -7,11 +7,8 @@ use crate::{
         fuel_types::Address,
     },
     db::{
-        DelegatesIndexes,
         KvStoreError,
         Messages,
-        StakingDiffs,
-        ValidatorsSet,
     },
     model::{
         BlockHeight,
@@ -74,133 +71,31 @@ impl StakingDiff {
 // From relayer perspective messages are just inserted when they get finalized.
 // But for ValidatorSet, it is little bit different.
 #[async_trait]
-pub trait RelayerDb:
-    StorageMutate<Messages, Error = KvStoreError>
-    + StorageMutate<ValidatorsSet, Error = KvStoreError>
-    + StorageMutate<DelegatesIndexes, Error = KvStoreError>
-    + StorageMutate<StakingDiffs, Error = KvStoreError>
-    + Send
-    + Sync
-{
+pub trait RelayerDb: StorageMutate<Messages, Error = KvStoreError> + Send + Sync {
     /// Add bridge message to database. Messages are not revertible.
     async fn insert_message(&mut self, message: &CheckedMessage) {
         let _ = self
             .storage::<Messages>()
             .insert(message.id(), message.as_ref());
     }
 
-    /// Insert difference make on staking in this particular DA height.
-    async fn insert_staking_diff(
-        &mut self,
-        da_height: DaBlockHeight,
-        stakes: &StakingDiff,
-    ) {
-        let _ = self.storage::<StakingDiffs>().insert(&da_height, stakes);
-    }
-
-    /// Query delegate index to find list of blocks that delegation changed
-    /// iterate over list of indexed to find height that is less but closest to da_height
-    /// Query that block StakeDiff to find actual delegation change.
-    async fn get_first_lesser_delegation(
-        &mut self,
-        delegate: &Address,
-        da_height: DaBlockHeight,
-    ) -> Option<HashMap<ValidatorId, ValidatorStake>> {
-        let delegate_index = self
-            .storage::<DelegatesIndexes>()
-            .get(delegate)
-            .expect("Expect to get data without problem")?;
-        let mut last_da_height = 0;
-        for index in delegate_index.iter() {
-            if *index >= da_height {
-                break
-            }
-            last_da_height = **index;
-        }
-        // means that first delegate is in future or not existing in current delegate_index
-        if last_da_height == 0 {
-            return None
-        }
-        // get staking diff
-        let staking_diff = self
-            .storage::<StakingDiffs>()
-            .get(&last_da_height.into())
-            .expect("Expect to get data without problem")?;
-
-        staking_diff.delegations.get(delegate).unwrap().clone()
-    }
-
-    async fn append_delegate_index(
-        &mut self,
-        delegate: &Address,
-        da_height: DaBlockHeight,
-    ) {
-        let new_indexes = if let Some(indexes) =
-            self.storage::<DelegatesIndexes>().get(delegate).unwrap()
-        {
-            let mut indexes = (*indexes).clone();
-            indexes.push(da_height);
-            indexes
-        } else {
-            vec![da_height]
-        };
-        self.storage::<DelegatesIndexes>()
-            .insert(delegate, &new_indexes)
-            .expect("Expect to insert without problem");
-    }
-
-    /// get stakes difference between fuel blocks. Return vector of changed (some blocks are not going to have any change)
-    async fn get_staking_diffs(
-        &self,
-        _from_da_height: DaBlockHeight,
-        _to_da_height: Option<DaBlockHeight>,
-    ) -> Vec<(DaBlockHeight, StakingDiff)> {
-        Vec::new()
-    }
-
-    /// Apply validators diff to validator set and update validators_da_height. This operation needs
-    /// to be atomic.
-    async fn apply_validator_diffs(
-        &mut self,
-        da_height: DaBlockHeight,
-        changes: &HashMap<ValidatorId, (ValidatorStake, Option<ConsensusId>)>,
-    ) {
-        // this is reimplemented inside fuel-core db to assure it is atomic operation in case of poweroff situation
-        for (address, stake) in changes {
-            let _ = self.storage::<ValidatorsSet>().insert(address, stake);
-        }
-        self.set_validators_da_height(da_height).await;
-    }
-
     /// current best block number
     async fn get_chain_height(&self) -> BlockHeight;
 
     async fn get_sealed_block(&self, height: BlockHeight)
         -> Option<Arc<SealedFuelBlock>>;
 
-    /// get validator set for current eth height
-    async fn get_validators(&self) -> ValidatorSet;
-
-    /// Set data availability block height that corresponds to current_validator_set
-    async fn set_validators_da_height(&self, block: DaBlockHeight);
-
-    /// Assume it is always set as initialization of database.
-    async fn get_validators_da_height(&self) -> DaBlockHeight;
-
     /// set finalized da height that represent last block from da layer that got finalized.
     async fn set_finalized_da_height(&self, block: DaBlockHeight);
 
     /// Assume it is always set as initialization of database.
     async fn get_finalized_da_height(&self) -> DaBlockHeight;
 
-    /// Until blocks gets committed to da layer it is expected for it to still contains consensus
-    /// votes and be saved in database until commitment is send to da layer and finalization period passes.
-    /// In case that committed_finalized_fuel_height is zero we need to return genesis block.
-    async fn get_last_committed_finalized_fuel_height(&self) -> BlockHeight;
+    /// Get the last fuel block height that was published to the da layer.
+    async fn get_last_published_fuel_height(&self) -> Option<BlockHeight>;
 
-    /// Set last committed finalized fuel height this means we are safe to remove consensus votes from db
-    /// as from this moment they are not needed any more
-    async fn set_last_committed_finalized_fuel_height(&self, block_height: BlockHeight);
+    /// Set the last fuel block height that was published to the da layer.
+    async fn set_last_published_fuel_height(&self, block_height: BlockHeight);
 }
 
 pub type ValidatorSet = HashMap<ValidatorId, (ValidatorStake, Option<ConsensusId>)>;

fuel-core/Cargo.toml

@@ -73,6 +73,7 @@ tracing-subscriber = { version = "0.3", features = [
     "env-filter",
     "json",
 ] }
+url = "2.2"
 uuid = { version = "1.1", features = ["v4"] }
 
 [dev-dependencies]