Add pallet services payment to runtime

Cargo.toml

@@ -35,6 +35,7 @@ pallet-invulnerables = { path = "pallets/invulnerables", default-features = fals
 pallet-pooled-staking = { path = "pallets/pooled-staking", default-features = false }
 pallet-registrar = { path = "pallets/registrar", default-features = false }
 pallet-registrar-runtime-api = { path = "pallets/registrar/rpc/runtime-api", default-features = false }
+pallet-services-payment = { path = "pallets/services-payment", default-features = false }
 
 ccp-authorities-noting-inherent = { path = "container-chains/primitives/authorities-noting-inherent", default-features = false }
 ccp-xcm = { path = "container-chains/primitives/xcm", default-features = false }

node/src/chain_spec.rs

@@ -18,7 +18,7 @@ use {
     cumulus_primitives_core::ParaId,
     dancebox_runtime::{
         prod_or_fast, AccountId, MaintenanceModeConfig, MigrationsConfig, PolkadotXcmConfig,
-        RegistrarConfig, Signature, SudoConfig,
+        RegistrarConfig, ServicesPaymentConfig, Signature, SudoConfig,
     },
     nimbus_primitives::NimbusId,
     pallet_configuration::HostConfiguration,
@@ -293,6 +293,27 @@ fn testnet_genesis(
     mock_container_chains: &[ParaId],
     configuration: pallet_configuration::GenesisConfig<dancebox_runtime::Runtime>,
 ) -> dancebox_runtime::RuntimeGenesisConfig {
+    let para_ids: Vec<_> = container_chains
+        .iter()
+        .map(|x| {
+            container_chain_genesis_data_from_path(x).unwrap_or_else(|e| {
+                panic!(
+                    "Failed to build genesis data for container chain {:?}: {}",
+                    x, e
+                )
+            })
+        })
+        .chain(
+            mock_container_chains
+                .iter()
+                .map(|x| (*x, mock_container_chain_genesis_data(*x), vec![])),
+        )
+        .collect();
+    // Assign max block credits to all container chains registered in genesis
+    let para_id_credits: Vec<_> = para_ids
+        .iter()
+        .map(|(para_id, _genesis_data, _boot_nodes)| (*para_id, u32::MAX))
+        .collect();
     dancebox_runtime::RuntimeGenesisConfig {
         system: dancebox_runtime::SystemConfig {
             code: dancebox_runtime::WASM_BINARY
@@ -328,24 +349,8 @@ fn testnet_genesis(
         },
         parachain_system: Default::default(),
         configuration,
-        registrar: RegistrarConfig {
-            para_ids: container_chains
-                .iter()
-                .map(|x| {
-                    container_chain_genesis_data_from_path(x).unwrap_or_else(|e| {
-                        panic!(
-                            "Failed to build genesis data for container chain {:?}: {}",
-                            x, e
-                        )
-                    })
-                })
-                .chain(
-                    mock_container_chains
-                        .iter()
-                        .map(|x| (*x, mock_container_chain_genesis_data(*x), vec![])),
-                )
-                .collect(),
-        },
+        registrar: RegistrarConfig { para_ids },
+        services_payment: ServicesPaymentConfig { para_id_credits },
         sudo: SudoConfig {
             key: Some(root_key),
         },

pallets/collator-assignment/src/lib.rs

@@ -56,7 +56,7 @@ use {
     tp_collator_assignment::AssignedCollators,
     tp_traits::{
         GetContainerChainAuthor, GetHostConfiguration, GetSessionContainerChains, ParaId,
-        RemoveInvulnerables, ShouldRotateAllCollators, Slot,
+        RemoveInvulnerables, RemoveParaIdsWithNoCredits, ShouldRotateAllCollators, Slot,
     },
 };
 
@@ -97,6 +97,7 @@ pub mod pallet {
         type ShouldRotateAllCollators: ShouldRotateAllCollators<Self::SessionIndex>;
         type GetRandomnessForNextBlock: GetRandomnessForNextBlock<BlockNumberFor<Self>>;
         type RemoveInvulnerables: RemoveInvulnerables<Self::AccountId>;
+        type RemoveParaIdsWithNoCredits: RemoveParaIdsWithNoCredits;
         /// The weight information of this pallet.
         type WeightInfo: WeightInfo;
     }
@@ -161,6 +162,10 @@ pub mod pallet {
             // We get the containerChains that we will have at the target session
             let mut container_chain_ids =
                 T::ContainerChains::session_container_chains(target_session_index);
+            // Remove the containerChains that do not have enough credits for block production
+            T::RemoveParaIdsWithNoCredits::remove_para_ids_with_no_credits(
+                &mut container_chain_ids,
+            );
 
             // If the random_seed is all zeros, we don't shuffle the list of collators nor the list
             // of container chains.

pallets/collator-assignment/src/mock.rs

@@ -30,7 +30,7 @@ use {
         traits::{BlakeTwo256, IdentityLookup},
         BuildStorage,
     },
-    tp_traits::{ParaId, RemoveInvulnerables},
+    tp_traits::{ParaId, RemoveInvulnerables, RemoveParaIdsWithNoCredits},
 };
 
 type Block = frame_system::mocking::MockBlock<Test>;
@@ -193,6 +193,7 @@ impl pallet_collator_assignment::Config for Test {
     type ShouldRotateAllCollators = RotateCollatorsEveryNSessions<CollatorRotationSessionPeriod>;
     type GetRandomnessForNextBlock = MockGetRandomnessForNextBlock;
     type RemoveInvulnerables = RemoveAccountIdsAbove100;
+    type RemoveParaIdsWithNoCredits = RemoveParaIdsAbove5000;
     type WeightInfo = ();
 }
 
@@ -247,3 +248,12 @@ impl RemoveInvulnerables<u64> for RemoveAccountIdsAbove100 {
         invulnerables
     }
 }
+
+/// Any ParaId >= 5000 will be considered to not have enough credits
+pub struct RemoveParaIdsAbove5000;
+
+impl RemoveParaIdsWithNoCredits for RemoveParaIdsAbove5000 {
+    fn remove_para_ids_with_no_credits(para_ids: &mut Vec<ParaId>) {
+        para_ids.retain(|para_id| *para_id <= ParaId::from(5000));
+    }
+}

pallets/services-payment/Cargo.toml

@@ -15,10 +15,9 @@ log = { workspace = true }
 parity-scale-codec = { workspace = true, features = [ "derive", "max-encoded-len" ] }
 scale-info = { workspace = true }
 serde = { workspace = true, optional = true, features = [ "derive" ] }
-
 sp-runtime = { workspace = true }
-
 cumulus-primitives-core = { workspace = true }
+tp-traits = { workspace = true }
 
 [dev-dependencies]
 pallet-balances = { workspace = true }
@@ -36,3 +35,4 @@ std = [
 	"sp-runtime/std",
 ]
 try-runtime = [ "frame-support/try-runtime" ]
+runtime-benchmarks = []

pallets/services-payment/src/lib.rs

@@ -43,6 +43,8 @@ use {
         traits::Currency,
     },
     frame_system::pallet_prelude::*,
+    scale_info::prelude::vec::Vec,
+    tp_traits::{AuthorNotingHook, BlockNumber},
 };
 
 #[cfg(test)]
@@ -181,21 +183,24 @@ pub mod pallet {
 
     #[pallet::genesis_config]
     pub struct GenesisConfig<T: Config> {
-        _phantom: PhantomData<T>,
+        pub para_id_credits: Vec<(ParaId, BlockNumberFor<T>)>,
     }
 
-    #[cfg(feature = "std")]
     impl<T: Config> Default for GenesisConfig<T> {
         fn default() -> Self {
             Self {
-                _phantom: Default::default(),
+                para_id_credits: Default::default(),
             }
         }
     }
 
     #[pallet::genesis_build]
     impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
-        fn build(&self) {}
+        fn build(&self) {
+            for (para_id, credits) in &self.para_id_credits {
+                BlockProductionCredits::<T>::insert(para_id, credits);
+            }
+        }
     }
 }
 
@@ -219,3 +224,28 @@ pub trait OnChargeForBlockCredit<T: Config> {
 pub trait ProvideBlockProductionCost<T: Config> {
     fn block_cost(para_id: &ParaId) -> (BalanceOf<T>, Weight);
 }
+
+// This function should only be used to **reward** a container author.
+// There will be no additional check other than checking if we have already
+// rewarded this author for **in this tanssi block**
+// Any additional check should be done in the calling function
+// TODO: consider passing a vector here
+impl<T: Config> AuthorNotingHook<T::AccountId> for Pallet<T> {
+    fn on_container_author_noted(
+        _author: &T::AccountId,
+        _block_number: BlockNumber,
+        para_id: ParaId,
+    ) -> Weight {
+        let total_weight = T::DbWeight::get().reads_writes(1, 1);
+
+        if let Err(e) = Pallet::<T>::burn_credit_for_para(&para_id) {
+            log::warn!(
+                "Failed to burn credits for container chain {}: {:?}",
+                u32::from(para_id),
+                e
+            );
+        }
+
+        total_weight
+    }
+}

pallets/services-payment/src/mock.rs

@@ -28,15 +28,15 @@
 //! Using those two requirements we can select who the author was based on the collators assigned
 //! to that containerChain, by simply assigning the slot position.
 
-use frame_support::traits::{Currency, WithdrawReasons};
-
 use {
-    crate::{self as payment_services_pallet, OnChargeForBlockCredit, ProvideBlockProductionCost},
+    crate::{self as pallet_services_payment, OnChargeForBlockCredit, ProvideBlockProductionCost},
     cumulus_primitives_core::ParaId,
     frame_support::{
         pallet_prelude::*,
         parameter_types,
-        traits::{tokens::ExistenceRequirement, ConstU32, ConstU64, Everything},
+        traits::{
+            tokens::ExistenceRequirement, ConstU32, ConstU64, Currency, Everything, WithdrawReasons,
+        },
     },
     sp_core::H256,
     sp_runtime::{
@@ -54,7 +54,7 @@ frame_support::construct_runtime!(
     {
         System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
         Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
-        PaymentServices: payment_services_pallet::{Pallet, Call, Config<T>, Storage, Event<T>}
+        PaymentServices: pallet_services_payment::{Pallet, Call, Config<T>, Storage, Event<T>}
     }
 );
 
@@ -108,7 +108,7 @@ parameter_types! {
     pub const MaxCreditsStored: u64 = 5;
 }
 
-impl payment_services_pallet::Config for Test {
+impl pallet_services_payment::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type OnChargeForBlockCredit = ChargeForBlockCredit<Test>;
     type Currency = Balances;
@@ -123,7 +123,7 @@ impl OnChargeForBlockCredit<Test> for ChargeForBlockCredit<Test> {
         _para_id: &ParaId,
         _credits: u64,
         fee: u128,
-    ) -> Result<(), payment_services_pallet::Error<Test>> {
+    ) -> Result<(), pallet_services_payment::Error<Test>> {
         use frame_support::traits::tokens::imbalance::Imbalance;
 
         let result = Balances::withdraw(
@@ -133,7 +133,7 @@ impl OnChargeForBlockCredit<Test> for ChargeForBlockCredit<Test> {
             ExistenceRequirement::AllowDeath,
         );
         let imbalance = result
-            .map_err(|_| payment_services_pallet::Error::InsufficientFundsToPurchaseCredits)?;
+            .map_err(|_| pallet_services_payment::Error::InsufficientFundsToPurchaseCredits)?;
 
         if imbalance.peek() != fee {
             panic!("withdrawn balance incorrect");
@@ -178,7 +178,7 @@ impl ExtBuilder {
     }
 }
 
-pub(crate) fn events() -> Vec<payment_services_pallet::Event<Test>> {
+pub(crate) fn events() -> Vec<pallet_services_payment::Event<Test>> {
     System::events()
         .into_iter()
         .map(|r| r.event)

pallets/services-payment/src/tests.rs

@@ -29,7 +29,7 @@
 //! to that containerChain, by simply assigning the slot position.
 
 use {
-    crate::{mock::*, pallet as payment_services_pallet, BlockProductionCredits},
+    crate::{mock::*, pallet as pallet_services_payment, BlockProductionCredits},
     frame_support::{assert_err, assert_ok},
 };
 
@@ -52,7 +52,7 @@ fn purchase_credits_works() {
 
             assert_eq!(
                 events(),
-                vec![payment_services_pallet::Event::CreditsPurchased {
+                vec![pallet_services_payment::Event::CreditsPurchased {
                     para_id: 1.into(),
                     payer: ALICE,
                     fee: 500,
@@ -98,14 +98,14 @@ fn purchase_credits_purchases_zero_when_max_already_stored() {
             assert_eq!(
                 events(),
                 vec![
-                    payment_services_pallet::Event::CreditsPurchased {
+                    pallet_services_payment::Event::CreditsPurchased {
                         para_id,
                         payer: ALICE,
                         fee: 500,
                         credits_purchased: MaxCreditsStored::get(),
                         credits_remaining: MaxCreditsStored::get(),
                     },
-                    payment_services_pallet::Event::CreditsPurchased {
+                    pallet_services_payment::Event::CreditsPurchased {
                         para_id,
                         payer: ALICE,
                         fee: 0,
@@ -156,14 +156,14 @@ fn purchase_credits_purchases_max_possible_when_cant_purchase_all_requested() {
             assert_eq!(
                 events(),
                 vec![
-                    payment_services_pallet::Event::CreditsPurchased {
+                    pallet_services_payment::Event::CreditsPurchased {
                         para_id,
                         payer: ALICE,
                         fee: 100,
                         credits_purchased: amount_purchased,
                         credits_remaining: amount_purchased,
                     },
-                    payment_services_pallet::Event::CreditsPurchased {
+                    pallet_services_payment::Event::CreditsPurchased {
                         para_id,
                         payer: ALICE,
                         fee: 400,
@@ -181,7 +181,7 @@ fn purchase_credits_fails_with_insufficient_balance() {
         // really what we're testing is that purchase_credits fails when OnChargeForBlockCredits does
         assert_err!(
             PaymentServices::purchase_credits(RuntimeOrigin::signed(ALICE), 1.into(), 1, None),
-            payment_services_pallet::Error::<Test>::InsufficientFundsToPurchaseCredits,
+            pallet_services_payment::Error::<Test>::InsufficientFundsToPurchaseCredits,
         );
     });
 }
@@ -191,7 +191,7 @@ fn burn_credit_fails_with_no_credits() {
     ExtBuilder::default().build().execute_with(|| {
         assert_err!(
             PaymentServices::burn_credit_for_para(&1u32.into()),
-            payment_services_pallet::Error::<Test>::InsufficientCredits,
+            pallet_services_payment::Error::<Test>::InsufficientCredits,
         );
     });
 }
@@ -218,7 +218,7 @@ fn burn_credit_works() {
             // now should fail
             assert_err!(
                 PaymentServices::burn_credit_for_para(&para_id),
-                payment_services_pallet::Error::<Test>::InsufficientCredits,
+                pallet_services_payment::Error::<Test>::InsufficientCredits,
             );
         });
 }
@@ -241,7 +241,7 @@ fn burn_credit_fails_for_wrong_para() {
             let wrong_para_id = 2.into();
             assert_err!(
                 PaymentServices::burn_credit_for_para(&wrong_para_id),
-                payment_services_pallet::Error::<Test>::InsufficientCredits,
+                pallet_services_payment::Error::<Test>::InsufficientCredits,
             );
         });
 }
@@ -274,7 +274,7 @@ fn buy_credits_too_expensive_fails() {
                     1u64,
                     Some(FIXED_BLOCK_PRODUCTION_COST - 1),
                 ),
-                payment_services_pallet::Error::<Test>::CreditPriceTooExpensive,
+                pallet_services_payment::Error::<Test>::CreditPriceTooExpensive,
             );
         });
 }