Feature-gate all code in ironfish-rust that requires Sapling parameters

This commit adds a new `transaction-proofs` Cargo feature (enabled by
default) to the `ironfish-rust` crate. When this feature is disabled,
all the structs and methods that create or verify zero-knowledge proofs
are also disabled, hence making the Sapling parameters not needed.

This way, developers have an option to use some of the `ironfish-rust`
features (like transaction decryption) without having to deploy the
Sapling parameters, which are several MBs in size.

When `transaction-proofs` is disabled, all the transaction builder
structs (like `ProposedTransaction`, `SpendBuilder, `OutputBuilder`,
`MintBuilder`, ...) and related methods are unavailable, because those
structs/methods all generate proofs.

This commit also cleans up and reorganizes some code, in particular:

* renamed the `ironfish::transaction::utils` module to
  `ironfish::transaction::verify`, because this module only contains
  methods for verification;
* moved some of the transaction verification methods from
  `ironfish::transaction` to `ironfish::transaction::verify`;
* moved `ProposedTransaction` to a dedicated submodule;

Author: andiflabs

ironfish-rust/Cargo.toml

@@ -24,9 +24,12 @@ workspace = true
 workspace = true
 
 [features]
+default = ["transaction-proofs"]
+
 benchmark = []
 download-params = ["dep:reqwest"]
 note-encryption-stats = []
+transaction-proofs = []
 
 [lib]
 name = "ironfish"

ironfish-rust/src/lib.rs

@@ -14,32 +14,35 @@ pub mod mining;
 pub mod nacl;
 pub mod note;
 pub mod rolling_filter;
-pub mod sapling_bls12;
 pub mod serializing;
 pub mod signal_catcher;
 pub mod transaction;
 pub mod util;
 pub mod witness;
 pub mod xchacha20poly1305;
 
+#[cfg(any(test, feature = "benchmark"))]
+pub mod test_util;
+
+#[cfg(feature = "transaction-proofs")]
+pub mod sapling_bls12;
+
 pub use {
     ironfish_frost::frost,
     ironfish_frost::participant,
     keys::{IncomingViewKey, OutgoingViewKey, PublicAddress, SaplingKey, ViewKey},
     merkle_note::MerkleNote,
     merkle_note_hash::MerkleNoteHash,
     note::Note,
-    transaction::{
-        outputs::OutputDescription, spends::SpendDescription, ProposedTransaction, Transaction,
-    },
+    transaction::{outputs::OutputDescription, spends::SpendDescription, Transaction},
 };
 
-#[cfg(any(test, feature = "benchmark"))]
-pub mod test_util;
-
 #[cfg(feature = "benchmark")]
 pub use ironfish_zkp::primitives::ValueCommitment;
 
+#[cfg(feature = "transaction-proofs")]
+pub use transaction::ProposedTransaction;
+
 // The main entry-point to the sapling API. Construct this with loaded parameters, and then call
 // methods on it to do the actual work.
 //
@@ -57,6 +60,7 @@ pub struct Sapling {
     pub mint_verifying_key: groth16::PreparedVerifyingKey<Bls12>,
 }
 
+#[cfg(feature = "transaction-proofs")]
 impl Sapling {
     /// Initialize a Sapling instance and prepare for proving. Load the parameters from files
     /// at a known location (`$OUT_DIR/sapling_params`).

ironfish-rust/src/merkle_note.rs

@@ -2,31 +2,29 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+//! Implement a merkle note to store all the values that need to go into a merkle tree.
+//! A tree containing these values can serve as a snapshot of the entire chain.
+
 use crate::{
     errors::IronfishError,
     keys::EphemeralKeyPair,
-    serializing::{read_point, read_point_unchecked},
-};
-
-/// Implement a merkle note to store all the values that need to go into a merkle tree.
-/// A tree containing these values can serve as a snapshot of the entire chain.
-use super::{
     keys::{shared_secret, IncomingViewKey, OutgoingViewKey, PublicAddress},
     note::{Note, ENCRYPTED_NOTE_SIZE},
     serializing::{aead, read_scalar},
-    witness::{WitnessNode, WitnessTrait},
+    serializing::{read_point, read_point_unchecked},
     MerkleNoteHash,
 };
-
 use blake2b_simd::Params as Blake2b;
 use blstrs::Scalar;
 use ff::PrimeField;
 use group::GroupEncoding;
 use ironfish_jubjub::{ExtendedPoint, SubgroupPoint};
 use ironfish_zkp::primitives::ValueCommitment;
-
 use std::{convert::TryInto, io};
 
+#[cfg(feature = "transaction-proofs")]
+use crate::witness::{WitnessNode, WitnessTrait};
+
 pub const ENCRYPTED_SHARED_KEY_SIZE: usize = 64;
 
 pub const NOTE_ENCRYPTION_KEY_SIZE: usize = ENCRYPTED_SHARED_KEY_SIZE + aead::MAC_SIZE;
@@ -108,6 +106,7 @@ impl MerkleNote {
 
     /// Helper function to instantiate a MerkleNote with pre-set
     /// note_encryption_keys. Should only be used for miners fee transactions.
+    #[cfg(feature = "transaction-proofs")]
     pub(crate) fn new_for_miners_fee(
         note: &Note,
         value_commitment: &ValueCommitment,
@@ -283,6 +282,7 @@ impl MerkleNote {
     }
 }
 
+#[cfg(feature = "transaction-proofs")]
 pub(crate) fn sapling_auth_path(witness: &dyn WitnessTrait) -> Vec<Option<(Scalar, bool)>> {
     let mut auth_path = vec![];
     for element in &witness.get_auth_path() {
@@ -302,6 +302,7 @@ pub(crate) fn sapling_auth_path(witness: &dyn WitnessTrait) -> Vec<Option<(Scala
 /// on an assumption that the tree is complete and binary. And I didn't feel
 /// like making Witness a trait since it's otherwise very simple.
 /// So this hacky function gets to live here.
+#[cfg(feature = "transaction-proofs")]
 pub(crate) fn position(witness: &dyn WitnessTrait) -> u64 {
     let mut pos = 0;
     for (i, element) in witness.get_auth_path().iter().enumerate() {
@@ -460,9 +461,10 @@ mod test {
         );
     }
 
-    #[test]
     /// Test to confirm that creating a [`MerkleNote`] via new_for_miners_note()
     /// does use the hard-coded miners fee note encryption keys
+    #[test]
+    #[cfg(feature = "transaction-proofs")]
     fn test_new_miners_fee_key() {
         let receiver_key = SaplingKey::generate_key();
         let sender_key: SaplingKey = SaplingKey::generate_key();

ironfish-rust/src/transaction/mints.rs

@@ -2,8 +2,13 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use std::io;
-
+use crate::{
+    assets::asset::Asset,
+    errors::{IronfishError, IronfishErrorKind},
+    serializing::read_scalar,
+    transaction::TransactionVersion,
+    PublicAddress, SaplingKey,
+};
 use blstrs::{Bls12, Scalar};
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 use ff::Field;
@@ -12,25 +17,19 @@ use ironfish_bellperson::groth16;
 use ironfish_jubjub::ExtendedPoint;
 use ironfish_zkp::{
     constants::SPENDING_KEY_GENERATOR,
-    proofs::MintAsset,
     redjubjub::{self, Signature},
-    ProofGenerationKey,
 };
 use rand::thread_rng;
+use std::io;
 
-use crate::{
-    assets::asset::Asset,
-    errors::{IronfishError, IronfishErrorKind},
-    sapling_bls12::SAPLING,
-    serializing::read_scalar,
-    transaction::TransactionVersion,
-    PublicAddress, SaplingKey,
-};
-
-use super::utils::verify_mint_proof;
+#[cfg(feature = "transaction-proofs")]
+use crate::{sapling_bls12::SAPLING, transaction::verify::verify_mint_proof};
+#[cfg(feature = "transaction-proofs")]
+use ironfish_zkp::{proofs::MintAsset, ProofGenerationKey};
 
 /// Parameters used to build a circuit that verifies an asset can be minted with
 /// a given key
+#[cfg(feature = "transaction-proofs")]
 pub struct MintBuilder {
     /// Asset to be minted
     pub asset: Asset,
@@ -43,6 +42,7 @@ pub struct MintBuilder {
     pub transfer_ownership_to: Option<PublicAddress>,
 }
 
+#[cfg(feature = "transaction-proofs")]
 impl MintBuilder {
     pub fn new(asset: Asset, value: u64) -> Self {
         Self {
@@ -362,25 +362,25 @@ impl MintDescription {
 }
 
 #[cfg(test)]
+#[cfg(feature = "transaction-proofs")]
 mod test {
-    use ff::Field;
-    use ironfish_zkp::{constants::SPENDING_KEY_GENERATOR, redjubjub};
-    use rand::{random, thread_rng};
-
     use crate::{
         assets::asset::Asset,
         errors::IronfishErrorKind,
         transaction::{
             mints::{MintBuilder, MintDescription},
-            utils::verify_mint_proof,
+            verify::verify_mint_proof,
             TransactionVersion,
         },
         PublicAddress, SaplingKey,
     };
+    use ff::Field;
+    use ironfish_zkp::{constants::SPENDING_KEY_GENERATOR, redjubjub};
+    use rand::{random, thread_rng};
 
-    #[test]
     /// Test that we can create a builder with a valid asset and proof
     /// generation key
+    #[test]
     fn test_mint_builder() {
         let key = SaplingKey::generate_key();
         let creator = key.public_address();