Update Runtime to Support V5 Actors

blockchain/chain/src/store/chain_store.rs

@@ -291,6 +291,28 @@ where
         }
     }
 
+    pub async fn get_chain_randomness_looking_forward(
+        &self,
+        blocks: &TipsetKeys,
+        pers: DomainSeparationTag,
+        round: ChainEpoch,
+        entropy: &[u8],
+    ) -> Result<[u8; 32], Box<dyn std::error::Error>> {
+        self.get_chain_randomness(blocks, pers, round, entropy, false)
+            .await
+    }
+
+    pub async fn get_chain_randomness_looking_backward(
+        &self,
+        blocks: &TipsetKeys,
+        pers: DomainSeparationTag,
+        round: ChainEpoch,
+        entropy: &[u8],
+    ) -> Result<[u8; 32], Box<dyn std::error::Error>> {
+        self.get_chain_randomness(blocks, pers, round, entropy, true)
+            .await
+    }
+
     /// Gets 32 bytes of randomness for ChainRand paramaterized by the DomainSeparationTag, ChainEpoch,
     /// Entropy from the ticket chain.
     pub async fn get_chain_randomness(
@@ -299,6 +321,7 @@ where
         pers: DomainSeparationTag,
         round: ChainEpoch,
         entropy: &[u8],
+        lookback: bool,
     ) -> Result<[u8; 32], Box<dyn std::error::Error>> {
         let ts = self.tipset_from_keys(blocks).await?;
 
@@ -308,7 +331,7 @@ where
 
         let search_height = if round < 0 { 0 } else { round };
 
-        let rand_ts = self.tipset_by_height(search_height, ts, true).await?;
+        let rand_ts = self.tipset_by_height(search_height, ts, lookback).await?;
 
         draw_randomness(
             rand_ts
@@ -322,6 +345,28 @@ where
         )
     }
 
+    pub async fn get_beacon_randomness_looking_forward(
+        &self,
+        blocks: &TipsetKeys,
+        pers: DomainSeparationTag,
+        round: ChainEpoch,
+        entropy: &[u8],
+    ) -> Result<[u8; 32], Box<dyn std::error::Error>> {
+        self.get_beacon_randomness(blocks, pers, round, entropy, false)
+            .await
+    }
+
+    pub async fn get_beacon_randomness_looking_backward(
+        &self,
+        blocks: &TipsetKeys,
+        pers: DomainSeparationTag,
+        round: ChainEpoch,
+        entropy: &[u8],
+    ) -> Result<[u8; 32], Box<dyn std::error::Error>> {
+        self.get_beacon_randomness(blocks, pers, round, entropy, true)
+            .await
+    }
+
     /// Gets 32 bytes of randomness for ChainRand paramaterized by the DomainSeparationTag, ChainEpoch,
     /// Entropy from the latest beacon entry.
     pub async fn get_beacon_randomness(
@@ -330,6 +375,7 @@ where
         pers: DomainSeparationTag,
         round: ChainEpoch,
         entropy: &[u8],
+        lookback: bool,
     ) -> Result<[u8; 32], Box<dyn std::error::Error>> {
         let ts = self.tipset_from_keys(blocks).await?;
 
@@ -339,7 +385,7 @@ where
 
         let search_height = if round < 0 { 0 } else { round };
 
-        let rand_ts = self.tipset_by_height(search_height, ts, true).await?;
+        let rand_ts = self.tipset_by_height(search_height, ts, lookback).await?;
 
         let be = self.latest_beacon_entry(&rand_ts).await?;
 

blockchain/state_manager/Cargo.toml

@@ -35,7 +35,7 @@ bitfield = { package = "forest_bitfield", version = "0.1" }
 serde = { version = "1.0", features = ["derive"] }
 num-traits = "0.2.11"
 tokio = { version = "1.0", features = ["sync"] }
-filecoin-proofs-api = { version = "6.1", features = ["blst"], default_features = false }
+filecoin-proofs-api = { version = "8", features = ["blst"], default_features = false }
 futures = "0.3.5"
 runtime = { package = "forest_runtime", version = "0.2" }
 lazy_static = "1.4"

blockchain/state_manager/src/chain_rand.rs

@@ -36,7 +36,7 @@ where
     ) -> Result<[u8; 32], Box<dyn Error>> {
         task::block_on(
             self.cs
-                .get_chain_randomness(&self.blks, pers, round, entropy),
+                .get_chain_randomness_looking_backward(&self.blks, pers, round, entropy),
         )
     }
 
@@ -48,7 +48,31 @@ where
     ) -> Result<[u8; 32], Box<dyn Error>> {
         task::block_on(
             self.cs
-                .get_beacon_randomness(&self.blks, pers, round, entropy),
+                .get_beacon_randomness_looking_backward(&self.blks, pers, round, entropy),
+        )
+    }
+
+    fn get_chain_randomness_looking_forward(
+        &self,
+        pers: DomainSeparationTag,
+        round: ChainEpoch,
+        entropy: &[u8],
+    ) -> Result<[u8; 32], Box<dyn Error>> {
+        task::block_on(
+            self.cs
+                .get_chain_randomness_looking_forward(&self.blks, pers, round, entropy),
+        )
+    }
+
+    fn get_beacon_randomness_looking_forward(
+        &self,
+        pers: DomainSeparationTag,
+        round: ChainEpoch,
+        entropy: &[u8],
+    ) -> Result<[u8; 32], Box<dyn Error>> {
+        task::block_on(
+            self.cs
+                .get_beacon_randomness_looking_forward(&self.blks, pers, round, entropy),
         )
     }
 }

node/rpc/src/chain_api.rs

@@ -277,6 +277,7 @@ where
             DomainSeparationTag::from_i64(pers).ok_or("invalid DomainSeparationTag")?,
             epoch,
             &base64::decode(entropy)?,
+            epoch <= networks::UPGRADE_PLACEHOLDER_HEIGHT,
         )
         .await?)
 }
@@ -300,6 +301,7 @@ where
             DomainSeparationTag::from_i64(pers).ok_or("invalid DomainSeparationTag")?,
             epoch,
             &base64::decode(entropy)?,
+            epoch <= networks::UPGRADE_PLACEHOLDER_HEIGHT,
         )
         .await?)
 }

tests/conformance_tests/src/rand_replay.rs

@@ -65,4 +65,42 @@ impl Rand for ReplayingRand<'_> {
             self.fallback.get_beacon_randomness(dst, epoch, entropy)
         }
     }
+    // TODO: Check if this is going to be correct for when we integrate v5 Actors test vectors
+    fn get_beacon_randomness_looking_forward(
+        &self,
+        dst: DomainSeparationTag,
+        epoch: ChainEpoch,
+        entropy: &[u8],
+    ) -> Result<[u8; 32], Box<dyn StdError>> {
+        let rule = RandomnessRule {
+            kind: RandomnessKind::Beacon,
+            dst,
+            epoch,
+            entropy: entropy.to_vec(),
+        };
+        if let Some(bz) = self.matches(rule) {
+            Ok(bz)
+        } else {
+            self.fallback.get_beacon_randomness(dst, epoch, entropy)
+        }
+    }
+    // TODO: Check if this is going to be correct for when we integrate v5 Actors test vectors
+    fn get_chain_randomness_looking_forward(
+        &self,
+        dst: DomainSeparationTag,
+        epoch: ChainEpoch,
+        entropy: &[u8],
+    ) -> Result<[u8; 32], Box<dyn StdError>> {
+        let rule = RandomnessRule {
+            kind: RandomnessKind::Chain,
+            dst,
+            epoch,
+            entropy: entropy.to_vec(),
+        };
+        if let Some(bz) = self.matches(rule) {
+            Ok(bz)
+        } else {
+            self.fallback.get_chain_randomness(dst, epoch, entropy)
+        }
+    }
 }

tests/conformance_tests/src/stubs.rs

@@ -21,6 +21,22 @@ impl Rand for TestRand {
     ) -> Result<[u8; 32], Box<dyn StdError>> {
         Ok(*b"i_am_random_____i_am_random_____")
     }
+    fn get_beacon_randomness_looking_forward(
+        &self,
+        _: DomainSeparationTag,
+        _: ChainEpoch,
+        _: &[u8],
+    ) -> Result<[u8; 32], Box<dyn StdError>> {
+        Ok(*b"i_am_random_____i_am_random_____")
+    }
+    fn get_chain_randomness_looking_forward(
+        &self,
+        _: DomainSeparationTag,
+        _: ChainEpoch,
+        _: &[u8],
+    ) -> Result<[u8; 32], Box<dyn StdError>> {
+        Ok(*b"i_am_random_____i_am_random_____")
+    }
 }
 
 pub struct TestSyscalls;
@@ -49,4 +65,10 @@ impl Syscalls for TestSyscalls {
     ) -> Result<Option<ConsensusFault>, Box<dyn StdError>> {
         Ok(None)
     }
+    fn verify_aggregate_seals(
+        &self,
+        _: &fil_types::AggregateSealVerifyProofAndInfos,
+    ) -> Result<(), Box<dyn StdError>> {
+        Ok(())
+    }
 }

types/Cargo.toml

@@ -16,7 +16,7 @@ chrono = "0.4.9"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.56"
 commcid = { path = "../utils/commcid", version = "0.1.1", optional = true }
-filecoin-proofs-api = { version = "6.1", features = ["blst"], default_features = false, optional = true }
+filecoin-proofs-api = { version = "8", features = ["blst"], default_features = false, optional = true }
 vm = { package = "forest_vm", version = "0.3" }
 cid = { package = "forest_cid", features = ["cbor"], version = "0.3" }
 num-bigint = { path = "../utils/bigint", package = "forest_bigint", version = "0.1.1" }
@@ -29,6 +29,7 @@ forest_json_utils = { path = "../utils/json_utils", optional = true, version = "
 lazy_static = "1.4"
 async-std = "1.9"
 git-version = "0.3.4"
+rayon = "1"
 
 [features]
 json = ["base64", "forest_json_utils", "num-bigint/json"]

types/src/sector/registered_proof.rs

@@ -233,6 +233,13 @@ impl RegisteredSealProof {
     }
 }
 
+/// Seal proof type which defines the version and sector size.
+#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)]
+pub enum RegisteredAggregateProof {
+    SnarkPackV1,
+    Invalid(i64),
+}
+
 macro_rules! i64_conversion {
     ($ty:ident; $( $var:ident => $val:expr, )*) => {
         impl From<i64> for $ty {
@@ -283,6 +290,22 @@ i64_conversion! {
     StackedDRG64GiBV1P1 => 9,
 }
 
+i64_conversion! {
+    RegisteredAggregateProof;
+    SnarkPackV1 => 0,
+}
+#[cfg(feature = "proofs")]
+impl TryFrom<RegisteredAggregateProof> for filecoin_proofs_api::RegisteredAggregationProof {
+    type Error = String;
+    fn try_from(p: RegisteredAggregateProof) -> Result<Self, Self::Error> {
+        use RegisteredAggregateProof::*;
+        match p {
+            SnarkPackV1 => Ok(Self::SnarkPackV1),
+            Invalid(i) => Err(format!("unsupported aggregate proof type: {}", i)),
+        }
+    }
+}
+
 #[cfg(feature = "proofs")]
 impl TryFrom<RegisteredSealProof> for filecoin_proofs_api::RegisteredSealProof {
     type Error = String;
@@ -362,3 +385,22 @@ impl<'de> Deserialize<'de> for RegisteredSealProof {
         Ok(Self::from(val))
     }
 }
+
+impl Serialize for RegisteredAggregateProof {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        i64::from(*self).serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for RegisteredAggregateProof {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let val = i64::deserialize(deserializer)?;
+        Ok(Self::from(val))
+    }
+}

types/src/sector/seal.rs

@@ -1,7 +1,9 @@
 // Copyright 2020 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use crate::{Randomness, RegisteredSealProof, SectorID, SectorNumber};
+use crate::{
+    ActorID, Randomness, RegisteredAggregateProof, RegisteredSealProof, SectorID, SectorNumber,
+};
 use cid::Cid;
 use clock::ChainEpoch;
 use encoding::{serde_bytes, tuple::*};
@@ -42,3 +44,24 @@ pub struct SealVerifyParams {
     pub sector_num: SectorNumber,
     pub seal_rand_epoch: ChainEpoch,
 }
+
+/// Information needed to verify an aggregated seal proof.
+#[derive(Clone, Debug, PartialEq, Serialize_tuple, Deserialize_tuple)]
+pub struct AggregateSealVerifyInfo {
+    pub sector_number: SectorNumber,
+    pub randomness: SealRandomness,
+    pub interactive_randomness: InteractiveSealRandomness,
+
+    pub sealed_cid: Cid,   // Commr
+    pub unsealed_cid: Cid, // Commd
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize_tuple, Deserialize_tuple)]
+pub struct AggregateSealVerifyProofAndInfos {
+    pub miner: ActorID,
+    pub seal_proof: RegisteredSealProof,
+    pub aggregate_proof: RegisteredAggregateProof,
+    #[serde(with = "serde_bytes")]
+    pub proof: Vec<u8>,
+    pub infos: Vec<AggregateSealVerifyInfo>,
+}