Implement extension of claims by spending new datacap (filecoin-project#685)

Author: anorth

actors/market/src/ext.rs

@@ -37,6 +37,7 @@ pub mod miner {
 pub mod verifreg {
     use super::*;
     use cid::Cid;
+    use fil_actors_runtime::BatchReturn;
     use fvm_shared::clock::ChainEpoch;
     use fvm_shared::piece::PaddedPieceSize;
 
@@ -54,13 +55,26 @@ pub mod verifreg {
     }
 
     #[derive(Clone, Debug, PartialEq, Eq, Serialize_tuple, Deserialize_tuple)]
-    pub struct AllocationsRequest {
-        pub requests: Vec<AllocationRequest>,
+    pub struct ClaimExtensionRequest {
+        pub provider: Address,
+        pub claim: ClaimID,
+        pub term_max: ChainEpoch,
+    }
+
+    #[derive(Clone, Debug, PartialEq, Eq, Serialize_tuple, Deserialize_tuple)]
+    pub struct AllocationRequests {
+        pub allocations: Vec<AllocationRequest>,
+        pub extensions: Vec<ClaimExtensionRequest>,
     }
 
     #[derive(Clone, Debug, PartialEq, Eq, Serialize_tuple, Deserialize_tuple)]
     pub struct AllocationsResponse {
-        pub allocations: Vec<AllocationID>,
+        // Result for each allocation request.
+        pub allocation_results: BatchReturn,
+        // Result for each extension request.
+        pub extension_results: BatchReturn,
+        // IDs of new allocations created.
+        pub new_allocations: Vec<AllocationID>,
     }
 }
 

actors/market/src/lib.rs

@@ -379,6 +379,8 @@ impl Actor {
                     .and_then(|ret| datacap_transfer_response(&ret));
                 match alloc_ids {
                     Ok(ids) => {
+                        // Note: when changing this to do anything other than expect complete success,
+                        // inspect the BatchReturn values to determine which deals succeeded and which failed.
                         if ids.len() != 1 {
                             return Err(actor_error!(
                                 unspecified,
@@ -1156,7 +1158,7 @@ fn datacap_transfer_request(
         to: *VERIFIED_REGISTRY_ACTOR_ADDR,
         amount: TokenAmount::from_whole(datacap_required),
         operator_data: serialize(
-            &ext::verifreg::AllocationsRequest { requests: alloc_reqs },
+            &ext::verifreg::AllocationRequests { allocations: alloc_reqs, extensions: vec![] },
             "allocation requests",
         )?,
     })
@@ -1167,7 +1169,7 @@ fn datacap_transfer_response(ret: &RawBytes) -> Result<Vec<AllocationID>, ActorE
     let ret: TransferFromReturn = deserialize(ret, "transfer from response")?;
     let allocs: ext::verifreg::AllocationsResponse =
         deserialize(&ret.recipient_data, "allocations response")?;
-    Ok(allocs.allocations)
+    Ok(allocs.new_allocations)
 }
 
 pub fn gen_rand_next_epoch(

actors/market/tests/harness.rs

@@ -27,9 +27,9 @@ use fil_actors_runtime::{
     network::EPOCHS_IN_DAY,
     runtime::{Policy, Runtime},
     test_utils::*,
-    ActorError, SetMultimap, BURNT_FUNDS_ACTOR_ADDR, CRON_ACTOR_ADDR, DATACAP_TOKEN_ACTOR_ADDR,
-    REWARD_ACTOR_ADDR, STORAGE_MARKET_ACTOR_ADDR, STORAGE_POWER_ACTOR_ADDR, SYSTEM_ACTOR_ADDR,
-    VERIFIED_REGISTRY_ACTOR_ADDR,
+    ActorError, BatchReturn, SetMultimap, BURNT_FUNDS_ACTOR_ADDR, CRON_ACTOR_ADDR,
+    DATACAP_TOKEN_ACTOR_ADDR, REWARD_ACTOR_ADDR, STORAGE_MARKET_ACTOR_ADDR,
+    STORAGE_POWER_ACTOR_ADDR, SYSTEM_ACTOR_ADDR, VERIFIED_REGISTRY_ACTOR_ADDR,
 };
 use fvm_ipld_encoding::{to_vec, RawBytes};
 use fvm_shared::bigint::BigInt;
@@ -491,15 +491,16 @@ pub fn publish_deals(
         if deal.verified_deal {
             // Expect transfer of data cap to the verified registry, with spec for the allocation.
             let curr_epoch = rt.epoch;
-            let alloc_req = ext::verifreg::AllocationsRequest {
-                requests: vec![AllocationRequest {
+            let alloc_req = ext::verifreg::AllocationRequests {
+                allocations: vec![AllocationRequest {
                     provider: deal.provider,
                     data: deal.piece_cid,
                     size: deal.piece_size,
                     term_min: deal.end_epoch - deal.start_epoch,
                     term_max: (deal.end_epoch - deal.start_epoch) + 90 * EPOCHS_IN_DAY,
                     expiration: min(deal.start_epoch, curr_epoch + 60 * EPOCHS_IN_DAY),
                 }],
+                extensions: vec![],
             };
             let datacap_amount = TokenAmount::from_whole(deal.piece_size.0 as i64);
             let params = TransferFromParams {
@@ -508,7 +509,11 @@ pub fn publish_deals(
                 amount: datacap_amount.clone(),
                 operator_data: serialize(&alloc_req, "allocation requests").unwrap(),
             };
-            let alloc_ids = AllocationsResponse { allocations: vec![alloc_id] };
+            let alloc_ids = AllocationsResponse {
+                allocation_results: BatchReturn::ok(1),
+                extension_results: BatchReturn::empty(),
+                new_allocations: vec![alloc_id],
+            };
             rt.expect_send(
                 *DATACAP_TOKEN_ACTOR_ADDR,
                 ext::datacap::TRANSFER_FROM_METHOD as u64,

actors/market/tests/market_actor_test.rs

@@ -13,7 +13,7 @@ use fil_actors_runtime::network::EPOCHS_IN_DAY;
 use fil_actors_runtime::runtime::{Policy, Runtime};
 use fil_actors_runtime::test_utils::*;
 use fil_actors_runtime::{
-    make_empty_map, make_map_with_root_and_bitwidth, ActorError, Map, SetMultimap,
+    make_empty_map, make_map_with_root_and_bitwidth, ActorError, BatchReturn, Map, SetMultimap,
     BURNT_FUNDS_ACTOR_ADDR, DATACAP_TOKEN_ACTOR_ADDR, SYSTEM_ACTOR_ADDR,
     VERIFIED_REGISTRY_ACTOR_ADDR,
 };
@@ -863,15 +863,16 @@ fn provider_and_client_addresses_are_resolved_before_persisting_state_and_sent_t
     );
 
     // Data cap transfer is requested using the resolved address (not that it matters).
-    let alloc_req = ext::verifreg::AllocationsRequest {
-        requests: vec![AllocationRequest {
+    let alloc_req = ext::verifreg::AllocationRequests {
+        allocations: vec![AllocationRequest {
             provider: provider_resolved,
             data: deal.piece_cid,
             size: deal.piece_size,
             term_min: deal.end_epoch - deal.start_epoch,
             term_max: (deal.end_epoch - deal.start_epoch) + 90 * EPOCHS_IN_DAY,
             expiration: deal.start_epoch,
         }],
+        extensions: vec![],
     };
     let datacap_amount = TokenAmount::from_whole(deal.piece_size.0 as i64);
     let transfer_params = TransferFromParams {
@@ -885,7 +886,11 @@ fn provider_and_client_addresses_are_resolved_before_persisting_state_and_sent_t
         to_balance: datacap_amount,
         allowance: TokenAmount::zero(),
         recipient_data: serialize(
-            &AllocationsResponse { allocations: vec![1] },
+            &AllocationsResponse {
+                allocation_results: BatchReturn::ok(1),
+                extension_results: BatchReturn::empty(),
+                new_allocations: vec![1],
+            },
             "allocations response",
         )
         .unwrap(),