extras_filecoin/
miner.rs

1use cid::Cid;
2use fil_actor_miner::CompactCommD;
3use fil_actor_miner::{
4    ApplyRewardParams, ChangeMultiaddrsParams, ChangeOwnerAddressParams, ChangePeerIDParams,
5    ChangeWorkerAddressParams, CheckSectorProvenParams, CompactPartitionsParams,
6    CompactSectorNumbersParams, ConfirmSectorProofsParams, DeclareFaultsParams,
7    DeclareFaultsRecoveredParams, DeferredCronEventParams, DisputeWindowedPoStParams,
8    ExpirationExtension, ExtendSectorExpirationParams, FaultDeclaration, MinerConstructorParams,
9    PoStPartition, PreCommitSectorBatchParams, PreCommitSectorBatchParams2, PreCommitSectorParams,
10    ProveCommitAggregateParams, ProveCommitSectorParams, ProveReplicaUpdatesParams,
11    RecoveryDeclaration, ReplicaUpdate, ReportConsensusFaultParams, SectorPreCommitInfo,
12    SubmitWindowedPoStParams, TerminateSectorsParams, TerminationDeclaration,
13    WithdrawBalanceParams,
14};
15use fvm_ipld_bitfield::BitField;
16use fvm_ipld_encoding::{serde_bytes, BytesDe};
17use fvm_shared::address::Address;
18use fvm_shared::bigint::bigint_ser;
19use fvm_shared::clock::ChainEpoch;
20use fvm_shared::deal::DealID;
21use fvm_shared::econ::TokenAmount;
22use fvm_shared::randomness::Randomness;
23use fvm_shared::sector::{
24    PoStProof, RegisteredPoStProof, RegisteredSealProof, RegisteredUpdateProof, SectorNumber,
25    StoragePower,
26};
27use fvm_shared::smooth::FilterEstimate;
28use serde::{Deserialize, Serialize};
29
30use super::json::address;
31use super::json::serde_base64_vector;
32use super::json::tokenamount;
33use super::json::vec_address;
34
35/// Storage miner actor constructor params are defined here so the power actor can send them to the init actor
36/// to instantiate miners.
37#[derive(Serialize, Deserialize)]
38#[serde(remote = "MinerConstructorParams", rename_all = "PascalCase")]
39pub struct MinerConstructorParamsAPI {
40    #[serde(with = "address")]
41    pub owner: Address,
42    #[serde(with = "address")]
43    pub worker: Address,
44    #[serde(with = "vec_address")]
45    pub control_addresses: Vec<Address>,
46    pub window_post_proof_type: RegisteredPoStProof,
47    #[serde(with = "serde_base64_vector")]
48    pub peer_id: Vec<u8>,
49    pub multi_addresses: Vec<BytesDe>,
50}
51
52#[derive(Serialize, Deserialize)]
53#[serde(remote = "ChangeOwnerAddressParams", rename_all = "PascalCase")]
54pub struct ChangeOwnerAddressParamsAPI {
55    #[serde(with = "address")]
56    pub new_owner: Address,
57}
58
59#[derive(Serialize, Deserialize)]
60#[serde(remote = "ChangeWorkerAddressParams", rename_all = "PascalCase")]
61pub struct ChangeWorkerAddressParamsAPI {
62    #[serde(with = "address")]
63    pub new_worker: Address,
64    #[serde(with = "vec_address")]
65    pub new_control_addresses: Vec<Address>,
66}
67
68#[derive(Serialize, Deserialize)]
69#[serde(remote = "ChangePeerIDParams", rename_all = "PascalCase")]
70pub struct ChangePeerIDParamsAPI {
71    #[serde(with = "serde_base64_vector")]
72    pub new_id: Vec<u8>,
73}
74
75#[derive(Serialize, Deserialize)]
76#[serde(remote = "ChangeMultiaddrsParams", rename_all = "PascalCase")]
77pub struct ChangeMultiaddrsParamsAPI {
78    pub new_multi_addrs: Vec<BytesDe>,
79}
80
81#[derive(Serialize, Deserialize)]
82#[serde(remote = "ConfirmSectorProofsParams", rename_all = "PascalCase")]
83pub struct ConfirmSectorProofsParamsAPI {
84    pub sectors: Vec<SectorNumber>,
85    pub reward_smoothed: FilterEstimate,
86    #[serde(with = "bigint_ser")]
87    pub reward_baseline_power: StoragePower,
88    pub quality_adj_power_smoothed: FilterEstimate,
89}
90
91#[derive(Serialize, Deserialize)]
92#[serde(remote = "DeferredCronEventParams", rename_all = "PascalCase")]
93pub struct DeferredCronEventParamsAPI {
94    #[serde(with = "serde_bytes")]
95    pub event_payload: Vec<u8>,
96    pub reward_smoothed: FilterEstimate,
97    pub quality_adj_power_smoothed: FilterEstimate,
98}
99
100#[derive(Serialize, Deserialize)]
101#[serde(remote = "PoStPartition", rename_all = "PascalCase")]
102pub struct PoStPartitionAPI {
103    /// Partitions are numbered per-deadline, from zero.
104    pub index: u64,
105    /// Sectors skipped while proving that weren't already declared faulty.
106    pub skipped: BitField,
107}
108
109/// Information submitted by a miner to provide a Window PoSt.
110#[derive(Serialize, Deserialize)]
111#[serde(remote = "SubmitWindowedPoStParams", rename_all = "PascalCase")]
112pub struct SubmitWindowedPoStParamsAPI {
113    /// The deadline index which the submission targets.
114    pub deadline: u64,
115    /// The partitions being proven.
116    pub partitions: Vec<PoStPartition>,
117    /// Array of proofs, one per distinct registered proof type present in the sectors being proven.
118    /// In the usual case of a single proof type, this array will always have a single element (independent of number of partitions).
119    pub proofs: Vec<PoStProof>,
120    /// The epoch at which these proofs is being committed to a particular chain.
121    pub chain_commit_epoch: ChainEpoch,
122    /// The ticket randomness on the chain at the `chain_commit_epoch` on the chain this post is committed to.
123    pub chain_commit_rand: Randomness,
124}
125
126#[derive(Serialize, Deserialize)]
127#[serde(remote = "ProveCommitSectorParams", rename_all = "PascalCase")]
128pub struct ProveCommitSectorParamsAPI {
129    pub sector_number: SectorNumber,
130    #[serde(with = "serde_bytes")]
131    pub proof: Vec<u8>,
132}
133
134#[derive(Serialize, Deserialize)]
135#[serde(remote = "CheckSectorProvenParams", rename_all = "PascalCase")]
136pub struct CheckSectorProvenParamsAPI {
137    pub sector_number: SectorNumber,
138}
139
140#[derive(Serialize, Deserialize)]
141#[serde(remote = "ExtendSectorExpirationParams", rename_all = "PascalCase")]
142pub struct ExtendSectorExpirationParamsAPI {
143    pub extensions: Vec<ExpirationExtension>,
144}
145
146#[derive(Serialize, Deserialize)]
147#[serde(remote = "ExpirationExtension", rename_all = "PascalCase")]
148pub struct ExpirationExtensionAPI {
149    pub deadline: u64,
150    pub partition: u64,
151    pub sectors: BitField,
152    pub new_expiration: ChainEpoch,
153}
154
155#[derive(Serialize, Deserialize)]
156#[serde(remote = "TerminateSectorsParams", rename_all = "PascalCase")]
157pub struct TerminateSectorsParamsAPI {
158    pub terminations: Vec<TerminationDeclaration>,
159}
160
161#[derive(Serialize, Deserialize)]
162#[serde(remote = "TerminationDeclaration", rename_all = "PascalCase")]
163pub struct TerminationDeclarationAPI {
164    pub deadline: u64,
165    pub partition: u64,
166    pub sectors: BitField,
167}
168
169#[derive(Serialize, Deserialize)]
170#[serde(remote = "DeclareFaultsParams", rename_all = "PascalCase")]
171pub struct DeclareFaultsParamsAPI {
172    pub faults: Vec<FaultDeclaration>,
173}
174
175#[derive(Serialize, Deserialize)]
176#[serde(remote = "FaultDeclaration", rename_all = "PascalCase")]
177pub struct FaultDeclarationAPI {
178    /// The deadline to which the faulty sectors are assigned, in range [0..WPoStPeriodDeadlines)
179    pub deadline: u64,
180    /// Partition index within the deadline containing the faulty sectors.
181    pub partition: u64,
182    /// Sectors in the partition being declared faulty.
183    pub sectors: BitField,
184}
185
186#[derive(Serialize, Deserialize)]
187#[serde(remote = "DeclareFaultsRecoveredParams", rename_all = "PascalCase")]
188pub struct DeclareFaultsRecoveredParamsAPI {
189    pub recoveries: Vec<RecoveryDeclaration>,
190}
191
192#[derive(Serialize, Deserialize)]
193#[serde(remote = "RecoveryDeclaration", rename_all = "PascalCase")]
194pub struct RecoveryDeclarationAPI {
195    /// The deadline to which the recovered sectors are assigned, in range [0..WPoStPeriodDeadlines)
196    pub deadline: u64,
197    /// Partition index within the deadline containing the recovered sectors.
198    pub partition: u64,
199    /// Sectors in the partition being declared recovered.
200    pub sectors: BitField,
201}
202
203#[derive(Serialize, Deserialize)]
204#[serde(remote = "CompactPartitionsParams", rename_all = "PascalCase")]
205pub struct CompactPartitionsParamsAPI {
206    pub deadline: u64,
207    pub partitions: BitField,
208}
209
210#[derive(Serialize, Deserialize)]
211#[serde(remote = "CompactSectorNumbersParams", rename_all = "PascalCase")]
212pub struct CompactSectorNumbersParamsAPI {
213    pub mask_sector_numbers: BitField,
214}
215
216#[derive(Serialize, Deserialize)]
217#[serde(remote = "ReportConsensusFaultParams", rename_all = "PascalCase")]
218pub struct ReportConsensusFaultParamsAPI {
219    #[serde(with = "serde_base64_vector")]
220    pub header1: Vec<u8>,
221    #[serde(with = "serde_base64_vector")]
222    pub header2: Vec<u8>,
223    #[serde(with = "serde_base64_vector")]
224    pub header_extra: Vec<u8>,
225}
226
227#[derive(Serialize, Deserialize)]
228#[serde(remote = "WithdrawBalanceParams", rename_all = "PascalCase")]
229pub struct WithdrawBalanceParamsAPI {
230    #[serde(with = "tokenamount")]
231    pub amount_requested: TokenAmount,
232}
233
234#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
235#[serde(remote = "PreCommitSectorBatchParams", rename_all = "PascalCase")]
236pub struct PreCommitSectorBatchParamsAPI {
237    pub sectors: Vec<PreCommitSectorParams>,
238}
239
240#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
241#[serde(remote = "PreCommitSectorBatchParams2", rename_all = "PascalCase")]
242pub struct PreCommitSectorBatchParams2API {
243    pub sectors: Vec<SectorPreCommitInfo>,
244}
245
246#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
247#[serde(remote = "PreCommitSectorParams", rename_all = "PascalCase")]
248pub struct PreCommitSectorParamsAPI {
249    pub seal_proof: RegisteredSealProof,
250    pub sector_number: SectorNumber,
251    /// CommR
252    pub sealed_cid: Cid,
253    pub seal_rand_epoch: ChainEpoch,
254    pub deal_ids: Vec<DealID>,
255    pub expiration: ChainEpoch,
256    /// Whether to replace a "committed capacity" no-deal sector (requires non-empty DealIDs)
257    pub replace_capacity: bool,
258    /// The committed capacity sector to replace, and its deadline/partition location
259    pub replace_sector_deadline: u64,
260    pub replace_sector_partition: u64,
261    pub replace_sector_number: SectorNumber,
262}
263
264#[derive(Debug, Default, PartialEq, Eq, Clone, Serialize, Deserialize)]
265#[serde(remote = "SectorPreCommitInfo", rename_all = "PascalCase")]
266pub struct SectorPreCommitInfoAPI {
267    pub seal_proof: RegisteredSealProof,
268    pub sector_number: SectorNumber,
269    /// CommR
270    pub sealed_cid: Cid,
271    pub seal_rand_epoch: ChainEpoch,
272    pub deal_ids: Vec<DealID>,
273    pub expiration: ChainEpoch,
274    /// CommD
275    pub unsealed_cid: CompactCommD,
276}
277
278// * Added in v2 -- param was previously a big int.
279#[derive(Debug, Serialize, Deserialize)]
280#[serde(remote = "ApplyRewardParams", rename_all = "PascalCase")]
281pub struct ApplyRewardParamsAPI {
282    #[serde(with = "tokenamount")]
283    pub reward: TokenAmount,
284    #[serde(with = "tokenamount")]
285    pub penalty: TokenAmount,
286}
287
288#[derive(Debug, PartialEq, Clone, Copy, Serialize, Deserialize)]
289#[serde(remote = "DisputeWindowedPoStParams", rename_all = "PascalCase")]
290pub struct DisputeWindowedPoStParamsAPI {
291    pub deadline: u64,
292    pub post_index: u64, // only one is allowed at a time to avoid loading too many sector infos.
293}
294
295#[derive(Debug, Serialize, Deserialize)]
296#[serde(remote = "ProveCommitAggregateParams", rename_all = "PascalCase")]
297pub struct ProveCommitAggregateParamsAPI {
298    pub sector_numbers: BitField,
299    #[serde(with = "serde_base64_vector")]
300    pub aggregate_proof: Vec<u8>,
301}
302
303#[derive(Debug, PartialEq, Serialize, Deserialize)]
304#[serde(remote = "ReplicaUpdate", rename_all = "PascalCase")]
305pub struct ReplicaUpdateAPI {
306    pub sector_number: SectorNumber,
307    pub deadline: u64,
308    pub partition: u64,
309    pub new_sealed_cid: Cid,
310    pub deals: Vec<DealID>,
311    pub update_proof_type: RegisteredUpdateProof,
312    #[serde(with = "serde_base64_vector")]
313    pub replica_proof: Vec<u8>,
314}
315
316#[derive(Debug, Serialize, Deserialize)]
317#[serde(remote = "ProveReplicaUpdatesParams", rename_all = "PascalCase")]
318pub struct ProveReplicaUpdatesParamsAPI {
319    pub updates: Vec<ReplicaUpdate>,
320}
extras_filecoin/miner.rs

extras_filecoin/
miner.rs
