Struct fil_actor_market_state::v14::State

pub struct State {

    pub proposals: Cid,
    pub states: Cid,
    pub pending_proposals: Cid,
    pub escrow_table: Cid,
    pub locked_table: Cid,
    pub next_id: DealID,
    pub deal_ops_by_epoch: Cid,
    pub last_cron: ChainEpoch,
    pub total_client_locked_collateral: TokenAmount,
    pub total_provider_locked_collateral: TokenAmount,
    pub total_client_storage_fee: TokenAmount,
    pub pending_deal_allocation_ids: Cid,
    pub provider_sectors: Cid,
}

Market actor state

Fields

proposals: Cid

Proposals are deals that have been proposed and not yet cleaned up after expiry or termination. Array<DealID, DealProposal>

states: Cid

Array<DealID, DealState>

pending_proposals: Cid

PendingProposals tracks dealProposals that have not yet reached their deal start date. We track them here to ensure that miners can’t publish the same deal proposal twice Set

escrow_table: Cid

Total amount held in escrow, indexed by actor address (including both locked and unlocked amounts).

locked_table: Cid

Amount locked, indexed by actor address. Note: the amounts in this table do not affect the overall amount in escrow: only the portion of the total escrow amount that is locked.

next_id: DealID

Deal id state sequential incrementer

deal_ops_by_epoch: Cid

Metadata cached for efficient iteration over deals. SetMultimap

last_cron: ChainEpoch

total_client_locked_collateral: TokenAmount

Total Client Collateral that is locked -> unlocked when deal is terminated

total_provider_locked_collateral: TokenAmount

Total Provider Collateral that is locked -> unlocked when deal is terminated

total_client_storage_fee: TokenAmount

Total storage fee that is locked in escrow -> unlocked when payments are made

pending_deal_allocation_ids: Cid

Verified registry allocation IDs for deals that are not yet activated.

provider_sectors: Cid

Maps providers to their sector IDs to deal IDs. This supports finding affected deals when a sector is terminated early or has data replaced. Grouping by provider limits the cost of operations in the expected use case of multiple sectors all belonging to the same provider. HAMTActorIDHAMTSectorNumberDealID

Implementations

impl State

pub fn new<BS: Blockstore>(store: &BS) -> Result<Self, ActorError>

pub fn get_total_locked(&self) -> TokenAmount

pub fn load_deal_states<'bs, BS>( &self, store: &'bs BS, ) -> Result<DealMetaArray<'bs, BS>, ActorError>

where BS: Blockstore,

pub fn find_deal_state<BS>( &self, store: &BS, deal_id: DealID, ) -> Result<Option<DealState>, ActorError>

where BS: Blockstore,

pub fn put_deal_states<BS>( &mut self, store: &BS, new_deal_states: &[(DealID, DealState)], ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn remove_deal_state<BS>( &mut self, store: &BS, deal_id: DealID, ) -> Result<Option<DealState>, ActorError>

where BS: Blockstore,

pub fn load_proposals<'bs, BS>( &self, store: &'bs BS, ) -> Result<DealArray<'bs, BS>, ActorError>

where BS: Blockstore,

pub fn get_proposal<BS: Blockstore>( &self, store: &BS, id: DealID, ) -> Result<DealProposal, ActorError>

pub fn find_proposal<BS>( &self, store: &BS, deal_id: DealID, ) -> Result<Option<DealProposal>, ActorError>

where BS: Blockstore,

pub fn remove_proposal<BS>( &mut self, store: &BS, deal_id: DealID, ) -> Result<Option<DealProposal>, ActorError>

where BS: Blockstore,

pub fn put_deal_proposals<BS>( &mut self, store: &BS, new_deal_proposals: &[(DealID, DealProposal)], ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn load_pending_deal_allocation_ids<BS>( &mut self, store: BS, ) -> Result<PendingDealAllocationsMap<BS>, ActorError>

where BS: Blockstore,

pub fn save_pending_deal_allocation_ids<BS>( &mut self, pending_deal_allocation_ids: &mut PendingDealAllocationsMap<BS>, ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn put_pending_deal_allocation_ids<BS>( &mut self, store: &BS, new_pending_deal_allocation_ids: &[(DealID, AllocationID)], ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn get_pending_deal_allocation_ids<BS>( &mut self, store: &BS, deal_id_keys: &[DealID], ) -> Result<Vec<AllocationID>, ActorError>

where BS: Blockstore,

pub fn remove_pending_deal_allocation_id<BS>( &mut self, store: &BS, deal_id: DealID, ) -> Result<Option<AllocationID>, ActorError>

where BS: Blockstore,

pub fn load_deal_ops<BS>( &self, store: BS, ) -> Result<SetMultimap<BS, ChainEpoch, DealID>, ActorError>

where BS: Blockstore,

pub fn put_deals_by_epoch<BS>( &mut self, store: &BS, new_deals_by_epoch: &[(ChainEpoch, DealID)], ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn put_batch_deals_by_epoch<BS>( &mut self, store: &BS, new_deals_by_epoch: &BTreeMap<ChainEpoch, Vec<DealID>>, ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn get_deals_for_epoch<BS>( &self, store: &BS, key: ChainEpoch, ) -> Result<Vec<DealID>, ActorError>

where BS: Blockstore,

pub fn remove_deals_by_epoch<BS>( &mut self, store: &BS, epochs_to_remove: &[ChainEpoch], ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn add_balance_to_escrow_table<BS>( &mut self, store: &BS, addr: &Address, amount: &TokenAmount, ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn withdraw_balance_from_escrow_table<BS>( &mut self, store: &BS, addr: &Address, amount: &TokenAmount, ) -> Result<TokenAmount, ActorError>

where BS: Blockstore,

pub fn load_pending_deals<BS>( &self, store: BS, ) -> Result<PendingProposalsSet<BS>, ActorError>

where BS: Blockstore,

pub fn has_pending_deal<BS>( &self, store: &BS, key: &Cid, ) -> Result<bool, ActorError>

where BS: Blockstore,

pub fn put_pending_deals<BS>( &mut self, store: &BS, new_pending_deals: &[Cid], ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn remove_pending_deal<BS>( &mut self, store: &BS, pending_deal_key: Cid, ) -> Result<Option<()>, ActorError>

where BS: Blockstore,

pub fn put_sector_deal_ids( &mut self, store: &impl Blockstore, provider: ActorID, sector_deal_ids: &[(SectorNumber, Vec<DealID>)], ) -> Result<(), ActorError>

pub fn pop_sector_deal_ids( &mut self, store: &impl Blockstore, provider: ActorID, sector_numbers: impl Iterator<Item = SectorNumber>, ) -> Result<Vec<DealID>, ActorError>

pub fn remove_sector_deal_ids( &mut self, store: &impl Blockstore, provider_sector_deal_ids: &BTreeMap<ActorID, BTreeMap<SectorNumber, Vec<DealID>>>, ) -> Result<(), ActorError>

pub fn load_provider_sectors<BS>( &self, store: BS, ) -> Result<ProviderSectorsMap<BS>, ActorError>

where BS: Blockstore,

pub fn remove_completed_deal<BS>( &mut self, store: &BS, deal_id: DealID, ) -> Result<(), ActorError>

where BS: Blockstore,

Delete proposal and state simultaneously.

pub fn get_active_deal_or_process_timeout<BS>( &mut self, store: &BS, curr_epoch: ChainEpoch, deal_id: DealID, deal_proposal: &DealProposal, dcid: &Cid, ) -> Result<LoadDealState, ActorError>

where BS: Blockstore,

Given a DealProposal, checks that the corresponding deal has activated If not, checks that the deal is past its activation epoch and performs cleanup

pub fn process_deal_update<BS>( &mut self, store: &BS, state: &DealState, deal: &DealProposal, deal_cid: &Cid, epoch: ChainEpoch, ) -> Result<(TokenAmount, TokenAmount, bool, bool), ActorError>

where BS: Blockstore,

pub fn process_slashed_deal<BS>( &mut self, store: &BS, proposal: &DealProposal, state: &DealState, ) -> Result<TokenAmount, ActorError>

where BS: Blockstore,

pub fn process_deal_init_timed_out<BS>( &mut self, store: &BS, deal: &DealProposal, ) -> Result<TokenAmount, ActorError>

where BS: Blockstore,

Deal start deadline elapsed without appearing in a proven sector. Slash a portion of provider’s collateral, and unlock remaining collaterals for both provider and client.

pub fn generate_storage_deal_id(&mut self) -> DealID

pub fn escrow_table<'a, BS: Blockstore>( &self, store: &'a BS, ) -> Result<BalanceTable<&'a BS>, ActorError>

pub fn locked_table<'a, BS: Blockstore>( &self, store: &'a BS, ) -> Result<BalanceTable<&'a BS>, ActorError>

pub fn balance_covered<BS>( &self, store: &BS, addr: Address, amount_to_lock: &TokenAmount, ) -> Result<bool, ActorError>

where BS: Blockstore,

pub fn lock_client_and_provider_balances<BS>( &mut self, store: &BS, proposal: &DealProposal, ) -> Result<(), ActorError>

where BS: Blockstore,

pub fn verify_deals_for_activation<BS>( &self, store: &BS, addr: &Address, deal_ids: Vec<DealID>, curr_epoch: ChainEpoch, sector_exp: i64, ) -> Result<(DealWeight, DealWeight), ActorError>

where BS: Blockstore,

Verify that a given set of storage deals is valid for a sector currently being PreCommitted

Trait Implementations

impl Clone for State

fn clone(&self) -> State

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for State

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for State

fn default() -> State

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for State

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for State

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.