Basic PoT verification

crates/pallet-subspace/src/lib.rs

@@ -69,12 +69,12 @@ use sp_runtime::DispatchError;
 use sp_std::collections::btree_map::BTreeMap;
 use sp_std::prelude::*;
 use subspace_core_primitives::crypto::Scalar;
+#[cfg(feature = "pot")]
+use subspace_core_primitives::PotProof;
 use subspace_core_primitives::{
     ArchivedHistorySegment, HistorySize, PublicKey, Randomness, RewardSignature, SectorId,
     SectorIndex, SegmentHeader, SegmentIndex, SolutionRange,
 };
-#[cfg(feature = "pot")]
-use subspace_core_primitives::{PotProof, PotSeed};
 use subspace_solving::REWARD_SIGNING_CONTEXT;
 #[cfg(not(feature = "pot"))]
 use subspace_verification::derive_randomness;
@@ -789,20 +789,13 @@ impl<T: Config> Pallet<T> {
 
     fn do_initialize(block_number: T::BlockNumber) {
         #[cfg(feature = "pot")]
-        frame_system::Pallet::<T>::deposit_log(DigestItem::future_pot_seed(
-            if block_number.is_one() {
-                PotSeed::from_genesis_block_hash(
-                    frame_system::Pallet::<T>::block_hash(T::BlockNumber::zero())
-                        .as_ref()
-                        .try_into()
-                        .expect("Genesis block hash length must match, panic otherwise"),
-                )
-            } else {
+        if !block_number.is_one() {
+            frame_system::Pallet::<T>::deposit_log(DigestItem::future_pot_seed(
                 FuturePotSeed::<T>::get().expect(
                     "Is set at the end of `do_initialize` of every block after genesis; qed",
-                )
-            },
-        ));
+                ),
+            ));
+        }
 
         let pre_digest = <frame_system::Pallet<T>>::digest()
             .logs

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

@@ -11,7 +11,7 @@ use std::marker::PhantomData;
 use std::num::NonZeroU32;
 use std::sync::Arc;
 use std::thread;
-use subspace_core_primitives::{BlockHash, PotCheckpoints, PotKey, PotSeed, SlotNumber};
+use subspace_core_primitives::{PotCheckpoints, PotSeed, SlotNumber};
 use subspace_proof_of_time::PotError;
 use tracing::{debug, error};
 
@@ -28,12 +28,12 @@ pub struct PotSlotInfo {
 pub struct PotSlotInfoStream(mpsc::Receiver<PotSlotInfo>);
 
 /// Configuration for proof of time source
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Clone)]
 pub struct PotSourceConfig {
     /// Is this node a Timekeeper
     pub is_timekeeper: bool,
-    /// PoT key used initially when PoT chain starts
-    pub initial_key: PotKey,
+    /// External entropy, used initially when PoT chain starts to derive the first seed
+    pub external_entropy: Vec<u8>,
 }
 
 /// Source of proofs of time.
@@ -51,7 +51,6 @@ pub struct PotSource<Block, Client> {
 impl<Block, Client> PotSource<Block, Client>
 where
     Block: BlockT,
-    BlockHash: From<Block::Hash>,
     Client: ProvideRuntimeApi<Block> + HeaderBackend<Block>,
     Client::Api: SubspaceRuntimeApi<Block, FarmerPublicKey>,
 {
@@ -62,13 +61,12 @@ where
         let PotSourceConfig {
             // TODO: Respect this boolean flag
             is_timekeeper: _,
-            initial_key,
+            external_entropy,
         } = config;
         let info = client.info();
         // TODO: All 3 are incorrect and should be able to continue after node restart
         let start_slot = SlotNumber::MIN;
-        let start_seed = PotSeed::from_genesis_block_hash(BlockHash::from(info.genesis_hash));
-        let start_key = initial_key;
+        let start_seed = PotSeed::from_genesis(info.genesis_hash.as_ref(), &external_entropy);
         #[cfg(feature = "pot")]
         let best_hash = info.best_hash;
         #[cfg(feature = "pot")]
@@ -85,8 +83,7 @@ where
         thread::Builder::new()
             .name("timekeeper".to_string())
             .spawn(move || {
-                if let Err(error) =
-                    run_timekeeper(start_seed, start_key, start_slot, iterations, slot_sender)
+                if let Err(error) = run_timekeeper(start_seed, start_slot, iterations, slot_sender)
                 {
                     error!(%error, "Timekeeper exited with an error");
                 }
@@ -113,16 +110,14 @@ where
 /// Runs timekeeper, must be running on a fast dedicated CPU core
 fn run_timekeeper(
     mut seed: PotSeed,
-    mut key: PotKey,
     mut slot: SlotNumber,
     iterations: NonZeroU32,
     mut slot_sender: mpsc::Sender<PotSlotInfo>,
 ) -> Result<(), PotError> {
     loop {
-        let checkpoints = subspace_proof_of_time::prove(seed, key, iterations)?;
+        let checkpoints = subspace_proof_of_time::prove(seed, iterations)?;
 
         seed = checkpoints.output().seed();
-        key = seed.key();
 
         let slot_info = PotSlotInfo {
             slot: Slot::from(slot),

crates/sp-consensus-subspace/src/digests.rs

@@ -583,8 +583,10 @@ pub struct SubspaceDigestItems<PublicKey, RewardAddress, Signature> {
     /// Root plot public key was updated
     pub root_plot_public_key_update: Option<Option<FarmerPublicKey>>,
     /// Future proof of time seed, essentially output of parent block's future proof of time.
+    ///
+    /// This value is missing in block #1, but present in all blocks after that.
     #[cfg(feature = "pot")]
-    pub future_pot_seed: PotSeed,
+    pub future_pot_seed: Option<PotSeed>,
 }
 
 /// Extract the Subspace global randomness from the given header.
@@ -799,8 +801,7 @@ where
         enable_solution_range_adjustment_and_override: maybe_enable_and_override_solution_range,
         root_plot_public_key_update: maybe_root_plot_public_key_update,
         #[cfg(feature = "pot")]
-        future_pot_seed: maybe_future_pot_seed
-            .ok_or(Error::Missing(ErrorDigestType::FuturePotSeed))?,
+        future_pot_seed: maybe_future_pot_seed,
     })
 }
 

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

@@ -725,6 +725,9 @@ sp_api::decl_runtime_apis! {
         /// Returns `Vec<SegmentHeader>` if a given extrinsic has them.
         fn extract_segment_headers(ext: &Block::Extrinsic) -> Option<Vec<SegmentHeader >>;
 
+        /// Checks if the extrinsic is an inherent.
+        fn is_inherent(ext: &Block::Extrinsic) -> bool;
+
         /// Returns root plot public key in case block authoring is restricted.
         fn root_plot_public_key() -> Option<FarmerPublicKey>;
 

crates/subspace-core-primitives/src/lib.rs

@@ -43,7 +43,8 @@ extern crate alloc;
 
 use crate::crypto::kzg::{Commitment, Witness};
 use crate::crypto::{
-    blake2b_256_hash, blake2b_256_hash_list, blake2b_256_hash_with_key, blake3_hash, Scalar,
+    blake2b_256_hash, blake2b_256_hash_list, blake2b_256_hash_with_key, blake3_hash,
+    blake3_hash_list, Scalar,
 };
 #[cfg(feature = "serde")]
 use ::serde::{Deserialize, Serialize};
@@ -141,9 +142,6 @@ pub type SolutionRange = u64;
 /// The closer solution's tag is to the target, the heavier it is.
 pub type BlockWeight = u128;
 
-/// Block hash (the bytes from H256)
-pub type BlockHash = [u8; 32];
-
 // TODO: New type
 /// Segment commitment type.
 pub type SegmentCommitment = Commitment;
@@ -302,9 +300,10 @@ impl PotSeed {
 
     /// Derive initial PoT seed from genesis block hash
     #[inline]
-    pub fn from_genesis_block_hash(block_hash: BlockHash) -> Self {
+    pub fn from_genesis(genesis_block_hash: &[u8], external_entropy: &[u8]) -> Self {
+        let hash = blake3_hash_list(&[genesis_block_hash, external_entropy]);
         let mut seed = Self::default();
-        seed.copy_from_slice(&block_hash[..Self::SIZE]);
+        seed.copy_from_slice(&hash[..Self::SIZE]);
         seed
     }
 

crates/subspace-node/Cargo.toml

@@ -34,6 +34,7 @@ frame-benchmarking = { version = "4.0.0-dev", git = "https://github.com/subspace
 frame-benchmarking-cli = { version = "4.0.0-dev", git = "https://github.com/subspace/substrate", rev = "55c157cff49b638a59d81a9f971f0f9a66829c71", default-features = false }
 frame-support = { version = "4.0.0-dev", git = "https://github.com/subspace/substrate", rev = "55c157cff49b638a59d81a9f971f0f9a66829c71" }
 futures = "0.3.28"
+hex = "0.4.3"
 hex-literal = "0.4.0"
 log = "0.4.19"
 once_cell = "1.18.0"

crates/subspace-node/src/bin/subspace-node.rs

@@ -425,10 +425,10 @@ fn main() -> Result<(), Error> {
                     };
 
                     #[cfg(feature = "pot")]
-                    let maybe_chain_spec_pot_initial_key = consensus_chain_config
+                    let maybe_chain_spec_pot_external_entropy = consensus_chain_config
                         .chain_spec
                         .properties()
-                        .get("potInitialKey")
+                        .get("potExternalEntropy")
                         .map(|d| serde_json::from_value(d.clone()))
                         .transpose()
                         .map_err(|error| {
@@ -438,20 +438,20 @@ fn main() -> Result<(), Error> {
                         })?
                         .flatten();
                     #[cfg(feature = "pot")]
-                    if maybe_chain_spec_pot_initial_key.is_some()
-                        && cli.pot_initial_key.is_some()
-                        && maybe_chain_spec_pot_initial_key != cli.pot_initial_key
+                    if maybe_chain_spec_pot_external_entropy.is_some()
+                        && cli.pot_external_entropy.is_some()
+                        && maybe_chain_spec_pot_external_entropy != cli.pot_external_entropy
                     {
                         warn!(
-                        "--pot-initial-key CLI argument was ignored due to chain spec having a \
-                        different explicit value"
+                        "--pot-external-entropy CLI argument was ignored due to chain spec having \
+                        a different explicit value"
                     );
                     }
                     #[cfg(feature = "pot")]
                     let pot_source_config = PotSourceConfig {
                         is_timekeeper: cli.timekeeper,
-                        initial_key: maybe_chain_spec_pot_initial_key
-                            .or(cli.pot_initial_key)
+                        external_entropy: maybe_chain_spec_pot_external_entropy
+                            .or(cli.pot_external_entropy)
                             .unwrap_or_default(),
                     };
 

crates/subspace-node/src/chain_spec.rs

@@ -173,7 +173,7 @@ pub fn gemini_3f_compiled() -> Result<ConsensusChainSpec<GenesisConfig>, String>
         Some({
             let mut properties = chain_spec_properties();
             properties.insert(
-                "potInitialKey".to_string(),
+                "potExternalEntropy".to_string(),
                 serde_json::to_value(None::<PotKey>).expect("Serialization is not infallible; qed"),
             );
             properties
@@ -271,7 +271,7 @@ pub fn devnet_config_compiled() -> Result<ConsensusChainSpec<GenesisConfig>, Str
         Some({
             let mut properties = chain_spec_properties();
             properties.insert(
-                "potInitialKey".to_string(),
+                "potExternalEntropy".to_string(),
                 serde_json::to_value(None::<PotKey>).expect("Serialization is not infallible; qed"),
             );
             properties
@@ -326,7 +326,7 @@ pub fn dev_config() -> Result<ConsensusChainSpec<GenesisConfig>, String> {
         Some({
             let mut properties = chain_spec_properties();
             properties.insert(
-                "potInitialKey".to_string(),
+                "potExternalEntropy".to_string(),
                 serde_json::to_value(None::<PotKey>).expect("Serialization is not infallible; qed"),
             );
             properties
@@ -389,7 +389,7 @@ pub fn local_config() -> Result<ConsensusChainSpec<GenesisConfig>, String> {
         Some({
             let mut properties = chain_spec_properties();
             properties.insert(
-                "potInitialKey".to_string(),
+                "potExternalEntropy".to_string(),
                 serde_json::to_value(None::<PotKey>).expect("Serialization is not infallible; qed"),
             );
             properties

crates/subspace-node/src/lib.rs

@@ -30,8 +30,6 @@ use sc_telemetry::serde_json;
 use serde_json::Value;
 use std::io::Write;
 use std::{fs, io};
-#[cfg(feature = "pot")]
-use subspace_core_primitives::PotKey;
 use subspace_networking::libp2p::Multiaddr;
 
 /// Executor dispatch for subspace runtime
@@ -180,6 +178,11 @@ pub enum Subcommand {
     Benchmark(frame_benchmarking_cli::BenchmarkCmd),
 }
 
+#[cfg(feature = "pot")]
+fn parse_pot_external_entropy(s: &str) -> Result<Vec<u8>, hex::FromHexError> {
+    hex::decode(s)
+}
+
 /// Subspace Cli.
 #[derive(Debug, Parser)]
 #[clap(
@@ -265,12 +268,10 @@ pub struct Cli {
     #[cfg(feature = "pot")]
     pub timekeeper: bool,
 
-    /// Initial PoT key (unless specified in chain spec already).
-    ///
-    /// Key is a 16-byte hex string.
-    #[arg(long)]
+    /// External entropy, used initially when PoT chain starts to derive the first seed
+    #[arg(long, value_parser = parse_pot_external_entropy)]
     #[cfg(feature = "pot")]
-    pub pot_initial_key: Option<PotKey>,
+    pub pot_external_entropy: Option<Vec<u8>>,
 }
 
 impl SubstrateCli for Cli {

crates/subspace-proof-of-time/benches/pot.rs

@@ -2,35 +2,32 @@ use core::num::NonZeroU32;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use rand::{thread_rng, Rng};
 use std::num::NonZeroU64;
-use subspace_core_primitives::{PotKey, PotSeed};
+use subspace_core_primitives::PotSeed;
 use subspace_proof_of_time::{prove, verify};
 
 fn criterion_benchmark(c: &mut Criterion) {
     let mut seed = PotSeed::default();
     thread_rng().fill(seed.as_mut());
-    let mut key = PotKey::default();
-    thread_rng().fill(key.as_mut());
     // About 1s on 5.5 GHz Raptor Lake CPU
     let pot_iterations = NonZeroU32::new(183_270_000).expect("Not zero; qed");
 
     c.bench_function("prove", |b| {
         b.iter(|| {
-            prove(black_box(seed), black_box(key), black_box(pot_iterations)).unwrap();
+            black_box(prove(black_box(seed), black_box(pot_iterations))).unwrap();
         })
     });
 
-    let checkpoints = prove(seed, key, pot_iterations).unwrap();
+    let checkpoints = prove(seed, pot_iterations).unwrap();
 
     let pot_iterations = NonZeroU64::from(pot_iterations);
 
     c.bench_function("verify", |b| {
         b.iter(|| {
-            verify(
+            black_box(verify(
                 black_box(seed),
-                black_box(key),
                 black_box(pot_iterations),
                 black_box(&*checkpoints),
-            )
+            ))
             .unwrap();
         })
     });