chore: adapt to MMR::verify() return value change

Adapts neptune-core to a breaking change in twenty-first
2a331dd3267f53d04b3669d47eb0b54f04092e54

Cargo.toml

@@ -122,8 +122,8 @@ harness = false
 
 
 [patch.crates-io]
-# 15a708cf6fcbd9ed3e65e5e2067be6e622176328 is tip of branch: make_storage_async as of 2024-03-18
-tasm-lib = { git = "https://github.com/TritonVM/tasm-lib.git", rev = "0591f8eab9b5d86380afdcd422d77dfeaacc5870" }
+# 9478e0dbb70ae0795878d0402c8169c70df90485 is tip of branch: master as of 2024-04-22
+tasm-lib = { git = "https://github.com/TritonVM/tasm-lib.git", rev = "9478e0dbb70ae0795878d0402c8169c70df90485" }
 
-# 81573735e9df4836ca16655fd31884271984bac7 = tip of branch: make_storage_async on 2024-03-18
-# twenty-first = { git = "https://github.com/Neptune-Crypto/twenty-first.git", rev = "81573735e9df4836ca16655fd31884271984bac7" }
+# 2a331dd3267f53d04b3669d47eb0b54f04092e54 = tip of branch: master,  on 2024-04-22
+twenty-first = { git = "https://github.com/Neptune-Crypto/twenty-first.git", rev = "2a331dd3267f53d04b3669d47eb0b54f04092e54" }

src/models/blockchain/block/mod.rs

@@ -784,7 +784,7 @@ mod block_tests {
         let index = thread_rng().gen_range(0..blocks.len() - 1);
         let block_digest = blocks[index].hash();
         let membership_proof = ammr.prove_membership_async(index as u64).await;
-        let (v, _) = membership_proof.verify(
+        let v = membership_proof.verify(
             &last_block_mmra.get_peaks(),
             block_digest,
             last_block_mmra.count_leaves(),

src/models/blockchain/transaction/validity/removal_records_integrity.rs

@@ -303,7 +303,7 @@ impl RemovalRecordsIntegrityWitness {
             for (&(leaf, _mt_index, _original_index), mp) in
                 leafs_and_mt_indices.iter().zip(membership_proofs.iter())
             {
-                assert!(mp.verify(&dummy_peaks, leaf, leaf_count).0);
+                assert!(mp.verify(&dummy_peaks, leaf, leaf_count));
             }
 
             // collect membership proofs in vector, with indices matching those of the supplied leafs
@@ -318,7 +318,7 @@ impl RemovalRecordsIntegrityWitness {
 
         // sanity check
         for (&leaf, mp) in leafs.iter().zip(mps.iter()) {
-            assert!(mp.verify(&mmra.get_peaks(), leaf, mmra.count_leaves()).0);
+            assert!(mp.verify(&mmra.get_peaks(), leaf, mmra.count_leaves()));
         }
 
         (mmra, mps)
@@ -359,7 +359,7 @@ impl<'a> Arbitrary<'a> for RemovalRecordsIntegrityWitness {
 
         for (mp, &cc) in mmr_mps.iter().zip_eq(canonical_commitments.iter()) {
             assert!(
-                mp.verify(&aocl.get_peaks(), cc, aocl.count_leaves()).0,
+                mp.verify(&aocl.get_peaks(), cc, aocl.count_leaves()),
                 "Returned MPs must be valid for returned AOCL"
             );
         }

src/models/blockchain/transaction/validity/tasm/removal_records_integrity.rs

@@ -168,7 +168,6 @@ impl CompiledProgram for RemovalRecordsIntegrity {
                     cc.canonical_commitment,
                     removal_record_integrity_witness.aocl.count_leaves(),
                 )
-                .0
             }));
 
         Ok(vec![])

src/models/blockchain/transaction/validity/tasm/verify_aocl_membership.rs

@@ -182,7 +182,7 @@ mod tests {
             );
 
             // verify
-            let validation_result = memproof.auth_path_aocl.verify(&peaks, leaf, leaf_count).0;
+            let validation_result = memproof.auth_path_aocl.verify(&peaks, leaf, leaf_count);
             println!("RS validation_result: {validation_result}");
 
             // repopulate stack

src/tests/shared.rs

@@ -471,7 +471,7 @@ pub fn pseudorandom_removal_record_integrity_witness(
 
     for (mp, &cc) in mmr_mps.iter().zip_eq(canonical_commitments.iter()) {
         assert!(
-            mp.verify(&aocl.get_peaks(), cc, aocl.count_leaves()).0,
+            mp.verify(&aocl.get_peaks(), cc, aocl.count_leaves()),
             "Returned MPs must be valid for returned AOCL"
         );
     }

src/util_types/mutator_set/archival_mmr.rs

@@ -447,13 +447,11 @@ pub(crate) mod mmr_test {
             "accumulator and archival membership proofs must agree"
         );
         assert!(
-            archival_membership_proof
-                .verify(
-                    &archival_mmr.get_peaks().await,
-                    new_leaf,
-                    archival_mmr.count_leaves().await
-                )
-                .0,
+            archival_membership_proof.verify(
+                &archival_mmr.get_peaks().await,
+                new_leaf,
+                archival_mmr.count_leaves().await
+            ),
             "membership proof from arhival MMR must validate"
         );
     }
@@ -477,32 +475,24 @@ pub(crate) mod mmr_test {
 
         // Verify that the accumulated hash in the verifier is compared against the **correct** hash,
         // not just **any** hash in the peaks list.
-        assert!(membership_proof.verify(&peaks, leaf_hashes[0], 3,).0);
+        assert!(membership_proof.verify(&peaks, leaf_hashes[0], 3,));
         membership_proof.leaf_index = 2;
-        assert!(!membership_proof.verify(&peaks, leaf_hashes[0], 3,).0);
+        assert!(!membership_proof.verify(&peaks, leaf_hashes[0], 3,));
         membership_proof.leaf_index = 0;
 
         // verify the same behavior in the accumulator MMR
         let accumulator_mmr = MmrAccumulator::<H>::new(leaf_hashes.clone());
-        assert!(
-            membership_proof
-                .verify(
-                    &accumulator_mmr.get_peaks(),
-                    leaf_hashes[0],
-                    accumulator_mmr.count_leaves()
-                )
-                .0
-        );
+        assert!(membership_proof.verify(
+            &accumulator_mmr.get_peaks(),
+            leaf_hashes[0],
+            accumulator_mmr.count_leaves()
+        ));
         membership_proof.leaf_index = 2;
-        assert!(
-            !membership_proof
-                .verify(
-                    &accumulator_mmr.get_peaks(),
-                    leaf_hashes[0],
-                    accumulator_mmr.count_leaves()
-                )
-                .0
-        );
+        assert!(!membership_proof.verify(
+            &accumulator_mmr.get_peaks(),
+            leaf_hashes[0],
+            accumulator_mmr.count_leaves()
+        ));
     }
 
     #[tokio::test]
@@ -521,7 +511,7 @@ pub(crate) mod mmr_test {
 
         // Verify single leaf
 
-        let (mp1_verifies, _acc_hash_1) = mp1.verify(
+        let mp1_verifies = mp1.verify(
             &old_peaks,
             leaf_hashes[leaf_index as usize],
             leaf_count as u64,
@@ -559,15 +549,14 @@ pub(crate) mod mmr_test {
         assert_eq!(expected_num_peaks, new_peaks_two.len());
         assert_eq!(expected_num_peaks, old_peaks.len());
 
-        let (mp2_verifies_non_mutated_leaf, _acc_hash_3) = mp2.verify(
+        let mp2_verifies_non_mutated_leaf = mp2.verify(
             &new_peaks_two,
             leaf_hashes[leaf_index as usize],
             leaf_count as u64,
         );
         assert!(!mp2_verifies_non_mutated_leaf);
 
-        let (mp2_verifies_mutated_leaf, _acc_hash_4) =
-            mp2.verify(&new_peaks_two, mutated_leaf, leaf_count as u64);
+        let mp2_verifies_mutated_leaf = mp2.verify(&new_peaks_two, mutated_leaf, leaf_count as u64);
         assert!(mp2_verifies_mutated_leaf);
 
         // Create a new archival MMR with the same leaf hashes as in the
@@ -754,15 +743,11 @@ pub(crate) mod mmr_test {
                     accumulator_membership_proof, archival_membership_proof,
                     "membership proofs from append operation must agree"
                 );
-                assert!(
-                    archival_membership_proof
-                        .verify(
-                            &archival_iterative.get_peaks().await,
-                            leaf_hash,
-                            archival_iterative.count_leaves().await
-                        )
-                        .0
-                );
+                assert!(archival_membership_proof.verify(
+                    &archival_iterative.get_peaks().await,
+                    leaf_hash,
+                    archival_iterative.count_leaves().await
+                ));
 
                 // Verify that membership proofs are the same as generating them from an archival MMR
                 let archival_membership_proof_direct = archival_iterative
@@ -821,8 +806,7 @@ pub(crate) mod mmr_test {
             let peaks = mmr.get_peaks().await;
             let membership_proof = mmr.prove_membership_async(leaf_index).await;
             let valid_res = membership_proof.verify(&peaks, input_hash, 1);
-            assert!(valid_res.0);
-            assert!(valid_res.1.is_some());
+            assert!(valid_res);
         }
 
         mmr.append(new_input_hash).await;
@@ -894,18 +878,14 @@ pub(crate) mod mmr_test {
             let peaks = mmr.get_peaks().await;
             let mut membership_proof = mmr.prove_membership_async(leaf_index as u64).await;
 
-            let (mp_verifies_1, acc_hash_1) =
-                membership_proof.verify(&peaks, input_digest, num_leaves);
+            let mp_verifies_1 = membership_proof.verify(&peaks, input_digest, num_leaves);
             assert!(mp_verifies_1);
-            assert!(acc_hash_1.is_some());
 
             // Negative test for verify membership
             membership_proof.leaf_index += 1;
 
-            let (mp_verifies_2, acc_hash_2) =
-                membership_proof.verify(&peaks, input_digest, num_leaves);
+            let mp_verifies_2 = membership_proof.verify(&peaks, input_digest, num_leaves);
             assert!(!mp_verifies_2);
-            assert!(acc_hash_2.is_none());
         }
 
         let new_leaf_hash: Digest = H::hash(&BFieldElement::new(201));
@@ -972,17 +952,15 @@ pub(crate) mod mmr_test {
                 let valid_res =
                     membership_proof.verify(&peaks, input_hashes[index as usize], leaf_count);
 
-                assert!(valid_res.0);
-                assert!(valid_res.1.is_some());
+                assert!(valid_res);
             }
 
             // // Make a new MMR where we append with a value and run the verify_append
             let new_leaf_hash = H::hash(&BFieldElement::new(201));
             let orignal_peaks = mmr.get_peaks().await;
             let mp = mmr.append(new_leaf_hash).await;
             assert!(
-                mp.verify(&mmr.get_peaks().await, new_leaf_hash, leaf_count + 1)
-                    .0,
+                mp.verify(&mmr.get_peaks().await, new_leaf_hash, leaf_count + 1),
                 "Returned membership proof from append must verify"
             );
             assert_ne!(
@@ -1097,8 +1075,7 @@ pub(crate) mod mmr_test {
                 let mut membership_proof = mmr.prove_membership_async(leaf_index).await;
                 let valid_res =
                     membership_proof.verify(&peaks, input_digests[leaf_index as usize], size);
-                assert!(valid_res.0);
-                assert!(valid_res.1.is_some());
+                assert!(valid_res);
 
                 let new_leaf: Digest = random();
 
@@ -1108,7 +1085,7 @@ pub(crate) mod mmr_test {
                 membership_proof.leaf_index = wrong_leaf_index;
                 assert!(
                     wrong_leaf_index == leaf_index
-                        || !membership_proof.verify(&peaks, new_leaf, size).0
+                        || !membership_proof.verify(&peaks, new_leaf, size)
                 );
                 membership_proof.leaf_index = leaf_index;
 
@@ -1118,15 +1095,15 @@ pub(crate) mod mmr_test {
 
                 let new_peaks = mmr.get_peaks().await;
                 let new_mp = mmr.prove_membership_async(leaf_index).await;
-                assert!(new_mp.verify(&new_peaks, new_leaf, size).0);
-                assert!(!new_mp.verify(&new_peaks, old_leaf, size).0);
+                assert!(new_mp.verify(&new_peaks, new_leaf, size));
+                assert!(!new_mp.verify(&new_peaks, old_leaf, size));
 
                 // Return the element to its former value and run prove/verify for membership
                 mmr.mutate_leaf(leaf_index, old_leaf).await;
                 let old_peaks = mmr.get_peaks().await;
                 let old_mp = mmr.prove_membership_async(leaf_index).await;
-                assert!(!old_mp.verify(&old_peaks, new_leaf, size).0);
-                assert!(old_mp.verify(&old_peaks, old_leaf, size).0);
+                assert!(!old_mp.verify(&old_peaks, new_leaf, size));
+                assert!(old_mp.verify(&old_peaks, old_leaf, size));
             }
 
             // Make a new MMR where we append with a value and run the verify_append

src/util_types/mutator_set/mmra_and_membership_proofs.rs

@@ -128,7 +128,7 @@ impl Arbitrary for MmraAndMembershipProofs {
                 for (mmr_mp, leaf) in membership_proofs.iter().zip(leafs.iter()) {
                     let (_mti, _pi) =
                         leaf_index_to_mt_index_and_peak_index(mmr_mp.leaf_index, total_leaf_count);
-                    assert!(mmr_mp.verify(&peaks, *leaf, total_leaf_count).0);
+                    assert!(mmr_mp.verify(&peaks, *leaf, total_leaf_count));
                 }
 
                 MmraAndMembershipProofs {
@@ -174,14 +174,11 @@ mod test {
             .into_iter()
             .zip(mmra_and_membership_proofs.membership_proofs)
         {
-            prop_assert!(
-                mp.verify(
-                    &mmra_and_membership_proofs.mmra.get_peaks(),
-                    leaf,
-                    mmra_and_membership_proofs.mmra.count_leaves(),
-                )
-                .0
-            );
+            prop_assert!(mp.verify(
+                &mmra_and_membership_proofs.mmra.get_peaks(),
+                leaf,
+                mmra_and_membership_proofs.mmra.count_leaves(),
+            ));
         }
     }
 }

src/util_types/mutator_set/msa_and_records.rs

@@ -213,7 +213,7 @@ impl Arbitrary for MsaAndRecords {
                                     .zip(personalized_chunk_dictionaries.iter())
                                     .map(|(((item, sender_randomness, receiver_preimage), aocl_auth_path), target_chunks)| {
                                         let leaf = commit(*item, *sender_randomness, receiver_preimage.hash::<Hash>()).canonical_commitment;
-                                        assert!(aocl_auth_path.verify(&aocl_mmra.get_peaks(), leaf, aocl_mmra.count_leaves()).0);
+                                        assert!(aocl_auth_path.verify(&aocl_mmra.get_peaks(), leaf, aocl_mmra.count_leaves()));
                                         (((item, sender_randomness, receiver_preimage), aocl_auth_path), target_chunks)
                                     })
                                     .map(

src/util_types/mutator_set/mutator_set_accumulator.rs

@@ -250,7 +250,7 @@ impl MutatorSetAccumulator {
                 Digest::new([BFieldElement::zero(); DIGEST_LENGTH]),
             ),
         );
-        let (is_aocl_member, _) = membership_proof.auth_path_aocl.verify(
+        let is_aocl_member = membership_proof.auth_path_aocl.verify(
             &self.aocl.get_peaks(),
             leaf,
             self.aocl.count_leaves(),
@@ -294,7 +294,7 @@ impl MutatorSetAccumulator {
                     .dictionary
                     .get(&chunk_index)
                     .unwrap();
-                let (valid_auth_path, _) = mp_and_chunk.0.verify(
+                let valid_auth_path = mp_and_chunk.0.verify(
                     &self.swbf_inactive.get_peaks(),
                     Hash::hash(&mp_and_chunk.1),
                     self.swbf_inactive.count_leaves(),

src/util_types/mutator_set/removal_record.rs

@@ -286,9 +286,7 @@ impl RemovalRecord {
             .all(|(_i, (proof, chunk))| {
                 let leaf_digest = Hash::hash(chunk);
                 let leaf_count = mutator_set.swbf_inactive.count_leaves();
-                let (verified, _final_state) = proof.verify(&peaks, leaf_digest, leaf_count);
-
-                verified
+                proof.verify(&peaks, leaf_digest, leaf_count)
             })
     }