add authorities and min_slot_freq fn to interface (#25)

* add authorities and min_slot_freq fn to interface

* fix tests + clippy

* fmt

client/orchestrator-chain-interface/src/lib.rs

@@ -24,10 +24,13 @@
 //!
 //! prove_read: generates a storage proof of a given set of keys at a given Orchestrator parent
 
-pub use dp_core::{Hash as PHash, Header as PHeader};
 use {
-    core::pin::Pin, futures::Stream, polkadot_overseer::Handle, sc_client_api::StorageProof,
-    sp_api::ApiError, sp_state_machine::StorageValue, std::sync::Arc,
+    core::pin::Pin, dp_core::ParaId, futures::Stream, polkadot_overseer::Handle,
+    sc_client_api::StorageProof, sp_api::ApiError, sp_state_machine::StorageValue, std::sync::Arc,
+};
+pub use {
+    cumulus_primitives_core::relay_chain::Slot,
+    dp_core::{Hash as PHash, Header as PHeader},
 };
 
 #[derive(thiserror::Error, Debug)]
@@ -87,6 +90,8 @@ pub type OrchestratorChainResult<T> = Result<T, OrchestratorChainError>;
 /// Trait that provides all necessary methods for interaction between collator and orchestrator chain.
 #[async_trait::async_trait]
 pub trait OrchestratorChainInterface: Send + Sync {
+    type AuthorityId;
+
     /// Fetch a storage item by key.
     async fn get_storage_by_key(
         &self,
@@ -118,13 +123,30 @@ pub trait OrchestratorChainInterface: Send + Sync {
     async fn finality_notification_stream(
         &self,
     ) -> OrchestratorChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>>;
+
+    /// Return the set of authorities assigned to the paraId where
+    /// the first eligible key from the keystore is collating
+    async fn authorities(
+        &self,
+        orchestrator_parent: PHash,
+        para_id: ParaId,
+    ) -> OrchestratorChainResult<Option<Vec<Self::AuthorityId>>>;
+
+    /// Returns the minimum slot frequency for this para id.
+    async fn min_slot_freq(
+        &self,
+        orchestrator_parent: PHash,
+        para_id: ParaId,
+    ) -> OrchestratorChainResult<Option<Slot>>;
 }
 
 #[async_trait::async_trait]
 impl<T> OrchestratorChainInterface for Arc<T>
 where
     T: OrchestratorChainInterface + ?Sized,
 {
+    type AuthorityId = T::AuthorityId;
+
     fn overseer_handle(&self) -> OrchestratorChainResult<Handle> {
         (**self).overseer_handle()
     }
@@ -164,4 +186,20 @@ where
     ) -> OrchestratorChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>> {
         (**self).finality_notification_stream().await
     }
+
+    async fn authorities(
+        &self,
+        orchestrator_parent: PHash,
+        para_id: ParaId,
+    ) -> OrchestratorChainResult<Option<Vec<Self::AuthorityId>>> {
+        (**self).authorities(orchestrator_parent, para_id).await
+    }
+
+    async fn min_slot_freq(
+        &self,
+        orchestrator_parent: PHash,
+        para_id: ParaId,
+    ) -> OrchestratorChainResult<Option<Slot>> {
+        (**self).min_slot_freq(orchestrator_parent, para_id).await
+    }
 }

client/orchestrator-chain-rpc-interface/src/lib.rs

@@ -18,10 +18,12 @@ mod ws_client;
 
 use {
     async_trait::async_trait,
-    core::pin::Pin,
+    core::{marker::PhantomData, pin::Pin},
     dc_orchestrator_chain_interface::{
-        OrchestratorChainError, OrchestratorChainInterface, OrchestratorChainResult, PHash, PHeader,
+        OrchestratorChainError, OrchestratorChainInterface, OrchestratorChainResult, PHash,
+        PHeader, Slot,
     },
+    dp_core::ParaId,
     futures::{Stream, StreamExt},
     jsonrpsee::{core::params::ArrayParams, rpc_params},
     sc_client_api::{StorageData, StorageProof},
@@ -60,11 +62,11 @@ fn url_to_string_with_port(url: Url) -> Option<String> {
     ))
 }
 
-pub async fn create_client_and_start_worker(
+pub async fn create_client_and_start_worker<T>(
     urls: Vec<Url>,
     task_manager: &mut TaskManager,
     overseer_handle: Option<polkadot_overseer::Handle>,
-) -> OrchestratorChainResult<OrchestratorChainRpcClient> {
+) -> OrchestratorChainResult<OrchestratorChainRpcClient<T>> {
     let urls: Vec<_> = urls
         .into_iter()
         .filter_map(url_to_string_with_port)
@@ -84,18 +86,20 @@ pub async fn create_client_and_start_worker(
     let client = OrchestratorChainRpcClient {
         request_sender,
         overseer_handle,
+        _phantom: PhantomData,
     };
 
     Ok(client)
 }
 
 #[derive(Clone)]
-pub struct OrchestratorChainRpcClient {
+pub struct OrchestratorChainRpcClient<T> {
     request_sender: mpsc::Sender<WsClientRequest>,
     overseer_handle: Option<polkadot_overseer::Handle>,
+    _phantom: PhantomData<T>,
 }
 
-impl OrchestratorChainRpcClient {
+impl<T> OrchestratorChainRpcClient<T> {
     /// Call a call to `state_call` rpc method.
     pub async fn call_remote_runtime_function<R: Decode>(
         &self,
@@ -216,7 +220,9 @@ impl OrchestratorChainRpcClient {
 }
 
 #[async_trait]
-impl OrchestratorChainInterface for OrchestratorChainRpcClient {
+impl<T: Sync + Send + Decode> OrchestratorChainInterface for OrchestratorChainRpcClient<T> {
+    type AuthorityId = T;
+
     /// Fetch a storage item by key.
     async fn get_storage_by_key(
         &self,
@@ -245,8 +251,8 @@ impl OrchestratorChainInterface for OrchestratorChainRpcClient {
         relevant_keys: &[Vec<u8>],
     ) -> OrchestratorChainResult<StorageProof> {
         let mut cloned = Vec::new();
-        cloned.extend_from_slice(&relevant_keys);
-        let storage_keys: Vec<StorageKey> = cloned.into_iter().map(|key| StorageKey(key)).collect();
+        cloned.extend_from_slice(relevant_keys);
+        let storage_keys: Vec<StorageKey> = cloned.into_iter().map(StorageKey).collect();
 
         self.state_get_read_proof(storage_keys, Some(orchestrator_parent))
             .await
@@ -281,4 +287,29 @@ impl OrchestratorChainInterface for OrchestratorChainRpcClient {
         let stream = tokio_stream::wrappers::ReceiverStream::new(rx);
         Ok(stream.boxed())
     }
+
+    /// Return the set of authorities assigned to the paraId where
+    /// the first eligible key from the keystore is collating
+    async fn authorities(
+        &self,
+        orchestrator_parent: PHash,
+        para_id: ParaId,
+    ) -> OrchestratorChainResult<Option<Vec<Self::AuthorityId>>> {
+        self.call_remote_runtime_function("para_id_authorities", orchestrator_parent, Some(para_id))
+            .await
+    }
+
+    /// Returns the minimum slot frequency for this para id.
+    async fn min_slot_freq(
+        &self,
+        orchestrator_parent: PHash,
+        para_id: ParaId,
+    ) -> OrchestratorChainResult<Option<Slot>> {
+        self.call_remote_runtime_function(
+            "parathread_slot_frequency",
+            orchestrator_parent,
+            Some(para_id),
+        )
+        .await
+    }
 }

container-chain-pallets/authorities-noting/src/benchmarks.rs

@@ -69,8 +69,8 @@ mod test_sproof {
 benchmarks! {
     set_latest_authorities_data {
         // TODO: this could measure the proof size
-        let sproof_builder_relay = test_sproof::ParaHeaderSproofBuilder::default();
-        let sproof_builder_orchestrator = test_sproof::AuthorityAssignmentSproofBuilder::default();
+        let sproof_builder_relay = test_sproof::ParaHeaderSproofBuilder;
+        let sproof_builder_orchestrator = test_sproof::AuthorityAssignmentSproofBuilder;
 
         let (relay_root, relay_proof) = sproof_builder_relay.into_state_root_and_proof();
         let (orchestrator_root, orchestrator_proof) = sproof_builder_orchestrator.into_state_root_and_proof();

container-chain-pallets/authorities-noting/src/tests.rs

@@ -41,7 +41,7 @@ fn genesis_config_orchestrator_para_id() {
 fn genesis_config_orchestrator_para_id_storage_update() {
     new_test_ext().execute_with(|| {
         let new_para_id = ParaId::new(2000);
-        OrchestratorParaId::<Test>::put(&new_para_id);
+        OrchestratorParaId::<Test>::put(new_para_id);
         assert_eq!(OrchestratorParaId::<Test>::get(), new_para_id);
     });
 }

container-chain-primitives/authorities-noting-inherent/src/tests.rs

@@ -26,7 +26,7 @@ use {
         InboundDownwardMessage, InboundHrmpMessage, ParaId, PersistedValidationData,
     },
     cumulus_relay_chain_interface::{PHash, PHeader, RelayChainInterface, RelayChainResult},
-    dc_orchestrator_chain_interface::{OrchestratorChainInterface, OrchestratorChainResult},
+    dc_orchestrator_chain_interface::{OrchestratorChainInterface, OrchestratorChainResult, Slot},
     dp_core::{well_known_keys, Header as OrchestratorHeader},
     futures::Stream,
     polkadot_overseer::Handle,
@@ -84,6 +84,8 @@ impl DummyRelayChainInterface {
 
 #[async_trait]
 impl OrchestratorChainInterface for DummyOrchestratorChainInterface {
+    type AuthorityId = ();
+
     fn overseer_handle(&self) -> OrchestratorChainResult<Handle> {
         unimplemented!("Not needed for test")
     }
@@ -94,7 +96,7 @@ impl OrchestratorChainInterface for DummyOrchestratorChainInterface {
         key: &[u8],
     ) -> OrchestratorChainResult<Option<StorageValue>> {
         self.orchestrator_client
-            .storage(hash.into(), &StorageKey(key.to_vec()))
+            .storage(hash, &StorageKey(key.to_vec()))
             .map(|a| a.map(|b| b.0))
             .map_err(|e| e.into())
     }
@@ -128,6 +130,22 @@ impl OrchestratorChainInterface for DummyOrchestratorChainInterface {
     ) -> OrchestratorChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>> {
         unimplemented!("Not needed for test")
     }
+
+    async fn authorities(
+        &self,
+        _orchestrator_parent: PHash,
+        _para_id: ParaId,
+    ) -> OrchestratorChainResult<Option<Vec<Self::AuthorityId>>> {
+        unimplemented!("Not needed for test")
+    }
+
+    async fn min_slot_freq(
+        &self,
+        _orchestrator_parent: PHash,
+        _para_id: ParaId,
+    ) -> OrchestratorChainResult<Option<Slot>> {
+        unimplemented!("Not needed for test")
+    }
 }
 
 #[async_trait]
@@ -218,7 +236,7 @@ impl RelayChainInterface for DummyRelayChainInterface {
     ) -> RelayChainResult<Option<StorageValue>> {
         Ok(self
             .relay_client
-            .storage(hash.into(), &StorageKey(key.to_vec()))
+            .storage(hash, &StorageKey(key.to_vec()))
             .map(|a| a.map(|b| b.0))
             .unwrap())
     }

pallets/xcm-executor-utils/src/benchmarks.rs

@@ -115,5 +115,9 @@ mod benchmarks {
         Ok(())
     }
 
-    impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
+    impl_benchmark_test_suite!(
+        Pallet,
+        crate::mock::mock_never::new_test_ext(),
+        crate::mock::mock_never::TestNever
+    );
 }

pallets/xcm-executor-utils/src/filters.rs

@@ -174,15 +174,12 @@ mod test {
             fun: Fungible(1_000),
         };
 
-        assert_eq!(
-            apply_policy::<TestAllNative>(
-                &grandparent_asset,
-                &parent_location,
-                None,
-                <TestAllNative as Config>::ReserveDefaultTrustPolicy::get(),
-            ),
-            false
-        );
+        assert!(!apply_policy::<TestAllNative>(
+            &grandparent_asset,
+            &parent_location,
+            None,
+            <TestAllNative as Config>::ReserveDefaultTrustPolicy::get(),
+        ));
     }
 
     #[test]
@@ -193,15 +190,12 @@ mod test {
             fun: Fungible(1_000),
         };
 
-        assert_eq!(
-            apply_policy::<TestNever>(
-                &parent_asset,
-                &parent_location,
-                None,
-                <TestNever as Config>::ReserveDefaultTrustPolicy::get(),
-            ),
-            false
-        );
+        assert!(!apply_policy::<TestNever>(
+            &parent_asset,
+            &parent_location,
+            None,
+            <TestNever as Config>::ReserveDefaultTrustPolicy::get(),
+        ));
     }
 
     #[test]
@@ -260,15 +254,12 @@ mod test {
             DefaultTrustPolicy::AllNative,
         ));
 
-        assert_eq!(
-            apply_policy::<TestNever>(
-                &grandparent_asset,
-                &parent_location,
-                origin_policy,
-                default_policy
-            ),
-            false
-        );
+        assert!(!apply_policy::<TestNever>(
+            &grandparent_asset,
+            &parent_location,
+            origin_policy,
+            default_policy
+        ));
     }
 
     #[test]
@@ -314,14 +305,11 @@ mod test {
         ));
 
         // parent_asset should be rejected
-        assert_eq!(
-            apply_policy::<TestNever>(
-                &parent_asset,
-                &parent_location,
-                origin_policy,
-                default_policy
-            ),
-            false
-        );
+        assert!(!apply_policy::<TestNever>(
+            &parent_asset,
+            &parent_location,
+            origin_policy,
+            default_policy
+        ));
     }
 }