share the language with FIP

actors/miner/src/deadlines.rs

@@ -140,40 +140,40 @@ fn deadline_distance(policy: &Policy, from_deadline: u64, to_deadline: u64) -> u
 // only allow moving to a nearer deadline from current one
 pub fn deadline_available_for_move(
     policy: &Policy,
-    from_deadline: u64,
-    to_deadline: u64,
+    orig_deadline: u64,
+    dest_deadline: u64,
     current_deadline: &DeadlineInfo,
 ) -> Result<(), String> {
     if !deadline_is_mutable(
         policy,
         current_deadline.period_start,
-        from_deadline,
+        orig_deadline,
         current_deadline.current_epoch,
     ) {
         return Err(format!(
             "cannot move from a deadline {}, immutable at epoch {}",
-            from_deadline, current_deadline.current_epoch
+            orig_deadline, current_deadline.current_epoch
         ));
     }
 
     if !deadline_is_mutable(
         policy,
         current_deadline.period_start,
-        to_deadline,
+        dest_deadline,
         current_deadline.current_epoch,
     ) {
         return Err(format!(
             "cannot move to a deadline {}, immutable at epoch {}",
-            to_deadline, current_deadline.current_epoch
+            dest_deadline, current_deadline.current_epoch
         ));
     }
 
-    if deadline_distance(policy, current_deadline.index, to_deadline)
-        >= deadline_distance(policy, current_deadline.index, from_deadline)
+    if deadline_distance(policy, current_deadline.index, dest_deadline)
+        >= deadline_distance(policy, current_deadline.index, orig_deadline)
     {
         return Err(format!(
-            "can only move to a deadline which is nearer from current deadline {}, to_deadline {} is not nearer than from_deadline {}",
-            current_deadline.index, to_deadline, from_deadline
+            "can only move to a deadline which is nearer from current deadline {}, dest_deadline {} is not nearer than orig_deadline {}",
+            current_deadline.index, dest_deadline, orig_deadline
         ));
     }
 

actors/miner/src/lib.rs

@@ -2993,18 +2993,18 @@ impl Actor {
     }
 
     fn move_partitions(rt: &impl Runtime, params: MovePartitionsParams) -> Result<(), ActorError> {
-        if params.from_deadline == params.to_deadline {
-            return Err(actor_error!(illegal_argument, "from_deadline == to_deadline"));
+        if params.orig_deadline == params.dest_deadline {
+            return Err(actor_error!(illegal_argument, "orig_deadline == dest_deadline"));
         }
         let policy = rt.policy();
-        if params.from_deadline >= policy.wpost_period_deadlines
-            || params.to_deadline >= policy.wpost_period_deadlines
+        if params.orig_deadline >= policy.wpost_period_deadlines
+            || params.dest_deadline >= policy.wpost_period_deadlines
         {
             return Err(actor_error!(
                 illegal_argument,
-                "invalid param, from_deadline: {}, to_deadline: {}",
-                params.from_deadline,
-                params.to_deadline
+                "invalid param, orig_deadline: {}, dest_deadline: {}",
+                params.orig_deadline,
+                params.dest_deadline
             ));
         }
         if params.partitions.is_empty() {
@@ -3026,19 +3026,19 @@ impl Actor {
 
             deadline_available_for_move(
                 policy,
-                params.from_deadline,
-                params.to_deadline,
+                params.orig_deadline,
+                params.dest_deadline,
                 &current_deadline,
             )
             .context_code(
                 ExitCode::USR_FORBIDDEN,
                 "conditions not satisfied for deadline_available_for_move",
             )?;
 
-            let mut from_deadline =
-                deadlines.load_deadline(policy, store, params.from_deadline).context_code(
+            let mut orig_deadline =
+                deadlines.load_deadline(policy, store, params.orig_deadline).context_code(
                     ExitCode::USR_ILLEGAL_STATE,
-                    format!("failed to load deadline {}", params.from_deadline),
+                    format!("failed to load deadline {}", params.orig_deadline),
                 )?;
             // only try to do synchronous Window Post verification if the from deadline is in dispute window
             // note that as window post is batched, the best we can do is to verify only those that contains at least one partition being moved.
@@ -3047,25 +3047,25 @@ impl Actor {
             if deadline_available_for_optimistic_post_dispute(
                 policy,
                 current_deadline.period_start,
-                params.from_deadline,
+                params.orig_deadline,
                 rt.curr_epoch(),
             ) {
-                let proofs_snapshot = from_deadline
+                let proofs_snapshot = orig_deadline
                     .optimistic_proofs_snapshot_amt(store)
                     .context_code(ExitCode::USR_ILLEGAL_STATE, "failed to load proofs snapshot")?;
 
                 let partitions_snapshot =
-                    from_deadline.partitions_snapshot_amt(store).context_code(
+                    orig_deadline.partitions_snapshot_amt(store).context_code(
                         ExitCode::USR_ILLEGAL_STATE,
                         "failed to load partitions snapshot",
                     )?;
 
                 // Find the proving period start for the deadline in question.
                 let target_deadline =
-                    nearest_occured_deadline_info(policy, &current_deadline, params.from_deadline);
+                    nearest_occured_deadline_info(policy, &current_deadline, params.orig_deadline);
 
                 // Load sectors for the dispute.
-                let sectors = Sectors::load(rt.store(), &from_deadline.sectors_snapshot)
+                let sectors = Sectors::load(rt.store(), &orig_deadline.sectors_snapshot)
                     .context_code(ExitCode::USR_ILLEGAL_STATE, "failed to load sectors array")?;
 
                 proofs_snapshot
@@ -3140,41 +3140,41 @@ impl Actor {
                     .context_code(ExitCode::USR_ILLEGAL_STATE, "while removing partitions")?;
             }
 
-            let to_quant = state.quant_spec_for_deadline(policy, params.to_deadline);
+            let dest_quant = state.quant_spec_for_deadline(policy, params.dest_deadline);
 
-            let mut to_deadline =
-                deadlines.load_deadline(policy, store, params.to_deadline).context_code(
+            let mut dest_deadline =
+                deadlines.load_deadline(policy, store, params.dest_deadline).context_code(
                     ExitCode::USR_ILLEGAL_STATE,
-                    format!("failed to load deadline {}", params.to_deadline),
+                    format!("failed to load deadline {}", params.dest_deadline),
                 )?;
 
             Deadlines::move_partitions(
                 store,
-                &mut from_deadline,
-                &mut to_deadline,
-                to_quant,
+                &mut orig_deadline,
+                &mut dest_deadline,
+                dest_quant,
                 &params.partitions,
             )
             .context_code(ExitCode::USR_ILLEGAL_STATE, "failed to move partitions")?;
 
             deadlines
-                .update_deadline(policy, store, params.from_deadline, &from_deadline)
+                .update_deadline(policy, store, params.orig_deadline, &orig_deadline)
                 .context_code(
                     ExitCode::USR_ILLEGAL_STATE,
-                    format!("failed to update deadline {}", params.from_deadline),
+                    format!("failed to update deadline {}", params.orig_deadline),
                 )?;
             deadlines
-                .update_deadline(policy, store, params.to_deadline, &to_deadline)
+                .update_deadline(policy, store, params.dest_deadline, &dest_deadline)
                 .context_code(
                     ExitCode::USR_ILLEGAL_STATE,
-                    format!("failed to update deadline {}", params.to_deadline),
+                    format!("failed to update deadline {}", params.dest_deadline),
                 )?;
 
             state.save_deadlines(store, deadlines).context_code(
                 ExitCode::USR_ILLEGAL_STATE,
                 format!(
                     "failed to save deadline when move_partitions from {} to {}",
-                    params.from_deadline, params.to_deadline
+                    params.orig_deadline, params.dest_deadline
                 ),
             )?;
 

actors/miner/src/types.rs

@@ -245,8 +245,8 @@ pub struct CompactPartitionsParams {
 
 #[derive(Serialize_tuple, Deserialize_tuple)]
 pub struct MovePartitionsParams {
-    pub from_deadline: u64,
-    pub to_deadline: u64,
+    pub orig_deadline: u64,
+    pub dest_deadline: u64,
     pub partitions: BitField,
 }
 

actors/miner/tests/util.rs

@@ -2602,14 +2602,14 @@ impl ActorHarness {
     pub fn move_partitions(
         &self,
         rt: &MockRuntime,
-        from_deadline: u64,
-        to_deadline: u64,
+        orig_deadline: u64,
+        dest_deadline: u64,
         partitions: BitField,
         mut f: impl FnMut(),
     ) -> Result<(), ActorError> {
         f();
 
-        let params = MovePartitionsParams { from_deadline, to_deadline, partitions };
+        let params = MovePartitionsParams { orig_deadline, dest_deadline, partitions };
 
         rt.expect_validate_caller_addr(self.caller_addrs());
         rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, self.worker);

test_vm/tests/move_partitions_test.rs

@@ -40,8 +40,8 @@ fn move_partitions_success() {
     advance_by_deadline_to_epoch(&v, &miner.miner_id, prove_time);
 
     let move_params = MovePartitionsParams {
-        from_deadline: 0,
-        to_deadline: 47,
+        orig_deadline: 0,
+        dest_deadline: 47,
         partitions: make_bitfield(&[0u64]),
     };
     let prove_params_ser = IpldBlock::serialize_cbor(&move_params).unwrap();