fix: 🐛 Use Proofs Dealer tick when requesting last proof submitters in Payment Streams pallet (#217)

* fix: 🐛 Use Proofs Dealer tick when requesting last proof submitters in Payment Streams pallet

* test: ✅ Add test case where Proof Submitters tick stops

* chore: 🏷️ Update `api-augment`

Author: ffarall

api-augment/dist/types/interfaces/augment-api-query.d.ts

@@ -1067,6 +1067,15 @@ declare module "@polkadot/api-base/types/storage" {
         [H256]
       > &
         QueryableStorageEntry<ApiType, [H256]>;
+      /**
+       * The last tick from the Providers Proof Submitters pallet that was registered.
+       *
+       * This is used to keep track of the last tick from the Providers Proof Submitters pallet, that this pallet
+       * registered. For the tick in this storage element, this pallet already knows the Providers that submitted
+       * a valid proof.
+       **/
+      lastSubmittersTickRegistered: AugmentedQuery<ApiType, () => Observable<u32>, []> &
+        QueryableStorageEntry<ApiType, []>;
       /**
        * A counter of blocks for which Providers can charge their streams.
        *

api-augment/src/interfaces/augment-api-query.ts

@@ -1053,6 +1053,15 @@ declare module "@polkadot/api-base/types/storage" {
         [H256]
       > &
         QueryableStorageEntry<ApiType, [H256]>;
+      /**
+       * The last tick from the Providers Proof Submitters pallet that was registered.
+       *
+       * This is used to keep track of the last tick from the Providers Proof Submitters pallet, that this pallet
+       * registered. For the tick in this storage element, this pallet already knows the Providers that submitted
+       * a valid proof.
+       **/
+      lastSubmittersTickRegistered: AugmentedQuery<ApiType, () => Observable<u32>, []> &
+        QueryableStorageEntry<ApiType, []>;
       /**
        * A counter of blocks for which Providers can charge their streams.
        *

api-augment/storagehub.json

@@ -361,6 +361,10 @@ impl ProofSubmittersInterface for MockSubmittingProviders {
         None
     }
 
+    fn get_current_tick() -> Self::TickNumber {
+        System::block_number()
+    }
+
     fn get_accrued_failed_proof_submissions(_provider_id: &Self::ProviderId) -> Option<u32> {
         None
     }

pallets/bucket-nfts/src/mock.rs

@@ -295,6 +295,10 @@ impl ProofSubmittersInterface for MockSubmittingProviders {
         None
     }
 
+    fn get_current_tick() -> Self::TickNumber {
+        System::block_number()
+    }
+
     fn get_accrued_failed_proof_submissions(_provider_id: &Self::ProviderId) -> Option<u32> {
         None
     }

pallets/file-system/src/mock.rs

@@ -160,6 +160,15 @@ pub mod pallet {
         ValueQuery,
     >;
 
+    /// The last tick from the Providers Proof Submitters pallet that was registered.
+    ///
+    /// This is used to keep track of the last tick from the Providers Proof Submitters pallet, that this pallet
+    /// registered. For the tick in this storage element, this pallet already knows the Providers that submitted
+    /// a valid proof.
+    #[pallet::storage]
+    pub type LastSubmittersTickRegistered<T: Config> =
+        StorageValue<_, BlockNumberFor<T>, ValueQuery>;
+
     /// The mapping from a user to if it has been flagged for not having enough funds to pay for its requested services.
     ///
     /// This is used to flag users that do not have enough funds to pay for their requested services, so other Providers

pallets/payment-streams/src/lib.rs

@@ -255,6 +255,10 @@ impl ProofSubmittersInterface for MockSubmittingProviders {
         Some(set)
     }
 
+    fn get_current_tick() -> Self::TickNumber {
+        System::block_number()
+    }
+
     fn get_accrued_failed_proof_submissions(_provider_id: &Self::ProviderId) -> Option<u32> {
         None
     }

pallets/payment-streams/src/mock.rs

@@ -1654,7 +1654,7 @@ mod fixed_rate_streams {
                 );
 
                 // Set the last valid proof of the payment stream from Bob to Alice to block 123 (represented by Alice's account ID)
-                // Since we are using the mocked ReadProofSubmittersInterface, we can pass the account ID as the
+                // Since we are using the mocked ProofSubmittersInterface, we can pass the account ID as the
                 // block number to the `on_poll` hook and it will consider that Provider as one that submitted a proof
                 run_to_block(alice_on_poll);
 
@@ -1665,7 +1665,62 @@ mod fixed_rate_streams {
                 // The payment stream should be updated with the correct last valid proof
                 assert_eq!(
                     alice_last_chargeable_info.last_chargeable_tick,
-                    System::block_number() - 1 // We subtract one since the chargeable info is set for the previous block always
+                    System::block_number()
+                );
+            });
+        }
+
+        #[test]
+        fn update_last_chargeable_tick_with_submitters_paused_works() {
+            ExtBuilder::build().execute_with(|| {
+                let alice_on_poll: AccountId = 123;
+                let bob: AccountId = 1;
+
+                // Register Alice as a MSP with 100 units of data and get her MSP ID
+                register_account_as_msp(alice_on_poll, 100);
+                let alice_msp_id =
+                    <StorageProviders as ReadProvidersInterface>::get_provider_id(alice_on_poll)
+                        .unwrap();
+
+                // Create a payment stream from Bob to Alice of 10 units per block
+                let rate: BalanceOf<Test> = 10;
+                assert_ok!(
+                    <PaymentStreams as PaymentStreamsInterface>::create_fixed_rate_payment_stream(
+                        &alice_msp_id,
+                        &bob,
+                        rate
+                    )
+                );
+
+                // Set the last valid proof of the payment stream from Bob to Alice to block 123 (represented by Alice's account ID)
+                // Since we are using the mocked ProofSubmittersInterface, we can pass the account ID as the
+                // block number to the `on_poll` hook and it will consider that Provider as one that submitted a proof.
+                // We advance to one block before Alice's turn.
+                run_to_block(alice_on_poll - 1);
+
+                // Mock blocks advancing where the Proofs Submitters' tick is stopped.
+                let tick_before = crate::OnPollTicker::<Test>::get();
+                for _ in 0..10 {
+                    // For that, we run `on_poll` hooks of this Payment Stream's pallet, without actually advancing blocks.
+                    PaymentStreams::on_poll(System::block_number(), &mut WeightMeter::new());
+                }
+                let tick_after = crate::OnPollTicker::<Test>::get();
+                assert!(tick_before == tick_after - 10);
+
+                // Now the Proof Submitters pallet "resumes", so we advance one more block to when
+                // it is Alice's turn to be in the valid proofs submitters set.
+                run_to_block(alice_on_poll);
+
+                // Get Alice's last chargeable information
+                let alice_last_chargeable_info =
+                    PaymentStreams::get_last_chargeable_info(&alice_msp_id);
+                let current_tick = crate::OnPollTicker::<Test>::get();
+
+                // The payment stream should be updated and considering that the last chargeable tick
+                // is the current tick for the Payment Streams pallet.
+                assert_eq!(
+                    alice_last_chargeable_info.last_chargeable_tick,
+                    current_tick
                 );
             });
         }

pallets/payment-streams/src/tests.rs

@@ -967,25 +967,47 @@ where
         Ok(())
     }
 
-    /// This function gets the Providers that submitted a valid proof in the last tick using the `ReadProofSubmittersInterface`,
+    /// This function gets the Providers that submitted a valid proof in the last tick using the `ProofSubmittersInterface`,
     /// and updates the last chargeable tick and last chargeable price index of those Providers.
     pub fn do_update_last_chargeable_info(
         n: BlockNumberFor<T>,
         weight: &mut frame_support::weights::WeightMeter,
     ) {
-        // Get last tick's number
-        let n = n.saturating_sub(One::one());
-        // Get the Providers that submitted a valid proof in the last tick, if there are any
+        // Get the previous tick from the Providers Proof Submitters pallet.
+        let submitters_prev_tick =
+            <T::ProvidersProofSubmitters as ProofSubmittersInterface>::get_current_tick()
+                .saturating_sub(One::one());
+        weight.consume(T::DbWeight::get().reads(1));
+
+        // Check if we already registered this tick from the Providers Proof Submitters pallet.
+        let last_submitters_tick_registered = LastSubmittersTickRegistered::<T>::get();
+        weight.consume(T::DbWeight::get().reads(1));
+
+        // If we already registered this tick from the Providers Proof Submitters pallet, we don't need to do anything.
+        if submitters_prev_tick <= last_submitters_tick_registered {
+            return;
+        }
+
+        // Update the last submitters tick registered.
+        LastSubmittersTickRegistered::<T>::set(submitters_prev_tick);
+        weight.consume(T::DbWeight::get().writes(1));
+
+        // Get the Providers that submitted a valid proof in the last tick from the Providers Proof Submitters pallet,
+        // if there's any
         let proof_submitters =
-            <T::ProvidersProofSubmitters as ProofSubmittersInterface>::get_proof_submitters_for_tick(&n);
+            <T::ProvidersProofSubmitters as ProofSubmittersInterface>::get_proof_submitters_for_tick(&submitters_prev_tick);
         weight.consume(T::DbWeight::get().reads(1));
 
-        // If there are any proof submitters in the last tick
+        // If there are any proof submitters in the last tick...
         if let Some(proof_submitters) = proof_submitters {
             // Update all Providers
             // Iterate through the proof submitters and update their last chargeable tick and last chargeable price index
             for provider_id in proof_submitters {
-                // Update the last chargeable tick and last chargeable price index of the Provider
+                // Update the last chargeable tick and last chargeable price index of the Provider.
+                // The last chargeable tick is set to the current tick of THIS PALLET. That means, if the tick from
+                // the Providers Proof Submitters pallet is stalled for some time, and this pallet continues to increment
+                // its tick, when the Providers Proof Submitters pallet continues to increment its tick, this pallet will
+                // allow Providers to charge for the time that the Providers Proof Submitters pallet has been stalled.
                 let accumulated_price_index = AccumulatedPriceIndex::<T>::get();
                 LastChargeableInfo::<T>::mutate(provider_id, |provider_info| {
                     provider_info.last_chargeable_tick = n;

pallets/payment-streams/src/utils.rs

@@ -196,6 +196,10 @@ impl ProofSubmittersInterface for MockSubmittingProviders {
         None
     }
 
+    fn get_current_tick() -> Self::TickNumber {
+        System::block_number()
+    }
+
     fn get_accrued_failed_proof_submissions(_provider_id: &Self::ProviderId) -> Option<u32> {
         None
     }