fvm_shared/sector/
registered_proof.rs

1// Copyright 2021-2023 Protocol Labs
2// Copyright 2019-2022 ChainSafe Systems
3// SPDX-License-Identifier: Apache-2.0, MIT
4
5#[cfg(feature = "proofs")]
6use std::convert::TryFrom;
7
8use serde::{Deserialize, Deserializer, Serialize, Serializer};
9
10use super::SectorSize;
11use crate::clock;
12use crate::version::NetworkVersion;
13
14/// Seal proof type which defines the version and sector size.
15#[allow(non_camel_case_types)]
16#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)]
17pub enum RegisteredSealProof {
18    StackedDRG2KiBV1,
19    StackedDRG512MiBV1,
20    StackedDRG8MiBV1,
21    StackedDRG32GiBV1,
22    StackedDRG64GiBV1,
23
24    StackedDRG2KiBV1P1,
25    StackedDRG512MiBV1P1,
26    StackedDRG8MiBV1P1,
27    StackedDRG32GiBV1P1,
28    StackedDRG64GiBV1P1,
29
30    StackedDRG2KiBV1P1_Feat_SyntheticPoRep,
31    StackedDRG512MiBV1P1_Feat_SyntheticPoRep,
32    StackedDRG8MiBV1P1_Feat_SyntheticPoRep,
33    StackedDRG32GiBV1P1_Feat_SyntheticPoRep,
34    StackedDRG64GiBV1P1_Feat_SyntheticPoRep,
35
36    StackedDRG2KiBV1P2_Feat_NiPoRep,
37    StackedDRG512MiBV1P2_Feat_NiPoRep,
38    StackedDRG8MiBV1P2_Feat_NiPoRep,
39    StackedDRG32GiBV1P2_Feat_NiPoRep,
40    StackedDRG64GiBV1P2_Feat_NiPoRep,
41    // TODO: get rid of this option once we no longer need go compat.
42    // We use it to ensure that we can deserialize bad values here because go checks this value
43    // later.
44    Invalid(i64),
45}
46
47impl RegisteredSealProof {
48    /// Returns registered seal proof for given sector size
49    pub fn from_sector_size(size: SectorSize, network_version: NetworkVersion) -> Self {
50        if network_version < NetworkVersion::V7 {
51            match size {
52                SectorSize::_2KiB => Self::StackedDRG2KiBV1,
53                SectorSize::_8MiB => Self::StackedDRG8MiBV1,
54                SectorSize::_512MiB => Self::StackedDRG512MiBV1,
55                SectorSize::_32GiB => Self::StackedDRG32GiBV1,
56                SectorSize::_64GiB => Self::StackedDRG64GiBV1,
57            }
58        } else {
59            match size {
60                SectorSize::_2KiB => Self::StackedDRG2KiBV1P1,
61                SectorSize::_8MiB => Self::StackedDRG8MiBV1P1,
62                SectorSize::_512MiB => Self::StackedDRG512MiBV1P1,
63                SectorSize::_32GiB => Self::StackedDRG32GiBV1P1,
64                SectorSize::_64GiB => Self::StackedDRG64GiBV1P1,
65            }
66        }
67    }
68
69    /// Convert the original proof type to the v1 proof added in network version 7.
70    pub fn update_to_v1(&mut self) {
71        *self = match self {
72            Self::StackedDRG2KiBV1 => Self::StackedDRG2KiBV1P1,
73            Self::StackedDRG512MiBV1 => Self::StackedDRG512MiBV1P1,
74            Self::StackedDRG8MiBV1 => Self::StackedDRG8MiBV1P1,
75            Self::StackedDRG32GiBV1 => Self::StackedDRG32GiBV1P1,
76            Self::StackedDRG64GiBV1 => Self::StackedDRG64GiBV1P1,
77            _ => return,
78        };
79    }
80
81    #[deprecated(since = "0.1.10", note = "Logic should exist in actors")]
82    /// The maximum duration a sector sealed with this proof may exist between activation and expiration.
83    pub fn sector_maximum_lifetime(self) -> clock::ChainEpoch {
84        // For all Stacked DRG sectors, the max is 5 years
85        let epochs_per_year = 1_262_277;
86        5 * epochs_per_year
87    }
88
89    /// Proof size for each SealProof type
90    pub fn proof_size(self) -> Result<usize, String> {
91        use RegisteredSealProof::*;
92        match self {
93            StackedDRG2KiBV1
94            | StackedDRG512MiBV1
95            | StackedDRG8MiBV1
96            | StackedDRG2KiBV1P1
97            | StackedDRG512MiBV1P1
98            | StackedDRG8MiBV1P1
99            | StackedDRG2KiBV1P1_Feat_SyntheticPoRep
100            | StackedDRG512MiBV1P1_Feat_SyntheticPoRep
101            | StackedDRG8MiBV1P1_Feat_SyntheticPoRep => Ok(192),
102
103            StackedDRG2KiBV1P2_Feat_NiPoRep
104            | StackedDRG512MiBV1P2_Feat_NiPoRep
105            | StackedDRG8MiBV1P2_Feat_NiPoRep => Ok(14_164),
106
107            StackedDRG32GiBV1
108            | StackedDRG64GiBV1
109            | StackedDRG32GiBV1P1
110            | StackedDRG64GiBV1P1
111            | StackedDRG32GiBV1P1_Feat_SyntheticPoRep
112            | StackedDRG64GiBV1P1_Feat_SyntheticPoRep => Ok(1_920),
113
114            StackedDRG32GiBV1P2_Feat_NiPoRep | StackedDRG64GiBV1P2_Feat_NiPoRep => Ok(23_092),
115
116            Invalid(i) => Err(format!("unsupported proof type: {}", i)),
117        }
118    }
119}
120
121impl Default for RegisteredSealProof {
122    fn default() -> Self {
123        Self::Invalid(-1)
124    }
125}
126
127/// Proof of spacetime type, indicating version and sector size of the proof.
128#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)]
129#[cfg_attr(feature = "arb", derive(arbitrary::Arbitrary))]
130pub enum RegisteredPoStProof {
131    StackedDRGWinning2KiBV1,
132    StackedDRGWinning8MiBV1,
133    StackedDRGWinning512MiBV1,
134    StackedDRGWinning32GiBV1,
135    StackedDRGWinning64GiBV1,
136    StackedDRGWindow2KiBV1P1,
137    StackedDRGWindow8MiBV1P1,
138    StackedDRGWindow512MiBV1P1,
139    StackedDRGWindow32GiBV1P1,
140    StackedDRGWindow64GiBV1P1,
141    Invalid(i64),
142}
143
144impl RegisteredPoStProof {
145    /// Returns the sector size of the proof type, which is measured in bytes.
146    pub fn sector_size(self) -> Result<SectorSize, String> {
147        use RegisteredPoStProof::*;
148        match self {
149            StackedDRGWindow2KiBV1P1 | StackedDRGWinning2KiBV1 => Ok(SectorSize::_2KiB),
150            StackedDRGWindow8MiBV1P1 | StackedDRGWinning8MiBV1 => Ok(SectorSize::_8MiB),
151            StackedDRGWindow512MiBV1P1 | StackedDRGWinning512MiBV1 => Ok(SectorSize::_512MiB),
152            StackedDRGWindow32GiBV1P1 | StackedDRGWinning32GiBV1 => Ok(SectorSize::_32GiB),
153            StackedDRGWindow64GiBV1P1 | StackedDRGWinning64GiBV1 => Ok(SectorSize::_64GiB),
154            Invalid(i) => Err(format!("unsupported proof type: {}", i)),
155        }
156    }
157
158    /// Proof size for each PoStProof type
159    pub fn proof_size(self) -> Result<usize, String> {
160        use RegisteredPoStProof::*;
161        match self {
162            StackedDRGWinning2KiBV1
163            | StackedDRGWinning8MiBV1
164            | StackedDRGWinning512MiBV1
165            | StackedDRGWinning32GiBV1
166            | StackedDRGWinning64GiBV1
167            | StackedDRGWindow2KiBV1P1
168            | StackedDRGWindow8MiBV1P1
169            | StackedDRGWindow512MiBV1P1
170            | StackedDRGWindow32GiBV1P1
171            | StackedDRGWindow64GiBV1P1 => Ok(192),
172            Invalid(i) => Err(format!("unsupported proof type: {}", i)),
173        }
174    }
175    /// Returns the partition size, in sectors, associated with a proof type.
176    /// The partition size is the number of sectors proven in a single PoSt proof.
177    pub fn window_post_partition_sectors(self) -> Result<u64, String> {
178        // Resolve to post proof and then compute size from that.
179        use RegisteredPoStProof::*;
180        match self {
181            StackedDRGWinning64GiBV1 | StackedDRGWindow64GiBV1P1 => Ok(2300),
182            StackedDRGWinning32GiBV1 | StackedDRGWindow32GiBV1P1 => Ok(2349),
183            StackedDRGWinning2KiBV1 | StackedDRGWindow2KiBV1P1 => Ok(2),
184            StackedDRGWinning8MiBV1 | StackedDRGWindow8MiBV1P1 => Ok(2),
185            StackedDRGWinning512MiBV1 | StackedDRGWindow512MiBV1P1 => Ok(2),
186            Invalid(i) => Err(format!("unsupported proof type: {}", i)),
187        }
188    }
189}
190
191impl RegisteredSealProof {
192    /// Returns the sector size of the proof type, which is measured in bytes.
193    pub fn sector_size(self) -> Result<SectorSize, String> {
194        use RegisteredSealProof::*;
195        match self {
196            StackedDRG2KiBV1
197            | StackedDRG2KiBV1P1
198            | StackedDRG2KiBV1P1_Feat_SyntheticPoRep
199            | StackedDRG2KiBV1P2_Feat_NiPoRep => Ok(SectorSize::_2KiB),
200            StackedDRG8MiBV1
201            | StackedDRG8MiBV1P1
202            | StackedDRG8MiBV1P1_Feat_SyntheticPoRep
203            | StackedDRG8MiBV1P2_Feat_NiPoRep => Ok(SectorSize::_8MiB),
204            StackedDRG512MiBV1
205            | StackedDRG512MiBV1P1
206            | StackedDRG512MiBV1P1_Feat_SyntheticPoRep
207            | StackedDRG512MiBV1P2_Feat_NiPoRep => Ok(SectorSize::_512MiB),
208            StackedDRG32GiBV1
209            | StackedDRG32GiBV1P1
210            | StackedDRG32GiBV1P1_Feat_SyntheticPoRep
211            | StackedDRG32GiBV1P2_Feat_NiPoRep => Ok(SectorSize::_32GiB),
212            StackedDRG64GiBV1
213            | StackedDRG64GiBV1P1
214            | StackedDRG64GiBV1P1_Feat_SyntheticPoRep
215            | StackedDRG64GiBV1P2_Feat_NiPoRep => Ok(SectorSize::_64GiB),
216            Invalid(i) => Err(format!("unsupported proof type: {}", i)),
217        }
218    }
219
220    /// Returns the partition size, in sectors, associated with a proof type.
221    /// The partition size is the number of sectors proven in a single PoSt proof.
222    pub fn window_post_partition_sectors(self) -> Result<u64, String> {
223        // Resolve to seal proof and then compute size from that.
224        use RegisteredSealProof::*;
225        match self {
226            StackedDRG64GiBV1
227            | StackedDRG64GiBV1P1
228            | StackedDRG64GiBV1P1_Feat_SyntheticPoRep
229            | StackedDRG64GiBV1P2_Feat_NiPoRep => Ok(2300),
230            StackedDRG32GiBV1
231            | StackedDRG32GiBV1P1
232            | StackedDRG32GiBV1P1_Feat_SyntheticPoRep
233            | StackedDRG32GiBV1P2_Feat_NiPoRep => Ok(2349),
234            StackedDRG2KiBV1
235            | StackedDRG2KiBV1P1
236            | StackedDRG2KiBV1P1_Feat_SyntheticPoRep
237            | StackedDRG2KiBV1P2_Feat_NiPoRep => Ok(2),
238            StackedDRG8MiBV1
239            | StackedDRG8MiBV1P1
240            | StackedDRG8MiBV1P1_Feat_SyntheticPoRep
241            | StackedDRG8MiBV1P2_Feat_NiPoRep => Ok(2),
242            StackedDRG512MiBV1
243            | StackedDRG512MiBV1P1
244            | StackedDRG512MiBV1P1_Feat_SyntheticPoRep
245            | StackedDRG512MiBV1P2_Feat_NiPoRep => Ok(2),
246            Invalid(i) => Err(format!("unsupported proof type: {}", i)),
247        }
248    }
249
250    /// Produces the windowed PoSt-specific RegisteredProof corresponding
251    /// to the receiving RegisteredProof.
252    pub fn registered_window_post_proof(self) -> Result<RegisteredPoStProof, String> {
253        use RegisteredPoStProof::*;
254        match self {
255            Self::StackedDRG64GiBV1
256            | Self::StackedDRG64GiBV1P1
257            | Self::StackedDRG64GiBV1P1_Feat_SyntheticPoRep
258            | Self::StackedDRG64GiBV1P2_Feat_NiPoRep => Ok(StackedDRGWindow64GiBV1P1),
259            Self::StackedDRG32GiBV1
260            | Self::StackedDRG32GiBV1P1
261            | Self::StackedDRG32GiBV1P1_Feat_SyntheticPoRep
262            | Self::StackedDRG32GiBV1P2_Feat_NiPoRep => Ok(StackedDRGWindow32GiBV1P1),
263            Self::StackedDRG2KiBV1
264            | Self::StackedDRG2KiBV1P1
265            | Self::StackedDRG2KiBV1P1_Feat_SyntheticPoRep
266            | Self::StackedDRG2KiBV1P2_Feat_NiPoRep => Ok(StackedDRGWindow2KiBV1P1),
267            Self::StackedDRG8MiBV1
268            | Self::StackedDRG8MiBV1P1
269            | Self::StackedDRG8MiBV1P1_Feat_SyntheticPoRep
270            | Self::StackedDRG8MiBV1P2_Feat_NiPoRep => Ok(StackedDRGWindow8MiBV1P1),
271            Self::StackedDRG512MiBV1
272            | Self::StackedDRG512MiBV1P1
273            | Self::StackedDRG512MiBV1P1_Feat_SyntheticPoRep
274            | Self::StackedDRG512MiBV1P2_Feat_NiPoRep => Ok(StackedDRGWindow512MiBV1P1),
275            Self::Invalid(_) => Err(format!(
276                "Unsupported mapping from {:?} to PoSt-window RegisteredProof",
277                self
278            )),
279        }
280    }
281
282    /// Produces the update RegisteredProof corresponding to the receiving RegisteredProof.
283    pub fn registered_update_proof(self) -> Result<RegisteredUpdateProof, String> {
284        use RegisteredUpdateProof::*;
285        match self {
286            Self::StackedDRG64GiBV1
287            | Self::StackedDRG64GiBV1P1
288            | Self::StackedDRG64GiBV1P1_Feat_SyntheticPoRep
289            | Self::StackedDRG64GiBV1P2_Feat_NiPoRep => Ok(StackedDRG64GiBV1),
290            Self::StackedDRG32GiBV1
291            | Self::StackedDRG32GiBV1P1
292            | Self::StackedDRG32GiBV1P1_Feat_SyntheticPoRep
293            | Self::StackedDRG32GiBV1P2_Feat_NiPoRep => Ok(StackedDRG32GiBV1),
294            Self::StackedDRG2KiBV1
295            | Self::StackedDRG2KiBV1P1
296            | Self::StackedDRG2KiBV1P1_Feat_SyntheticPoRep
297            | Self::StackedDRG2KiBV1P2_Feat_NiPoRep => Ok(StackedDRG2KiBV1),
298            Self::StackedDRG8MiBV1
299            | Self::StackedDRG8MiBV1P1
300            | Self::StackedDRG8MiBV1P1_Feat_SyntheticPoRep
301            | Self::StackedDRG8MiBV1P2_Feat_NiPoRep => Ok(StackedDRG8MiBV1),
302            Self::StackedDRG512MiBV1
303            | Self::StackedDRG512MiBV1P1
304            | Self::StackedDRG512MiBV1P1_Feat_SyntheticPoRep
305            | Self::StackedDRG512MiBV1P2_Feat_NiPoRep => Ok(StackedDRG512MiBV1),
306            Self::Invalid(_) => Err(format!(
307                "Unsupported mapping from {:?} to Update RegisteredProof",
308                self
309            )),
310        }
311    }
312}
313
314/// Seal proof type which defines the version and sector size.
315#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)]
316pub enum RegisteredAggregateProof {
317    SnarkPackV1,
318    SnarkPackV2,
319    Invalid(i64),
320}
321
322/// Proof of update type
323#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)]
324pub enum RegisteredUpdateProof {
325    StackedDRG2KiBV1,
326    StackedDRG8MiBV1,
327    StackedDRG512MiBV1,
328    StackedDRG32GiBV1,
329    StackedDRG64GiBV1,
330    Invalid(i64),
331}
332
333macro_rules! i64_conversion {
334    ($ty:ident; $( $var:ident => $val:expr, )*) => {
335        impl From<i64> for $ty {
336            fn from(value: i64) -> Self {
337                match value {
338                    $( $val => $ty::$var, )*
339                    other => $ty::Invalid(other),
340                }
341            }
342        }
343        impl From<$ty> for i64 {
344            fn from(proof: $ty) -> Self {
345                match proof {
346                    $( $ty::$var => $val, )*
347                    $ty::Invalid(other) => other,
348                }
349            }
350        }
351    }
352}
353
354i64_conversion! {
355    RegisteredPoStProof;
356    StackedDRGWinning2KiBV1 => 0,
357    StackedDRGWinning8MiBV1 => 1,
358    StackedDRGWinning512MiBV1 => 2,
359    StackedDRGWinning32GiBV1 => 3,
360    StackedDRGWinning64GiBV1 => 4,
361    // The hole here is due to the removal of v1 PoSt proof types.
362    // We can not modify those numbers since they are consensus-critical.
363    StackedDRGWindow2KiBV1P1 => 10,
364    StackedDRGWindow8MiBV1P1 => 11,
365    StackedDRGWindow512MiBV1P1 => 12,
366    StackedDRGWindow32GiBV1P1 => 13,
367    StackedDRGWindow64GiBV1P1 => 14,
368}
369
370i64_conversion! {
371    RegisteredSealProof;
372    StackedDRG2KiBV1 => 0,
373    StackedDRG8MiBV1 => 1,
374    StackedDRG512MiBV1 => 2,
375    StackedDRG32GiBV1 => 3,
376    StackedDRG64GiBV1 => 4,
377
378    StackedDRG2KiBV1P1 => 5,
379    StackedDRG8MiBV1P1 => 6,
380    StackedDRG512MiBV1P1 => 7,
381    StackedDRG32GiBV1P1 => 8,
382    StackedDRG64GiBV1P1 => 9,
383
384    StackedDRG2KiBV1P1_Feat_SyntheticPoRep => 10,
385    StackedDRG8MiBV1P1_Feat_SyntheticPoRep => 11,
386    StackedDRG512MiBV1P1_Feat_SyntheticPoRep => 12,
387    StackedDRG32GiBV1P1_Feat_SyntheticPoRep => 13,
388    StackedDRG64GiBV1P1_Feat_SyntheticPoRep => 14,
389
390    StackedDRG2KiBV1P2_Feat_NiPoRep => 15,
391    StackedDRG8MiBV1P2_Feat_NiPoRep => 16,
392    StackedDRG512MiBV1P2_Feat_NiPoRep => 17,
393    StackedDRG32GiBV1P2_Feat_NiPoRep => 18,
394    StackedDRG64GiBV1P2_Feat_NiPoRep => 19,
395}
396
397i64_conversion! {
398    RegisteredAggregateProof;
399    SnarkPackV1 => 0,
400    SnarkPackV2 => 1,
401}
402
403i64_conversion! {
404    RegisteredUpdateProof;
405    StackedDRG2KiBV1 => 0,
406    StackedDRG8MiBV1 => 1,
407    StackedDRG512MiBV1 => 2,
408    StackedDRG32GiBV1 => 3,
409    StackedDRG64GiBV1 => 4,
410}
411#[cfg(feature = "proofs")]
412impl TryFrom<RegisteredAggregateProof> for filecoin_proofs_api::RegisteredAggregationProof {
413    type Error = String;
414    fn try_from(p: RegisteredAggregateProof) -> Result<Self, Self::Error> {
415        use RegisteredAggregateProof::*;
416        match p {
417            SnarkPackV1 => Ok(Self::SnarkPackV1),
418            SnarkPackV2 => Ok(Self::SnarkPackV2),
419            Invalid(i) => Err(format!("unsupported aggregate proof type: {}", i)),
420        }
421    }
422}
423
424#[cfg(feature = "proofs")]
425impl TryFrom<RegisteredSealProof> for filecoin_proofs_api::RegisteredSealProof {
426    type Error = String;
427    fn try_from(p: RegisteredSealProof) -> Result<Self, Self::Error> {
428        use RegisteredSealProof::*;
429        match p {
430            StackedDRG64GiBV1 => Ok(Self::StackedDrg64GiBV1),
431            StackedDRG32GiBV1 => Ok(Self::StackedDrg32GiBV1),
432            StackedDRG2KiBV1 => Ok(Self::StackedDrg2KiBV1),
433            StackedDRG8MiBV1 => Ok(Self::StackedDrg8MiBV1),
434            StackedDRG512MiBV1 => Ok(Self::StackedDrg512MiBV1),
435            StackedDRG64GiBV1P1 => Ok(Self::StackedDrg64GiBV1_1),
436            StackedDRG32GiBV1P1 => Ok(Self::StackedDrg32GiBV1_1),
437            StackedDRG2KiBV1P1 => Ok(Self::StackedDrg2KiBV1_1),
438            StackedDRG8MiBV1P1 => Ok(Self::StackedDrg8MiBV1_1),
439            StackedDRG512MiBV1P1 => Ok(Self::StackedDrg512MiBV1_1),
440            StackedDRG64GiBV1P1_Feat_SyntheticPoRep => {
441                Ok(Self::StackedDrg64GiBV1_1_Feat_SyntheticPoRep)
442            }
443            StackedDRG32GiBV1P1_Feat_SyntheticPoRep => {
444                Ok(Self::StackedDrg32GiBV1_1_Feat_SyntheticPoRep)
445            }
446            StackedDRG2KiBV1P1_Feat_SyntheticPoRep => {
447                Ok(Self::StackedDrg2KiBV1_1_Feat_SyntheticPoRep)
448            }
449            StackedDRG8MiBV1P1_Feat_SyntheticPoRep => {
450                Ok(Self::StackedDrg8MiBV1_1_Feat_SyntheticPoRep)
451            }
452            StackedDRG512MiBV1P1_Feat_SyntheticPoRep => {
453                Ok(Self::StackedDrg512MiBV1_1_Feat_SyntheticPoRep)
454            }
455            StackedDRG2KiBV1P2_Feat_NiPoRep => {
456                Ok(Self::StackedDrg2KiBV1_2_Feat_NonInteractivePoRep)
457            }
458            StackedDRG512MiBV1P2_Feat_NiPoRep => {
459                Ok(Self::StackedDrg512MiBV1_2_Feat_NonInteractivePoRep)
460            }
461            StackedDRG8MiBV1P2_Feat_NiPoRep => {
462                Ok(Self::StackedDrg8MiBV1_2_Feat_NonInteractivePoRep)
463            }
464            StackedDRG32GiBV1P2_Feat_NiPoRep => {
465                Ok(Self::StackedDrg32GiBV1_2_Feat_NonInteractivePoRep)
466            }
467            StackedDRG64GiBV1P2_Feat_NiPoRep => {
468                Ok(Self::StackedDrg64GiBV1_2_Feat_NonInteractivePoRep)
469            }
470            Invalid(i) => Err(format!("unsupported proof type: {}", i)),
471        }
472    }
473}
474
475#[cfg(feature = "proofs")]
476impl TryFrom<RegisteredPoStProof> for filecoin_proofs_api::RegisteredPoStProof {
477    type Error = String;
478    fn try_from(p: RegisteredPoStProof) -> Result<Self, Self::Error> {
479        use RegisteredPoStProof::*;
480        match p {
481            StackedDRGWinning2KiBV1 => Ok(Self::StackedDrgWinning2KiBV1),
482            StackedDRGWinning8MiBV1 => Ok(Self::StackedDrgWinning8MiBV1),
483            StackedDRGWinning512MiBV1 => Ok(Self::StackedDrgWinning512MiBV1),
484            StackedDRGWinning32GiBV1 => Ok(Self::StackedDrgWinning32GiBV1),
485            StackedDRGWinning64GiBV1 => Ok(Self::StackedDrgWinning64GiBV1),
486            StackedDRGWindow2KiBV1P1 => Ok(Self::StackedDrgWindow2KiBV1_2),
487            StackedDRGWindow8MiBV1P1 => Ok(Self::StackedDrgWindow8MiBV1_2),
488            StackedDRGWindow512MiBV1P1 => Ok(Self::StackedDrgWindow512MiBV1_2),
489            StackedDRGWindow32GiBV1P1 => Ok(Self::StackedDrgWindow32GiBV1_2),
490            StackedDRGWindow64GiBV1P1 => Ok(Self::StackedDrgWindow64GiBV1_2),
491            Invalid(i) => Err(format!("unsupported proof type: {}", i)),
492        }
493    }
494}
495
496#[cfg(feature = "proofs")]
497impl TryFrom<RegisteredUpdateProof> for filecoin_proofs_api::RegisteredUpdateProof {
498    type Error = String;
499    fn try_from(p: RegisteredUpdateProof) -> Result<Self, Self::Error> {
500        use RegisteredUpdateProof::*;
501        match p {
502            StackedDRG2KiBV1 => Ok(Self::StackedDrg2KiBV1),
503            StackedDRG8MiBV1 => Ok(Self::StackedDrg8MiBV1),
504            StackedDRG512MiBV1 => Ok(Self::StackedDrg512MiBV1),
505            StackedDRG32GiBV1 => Ok(Self::StackedDrg32GiBV1),
506            StackedDRG64GiBV1 => Ok(Self::StackedDrg64GiBV1),
507            Invalid(i) => Err(format!("unsupported proof type: {}", i)),
508        }
509    }
510}
511
512impl Serialize for RegisteredPoStProof {
513    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
514    where
515        S: Serializer,
516    {
517        i64::from(*self).serialize(serializer)
518    }
519}
520
521impl<'de> Deserialize<'de> for RegisteredPoStProof {
522    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
523    where
524        D: Deserializer<'de>,
525    {
526        let val = i64::deserialize(deserializer)?;
527        Ok(Self::from(val))
528    }
529}
530
531impl Serialize for RegisteredSealProof {
532    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
533    where
534        S: Serializer,
535    {
536        i64::from(*self).serialize(serializer)
537    }
538}
539
540impl<'de> Deserialize<'de> for RegisteredSealProof {
541    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
542    where
543        D: Deserializer<'de>,
544    {
545        let val = i64::deserialize(deserializer)?;
546        Ok(Self::from(val))
547    }
548}
549
550impl Serialize for RegisteredAggregateProof {
551    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
552    where
553        S: Serializer,
554    {
555        i64::from(*self).serialize(serializer)
556    }
557}
558
559impl<'de> Deserialize<'de> for RegisteredAggregateProof {
560    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
561    where
562        D: Deserializer<'de>,
563    {
564        let val = i64::deserialize(deserializer)?;
565        Ok(Self::from(val))
566    }
567}
568
569impl Serialize for RegisteredUpdateProof {
570    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
571    where
572        S: Serializer,
573    {
574        i64::from(*self).serialize(serializer)
575    }
576}
577
578impl<'de> Deserialize<'de> for RegisteredUpdateProof {
579    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
580    where
581        D: Deserializer<'de>,
582    {
583        let val = i64::deserialize(deserializer)?;
584        Ok(Self::from(val))
585    }
586}
fvm_shared/sector/registered_proof.rs

fvm_shared/sector/
registered_proof.rs
