1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
use crate::{smooth::FilterEstimate, DealWeight};
use address::Address;
use bitfield::UnvalidatedBitField;
use cid::Cid;
use clock::ChainEpoch;
use encoding::{serde_bytes, tuple::*, BytesDe};
use fil_types::{
PoStProof, Randomness, RegisteredPoStProof, RegisteredSealProof, SectorNumber, StoragePower,
};
use num_bigint::bigint_ser;
use vm::{DealID, TokenAmount};
pub type CronEvent = i64;
pub const CRON_EVENT_WORKER_KEY_CHANGE: CronEvent = 0;
pub const CRON_EVENT_PROVING_DEADLINE: CronEvent = 1;
pub const CRON_EVENT_PROCESS_EARLY_TERMINATIONS: CronEvent = 2;
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct MinerConstructorParams {
pub owner: Address,
pub worker: Address,
pub control_addresses: Vec<Address>,
pub window_post_proof_type: RegisteredPoStProof,
#[serde(with = "serde_bytes")]
pub peer_id: Vec<u8>,
pub multi_addresses: Vec<BytesDe>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct CronEventPayload {
pub event_type: i64,
}
#[derive(Debug)]
pub struct PartitionKey {
pub deadline: usize,
pub partition: usize,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct GetControlAddressesReturn {
pub owner: Address,
pub worker: Address,
pub control_addresses: Vec<Address>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct ChangeWorkerAddressParams {
pub new_worker: Address,
pub new_control_addresses: Vec<Address>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct ChangePeerIDParams {
#[serde(with = "serde_bytes")]
pub new_id: Vec<u8>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct ChangeMultiaddrsParams {
pub new_multi_addrs: Vec<BytesDe>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct ConfirmSectorProofsParams {
pub sectors: Vec<SectorNumber>,
pub reward_smoothed: FilterEstimate,
#[serde(with = "bigint_ser")]
pub reward_baseline_power: StoragePower,
pub quality_adj_power_smoothed: FilterEstimate,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct DeferredCronEventParams {
#[serde(with = "serde_bytes")]
pub event_payload: Vec<u8>,
pub reward_smoothed: FilterEstimate,
pub quality_adj_power_smoothed: FilterEstimate,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct PoStPartition {
pub index: usize,
pub skipped: UnvalidatedBitField,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct SubmitWindowedPoStParams {
pub deadline: usize,
pub partitions: Vec<PoStPartition>,
pub proofs: Vec<PoStProof>,
pub chain_commit_epoch: ChainEpoch,
pub chain_commit_rand: Randomness,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct ProveCommitSectorParams {
pub sector_number: SectorNumber,
#[serde(with = "serde_bytes")]
pub proof: Vec<u8>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct CheckSectorProvenParams {
pub sector_number: SectorNumber,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct ExtendSectorExpirationParams {
pub extensions: Vec<ExpirationExtension>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct ExpirationExtension {
pub deadline: usize,
pub partition: usize,
pub sectors: UnvalidatedBitField,
pub new_expiration: ChainEpoch,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct TerminateSectorsParams {
pub terminations: Vec<TerminationDeclaration>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct TerminationDeclaration {
pub deadline: usize,
pub partition: usize,
pub sectors: UnvalidatedBitField,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct TerminateSectorsReturn {
pub done: bool,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct DeclareFaultsParams {
pub faults: Vec<FaultDeclaration>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct FaultDeclaration {
pub deadline: usize,
pub partition: usize,
pub sectors: UnvalidatedBitField,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct DeclareFaultsRecoveredParams {
pub recoveries: Vec<RecoveryDeclaration>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct RecoveryDeclaration {
pub deadline: usize,
pub partition: usize,
pub sectors: UnvalidatedBitField,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct CompactPartitionsParams {
pub deadline: usize,
pub partitions: UnvalidatedBitField,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct CompactSectorNumbersParams {
pub mask_sector_numbers: UnvalidatedBitField,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct ReportConsensusFaultParams {
#[serde(with = "serde_bytes")]
pub header1: Vec<u8>,
#[serde(with = "serde_bytes")]
pub header2: Vec<u8>,
#[serde(with = "serde_bytes")]
pub header_extra: Vec<u8>,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct WithdrawBalanceParams {
#[serde(with = "bigint_ser")]
pub amount_requested: TokenAmount,
}
#[derive(Serialize_tuple, Deserialize_tuple)]
#[serde(transparent)]
pub struct WithdrawBalanceReturn {
#[serde(with = "bigint_ser")]
pub amount_withdrawn: TokenAmount,
}
#[derive(Debug, PartialEq, Serialize_tuple, Deserialize_tuple)]
pub struct WorkerKeyChange {
pub new_worker: Address,
pub effective_at: ChainEpoch,
}
pub type PreCommitSectorParams = SectorPreCommitInfo;
#[derive(Debug, PartialEq, Clone, Serialize_tuple, Deserialize_tuple)]
pub struct PreCommitSectorBatchParams {
pub sectors: Vec<SectorPreCommitInfo>,
}
#[derive(Debug, PartialEq, Clone, Serialize_tuple, Deserialize_tuple)]
pub struct SectorPreCommitInfo {
pub seal_proof: RegisteredSealProof,
pub sector_number: SectorNumber,
pub sealed_cid: Cid,
pub seal_rand_epoch: ChainEpoch,
pub deal_ids: Vec<DealID>,
pub expiration: ChainEpoch,
pub replace_capacity: bool,
pub replace_sector_deadline: usize,
pub replace_sector_partition: usize,
pub replace_sector_number: SectorNumber,
}
#[derive(Debug, PartialEq, Clone, Serialize_tuple, Deserialize_tuple)]
pub struct SectorPreCommitOnChainInfo {
pub info: SectorPreCommitInfo,
#[serde(with = "bigint_ser")]
pub pre_commit_deposit: TokenAmount,
pub pre_commit_epoch: ChainEpoch,
#[serde(with = "bigint_ser")]
pub deal_weight: DealWeight,
#[serde(with = "bigint_ser")]
pub verified_deal_weight: DealWeight,
}
#[derive(Debug, PartialEq, Clone, Serialize_tuple, Deserialize_tuple)]
pub struct SectorOnChainInfo {
pub sector_number: SectorNumber,
pub seal_proof: RegisteredSealProof,
pub sealed_cid: Cid,
pub deal_ids: Vec<DealID>,
pub activation: ChainEpoch,
pub expiration: ChainEpoch,
#[serde(with = "bigint_ser")]
pub deal_weight: DealWeight,
#[serde(with = "bigint_ser")]
pub verified_deal_weight: DealWeight,
#[serde(with = "bigint_ser")]
pub initial_pledge: TokenAmount,
#[serde(with = "bigint_ser")]
pub expected_day_reward: TokenAmount,
#[serde(with = "bigint_ser")]
pub expected_storage_pledge: TokenAmount,
pub replaced_sector_age: ChainEpoch,
#[serde(with = "bigint_ser")]
pub replaced_day_reward: TokenAmount,
}
#[derive(Debug, PartialEq, Copy, Clone, Serialize_tuple, Deserialize_tuple)]
pub struct Fault {
pub miner: Address,
pub fault: ChainEpoch,
}
#[derive(Debug, Serialize_tuple, Deserialize_tuple)]
pub struct ApplyRewardParams {
#[serde(with = "bigint_ser")]
pub reward: TokenAmount,
#[serde(with = "bigint_ser")]
pub penalty: TokenAmount,
}
#[derive(Debug, PartialEq, Clone, Copy, Serialize_tuple, Deserialize_tuple)]
pub struct DisputeWindowedPoStParams {
pub deadline: usize,
pub post_index: u64,
}
#[derive(Debug, Serialize_tuple, Deserialize_tuple)]
pub struct ProveCommitAggregateParams {
pub sector_numbers: UnvalidatedBitField,
#[serde(with = "serde_bytes")]
pub aggregate_proof: Vec<u8>,
}