Download sprout parameters in zcash_proofs

zcash_proofs/Cargo.toml

@@ -40,7 +40,7 @@ pprof = { version = "0.8", features = ["criterion", "flamegraph"] } # MSRV 1.56
 [features]
 default = ["local-prover", "multicore"]
 bundled-prover = ["wagyu-zcash-parameters"]
-download-params = ["minreq"]
+download-params = ["minreq", "directories"]
 local-prover = ["directories"]
 multicore = ["bellman/multicore"]
 
@@ -60,5 +60,9 @@ required-features = ["directories"]
 name = "download-params"
 required-features = ["download-params"]
 
+[[example]]
+name = "download-sprout-and-sapling-params"
+required-features = ["download-params"]
+
 [badges]
 maintenance = { status = "actively-developed" }

zcash_proofs/examples/download-params.rs

@@ -1,3 +1,4 @@
 fn main() -> Result<(), minreq::Error> {
+    #[allow(deprecated)]
     zcash_proofs::download_parameters()
 }

zcash_proofs/examples/download-sprout-and-sapling-params.rs

@@ -0,0 +1,26 @@
+fn main() -> Result<(), minreq::Error> {
+    const DOWNLOAD_TIMEOUT_SECONDS: u64 = 3600;
+
+    #[allow(unused_mut, unused_assignments)]
+    let mut params_folder =
+        zcash_proofs::default_params_folder().expect("unexpected missing HOME env var");
+
+    // Always do a download to /tmp, if compiled with `RUSTFLAGS="--cfg always_download"`
+    #[cfg(always_download)]
+    {
+        std::env::set_var("HOME", "/tmp");
+        params_folder =
+            zcash_proofs::default_params_folder().expect("unexpected missing HOME env var");
+
+        println!("removing temporary parameters folder: {:?}", params_folder);
+        let _ = std::fs::remove_dir_all(&params_folder);
+    }
+
+    println!("downloading sapling parameters to: {:?}", params_folder);
+    zcash_proofs::download_sapling_parameters(Some(DOWNLOAD_TIMEOUT_SECONDS))?;
+
+    println!("downloading sprout parameters to: {:?}", params_folder);
+    zcash_proofs::download_sprout_parameters(Some(DOWNLOAD_TIMEOUT_SECONDS))?;
+
+    Ok(())
+}

zcash_proofs/src/downloadreader.rs

@@ -0,0 +1,79 @@
+//! [`io::Read`] implementations for [`minreq`].
+
+use std::io;
+
+/// A wrapper that implements [`io::Read`] on a [`minreq::ResponseLazy`].
+pub enum ResponseLazyReader {
+    Request(minreq::Request),
+    Response(minreq::ResponseLazy),
+    Complete(Result<(), String>),
+}
+
+impl From<minreq::Request> for ResponseLazyReader {
+    fn from(request: minreq::Request) -> ResponseLazyReader {
+        ResponseLazyReader::Request(request)
+    }
+}
+
+impl From<minreq::ResponseLazy> for ResponseLazyReader {
+    fn from(response: minreq::ResponseLazy) -> ResponseLazyReader {
+        ResponseLazyReader::Response(response)
+    }
+}
+
+impl io::Read for ResponseLazyReader {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        use ResponseLazyReader::{Complete, Request, Response};
+
+        // Zero-sized buffer. This should never happen.
+        if buf.is_empty() {
+            return Ok(0);
+        }
+
+        loop {
+            match self {
+                // Launch a lazy response for this request
+                Request(request) => match request.clone().send_lazy() {
+                    Ok(response) => *self = Response(response),
+                    Err(error) => {
+                        let error = Err(format!("download request failed: {:?}", error));
+
+                        *self = Complete(error);
+                    }
+                },
+
+                // Read from the response
+                Response(response) => {
+                    // minreq has a very limited lazy reading interface.
+                    match &mut response.next() {
+                        // Read one byte into the buffer.
+                        // We ignore the expected length, because we have no way of telling the BufReader.
+                        Some(Ok((byte, _length))) => {
+                            buf[0] = *byte;
+                            return Ok(1);
+                        }
+
+                        // Reading failed.
+                        Some(Err(error)) => {
+                            let error = Err(format!("download response failed: {:?}", error));
+
+                            *self = Complete(error);
+                        }
+
+                        // Finished reading.
+                        None => *self = Complete(Ok(())),
+                    }
+                }
+
+                Complete(result) => {
+                    return match result {
+                        // Return a zero-byte read for download success and EOF.
+                        Ok(()) => Ok(0),
+                        // Keep returning the download error,
+                        Err(error) => Err(io::Error::new(io::ErrorKind::Other, error.clone())),
+                    };
+                }
+            }
+        }
+    }
+}

zcash_proofs/src/hashreader.rs

@@ -1,10 +1,15 @@
+use std::{
+    fmt::Write,
+    io::{self, Read},
+};
+
 use blake2b_simd::State;
-use std::io::{self, Read};
 
 /// Abstraction over a reader which hashes the data being read.
 pub struct HashReader<R: Read> {
     reader: R,
     hasher: State,
+    byte_count: usize,
 }
 
 impl<R: Read> HashReader<R> {
@@ -13,6 +18,7 @@ impl<R: Read> HashReader<R> {
         HashReader {
             reader,
             hasher: State::new(),
+            byte_count: 0,
         }
     }
 
@@ -22,11 +28,16 @@ impl<R: Read> HashReader<R> {
 
         let mut s = String::new();
         for c in hash.as_bytes().iter() {
-            s += &format!("{:02x}", c);
+            write!(&mut s, "{:02x}", c).expect("writing to a string never fails");
         }
 
         s
     }
+
+    /// Return the number of bytes read so far.
+    pub fn byte_count(&self) -> usize {
+        self.byte_count
+    }
 }
 
 impl<R: Read> Read for HashReader<R> {
@@ -35,6 +46,7 @@ impl<R: Read> Read for HashReader<R> {
 
         if bytes > 0 {
             self.hasher.update(&buf[0..bytes]);
+            self.byte_count += bytes;
         }
 
         Ok(bytes)