A0-4343: Implement runtime api for storing abft scores on chain. (#1879)

# Description

Adds runtime api for the client side to store abft performance scores on
chain. It's implemented using unsigned transactions since finality
committee is considerably smaller than block production committee.

## Type of change

- New feature (non-breaking change which adds functionality)

---------

Co-authored-by: Michal Swietek <mike1729@users.noreply.github.com>

bin/fake-runtime-api/src/lib.rs

@@ -8,9 +8,9 @@ use pallet_aleph_runtime_api::*;
 use pallet_transaction_payment::FeeDetails;
 use pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo;
 use primitives::{
-    AccountId, ApiError as AlephApiError, AuraId, AuthorityId as AlephId, Balance, Block, Nonce,
-    Perbill, SessionAuthorityData, SessionCommittee, SessionIndex, SessionValidatorError,
-    Version as FinalityVersion,
+    crypto::SignatureSet, AccountId, ApiError as AlephApiError, AuraId, AuthorityId as AlephId,
+    AuthoritySignature, Balance, Block, Nonce, Perbill, Score, SessionAuthorityData,
+    SessionCommittee, SessionIndex, SessionValidatorError, Version as FinalityVersion,
 };
 use sp_consensus_aura::SlotDuration;
 use sp_core::OpaqueMetadata;
@@ -195,6 +195,10 @@ pub mod fake_runtime {
             fn current_era_payout() -> (Balance, Balance) {
                 unimplemented!()
             }
+
+            fn submit_abft_score(_score: Score, _signature: SignatureSet<AuthoritySignature>) -> Option<()>{
+                unimplemented!()
+            }
         }
 
         /// There’s an important remark on how this fake runtime must be implemented - it does not need to

bin/runtime/src/lib.rs

@@ -44,13 +44,13 @@ use pallet_transaction_payment::{CurrencyAdapter, Multiplier, TargetedFeeAdjustm
 use pallet_tx_pause::RuntimeCallNameOf;
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use primitives::{
-    staking::MAX_NOMINATORS_REWARDED_PER_VALIDATOR, wrap_methods, Address,
+    crypto::SignatureSet, staking::MAX_NOMINATORS_REWARDED_PER_VALIDATOR, wrap_methods, Address,
     AlephNodeSessionKeys as SessionKeys, ApiError as AlephApiError, AuraId, AuthorityId as AlephId,
-    BlockNumber as AlephBlockNumber, Header as AlephHeader, SessionAuthorityData, SessionCommittee,
-    SessionIndex, SessionInfoProvider, SessionValidatorError,
-    TotalIssuanceProvider as TotalIssuanceProviderT, Version as FinalityVersion,
-    ADDRESSES_ENCODING, DEFAULT_BAN_REASON_LENGTH, DEFAULT_MAX_WINNERS, DEFAULT_SESSIONS_PER_ERA,
-    DEFAULT_SESSION_PERIOD, MAX_BLOCK_SIZE, MILLISECS_PER_BLOCK, TOKEN,
+    AuthoritySignature, BlockNumber as AlephBlockNumber, Header as AlephHeader, Score,
+    SessionAuthorityData, SessionCommittee, SessionIndex, SessionInfoProvider,
+    SessionValidatorError, TotalIssuanceProvider as TotalIssuanceProviderT,
+    Version as FinalityVersion, ADDRESSES_ENCODING, DEFAULT_BAN_REASON_LENGTH, DEFAULT_MAX_WINNERS,
+    DEFAULT_SESSIONS_PER_ERA, DEFAULT_SESSION_PERIOD, MAX_BLOCK_SIZE, MILLISECS_PER_BLOCK, TOKEN,
 };
 pub use primitives::{AccountId, AccountIndex, Balance, Hash, Nonce, Signature};
 use sp_api::impl_runtime_apis;
@@ -80,10 +80,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     spec_name: create_runtime_str!("aleph-node"),
     impl_name: create_runtime_str!("aleph-node"),
     authoring_version: 1,
-    spec_version: 15_000_000,
+    spec_version: 16_000_000,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
-    transaction_version: 18,
+    transaction_version: 19,
     state_version: 0,
 };
 
@@ -1238,6 +1238,10 @@ impl_runtime_apis! {
 
             ExponentialEraPayout::era_payout(total_issuance, MILLISECONDS_PER_ERA)
         }
+
+        fn submit_abft_score(score: Score, signature: SignatureSet<AuthoritySignature>) -> Option<()> {
+            Aleph::submit_abft_score(score, signature)
+        }
     }
 
     impl pallet_nomination_pools_runtime_api::NominationPoolsApi<Block, AccountId, Balance> for Runtime {

finality-aleph/src/abft/mod.rs

@@ -80,15 +80,15 @@ impl<S: 'static> IntoIterator for SignatureSet<S> {
 
 impl From<SignatureSet<Signature>> for PrimitivesSignatureSet<AuthoritySignature> {
     fn from(signature_set: SignatureSet<Signature>) -> PrimitivesSignatureSet<AuthoritySignature> {
-        let score_sigantures: Vec<IndexedSignature<AuthoritySignature>> = signature_set
+        let score_signatures: Vec<IndexedSignature<AuthoritySignature>> = signature_set
             .0
             .into_iter()
             .map(|(idx, s)| IndexedSignature {
                 index: idx.0 as u64,
                 signature: s.0,
             })
             .collect();
-        PrimitivesSignatureSet(score_sigantures)
+        PrimitivesSignatureSet(score_signatures)
     }
 }
 

pallets/aleph-runtime-api/src/lib.rs

@@ -2,8 +2,8 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use primitives::{
-    AccountId, ApiError, AuthorityId, Balance, Perbill, SessionAuthorityData, SessionCommittee,
-    SessionIndex, SessionValidatorError, Version,
+    crypto::SignatureSet, AccountId, ApiError, AuthorityId, AuthoritySignature, Balance, Perbill,
+    Score, SessionAuthorityData, SessionCommittee, SessionIndex, SessionValidatorError, Version,
 };
 pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;
 use sp_std::vec::Vec;
@@ -37,5 +37,7 @@ sp_api::decl_runtime_apis! {
         fn yearly_inflation() -> Perbill;
         /// Returns payout. First tuple item is a validators payout, 2nd is the rest.
         fn current_era_payout() -> (Balance, Balance);
+        /// Submits score for a nonce in a session of performance of finality committee members.
+        fn submit_abft_score(score: Score, signature: SignatureSet<AuthoritySignature>) -> Option<()>;
     }
 }

pallets/aleph/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-aleph"
-version = "0.6.0"
+version = "0.7.0"
 license = "Apache 2.0"
 authors.workspace = true
 edition.workspace = true

pallets/aleph/src/lib.rs

@@ -19,6 +19,7 @@ use primitives::{
     Balance, SessionIndex, Version, VersionChange, DEFAULT_FINALITY_VERSION,
     LEGACY_FINALITY_VERSION, TOKEN,
 };
+use sp_runtime::Perbill;
 use sp_std::prelude::*;
 
 /// The current storage version.
@@ -28,13 +29,18 @@ pub(crate) const LOG_TARGET: &str = "pallet-aleph";
 #[frame_support::pallet]
 #[pallet_doc("../README.md")]
 pub mod pallet {
-    use frame_support::{pallet_prelude::*, sp_runtime::RuntimeAppPublic};
+    use frame_support::{
+        dispatch::{DispatchResult, DispatchResultWithPostInfo, Pays},
+        pallet_prelude::{TransactionSource, TransactionValidityError, ValueQuery, *},
+        sp_runtime::RuntimeAppPublic,
+    };
     use frame_system::{
-        ensure_root,
+        ensure_none, ensure_root,
         pallet_prelude::{BlockNumberFor, OriginFor},
     };
     use pallet_session::SessionManager;
-    use primitives::{SessionInfoProvider, TotalIssuanceProvider};
+    use primitives::{Score, ScoreNonce, SessionInfoProvider, TotalIssuanceProvider};
+    use sp_runtime::traits::ValidateUnsigned;
     use sp_std::collections::btree_map::BTreeMap;
     #[cfg(feature = "std")]
     use sp_std::marker::PhantomData;
@@ -43,7 +49,9 @@ pub mod pallet {
     use crate::traits::NextSessionAuthorityProvider;
 
     #[pallet::config]
-    pub trait Config: frame_system::Config {
+    pub trait Config:
+        frame_system::Config + frame_system::offchain::SendTransactionTypes<Call<Self>>
+    {
         type AuthorityId: Member + Parameter + RuntimeAppPublic + MaybeSerializeDeserialize;
         type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
         type SessionInfoProvider: SessionInfoProvider<BlockNumberFor<Self>>;
@@ -130,9 +138,14 @@ pub mod pallet {
     pub(super) type FinalityScheduledVersionChange<T: Config> =
         StorageValue<_, VersionChange, OptionQuery>;
 
+    // clear this storage on session end
+    #[pallet::storage]
+    #[pallet::getter(fn abft_scores)]
+    pub type AbftScores<T: Config> = StorageMap<_, Twox64Concat, SessionIndex, Score>;
+
     #[pallet::storage]
-    pub(super) type AbftSignature<T: Config> =
-        StorageValue<_, SignatureSet<Signature<T>>, OptionQuery>;
+    #[pallet::getter(fn last_score_nonce)]
+    pub(super) type LastScoreNonce<T: Config> = StorageValue<_, ScoreNonce, ValueQuery>;
 
     impl<T: Config> Pallet<T> {
         pub(crate) fn initialize_authorities(
@@ -295,9 +308,58 @@ pub mod pallet {
             }
         }
 
-        pub fn verify_multisignature(msg: &Vec<u8>, sgn: &SignatureSet<Signature<T>>) -> bool {
+        fn check_session_id(session_id: SessionIndex) -> Result<(), TransactionValidityError> {
+            let current_session_id = Self::current_session();
+            if current_session_id < session_id {
+                return Err(InvalidTransaction::Future.into());
+            }
+            if current_session_id > session_id {
+                return Err(InvalidTransaction::Stale.into());
+            }
+
+            Ok(())
+        }
+
+        fn check_nonce(nonce: ScoreNonce) -> Result<(), TransactionValidityError> {
+            let last_nonce = Self::last_score_nonce();
+            if nonce <= last_nonce {
+                return Err(InvalidTransaction::Stale.into());
+            }
+
+            Ok(())
+        }
+
+        fn check_score(
+            score: &Score,
+            signature: &SignatureSet<Signature<T>>,
+        ) -> Result<(), TransactionValidityError> {
+            Self::check_session_id(score.session_id)?;
+            Self::check_nonce(score.nonce)?;
+            Self::verify_score(score, signature)?;
+
+            Ok(())
+        }
+
+        pub fn verify_score(
+            score: &Score,
+            signature: &SignatureSet<Signature<T>>,
+        ) -> Result<(), TransactionValidityError> {
+            let msg = score.encode();
             let authority_verifier = AuthorityVerifier::new(Self::authorities());
-            AuthorityVerifier::is_complete(&authority_verifier, msg, sgn)
+            if !AuthorityVerifier::is_complete(&authority_verifier, &msg, signature) {
+                return Err(InvalidTransaction::BadProof.into());
+            }
+            Ok(())
+        }
+
+        pub fn submit_abft_score(
+            score: Score,
+            signature: SignatureSet<Signature<T>>,
+        ) -> Option<()> {
+            use frame_system::offchain::SubmitTransaction;
+
+            let call = Call::unsigned_submit_abft_score { score, signature };
+            SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into()).ok()
         }
     }
 
@@ -381,6 +443,41 @@ pub mod pallet {
 
             Ok(())
         }
+
+        // fix weight, take into account validate_unsigned
+        #[pallet::call_index(3)]
+        #[pallet::weight(T::BlockWeights::get().max_block * Perbill::from_percent(10))]
+        /// Stores abft score
+        pub fn unsigned_submit_abft_score(
+            origin: OriginFor<T>,
+            score: Score,
+            _signature: SignatureSet<Signature<T>>, // We don't check signature as it was checked by ValidateUnsigned trait
+        ) -> DispatchResultWithPostInfo {
+            ensure_none(origin)?;
+
+            <LastScoreNonce<T>>::put(score.nonce);
+            AbftScores::<T>::insert(score.session_id, score);
+
+            Ok(Pays::No.into())
+        }
+    }
+
+    #[pallet::validate_unsigned]
+    impl<T: Config> ValidateUnsigned for Pallet<T> {
+        type Call = Call<T>;
+
+        fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+            if let Call::unsigned_submit_abft_score { score, signature } = call {
+                Self::check_score(score, signature)?;
+                ValidTransaction::with_tag_prefix("AbftScore")
+                    .priority(score.nonce as u64) // this ensures that later nonces are first in tx queue
+                    .longevity(TransactionLongevity::MAX) // consider restricting longevity
+                    .propagate(true)
+                    .build()
+            } else {
+                InvalidTransaction::Call.into()
+            }
+        }
     }
 
     impl<T: Config> BoundToRuntimeAppPublic for Pallet<T> {

primitives/src/lib.rs

@@ -414,6 +414,15 @@ pub mod staking {
     }
 }
 
+pub type ScoreNonce = u32;
+
+#[derive(PartialEq, Decode, Encode, TypeInfo, Debug, Clone)]
+pub struct Score {
+    pub session_id: SessionIndex,
+    pub nonce: ScoreNonce,
+    pub points: Vec<u32>,
+}
+
 pub mod crypto {
     use core::marker::PhantomData;
 
@@ -424,13 +433,13 @@ pub mod crypto {
 
     use super::AuthoritySignature;
 
-    #[derive(Decode, Encode, TypeInfo, Debug, Clone)]
+    #[derive(PartialEq, Decode, Encode, TypeInfo, Debug, Clone)]
     pub struct IndexedSignature<S> {
         pub index: u64,
         pub signature: S,
     }
 
-    #[derive(Decode, Encode, TypeInfo, Debug, Clone)]
+    #[derive(PartialEq, Decode, Encode, TypeInfo, Debug, Clone)]
     pub struct SignatureSet<S>(pub Vec<IndexedSignature<S>>);
 
     #[cfg_attr(feature = "std", derive(Hash))]