feat: update to v19 params and new porep

* feat: update to v18 params and new porep
* refactor: update dependencies and remove once_cell
* update cbindgen and switch fil_logger
* update to v19 params

Author: dignifiedquire

.circleci/config.yml

@@ -166,7 +166,7 @@ commands:
     steps:
       - run:
           name: Obtain filecoin groth parameters
-          command: ./paramcache --params-for-sector-sizes=1024
+          command: ./paramcache --params-for-sector-sizes='1024'
           no_output_timeout: 60m
   build_project:
     steps:
@@ -177,7 +177,7 @@ commands:
           name: Ensure paramcache is installed to project root
           command: |
             test -f ./paramcache \
-              || (rustup run --install nightly cargo install filecoin-proofs --force --git=https://github.com/filecoin-project/rust-fil-proofs.git --branch=bugs/v17-manifest --bin=paramcache --root=./ \
+              || (rustup run --install nightly cargo install filecoin-proofs --force --git=https://github.com/filecoin-project/rust-fil-proofs.git --branch=master --bin=paramcache --root=./ \
                 && mv ./bin/paramcache ./paramcache)
           no_output_timeout: 60m
   build_and_run_tests:
@@ -195,10 +195,10 @@ commands:
     steps:
       - restore_cache:
           keys:
-            - v17b-proof-params-{{ arch }}
+            - v19-proof-params-{{ arch }}
   save_parameter_cache:
     steps:
       - save_cache:
-          key: v17b-proof-params-{{ arch }}
+          key: v19-proof-params-{{ arch }}
           paths:
             - "~/filecoin-proof-parameters/"

rust/Cargo.lock

@@ -18,19 +18,18 @@ storage-proofs = { git = "https://github.com/filecoin-project/rust-fil-proofs.gi
 bls-signatures = { git = "https://github.com/filecoin-project/bls-signatures.git", branch = "master" }
 byteorder = "1.2"
 drop_struct_macro_derive = "0.4.0"
-failure = "0.1.5"
-ff = "0.4"
+ff = "0.5"
 ffi-toolkit = "0.4.0"
 libc = "0.2.58"
 log = "0.4.7"
-once_cell = "0.2.4"
 paired = "0.16.0"
-pretty_env_logger = "0.3.0"
-rand = "0.4"
+fil_logger = "0.1.0"
+rand = "0.7"
 rayon = "1"
+anyhow = "1.0.23"
 
 [build-dependencies]
-cbindgen = "0.9"
+cbindgen = "0.10"
 
 [dev-dependencies]
 tempfile = "3.0.8"

rust/Cargo.toml

@@ -1,14 +1,14 @@
 use std::slice::from_raw_parts;
 
 use bls_signatures::{
-    aggregate as aggregate_sig, hash as hash_sig,
+    aggregate as aggregate_sig,
+    groupy::{CurveAffine, CurveProjective, EncodedPoint, GroupDecodingError},
+    hash as hash_sig,
     paired::bls12_381::{G2Affine, G2Compressed},
-    paired::GroupDecodingError,
-    paired::{CurveAffine, CurveProjective, EncodedPoint},
     verify as verify_sig, PrivateKey, PublicKey, Serialize, Signature,
 };
 use libc;
-use rand::OsRng;
+use rand::rngs::OsRng;
 
 use rayon::prelude::*;
 
@@ -161,10 +161,8 @@ pub unsafe extern "C" fn verify(
 /// * `raw_seed_ptr` - pointer to a seed byte array
 #[no_mangle]
 pub unsafe extern "C" fn private_key_generate() -> *mut types::PrivateKeyGenerateResponse {
-    let rng = &mut OsRng::new().expect("not enough randomness");
-
     let mut raw_private_key: [u8; PRIVATE_KEY_BYTES] = [0; PRIVATE_KEY_BYTES];
-    PrivateKey::generate(rng)
+    PrivateKey::generate(&mut OsRng)
         .write_bytes(&mut raw_private_key.as_mut())
         .expect("preallocated");
 

rust/src/bls/api.rs

@@ -2,7 +2,7 @@
 #![allow(clippy::missing_safety_doc)]
 
 #[macro_use]
-extern crate failure;
+extern crate anyhow;
 #[macro_use]
 extern crate log;
 

rust/src/lib.rs

@@ -1,5 +1,6 @@
 use std::mem;
 use std::slice::from_raw_parts;
+use std::sync::Once;
 
 use ffi_toolkit::{
     c_str_to_pbuf, catch_panic_response, raw_ptr, rust_str_to_c_str, FCPResponseStatus,
@@ -10,7 +11,6 @@ use filecoin_proofs::{
     PoStConfig, SectorClass, SectorSize, UnpaddedByteIndex, UnpaddedBytesAmount,
 };
 use libc;
-use once_cell::sync::OnceCell;
 use storage_proofs::hasher::pedersen::PedersenDomain;
 use storage_proofs::hasher::Domain;
 use storage_proofs::sector::SectorId;
@@ -320,8 +320,11 @@ pub unsafe extern "C" fn verify_seal(
         let porep_bytes = super::helpers::try_into_porep_proof_bytes(proof_ptr, proof_len);
 
         let result = porep_bytes.and_then(|bs| {
-            super::helpers::porep_proof_partitions_try_from_bytes(&bs).and_then(|ppp| {
-                let cfg = api_types::PoRepConfig(api_types::SectorSize(sector_size), ppp);
+            super::helpers::porep_proof_partitions_try_from_bytes(&bs).and_then(|partitions| {
+                let cfg = api_types::PoRepConfig {
+                    sector_size: api_types::SectorSize(sector_size),
+                    partitions,
+                };
 
                 api_fns::verify_seal(
                     cfg,
@@ -419,9 +422,11 @@ pub unsafe extern "C" fn verify_post(
         let result = convert.and_then(|map| {
             let proofs = c_to_rust_proofs(flattened_proofs_ptr, flattened_proofs_len)?;
             let winners = c_to_rust_candidates(winners_ptr, winners_len)?;
-
+            let cfg = api_types::PoStConfig {
+                sector_size: api_types::SectorSize(sector_size),
+            };
             api_fns::verify_post(
-                api_types::PoStConfig(api_types::SectorSize(sector_size)),
+                cfg,
                 randomness,
                 challenge_count,
                 &proofs,
@@ -504,7 +509,10 @@ pub unsafe extern "C" fn generate_data_commitment(
             .collect();
 
         let result = api_fns::compute_comm_d(
-            PoRepConfig(SectorSize(sector_size), PoRepProofPartitions(0)),
+            PoRepConfig {
+                sector_size: SectorSize(sector_size),
+                partitions: PoRepProofPartitions(0),
+            },
             &public_pieces,
         );
 
@@ -545,7 +553,9 @@ pub unsafe extern "C" fn generate_candidates(
 
         let result = to_private_replica_info_map(replicas_ptr, replicas_len).and_then(|rs| {
             api_fns::generate_candidates(
-                PoStConfig(SectorSize(sector_size)),
+                PoStConfig {
+                    sector_size: SectorSize(sector_size),
+                },
                 randomness,
                 challenge_count,
                 &rs,
@@ -603,7 +613,9 @@ pub unsafe extern "C" fn generate_post(
 
         let result = to_private_replica_info_map(replicas_ptr, replicas_len).and_then(|rs| {
             api_fns::generate_post(
-                PoStConfig(SectorSize(sector_size)),
+                PoStConfig {
+                    sector_size: SectorSize(sector_size),
+                },
                 randomness,
                 &rs,
                 c_to_rust_candidates(winners_ptr, winners_len)?,
@@ -718,13 +730,12 @@ pub unsafe extern "C" fn destroy_generate_candidates_response(
 }
 
 /// Protects the init off the logger.
-static LOG_INIT: OnceCell<bool> = OnceCell::new();
+static LOG_INIT: Once = Once::new();
 
 /// Ensures the logger is initialized.
 fn init_log() {
-    LOG_INIT.get_or_init(|| {
-        let _ = pretty_env_logger::try_init_timed();
-        true
+    LOG_INIT.call_once(|| {
+        fil_logger::init();
     });
 }
 
@@ -733,13 +744,14 @@ pub mod tests {
     use std::io::{Read, Seek, SeekFrom, Write};
     use std::os::unix::io::IntoRawFd;
 
+    use anyhow::Result;
     use ffi_toolkit::{c_str_to_rust_str, FCPResponseStatus};
     use rand::{thread_rng, Rng};
 
     use super::*;
 
     #[test]
-    fn test_write_with_and_without_alignment() -> Result<(), failure::Error> {
+    fn test_write_with_and_without_alignment() -> Result<()> {
         // write some bytes to a temp file to be used as the byte source
         let mut rng = thread_rng();
         let buf: Vec<u8> = (0..508).map(|_| rng.gen()).collect();
@@ -802,7 +814,7 @@ pub mod tests {
     }
 
     #[test]
-    fn test_sealing() -> Result<(), failure::Error> {
+    fn test_sealing() -> Result<()> {
         // miscellaneous setup and shared values
         let sector_class = FFISectorClass {
             sector_size: 1024,

rust/src/proofs/api.rs

@@ -1,16 +1,17 @@
 use std::collections::btree_map::BTreeMap;
 use std::slice::from_raw_parts;
 
+use anyhow::Result;
 use ffi_toolkit::{c_str_to_pbuf, c_str_to_rust_str};
 use filecoin_proofs::{constants as api_constants, Commitment, PublicReplicaInfo};
 use filecoin_proofs::{types as api_types, PrivateReplicaInfo};
 use libc;
 use paired::bls12_381::{Bls12, Fr};
+use storage_proofs::election_post::Candidate;
 use storage_proofs::fr32::fr_into_bytes;
 use storage_proofs::sector::SectorId;
 
 use super::types::{FFICandidate, FFIPrivateReplicaInfo};
-use storage_proofs::election_post::Candidate;
 
 /// Produce a map from sector id to replica info by pairing sector ids and
 /// replica commitments (by index in their respective arrays), setting the
@@ -23,7 +24,7 @@ pub unsafe fn to_public_replica_info_map(
     sector_ids_len: libc::size_t,
     flattened_comm_rs_ptr: *const u8,
     flattened_comm_rs_len: libc::size_t,
-) -> super::error::Result<BTreeMap<SectorId, PublicReplicaInfo>> {
+) -> Result<BTreeMap<SectorId, PublicReplicaInfo>> {
     ensure!(!sector_ids_ptr.is_null(), "sector_ids_ptr must not be null");
     ensure!(
         !flattened_comm_rs_ptr.is_null(),
@@ -58,7 +59,7 @@ pub unsafe fn to_public_replica_info_map(
 pub unsafe fn try_into_porep_proof_bytes(
     proof_ptr: *const u8,
     proof_len: libc::size_t,
-) -> super::error::Result<Vec<u8>> {
+) -> Result<Vec<u8>> {
     into_proof_vecs(proof_len, proof_ptr, proof_len)?
         .first()
         .map(Vec::clone)
@@ -89,7 +90,7 @@ pub unsafe fn into_commitments(
 ///
 pub fn porep_proof_partitions_try_from_bytes(
     proof: &[u8],
-) -> super::error::Result<api_types::PoRepProofPartitions> {
+) -> Result<api_types::PoRepProofPartitions> {
     let n = proof.len();
 
     ensure!(
@@ -107,7 +108,7 @@ unsafe fn into_proof_vecs(
     proof_chunk: usize,
     flattened_proofs_ptr: *const u8,
     flattened_proofs_len: libc::size_t,
-) -> super::error::Result<Vec<Vec<u8>>> {
+) -> Result<Vec<Vec<u8>>> {
     ensure!(
         !flattened_proofs_ptr.is_null(),
         "flattened_proofs_ptr must not be a null pointer"
@@ -137,7 +138,7 @@ pub fn bls_12_fr_into_bytes(fr: Fr) -> [u8; 32] {
 pub unsafe fn to_private_replica_info_map(
     replicas_ptr: *const FFIPrivateReplicaInfo,
     replicas_len: libc::size_t,
-) -> super::error::Result<BTreeMap<SectorId, PrivateReplicaInfo>> {
+) -> Result<BTreeMap<SectorId, PrivateReplicaInfo>> {
     ensure!(!replicas_ptr.is_null(), "replicas_ptr must not be null");
 
     from_raw_parts(replicas_ptr, replicas_len)
@@ -168,7 +169,7 @@ pub unsafe fn to_private_replica_info_map(
 pub unsafe fn c_to_rust_candidates(
     winners_ptr: *const FFICandidate,
     winners_len: libc::size_t,
-) -> super::error::Result<Vec<Candidate>> {
+) -> Result<Vec<Candidate>> {
     ensure!(!winners_ptr.is_null(), "winners_ptr must not be null");
 
     from_raw_parts(winners_ptr, winners_len)
@@ -181,7 +182,7 @@ pub unsafe fn c_to_rust_candidates(
 pub unsafe fn c_to_rust_proofs(
     flattened_proofs_ptr: *const u8,
     flattened_proofs_len: libc::size_t,
-) -> super::error::Result<Vec<Vec<u8>>> {
+) -> Result<Vec<Vec<u8>>> {
     ensure!(
         !flattened_proofs_ptr.is_null(),
         "flattened_proof_ptr must not be null"

rust/src/proofs/error.rs

@@ -1,4 +1,3 @@
-mod error;
 mod helpers;
 
 pub mod api;

rust/src/proofs/helpers.rs

@@ -4,6 +4,7 @@ use std::ptr;
 use drop_struct_macro_derive::DropStructMacro;
 use paired::bls12_381::Bls12;
 // `CodeAndMessage` is the trait implemented by `code_and_message_impl`
+use anyhow::Result;
 use ffi_toolkit::{code_and_message_impl, free_c_str, CodeAndMessage, FCPResponseStatus};
 use filecoin_proofs::{Candidate, PieceInfo, SectorClass, UnpaddedBytesAmount};
 use storage_proofs::fr32::bytes_into_fr;
@@ -65,10 +66,10 @@ impl From<FFISectorClass> for SectorClass {
             porep_proof_partitions,
         } = fsc;
 
-        SectorClass(
-            filecoin_proofs::SectorSize(sector_size),
-            filecoin_proofs::PoRepProofPartitions(porep_proof_partitions),
-        )
+        SectorClass {
+            sector_size: filecoin_proofs::SectorSize(sector_size),
+            partitions: filecoin_proofs::PoRepProofPartitions(porep_proof_partitions),
+        }
     }
 }
 
@@ -99,7 +100,7 @@ pub struct FFICandidate {
 }
 
 impl FFICandidate {
-    pub fn try_into_candidate(self) -> Result<Candidate, storage_proofs::error::Error> {
+    pub fn try_into_candidate(self) -> Result<Candidate> {
         let FFICandidate {
             sector_id,
             partial_ticket,