PoT parameters change and sync

crates/pallet-subspace/src/lib.rs

@@ -378,6 +378,7 @@ mod pallet {
     pub(super) type GlobalRandomnesses<T> =
         StorageValue<_, sp_consensus_subspace::GlobalRandomnesses, ValueQuery>;
 
+    // TODO: Clarify when this value is updated (when it is updated, right now it is not)
     /// Number of iterations for proof of time per slot
     #[pallet::storage]
     pub(super) type PotSlotIterations<T> = StorageValue<_, NonZeroU32>;

crates/sc-consensus-subspace/src/import_queue.rs

@@ -234,16 +234,47 @@ where
             return Ok(CheckedHeader::Deferred(header, slot));
         }
 
+        #[cfg(feature = "pot")]
+        let slot_iterations;
+        #[cfg(feature = "pot")]
+        let pot_seed;
+        #[cfg(feature = "pot")]
+        let next_slot = slot + Slot::from(1);
+        #[cfg(feature = "pot")]
+        // The change to number of iterations might have happened before `next_slot`
+        if let Some(parameters_change) = subspace_digest_items.pot_parameters_change
+            && parameters_change.slot <= next_slot
+        {
+            slot_iterations = parameters_change.slot_iterations;
+            // Only if entropy injection happens exactly on next slot we need to mix it in
+            if parameters_change.slot == next_slot {
+                pot_seed = pre_digest
+                    .pot_info()
+                    .proof_of_time()
+                    .seed_with_entropy(&parameters_change.entropy);
+            } else {
+                pot_seed = pre_digest.pot_info().proof_of_time().seed();
+            }
+        } else {
+            slot_iterations = subspace_digest_items.pot_slot_iterations;
+            pot_seed = pre_digest.pot_info().proof_of_time().seed();
+        }
+
         // TODO: Extend/optimize this check once we have checkpoints in justifications
         // Check proof of time between slot of the block and future proof of time
+        // Here during stateless verification we do not have access to parent block, thus only
+        // verify proofs after proof of time of at current slot up until future proof of time
+        // (inclusive), during block import we verify the rest.
         #[cfg(feature = "pot")]
         if !self
             .pot_verifier
             .is_proof_valid(
-                pre_digest.pot_info().proof_of_time().seed(),
-                subspace_digest_items.pot_slot_iterations,
+                next_slot,
+                pot_seed,
+                slot_iterations,
                 self.chain_constants.block_authoring_delay(),
                 pre_digest.pot_info().future_proof_of_time(),
+                subspace_digest_items.pot_parameters_change,
             )
             .await
         {

crates/sc-consensus-subspace/src/lib.rs

@@ -16,7 +16,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 #![doc = include_str!("../README.md")]
-#![feature(try_blocks)]
+#![feature(let_chains, try_blocks)]
 #![forbid(unsafe_code)]
 #![warn(missing_docs)]
 
@@ -401,6 +401,10 @@ where
     /// Handle use to report telemetries.
     pub telemetry: Option<TelemetryHandle>,
 
+    /// Proof of time verifier
+    #[cfg(feature = "pot")]
+    pub pot_verifier: PotVerifier,
+
     /// Stream with proof of time slots.
     #[cfg(feature = "pot")]
     pub pot_slot_info_stream: PotSlotInfoStream,
@@ -424,6 +428,8 @@ pub fn start_subspace<PosTable, Block, Client, SC, E, I, SO, CIDP, BS, L, AS, Er
         max_block_proposal_slot_portion,
         telemetry,
         #[cfg(feature = "pot")]
+        pot_verifier,
+        #[cfg(feature = "pot")]
         pot_slot_info_stream,
     }: SubspaceParams<Block, Client, SC, E, I, SO, L, CIDP, BS, AS>,
 ) -> Result<SubspaceWorker, sp_consensus::Error>
@@ -476,6 +482,8 @@ where
         pending_solutions: Default::default(),
         #[cfg(feature = "pot")]
         pot_checkpoints: Default::default(),
+        #[cfg(feature = "pot")]
+        pot_verifier,
         _pos_table: PhantomData::<PosTable>,
     };
 
@@ -745,6 +753,8 @@ where
         let correct_global_randomness;
         #[cfg(feature = "pot")]
         let pot_seed;
+        #[cfg(feature = "pot")]
+        let slot_iterations;
         let correct_solution_range;
 
         if block_number.is_one() {
@@ -759,6 +769,11 @@ where
             }
             #[cfg(feature = "pot")]
             {
+                slot_iterations = self
+                    .client
+                    .runtime_api()
+                    .pot_parameters(parent_hash)?
+                    .slot_iterations();
                 pot_seed = self.pot_verifier.genesis_seed();
             }
 
@@ -782,7 +797,19 @@ where
                     };
             }
             #[cfg(feature = "pot")]
+            // In case parameters change in the very first slot after slot of the parent block,
+            // account for them
+            if let Some(parameters_change) = subspace_digest_items.pot_parameters_change
+                && parameters_change.slot == (parent_slot + Slot::from(1))
             {
+                slot_iterations = parameters_change.slot_iterations;
+                pot_seed = parent_subspace_digest_items
+                    .pre_digest
+                    .pot_info()
+                    .proof_of_time()
+                    .seed_with_entropy(&parameters_change.entropy);
+            } else {
+                slot_iterations = subspace_digest_items.pot_slot_iterations;
                 pot_seed = parent_subspace_digest_items
                     .pre_digest
                     .pot_info()
@@ -802,13 +829,21 @@ where
         }
         #[cfg(feature = "pot")]
         // TODO: Extend/optimize this check once we have checkpoints in justifications
+        // Here we check that there is continuity from parent block's proof of time (but not future
+        // entropy since this block may be produced before slot corresponding to parent block's
+        // future proof of time) to current block's proof of time. During stateless verification we
+        // do not have access to parent block, thus only verify proofs after proof of time of at
+        // current slot up until future proof of time (inclusive), here during block import we
+        // verify the rest.
         if !self
             .pot_verifier
             .is_proof_valid(
+                parent_slot + Slot::from(1),
                 pot_seed,
-                subspace_digest_items.pot_slot_iterations,
+                slot_iterations,
                 slots_since_parent,
                 subspace_digest_items.pre_digest.pot_info().proof_of_time(),
+                subspace_digest_items.pot_parameters_change,
             )
             .await
         {

crates/sc-consensus-subspace/src/slot_worker.rs

@@ -32,6 +32,8 @@ use sc_consensus_slots::{
     BackoffAuthoringBlocksStrategy, SimpleSlotWorker, SlotInfo, SlotLenienceType, SlotProportion,
 };
 #[cfg(feature = "pot")]
+use sc_proof_of_time::verifier::PotVerifier;
+#[cfg(feature = "pot")]
 use sc_proof_of_time::PotSlotWorker;
 use sc_telemetry::TelemetryHandle;
 use sc_utils::mpsc::tracing_unbounded;
@@ -140,6 +142,8 @@ where
     #[cfg(feature = "pot")]
     // TODO: Substrate should make `fn claim_slot` take `&mut self`, the  we'll not need `Mutex`
     pub(super) pot_checkpoints: Mutex<BTreeMap<Slot, PotCheckpoints>>,
+    #[cfg(feature = "pot")]
+    pub(super) pot_verifier: PotVerifier,
     pub(super) _pos_table: PhantomData<PosTable>,
 }
 
@@ -153,7 +157,14 @@ where
     SO: SyncOracle + Send + Sync,
 {
     fn on_proof(&mut self, slot: Slot, checkpoints: PotCheckpoints) {
-        self.pot_checkpoints.lock().insert(slot, checkpoints);
+        {
+            let mut pot_checkpoints = self.pot_checkpoints.lock();
+
+            // Remove checkpoints from future slots, if present they are out of date anyway
+            pot_checkpoints.retain(|&stored_slot, _checkpoints| stored_slot < slot);
+
+            pot_checkpoints.insert(slot, checkpoints);
+        }
 
         if self.sync_oracle.is_major_syncing() {
             debug!(
@@ -303,27 +314,90 @@ where
 
         #[cfg(feature = "pot")]
         let (proof_of_time, future_proof_of_time, new_checkpoints) = {
-            let mut pot_checkpoints = self.pot_checkpoints.lock();
+            // TODO: These variables and code block below are only necessary to work around
+            //  https://github.com/rust-lang/rust/issues/57478
+            let proof_of_time;
+            let future_slot;
+            let future_proof_of_time;
+            let new_checkpoints;
+            {
+                let mut pot_checkpoints = self.pot_checkpoints.lock();
+
+                // Remove checkpoints from old slots we will not need anymore
+                pot_checkpoints.retain(|&stored_slot, _checkpoints| stored_slot > parent_slot);
+
+                proof_of_time = pot_checkpoints.get(&slot)?.output();
+
+                // Future slot for which proof must be available before authoring block at this slot
+                future_slot = slot + self.chain_constants.block_authoring_delay();
+                let parent_future_slot = parent_slot + self.chain_constants.block_authoring_delay();
+                future_proof_of_time = pot_checkpoints.get(&future_slot)?.output();
+
+                // New checkpoints that were produced since parent block's future slot up to current
+                // future slot (inclusive)
+                new_checkpoints = pot_checkpoints
+                    .iter()
+                    .filter_map(|(&stored_slot, &checkpoints)| {
+                        (stored_slot > parent_future_slot && stored_slot <= future_slot)
+                            .then_some(checkpoints)
+                    })
+                    .collect::<Vec<_>>();
+            }
 
-            // Remove checkpoints from old slots we will not need anymore
-            pot_checkpoints.retain(|&stored_slot, _checkpoints| stored_slot > parent_slot);
-
-            let proof_of_time = pot_checkpoints.get(&slot)?.output();
-
-            // Future slot for which proof must be available before authoring block at this slot
-            let future_slot = slot + self.chain_constants.block_authoring_delay();
-            let parent_future_slot = parent_slot + self.chain_constants.block_authoring_delay();
-            let future_proof_of_time = pot_checkpoints.get(&future_slot)?.output();
-
-            // New checkpoints that were produced since parent block's future slot up to current
-            // future slot (inclusive)
-            let new_checkpoints = pot_checkpoints
-                .iter()
-                .filter_map(|(&stored_slot, &checkpoints)| {
-                    (stored_slot > parent_future_slot && stored_slot <= future_slot)
-                        .then_some(checkpoints)
-                })
-                .collect::<Vec<_>>();
+            let pot_parameters = runtime_api.pot_parameters(parent_hash).ok()?;
+            let slot_iterations;
+            let pot_seed;
+            let after_parent_slot = parent_slot + Slot::from(1);
+
+            if parent_header.number().is_zero() {
+                slot_iterations = pot_parameters.slot_iterations();
+                pot_seed = self.pot_verifier.genesis_seed();
+            } else {
+                let pot_info = parent_pre_digest.pot_info();
+                // The change to number of iterations might have happened before
+                // `after_parent_slot`
+                if let Some(parameters_change) = pot_parameters.next_parameters_change()
+                    && parameters_change.slot <= after_parent_slot
+                {
+                    slot_iterations = parameters_change.slot_iterations;
+                    // Only if entropy injection happens exactly after parent slot we need to \
+                    // mix it in
+                    if parameters_change.slot == after_parent_slot {
+                        pot_seed = pot_info
+                            .proof_of_time()
+                            .seed_with_entropy(&parameters_change.entropy);
+                    } else {
+                        pot_seed = pot_info
+                            .proof_of_time().seed();
+                    }
+                } else {
+                    slot_iterations = pot_parameters.slot_iterations();
+                    pot_seed = pot_info
+                        .proof_of_time()
+                        .seed();
+                }
+            };
+
+            // Ensure proof of time and future proof of time included in upcoming block are valid
+            if !self
+                .pot_verifier
+                .is_proof_valid(
+                    after_parent_slot,
+                    pot_seed,
+                    slot_iterations,
+                    Slot::from(u64::from(future_slot) - u64::from(parent_slot)),
+                    future_proof_of_time,
+                    pot_parameters.next_parameters_change(),
+                )
+                .await
+            {
+                warn!(
+                    target: "subspace",
+                    "Proof of time or future proof of time is invalid, skipping block \
+                    production at slot {slot:?}"
+                );
+                return None;
+            }
 
             (proof_of_time, future_proof_of_time, new_checkpoints)
         };

crates/sc-proof-of-time/src/lib.rs

@@ -1,6 +1,7 @@
 //! Subspace proof of time implementation.
 
-pub mod gossip;
+#![feature(let_chains, stmt_expr_attributes)]
+
 mod slots;
 pub mod source;
 pub mod verifier;