Feature: move partitions

actors/miner/src/deadlines.rs

@@ -128,6 +128,26 @@ pub fn deadline_available_for_compaction(
         )
 }
 
+// the distance between from_deadline and to_deadline clockwise in deadline unit.
+fn deadline_distance(policy: &Policy, from_deadline: u64, to_deadline: u64) -> u64 {
+    if to_deadline > from_deadline {
+        to_deadline - from_deadline
+    } else {
+        policy.wpost_period_deadlines - from_deadline + to_deadline
+    }
+}
+
+// only allow moving to a nearer deadline from current one
+pub fn deadline_available_for_move(
+    policy: &Policy,
+    from_deadline: u64,
+    to_deadline: u64,
+    current_deadline: u64,
+) -> bool {
+    deadline_distance(policy, current_deadline, to_deadline)
+        < deadline_distance(policy, current_deadline, from_deadline)
+}
+
 // Determine current period start and deadline index directly from current epoch and
 // the offset implied by the proving period. This works correctly even for the state
 // of a miner actor without an active deadline cron

actors/miner/src/lib.rs

@@ -128,6 +128,7 @@ pub enum Method {
     ChangeBeneficiary = 30,
     GetBeneficiary = 31,
     ExtendSectorExpiration2 = 32,
+    MovePartitions = 33,
     // Method numbers derived from FRC-0042 standards
     ChangeWorkerAddressExported = frc42_dispatch::method_hash!("ChangeWorkerAddress"),
     ChangePeerIDExported = frc42_dispatch::method_hash!("ChangePeerID"),
@@ -2995,6 +2996,297 @@ impl Actor {
         Ok(())
     }
 
+    fn move_partitions(
+        rt: &impl Runtime,
+        mut params: MovePartitionsParams,
+    ) -> Result<(), ActorError> {
+        let policy = rt.policy();
+        if params.from_deadline == params.to_deadline {
+            return Err(actor_error!(illegal_argument, "from_deadline == to_deadline"));
+        }
+        if params.from_deadline >= policy.wpost_period_deadlines
+            || params.to_deadline >= policy.wpost_period_deadlines
+        {
+            return Err(actor_error!(
+                illegal_argument,
+                "invalid deadline {}",
+                if params.from_deadline >= policy.wpost_period_deadlines {
+                    params.from_deadline
+                } else {
+                    params.to_deadline
+                }
+            ));
+        }
+
+        let partitions = &mut params.partitions;
+
+        rt.transaction(|state: &mut State, rt| {
+            let info = get_miner_info(rt.store(), state)?;
+
+            rt.validate_immediate_caller_is(&[info.worker, info.owner])?;
+
+            let store = rt.store();
+            let current_deadline = state.deadline_info(policy, rt.curr_epoch());
+            let mut deadlines =
+                state.load_deadlines(store).map_err(|e| e.wrap("failed to load deadlines"))?;
+
+            // only try to do synchronous Window Post verification if from_deadline doesn't satisfy deadline_available_for_compaction
+            if !deadline_available_for_compaction(
+                policy,
+                current_deadline.period_start,
+                params.from_deadline,
+                rt.curr_epoch(),
+            ) {
+                // the heavy path: try to do synchronous Window Post verification
+
+                // current deadline must be in the dispute window to satisfy the condition of synchronous Window POST verification
+                if !deadline_available_for_optimistic_post_dispute(
+                    policy,
+                    current_deadline.period_start,
+                    params.from_deadline,
+                    rt.curr_epoch(),
+                ) {
+                    return Err(actor_error!(
+                        forbidden,
+                        "cannot move from deadline {} when !deadline_available_for_compaction && !deadline_available_for_optimistic_post_dispute",
+                        params.from_deadline
+                    ));
+                }
+
+
+                let dl_current = deadlines
+                    .load_deadline(policy, rt.store(), params.from_deadline)
+                    .map_err(|e| {
+                        e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to load deadline")
+                    })?;
+
+                let proofs_snapshot =
+                    dl_current.optimistic_proofs_snapshot_amt(store).map_err(|e| {
+                        e.downcast_default(
+                            ExitCode::USR_ILLEGAL_STATE,
+                            "failed to load proofs snapshot",
+                        )
+                    })?;
+
+                let partitions_snapshot =
+                    dl_current.partitions_snapshot_amt(store).map_err(|e| {
+                        e.downcast_default(
+                            ExitCode::USR_ILLEGAL_STATE,
+                            "failed to load partitions snapshot",
+                        )
+                    })?;
+
+                // Load sectors for the dispute.
+                let sectors =
+                    Sectors::load(rt.store(), &dl_current.sectors_snapshot).map_err(|e| {
+                        e.downcast_default(
+                            ExitCode::USR_ILLEGAL_STATE,
+                            "failed to load sectors array",
+                        )
+                    })?;
+
+                proofs_snapshot
+                    .for_each(|_, window_proof| {
+                        let mut all_sectors =
+                            Vec::<BitField>::with_capacity(window_proof.partitions.len() as usize);
+                        let mut all_ignored =
+                            Vec::<BitField>::with_capacity(window_proof.partitions.len() as usize);
+
+                        for partition_idx in window_proof.partitions.iter() {
+                            let partition = partitions_snapshot
+                                .get(partition_idx)
+                                .map_err(|e| {
+                                    e.downcast_default(
+                                        ExitCode::USR_ILLEGAL_STATE,
+                                        "failed to load partitions snapshot for proof",
+                                    )
+                                })?
+                                .ok_or_else(|| {
+                                    actor_error!(
+                                        illegal_state,
+                                        "failed to load partitions snapshot for proof"
+                                    )
+                                })?;
+                            all_sectors.push(partition.sectors.clone());
+                            all_ignored.push(partition.terminated.clone());
+                            // fail early since remove_partitions will fail when there're faults anyway.
+                            if !partition.faults.is_empty() {
+                                return Err(anyhow::anyhow!("unable to do synchronous Window POST verification while there're faults in from deadline {}",
+                                    params.from_deadline
+                                ));
+                            }
+                        }
+
+                        // Load sector infos for proof, substituting a known-good sector for known-faulty sectors.
+                        // Note: this is slightly sub-optimal, loading info for the recovering sectors again after they were already
+                        // loaded above.
+                        let sector_infos = sectors
+                            .load_for_proof(
+                                &BitField::union(&all_sectors),
+                                &BitField::union(&all_ignored),
+                            )
+                            .map_err(|e| {
+                                e.downcast_default(
+                                    ExitCode::USR_ILLEGAL_STATE,
+                                    "failed to load sectors for post verification",
+                                )
+                            })?;
+                        if !verify_windowed_post(
+                            rt,
+                            current_deadline.challenge,
+                            &sector_infos,
+                            window_proof.proofs.clone(),
+                        )
+                        .map_err(|e| e.wrap("window post failed"))?
+                        {
+                            return Err(actor_error!(
+                                illegal_argument,
+                                "invalid post was submitted"
+                            )
+                            .into());
+                        }
+                        Ok(())
+                    })
+                    .map_err(|e| {
+                        e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "while removing partitions")
+                    })?;
+            }
+
+            if !deadline_available_for_compaction(
+                policy,
+                current_deadline.period_start,
+                params.to_deadline,
+                rt.curr_epoch(),
+            ) {
+                return Err(actor_error!(
+                    forbidden,
+                    "cannot move to deadline {} during its challenge window, \
+                        or the prior challenge window,
+                        or before {} epochs have passed since its last challenge window ended",
+                    params.to_deadline,
+                    policy.wpost_dispute_window
+                ));
+            }
+
+            if !deadline_available_for_move(
+                policy,
+                params.from_deadline,
+                params.to_deadline,
+                current_deadline.index,
+            ) {
+                return Err(actor_error!(
+                    forbidden,
+                    "cannot move to a deadline which is further from current deadline"
+                ));
+            }
+
+            let from_quant = state.quant_spec_for_deadline(policy, params.from_deadline);
+            let to_quant = state.quant_spec_for_deadline(policy, params.to_deadline);
+
+            let mut from_deadline =
+                deadlines.load_deadline(policy, store, params.from_deadline).map_err(|e| {
+                    e.downcast_default(
+                        ExitCode::USR_ILLEGAL_STATE,
+                        format!("failed to load deadline {}", params.from_deadline),
+                    )
+                })?;
+            let mut to_deadline =
+                deadlines.load_deadline(policy, store, params.to_deadline).map_err(|e| {
+                    e.downcast_default(
+                        ExitCode::USR_ILLEGAL_STATE,
+                        format!("failed to load deadline {}", params.to_deadline),
+                    )
+                })?;
+
+            if partitions.len() == 0 {
+                let partitions_amt = from_deadline.partitions_amt(rt.store()).map_err(|e| {
+                    e.downcast_default(
+                        ExitCode::USR_ILLEGAL_STATE,
+                        format!("failed to load partitions for deadline {}", params.from_deadline),
+                    )
+                })?;
+
+                for partition_idx in 0..partitions_amt.count() {
+                    partitions.set(partition_idx);
+                }
+            }
+
+            let (live, dead, removed_power) =
+                from_deadline.remove_partitions(store, partitions, from_quant).map_err(|e| {
+                    e.downcast_default(
+                        ExitCode::USR_ILLEGAL_STATE,
+                        format!(
+                            "failed to remove partitions from deadline {}",
+                            params.from_deadline
+                        ),
+                    )
+                })?;
+
+            state.delete_sectors(store, &dead).map_err(|e| {
+                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to delete dead sectors")
+            })?;
+
+            let sectors = state.load_sector_infos(store, &live).map_err(|e| {
+                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to load moved sectors")
+            })?;
+            let proven = true;
+            let added_power = to_deadline
+                .add_sectors(
+                    store,
+                    info.window_post_partition_sectors,
+                    proven,
+                    &sectors,
+                    info.sector_size,
+                    to_quant,
+                )
+                .map_err(|e| {
+                    e.downcast_default(
+                        ExitCode::USR_ILLEGAL_STATE,
+                        "failed to add back moved sectors",
+                    )
+                })?;
+
+            if removed_power != added_power {
+                return Err(actor_error!(
+                    illegal_state,
+                    "power changed when compacting partitions: was {:?}, is now {:?}",
+                    removed_power,
+                    added_power
+                ));
+            }
+
+            deadlines
+                .update_deadline(policy, store, params.from_deadline, &from_deadline)
+                .map_err(|e| {
+                    e.downcast_default(
+                        ExitCode::USR_ILLEGAL_STATE,
+                        format!("failed to update deadline {}", params.from_deadline),
+                    )
+                })?;
+            deadlines.update_deadline(policy, store, params.to_deadline, &to_deadline).map_err(
+                |e| {
+                    e.downcast_default(
+                        ExitCode::USR_ILLEGAL_STATE,
+                        format!("failed to update deadline {}", params.to_deadline),
+                    )
+                },
+            )?;
+
+            state.save_deadlines(store, deadlines).map_err(|e| {
+                e.downcast_default(
+                    ExitCode::USR_ILLEGAL_STATE,
+                    format!(
+                        "failed to save deadline when move_partitions from {} to {}",
+                        params.from_deadline, params.to_deadline
+                    ),
+                )
+            })?;
+
+            Ok(())
+        })?;
+
+        Ok(())
+    }
     /// Compacts sector number allocations to reduce the size of the allocated sector
     /// number bitfield.
     ///
@@ -5113,6 +5405,7 @@ impl ActorCode for Actor {
         ConfirmSectorProofsValid => confirm_sector_proofs_valid,
         ChangeMultiaddrs|ChangeMultiaddrsExported => change_multiaddresses,
         CompactPartitions => compact_partitions,
+        MovePartitions => move_partitions,
         CompactSectorNumbers => compact_sector_numbers,
         ConfirmChangeWorkerAddress|ConfirmChangeWorkerAddressExported => confirm_change_worker_address,
         RepayDebt|RepayDebtExported => repay_debt,

actors/miner/src/types.rs

@@ -243,6 +243,13 @@ pub struct CompactPartitionsParams {
     pub partitions: BitField,
 }
 
+#[derive(Serialize_tuple, Deserialize_tuple)]
+pub struct MovePartitionsParams {
+    pub from_deadline: u64,
+    pub to_deadline: u64,
+    pub partitions: BitField,
+}
+
 #[derive(Serialize_tuple, Deserialize_tuple)]
 pub struct CompactSectorNumbersParams {
     pub mask_sector_numbers: BitField,