From aef0fdd343863efe157d4d255abc8ff6a0a9fad0 Mon Sep 17 00:00:00 2001 From: Aarsh Shah Date: Wed, 10 Jan 2024 17:21:41 +0400 Subject: [PATCH] batch activate deals should return piece info --- actors/market/src/lib.rs | 6 ++ actors/market/src/types.rs | 9 ++ .../tests/verify_deals_for_activation_test.rs | 32 ++++++- actors/miner/src/ext.rs | 20 ++-- actors/miner/src/lib.rs | 91 ++++++++++--------- .../tests/extend_sector_expiration_test.rs | 8 +- actors/miner/tests/prove_commit.rs | 4 +- actors/miner/tests/terminate_sectors_test.rs | 2 + actors/miner/tests/util.rs | 77 ++++++++-------- 9 files changed, 149 insertions(+), 100 deletions(-) diff --git a/actors/market/src/lib.rs b/actors/market/src/lib.rs index e488c6b09..19aef450a 100644 --- a/actors/market/src/lib.rs +++ b/actors/market/src/lib.rs @@ -601,6 +601,7 @@ impl Actor { } let mut verified_infos = vec![]; + let mut unverified_infos: Vec = vec![]; let mut nonverified_deal_space: BigInt = BigInt::zero(); // Given that all deals validated, prepare the state updates for them all. // There's no continue below here to ensure updates are consistent. @@ -619,6 +620,10 @@ impl Actor { size: proposal.piece_size, }) } else { + unverified_infos.push(UnVerifiedDealInfo { + data: proposal.piece_cid, + size: proposal.piece_size, + }); nonverified_deal_space += proposal.piece_size.0; } @@ -646,6 +651,7 @@ impl Actor { activations.push(SectorDealActivation { nonverified_deal_space, verified_infos, + unverified_infos, unsealed_cid: data_commitment, }); diff --git a/actors/market/src/types.rs b/actors/market/src/types.rs index 49bdc6498..db3cbb20f 100644 --- a/actors/market/src/types.rs +++ b/actors/market/src/types.rs @@ -102,6 +102,13 @@ pub struct BatchActivateDealsParams { pub compute_cid: bool, } +// Information about a un-verified deal that has been activated. +#[derive(Serialize_tuple, Deserialize_tuple, Debug, Clone, Eq, PartialEq)] +pub struct UnVerifiedDealInfo { + pub data: Cid, + pub size: PaddedPieceSize, +} + // Information about a verified deal that has been activated. #[derive(Serialize_tuple, Deserialize_tuple, Debug, Clone, Eq, PartialEq)] pub struct VerifiedDealInfo { @@ -119,6 +126,8 @@ pub struct SectorDealActivation { pub nonverified_deal_space: BigInt, /// Information about each verified deal activated. pub verified_infos: Vec, + /// Information about each un-verified deal activated. + pub unverified_infos: Vec, /// Unsealed CID computed from the deals specified for the sector. /// A None indicates no deals were specified, or the computation was not requested. pub unsealed_cid: Option, diff --git a/actors/market/tests/verify_deals_for_activation_test.rs b/actors/market/tests/verify_deals_for_activation_test.rs index 28390bf05..e582cf4e6 100644 --- a/actors/market/tests/verify_deals_for_activation_test.rs +++ b/actors/market/tests/verify_deals_for_activation_test.rs @@ -11,7 +11,9 @@ use fvm_shared::piece::PieceInfo; use fvm_shared::sector::RegisteredSealProof; use num_traits::Zero; -use fil_actor_market::{Actor as MarketActor, Method, SectorDeals, VerifyDealsForActivationParams}; +use fil_actor_market::{ + Actor as MarketActor, Method, SectorDeals, UnVerifiedDealInfo, VerifyDealsForActivationParams, +}; use fil_actors_runtime::runtime::builtins::Type; use fil_actors_runtime::test_utils::{ expect_abort, expect_abort_contains_message, make_piece_cid, ACCOUNT_ACTOR_CODE_ID, @@ -57,8 +59,15 @@ fn verify_deal_and_activate_to_get_deal_space_for_unverified_deal_proposal() { assert_eq!(1, v_response.unsealed_cids.len()); assert_eq!(Some(make_piece_cid("1".as_bytes())), v_response.unsealed_cids[0]); assert!(s_response.verified_infos.is_empty()); + assert!(!s_response.unverified_infos.is_empty()); assert_eq!(BigInt::from(deal_proposal.piece_size.0), s_response.nonverified_deal_space); + let info = s_response.unverified_infos.get(0).unwrap(); + assert_eq!( + UnVerifiedDealInfo { data: deal_proposal.piece_cid, size: deal_proposal.piece_size }, + *info + ); + check_state(&rt); } @@ -95,6 +104,7 @@ fn verify_deal_and_activate_to_get_deal_space_for_verified_deal_proposal() { assert_eq!(1, response.unsealed_cids.len()); assert_eq!(Some(make_piece_cid("1".as_bytes())), response.unsealed_cids[0]); assert_eq!(1, s_response.verified_infos.len()); + assert!(s_response.unverified_infos.is_empty()); assert_eq!(deal_proposal.piece_size, s_response.verified_infos[0].size); assert_eq!(deal_proposal.client.id().unwrap(), s_response.verified_infos[0].client); assert_eq!(deal_proposal.piece_cid, s_response.verified_infos[0].data); @@ -161,6 +171,26 @@ fn verification_and_weights_for_verified_and_unverified_deals() { s_response.verified_infos.iter().map(|info| BigInt::from(info.size.0)).sum(); assert_eq!(verified_space, returned_verified_space); assert_eq!(unverified_space, s_response.nonverified_deal_space); + assert_eq!(2, s_response.unverified_infos.len()); + + let resp_unverified_deal_1 = s_response.unverified_infos.get(0).unwrap(); + let resp_unverified_deal_2 = s_response.unverified_infos.get(1).unwrap(); + + assert_eq!( + UnVerifiedDealInfo { + data: unverified_deal_1.piece_cid, + size: unverified_deal_1.piece_size, + }, + *resp_unverified_deal_1 + ); + + assert_eq!( + UnVerifiedDealInfo { + data: unverified_deal_2.piece_cid, + size: unverified_deal_2.piece_size, + }, + *resp_unverified_deal_2 + ); check_state(&rt); } diff --git a/actors/miner/src/ext.rs b/actors/miner/src/ext.rs index 48b07a894..d3e0bd69b 100644 --- a/actors/miner/src/ext.rs +++ b/actors/miner/src/ext.rs @@ -20,7 +20,6 @@ pub mod account { pub mod market { use super::*; use fvm_ipld_bitfield::BitField; - pub const VERIFY_DEALS_FOR_ACTIVATION_METHOD: u64 = 5; pub const BATCH_ACTIVATE_DEALS_METHOD: u64 = 6; pub const ON_MINER_SECTORS_TERMINATE_METHOD: u64 = 7; @@ -59,11 +58,18 @@ pub mod market { } } + #[derive(Serialize_tuple, Deserialize_tuple, Clone)] + pub struct UnVerifiedDealInfo { + pub data: Cid, + pub size: PaddedPieceSize, + } + #[derive(Serialize_tuple, Deserialize_tuple, Clone)] pub struct SectorDealActivation { #[serde(with = "bigint_ser")] pub nonverified_deal_space: BigInt, pub verified_infos: Vec, + pub unverified_infos: Vec, pub unsealed_cid: Option, } @@ -94,18 +100,6 @@ pub mod market { pub struct VerifyDealsForActivationReturn { pub unsealed_cids: Vec>, } - - #[derive(Serialize_tuple, Deserialize_tuple, Debug, Clone, Eq, PartialEq)] - #[serde(transparent)] - pub struct GetDealDataCommitmentParamsRef { - pub id: DealID, - } - - #[derive(Serialize_tuple, Deserialize_tuple, Clone)] - pub struct GetDealDataCommitmentReturn { - pub data: Cid, - pub size: PaddedPieceSize, - } } pub mod power { diff --git a/actors/miner/src/lib.rs b/actors/miner/src/lib.rs index e99bf266a..dafee5cdd 100644 --- a/actors/miner/src/lib.rs +++ b/actors/miner/src/lib.rs @@ -822,7 +822,7 @@ impl Actor { Therefore CommD on precommit has already been provided and checked so no further processing needed */ let compute_commd = false; - let (batch_return, activated_data) = + let (batch_return, activated_data, pieces) = activate_sectors_deals(rt, &data_activation_inputs, compute_commd)?; let activated_precommits = batch_return.successes(&valid_precommits); @@ -834,10 +834,14 @@ impl Actor { &info, )?; - for pc in activated_precommits { + for (i, pc) in activated_precommits.iter().enumerate() { let unsealed_cid = pc.info.unsealed_cid.get_cid(pc.info.seal_proof)?; - let pieces = get_piece_manifest_from_deals(rt, &pc.info.deal_ids)?; - emit::sector_activated(rt, pc.info.sector_number, &unsealed_cid, &pieces)?; + emit::sector_activated( + rt, + pc.info.sector_number, + &unsealed_cid, + pieces.get(i).unwrap(), + )?; } // The aggregate fee is paid on the sectors successfully proven. pay_aggregate_seal_proof_fee(rt, valid_precommits.len())?; @@ -921,7 +925,7 @@ impl Actor { - no CommD was specified on input so it must be computed for the first time here */ let compute_commd = true; - let (batch_return, data_activations) = + let (batch_return, data_activations, pieces) = activate_sectors_deals(rt, &data_activation_inputs, compute_commd)?; // associate the successfully activated sectors with the ReplicaUpdateInner and SectorOnChainInfo @@ -940,7 +944,7 @@ impl Actor { let mut updated_sectors: Vec = Vec::new(); let mut decls_by_deadline = BTreeMap::>::new(); let mut deadlines_to_load = Vec::::new(); - for (usi, data_activation) in &validated_updates { + for (i, (usi, data_activation)) in validated_updates.iter().enumerate() { updated_sectors.push(usi.update.sector_number); let dl = usi.update.deadline; if !decls_by_deadline.contains_key(&dl) { @@ -978,8 +982,12 @@ impl Actor { activated_data, }); - let pieces = get_piece_manifest_from_deals(rt, &usi.update.deals)?; - emit::sector_updated(rt, usi.update.sector_number, &computed_commd, &pieces)?; + emit::sector_updated( + rt, + usi.update.sector_number, + &computed_commd, + pieces.get(i).unwrap(), + )?; } let (power_delta, pledge_delta) = update_replica_states( @@ -2000,7 +2008,7 @@ impl Actor { Therefore CommD on precommit has already been provided and checked so no further processing needed */ let compute_commd = false; - let (batch_return, data_activations) = + let (batch_return, data_activations, pieces) = activate_sectors_deals(rt, &data_activations, compute_commd)?; let successful_activations = batch_return.successes(&precommited_sectors); @@ -2018,10 +2026,14 @@ impl Actor { &info, )?; - for pc in successful_activations.iter() { - let pieces = get_piece_manifest_from_deals(rt, &pc.info.deal_ids)?; + for (i, pc) in successful_activations.iter().enumerate() { let unsealed_cid = pc.info.unsealed_cid.get_cid(pc.info.seal_proof)?; - emit::sector_activated(rt, pc.info.sector_number, &unsealed_cid, &pieces)?; + emit::sector_activated( + rt, + pc.info.sector_number, + &unsealed_cid, + pieces.get(i).unwrap(), + )?; } Ok(()) } @@ -4848,31 +4860,6 @@ fn verify_deals( ))?) } -fn get_piece_manifest_from_deals( - rt: &impl Runtime, - deal_ids: &Vec, -) -> Result, ActorError> { - let mut pieces: Vec<(Cid, PaddedPieceSize)> = vec![]; - - for deal_id in deal_ids { - let ret = get_deal_data_commitment(rt, deal_id)?; - pieces.push((ret.data, ret.size)); - } - Ok(pieces) -} - -fn get_deal_data_commitment( - rt: &impl Runtime, - deal_id: &DealID, -) -> Result { - deserialize_block(extract_send_result(rt.send_simple( - &STORAGE_MARKET_ACTOR_ADDR, - ext::market::GET_DEAL_DATA_COMMITMENT, - IpldBlock::serialize_cbor(&ext::market::GetDealDataCommitmentParamsRef { id: *deal_id })?, - TokenAmount::zero(), - ))?) -} - /// Requests the current epoch target block reward from the reward actor. /// return value includes reward, smoothed estimate of reward, and baseline power fn request_current_epoch_block_reward( @@ -5505,11 +5492,13 @@ fn activate_sectors_pieces( /// Deals and claims are grouped by sectors /// Successfully activated sectors have their DealSpaces returned /// Failure to claim datacap for any verified deal results in the whole batch failing +#[allow(clippy::complexity)] fn activate_sectors_deals( rt: &impl Runtime, activation_infos: &[DealsActivationInput], compute_unsealed_cid: bool, -) -> Result<(BatchReturn, Vec), ActorError> { +) -> Result<(BatchReturn, Vec, Vec>), ActorError> +{ let batch_activation_res = match activation_infos.iter().all(|p| p.deal_ids.is_empty()) { true => ext::market::BatchActivateDealsResult { // if all sectors are empty of deals, skip calling the market actor @@ -5517,6 +5506,7 @@ fn activate_sectors_deals( ext::market::SectorDealActivation { nonverified_deal_space: BigInt::default(), verified_infos: Vec::default(), + unverified_infos: Vec::default(), unsealed_cid: None, }; activation_infos.len() @@ -5551,6 +5541,8 @@ fn activate_sectors_deals( return Err(actor_error!(illegal_argument, "all deals failed to activate")); } + let mut piece_infos: Vec> = vec![]; + // Filter the DealsActivationInfo for successfully activated sectors let successful_activation_infos = batch_activation_res.activation_results.successes(activation_infos); @@ -5591,15 +5583,28 @@ fn activate_sectors_deals( .activations .iter() .zip(claim_res.sector_claims) - .map(|(sector_deals, sector_claim)| DataActivationOutput { - unverified_space: sector_deals.nonverified_deal_space.clone(), - verified_space: sector_claim.claimed_space, - unsealed_cid: sector_deals.unsealed_cid, + .map(|(sector_deals, sector_claim)| { + let mut piece_infos_for_sector: Vec<(Cid, PaddedPieceSize)> = vec![]; + + for verified_info in §or_deals.verified_infos { + piece_infos_for_sector.push((verified_info.data, verified_info.size)); + } + + for unverified_info in §or_deals.unverified_infos { + piece_infos_for_sector.push((unverified_info.data, unverified_info.size)); + } + piece_infos.push(piece_infos_for_sector); + + DataActivationOutput { + unverified_space: sector_deals.nonverified_deal_space.clone(), + verified_space: sector_claim.claimed_space, + unsealed_cid: sector_deals.unsealed_cid, + } }) .collect(); // Return the deal spaces for activated sectors only - Ok((batch_activation_res.activation_results, activation_and_claim_results)) + Ok((batch_activation_res.activation_results, activation_and_claim_results, piece_infos)) } fn batch_claim_allocations( diff --git a/actors/miner/tests/extend_sector_expiration_test.rs b/actors/miner/tests/extend_sector_expiration_test.rs index 3134cea5c..3d04d6207 100644 --- a/actors/miner/tests/extend_sector_expiration_test.rs +++ b/actors/miner/tests/extend_sector_expiration_test.rs @@ -13,6 +13,7 @@ use fil_actors_runtime::{ EPOCHS_IN_DAY, }; use fvm_ipld_bitfield::BitField; +use fvm_shared::deal::DealID; use fvm_shared::{ address::Address, clock::ChainEpoch, @@ -899,11 +900,16 @@ fn commit_sector_verified_deals( let mut pcc = ProveCommitConfig::empty(); pcc.add_verified_deals(h.next_sector_no, verified_deals.clone()); + let mut deal_ids: Vec = vec![]; + for i in 0..verified_deals.len() { + deal_ids.push(i as u64); + } + let sector_info = &h.commit_and_prove_sectors_with_cfgs( rt, 1, DEFAULT_SECTOR_EXPIRATION as u64, - vec![vec![42]], + vec![deal_ids], true, pcc, )[0]; diff --git a/actors/miner/tests/prove_commit.rs b/actors/miner/tests/prove_commit.rs index cb620c86e..a5a6dea88 100644 --- a/actors/miner/tests/prove_commit.rs +++ b/actors/miner/tests/prove_commit.rs @@ -1,5 +1,3 @@ -use std::collections::HashMap; - use fvm_shared::{ bigint::{BigInt, Zero}, clock::ChainEpoch, @@ -8,6 +6,7 @@ use fvm_shared::{ sector::{StoragePower, MAX_SECTOR_NUMBER}, smooth::FilterEstimate, }; +use std::collections::HashMap; use fil_actor_miner::{ initial_pledge_for_power, max_prove_commit_duration, pre_commit_deposit_for_power, @@ -508,6 +507,7 @@ fn drop_invalid_prove_commit_while_processing_valid_one() { let conf = ProveCommitConfig { verify_deals_exit: HashMap::from([(sector_no_a, ExitCode::USR_ILLEGAL_ARGUMENT)]), + verified_deal_infos: HashMap::from([(sector_no_b, vec![test_verified_deal(100)])]), ..Default::default() }; h.confirm_sector_proofs_valid_for( diff --git a/actors/miner/tests/terminate_sectors_test.rs b/actors/miner/tests/terminate_sectors_test.rs index 2c8b0d1d5..5485faf2d 100644 --- a/actors/miner/tests/terminate_sectors_test.rs +++ b/actors/miner/tests/terminate_sectors_test.rs @@ -106,6 +106,7 @@ fn removes_sector_with_without_deals() { size: PaddedPieceSize(1024), }], )]), + unverified_deal_infos: HashMap::new(), }, ); let snos: Vec = sectors.iter().map(|s| s.sector_number).collect(); @@ -184,6 +185,7 @@ fn owner_cannot_terminate_if_market_fails() { claim_allocs_exit: Default::default(), deal_space: HashMap::from_iter(vec![(0, DealWeight::from(1024))]), verified_deal_infos: Default::default(), + unverified_deal_infos: Default::default(), }, ); diff --git a/actors/miner/tests/util.rs b/actors/miner/tests/util.rs index 7f6ac3260..2ad27168d 100644 --- a/actors/miner/tests/util.rs +++ b/actors/miner/tests/util.rs @@ -46,8 +46,9 @@ use num_traits::Signed; use fil_actor_account::Method as AccountMethod; use fil_actor_market::{ BatchActivateDealsParams, BatchActivateDealsResult, Method as MarketMethod, - OnMinerSectorsTerminateParams, SectorDealActivation, SectorDeals, VerifiedDealInfo, - VerifyDealsForActivationParams, VerifyDealsForActivationReturn, NO_ALLOCATION_ID, + OnMinerSectorsTerminateParams, SectorDealActivation, SectorDeals, UnVerifiedDealInfo, + VerifiedDealInfo, VerifyDealsForActivationParams, VerifyDealsForActivationReturn, + NO_ALLOCATION_ID, }; use fil_actor_miner::{ aggregate_pre_commit_network_fee, aggregate_prove_commit_network_fee, consensus_fault_penalty, @@ -865,11 +866,16 @@ impl ActorHarness { rt.expect_aggregate_verify_seals(svis, params.aggregate_proof.clone().into(), Ok(())); // confirm sector proofs valid - self.confirm_sector_proofs_valid_internal(rt, config, &precommits); + let pieces = self.confirm_sector_proofs_valid_internal(rt, config, &precommits); + + println!("{} pieces is {:?}", pieces.len(), pieces); // sector activated event for (i, sc) in precommits.iter().enumerate() { - expect_sector_event_with_market_call(rt, "sector-activated", &sc.info, &comm_ds[i]); + let num = &sc.info.sector_number; + let piece_info = pieces.get(&num).unwrap(); + println!("{} piece info is {:?}", i, piece_info.len()); + expect_sector_event(rt, "sector-activated", &num, &comm_ds[i], &piece_info); } // burn network fee @@ -902,7 +908,7 @@ impl ActorHarness { pcs: Vec, valid_sectors: Vec, ) -> Result<(), ActorError> { - self.confirm_sector_proofs_valid_internal(rt, cfg, &pcs); + let pieces = self.confirm_sector_proofs_valid_internal(rt, cfg, &pcs); let mut all_sector_numbers = Vec::new(); for pc in pcs.clone() { @@ -922,11 +928,13 @@ impl ActorHarness { for sc in pcs { if valid_sectors.contains(&sc.info.sector_number) { let unsealed_cid = sc.info.unsealed_cid.get_cid(sc.info.seal_proof)?; - expect_sector_event_with_market_call( + let num = &sc.info.sector_number; + expect_sector_event( rt, "sector-activated", - &sc.info, + &num, &unsealed_cid, + pieces.get(&num).unwrap(), ); } } @@ -958,7 +966,7 @@ impl ActorHarness { rt: &MockRuntime, cfg: ProveCommitConfig, pcs: &[SectorPreCommitOnChainInfo], - ) { + ) -> HashMap> { let mut valid_pcs = Vec::new(); // claim FIL+ allocations @@ -968,8 +976,10 @@ impl ActorHarness { let mut sector_activation_params: Vec = Vec::new(); let mut sector_activations: Vec = Vec::new(); let mut sector_activation_results = BatchReturnGen::new(pcs.len()); + let mut pieces: HashMap> = HashMap::new(); for pc in pcs { + pieces.insert(pc.info.sector_number, Vec::new()); if !pc.info.deal_ids.is_empty() { let deal_space = cfg.deal_space(pc.info.sector_number); let activate_params = SectorDeals { @@ -987,9 +997,21 @@ impl ActorHarness { .get(&pc.info.sector_number) .cloned() .unwrap_or_default(), + unverified_infos: cfg + .unverified_deal_infos + .get(&pc.info.sector_number) + .cloned() + .unwrap_or_default(), unsealed_cid: None, }; + for info in &ret.verified_infos { + pieces.get_mut(&pc.info.sector_number).unwrap().push((info.data, info.size)); + } + for info in &ret.unverified_infos { + pieces.get_mut(&pc.info.sector_number).unwrap().push((info.data, info.size)); + } + let mut activate_deals_exit = ExitCode::OK; match cfg.verify_deals_exit.get(&pc.info.sector_number) { Some(exit_code) => { @@ -1032,6 +1054,7 @@ impl ActorHarness { nonverified_deal_space: BigInt::zero(), verified_infos: vec![], unsealed_cid: None, + unverified_infos: vec![], }); sector_activation_results.add_success(); sectors_claims.push(ext::verifreg::SectorAllocationClaims { @@ -1118,6 +1141,7 @@ impl ActorHarness { expect_update_pledge(rt, &expected_pledge); } + pieces } pub fn prove_commit_sectors2_for( @@ -1357,7 +1381,7 @@ impl ActorHarness { "sector-activated", &sm.sector_number, unsealed_cids.get(&sm.sector_number).unwrap(), - pieces, + &pieces, ) } } @@ -1579,7 +1603,7 @@ impl ActorHarness { "sector-updated", &sm.sector, unsealed_cids.get(&sm.sector).unwrap(), - pieces, + &pieces, ) } } @@ -2939,41 +2963,12 @@ impl ActorHarness { } } -pub fn expect_sector_event_with_market_call( - rt: &MockRuntime, - typ: &str, - sc: &SectorPreCommitInfo, - unsealed_cid: &Cid, -) { - let mut pieces: Vec<(Cid, PaddedPieceSize)> = vec![]; - for deal_id in &sc.deal_ids { - rt.expect_send_simple( - STORAGE_MARKET_ACTOR_ADDR, - MarketMethod::GetDealDataCommitmentExported as u64, - IpldBlock::serialize_cbor(&ext::market::GetDealDataCommitmentParamsRef { - id: *deal_id, - }) - .unwrap(), - TokenAmount::zero(), - IpldBlock::serialize_cbor(&ext::market::GetDealDataCommitmentReturn { - data: make_unsealed_cid("test verified deal".as_bytes()), - size: PaddedPieceSize(100), - }) - .unwrap(), - ExitCode::OK, - ); - pieces.push((make_unsealed_cid("test verified deal".as_bytes()), PaddedPieceSize(100))); - } - - expect_sector_event(rt, typ, &sc.sector_number, &unsealed_cid, pieces); -} - pub fn expect_sector_event( rt: &MockRuntime, typ: &str, sector: &SectorNumber, unsealed_cid: &Cid, - pieces: Vec<(Cid, PaddedPieceSize)>, + pieces: &Vec<(Cid, PaddedPieceSize)>, ) { let mut base_event = EventBuilder::new() .typ(typ) @@ -3049,6 +3044,7 @@ pub struct ProveCommitConfig { pub claim_allocs_exit: HashMap, pub deal_space: HashMap, pub verified_deal_infos: HashMap>, + pub unverified_deal_infos: HashMap>, } #[allow(dead_code)] @@ -3070,6 +3066,7 @@ impl ProveCommitConfig { claim_allocs_exit: HashMap::new(), deal_space: HashMap::new(), verified_deal_infos: HashMap::new(), + unverified_deal_infos: HashMap::new(), } }