Rest of V5 Updates

node/rpc/src/chain_api.rs

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

node/rpc/src/state_api.rs

@@ -710,6 +710,12 @@ pub(crate) async fn state_miner_sector_allocated<
             .get::<bitfield::BitField>(&m.allocated_sectors)?
             .ok_or("allocated sectors bitfield not found")?
             .get(sector_num as usize),
+        miner::State::V5(m) => data
+            .chain_store
+            .db
+            .get::<bitfield::BitField>(&m.allocated_sectors)?
+            .ok_or("allocated sectors bitfield not found")?
+            .get(sector_num as usize),
     };
 
     Ok(allocated_sectors)

types/networks/src/devnet/mod.rs

@@ -38,6 +38,8 @@ pub const UPGRADE_ACTORS_V3_HEIGHT: ChainEpoch = 550321;
 pub const UPGRADE_NORWEGIAN_HEIGHT: ChainEpoch = 665280;
 /// V12 network upgrade TODO
 pub const UPGRADE_ACTORS_V4_HEIGHT: ChainEpoch = 999999;
+/// V13 network upgrade TODO
+pub const UPGRADE_HYPERDRIVE_HEIGHT: ChainEpoch = 1000000;
 
 pub const UPGRADE_PLACEHOLDER_HEIGHT: ChainEpoch = 9999999;
 

types/networks/src/interopnet/mod.rs

@@ -36,6 +36,8 @@ pub const UPGRADE_ACTORS_V3_HEIGHT: ChainEpoch = 999999998;
 pub const UPGRADE_NORWEGIAN_HEIGHT: ChainEpoch = 999999999;
 /// V12 network upgrade TODO
 pub const UPGRADE_ACTORS_V4_HEIGHT: ChainEpoch = 999999999;
+/// V13 network upgrade TODO
+pub const UPGRADE_HYPERDRIVE_HEIGHT: ChainEpoch = 999999999;
 
 pub const UPGRADE_PLACEHOLDER_HEIGHT: ChainEpoch = 9999999;
 

types/networks/src/lib.rs

@@ -54,7 +54,7 @@ struct DrandPoint<'a> {
     pub config: &'a DrandConfig<'a>,
 }
 
-const VERSION_SCHEDULE: [Upgrade; 12] = [
+const VERSION_SCHEDULE: [Upgrade; 13] = [
     Upgrade {
         height: UPGRADE_BREEZE_HEIGHT,
         network: NetworkVersion::V1,
@@ -103,6 +103,10 @@ const VERSION_SCHEDULE: [Upgrade; 12] = [
         height: UPGRADE_ACTORS_V4_HEIGHT,
         network: NetworkVersion::V12,
     },
+    Upgrade {
+        height: UPGRADE_HYPERDRIVE_HEIGHT,
+        network: NetworkVersion::V13,
+    },
 ];
 
 /// Gets network version from epoch using default Mainnet schedule.

types/networks/src/mainnet/mod.rs

@@ -39,6 +39,8 @@ pub const UPGRADE_ACTORS_V3_HEIGHT: ChainEpoch = 550321;
 pub const UPGRADE_NORWEGIAN_HEIGHT: ChainEpoch = 665280;
 /// V12 network upgrade
 pub const UPGRADE_ACTORS_V4_HEIGHT: ChainEpoch = 712320;
+/// V13 network upgrade
+pub const UPGRADE_HYPERDRIVE_HEIGHT: ChainEpoch = 892800;
 
 pub const UPGRADE_PLACEHOLDER_HEIGHT: ChainEpoch = 9999999;
 

types/src/state.rs

@@ -16,8 +16,10 @@ pub enum StateTreeVersion {
     V1,
     /// Corresponds to actors = v3
     V2,
-    /// Corresponds to actors >= v4
+    /// Corresponds to actors = v4
     V3,
+    /// Corresponds to actors >= v5
+    V4,
 }
 
 /// State root information. Contains information about the version of the state tree,

types/src/verifier/mod.rs

@@ -61,13 +61,12 @@ pub trait ProofVerifier {
         }
         let spt: proofs::RegisteredSealProof = aggregate.seal_proof.try_into()?;
         let prover_id = prover_id_from_u64(aggregate.miner);
-
         struct AggregationInputs {
             // replica
             commr: [u8; 32],
             // data
             commd: [u8; 32],
-            sector_id: u64,
+            sector_id: SectorId,
             ticket: [u8; 32],
             seed: [u8; 32],
         }
@@ -80,7 +79,7 @@ pub trait ProofVerifier {
                 Ok(AggregationInputs {
                     commr,
                     commd,
-                    sector_id: info.sector_number,
+                    sector_id: SectorId::from(info.sector_number),
                     ticket: info.randomness.0,
                     seed: info.interactive_randomness.0,
                 })
@@ -95,7 +94,7 @@ pub trait ProofVerifier {
                     input.commr,
                     input.commd,
                     prover_id,
-                    input.sector_id.try_into()?,
+                    input.sector_id,
                     input.ticket,
                     input.seed,
                 )

utils/bitfield/src/rleplus/mod.rs

@@ -71,12 +71,24 @@ use super::{BitField, Result};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::borrow::Cow;
 
+// MaxEncodedSize is the maximum encoded size of a bitfield. When expanded into
+// a slice of runs, a bitfield of this size should not exceed 2MiB of memory.
+//
+// This bitfield can fit at least 3072 sparse elements.
+const MAX_ENCODED_SIZE: usize = 32 << 10;
+
 impl Serialize for BitField {
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let bytes = self.to_bytes();
+        if bytes.len() > MAX_ENCODED_SIZE {
+            return Err(serde::ser::Error::custom(format!(
+                "encoded bitfield was too large {}",
+                bytes.len()
+            )));
+        }
         serde_bytes::serialize(&bytes, serializer)
     }
 }

vm/actor/src/builtin/codes.rs

@@ -4,18 +4,18 @@
 use cid::{multihash::MultihashDigest, Cid, Code::Identity, RAW};
 
 lazy_static! {
-    pub static ref SYSTEM_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/system");
-    pub static ref INIT_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/init");
-    pub static ref CRON_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/cron");
-    pub static ref ACCOUNT_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/account");
-    pub static ref POWER_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/storagepower");
-    pub static ref MINER_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/storageminer");
-    pub static ref MARKET_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/storagemarket");
-    pub static ref PAYCH_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/paymentchannel");
-    pub static ref MULTISIG_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/multisig");
-    pub static ref REWARD_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/reward");
-    pub static ref VERIFREG_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/verifiedregistry");
-    pub static ref CHAOS_ACTOR_CODE_ID: Cid = make_builtin(b"fil/4/chaos");
+    pub static ref SYSTEM_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/system");
+    pub static ref INIT_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/init");
+    pub static ref CRON_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/cron");
+    pub static ref ACCOUNT_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/account");
+    pub static ref POWER_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/storagepower");
+    pub static ref MINER_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/storageminer");
+    pub static ref MARKET_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/storagemarket");
+    pub static ref PAYCH_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/paymentchannel");
+    pub static ref MULTISIG_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/multisig");
+    pub static ref REWARD_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/reward");
+    pub static ref VERIFREG_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/verifiedregistry");
+    pub static ref CHAOS_ACTOR_CODE_ID: Cid = make_builtin(b"fil/5/chaos");
 
     /// Set of actor code types that can represent external signing parties.
     pub static ref CALLER_TYPES_SIGNABLE: [Cid; 2] =

vm/actor/src/builtin/market/mod.rs

@@ -19,11 +19,10 @@ use crate::{
 };
 use address::Address;
 use ahash::AHashMap;
-use byteorder::{BigEndian, ByteOrder};
 use cid::Prefix;
 use clock::{ChainEpoch, EPOCH_UNDEFINED};
-use crypto::DomainSeparationTag;
 use encoding::{to_vec, Cbor};
+use fil_types::deadlines::QuantSpec;
 use fil_types::{PieceInfo, StoragePower};
 use ipld_blockstore::BlockStore;
 use num_bigint::BigInt;
@@ -330,13 +329,7 @@ impl Actor {
 
                 // We should randomize the first epoch for when the deal will be processed so an attacker isn't able to
                 // schedule too many deals for the same tick.
-                let process_epoch = gen_rand_next_epoch(rt, rt.curr_epoch(), &deal.proposal)
-                    .map_err(|e| {
-                        e.downcast_default(
-                            ExitCode::ErrIllegalState,
-                            "failed to generate random process epoch",
-                        )
-                    })?;
+                let process_epoch = gen_rand_next_epoch(deal.proposal.start_epoch, id);
 
                 msm.deals_by_epoch
                     .as_mut()
@@ -1096,27 +1089,18 @@ where
     ))
 }
 
-fn gen_rand_next_epoch<BS, RT>(
-    rt: &RT,
-    curr_epoch: ChainEpoch,
-    deal: &DealProposal,
-) -> Result<ChainEpoch, Box<dyn StdError>>
-where
-    BS: BlockStore,
-    RT: Runtime<BS>,
-{
-    let bytes = deal.marshal_cbor()?;
-
-    let rb = rt.get_randomness_from_beacon(
-        DomainSeparationTag::MarketDealCronSeed,
-        curr_epoch - 1,
-        &bytes,
-    )?;
-
-    // generate a random epoch in [baseEpoch, baseEpoch + DealUpdatesInterval)
-    let offset = BigEndian::read_u64(&rb.0);
-
-    Ok(deal.start_epoch + (offset % DEAL_UPDATES_INTERVAL as u64) as ChainEpoch)
+fn gen_rand_next_epoch(start_epoch: ChainEpoch, deal_id: DealID) -> ChainEpoch {
+    let offset = deal_id as i64 % DEAL_UPDATES_INTERVAL;
+    let q = QuantSpec {
+        unit: DEAL_UPDATES_INTERVAL,
+        offset: 0,
+    };
+    let prev_day = q.quantize_down(start_epoch);
+    if prev_day + offset >= start_epoch {
+        return prev_day + offset;
+    }
+    let next_day = q.quantize_up(start_epoch);
+    next_day + offset
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Checks

vm/actor/src/builtin/miner/deadline_state.rs

@@ -95,7 +95,7 @@ impl Deadlines {
 }
 
 /// Deadline holds the state for all sectors due at a specific deadline.
-#[derive(Serialize_tuple, Deserialize_tuple)]
+#[derive(Debug, Serialize_tuple, Deserialize_tuple)]
 pub struct Deadline {
     /// Partitions in this deadline, in order.
     /// The keys of this AMT are always sequential integers beginning with zero.

vm/actor/src/builtin/miner/mod.rs

@@ -1349,7 +1349,7 @@ impl Actor {
             .map_err(|e| {
                 ActorError::new(
                     ErrBalanceInvariantBroken,
-                    format!("balance invariants broken: {}", e),
+                    format!("balance invariant broken: {}", e),
                 )
             })?;
         if needs_cron {
@@ -3996,7 +3996,6 @@ where
     // Committed-capacity sectors licensed for early removal by new sectors being proven.
     let mut replace_sectors = DeadlineSectorMap::new();
     let activation = rt.curr_epoch();
-
     // Pre-commits for new sectors.
     let mut valid_pre_commits = Vec::<SectorPreCommitOnChainInfo>::new();
 

vm/actor/src/builtin/miner/policy.rs

@@ -72,7 +72,7 @@ pub const ADDRESSED_PARTITIONS_MAX: u64 = MAX_PARTITIONS_PER_DEADLINE;
 pub const DELCARATIONS_MAX: u64 = ADDRESSED_PARTITIONS_MAX;
 
 /// The maximum number of sector infos that may be required to be loaded in a single invocation.
-pub const ADDRESSED_SECTORS_MAX: u64 = 10_000;
+pub const ADDRESSED_SECTORS_MAX: u64 = 25_000;
 
 /// The maximum number of partitions that may be required to be loaded in a single invocation,
 /// when all the sector infos for the partitions will be loaded.

vm/actor/src/builtin/miner/state.rs

@@ -56,7 +56,7 @@ pub struct State {
     #[serde(with = "bigint_ser")]
     pub fee_debt: TokenAmount,
 
-    /// Sum of initial pledge requirements of all active sectors
+    /// Sum of initial pledge requirements of all active sectors.
     #[serde(with = "bigint_ser")]
     pub initial_pledge: TokenAmount,
 

vm/actor/src/builtin/verifreg/mod.rs

@@ -277,35 +277,28 @@ impl Actor {
                     )
                 })?;
 
-            // This is a one-time, upfront allocation.
-            // This allowance cannot be changed by calls to AddVerifiedClient as long as the
-            // client has not been removed. If parties need more allowance, they need to create a
-            // new verified client or use up the the current allowance and then create a new
-            // verified client.
-            let found = verified_clients
-                .contains_key(&client.to_bytes())
-                .map_err(|e| {
-                    e.downcast_default(
-                        ExitCode::ErrIllegalState,
-                        format!("Failed to get verified client {}", client),
-                    )
-                })?;
-            if found {
-                return Err(actor_error!(
-                    ErrIllegalArgument,
-                    "verified client already exists: {}",
-                    client
-                ));
-            }
+            let client_cap = verified_clients.get(&client.to_bytes()).map_err(|e| {
+                e.downcast_default(
+                    ExitCode::ErrIllegalState,
+                    format!("Failed to get verified client {}", client),
+                )
+            })?;
+            // if verified client exists, add allowance to existing cap
+            // otherwise, create new client with allownace
+            let client_cap = if let Some(BigIntDe(client_cap)) = client_cap {
+                client_cap + params.allowance
+            } else {
+                params.allowance
+            };
 
             verified_clients
-                .set(client.to_bytes().into(), BigIntDe(params.allowance.clone()))
+                .set(client.to_bytes().into(), BigIntDe(client_cap.clone()))
                 .map_err(|e| {
                     e.downcast_default(
                         ExitCode::ErrIllegalState,
                         format!(
                             "Failed to add verified client {} with cap {}",
-                            client, params.allowance,
+                            client, client_cap,
                         ),
                     )
                 })?;