Replace chain/tx assert macros with helper methods

Address comments from the issuse #2805, drop the 4 macros in favor of plain helper methods.
 - `assert_note_committed!`  -> `MockChain::is_note_committed`
 - `assert_note_unspent!`    -> `MockChain::is_note_unspent`
 - `assert_note_consumed!`   -> `MockChain::is_note_consumed`
 - `assert_note_consumed_by!` -> `ExecutedTransaction::consumes_note`

Keep `assert_note_created!` since it does spec matching with optional fields.

Author: marijamijailovic

crates/miden-protocol/src/testing/tx.rs

@@ -1,3 +1,4 @@
+use crate::note::NoteId;
 use crate::transaction::ExecutedTransaction;
 
 impl ExecutedTransaction {
@@ -9,4 +10,9 @@ impl ExecutedTransaction {
             self.block_header().fee_parameters().verification_base_fee() * verification_cycles;
         fee_amount as u64
     }
+
+    /// Returns `true` if the transaction consumes the note with the given ID.
+    pub fn consumes_note(&self, note_id: &NoteId) -> bool {
+        self.input_notes().iter().any(|n| n.id() == *note_id)
+    }
 }

crates/miden-testing/src/asserts.rs

@@ -0,0 +1,112 @@
+//! Assertion macro for note-lifecycle checks in tests.
+
+use alloc::vec::Vec;
+
+use miden_protocol::account::AccountId;
+use miden_protocol::asset::Asset;
+use miden_protocol::note::NoteType;
+use miden_protocol::transaction::ExecutedTransaction;
+
+/// Spec for [`assert_note_created!`]. Fields left as `None` are skipped.
+#[doc(hidden)]
+#[derive(Default, Debug, Clone)]
+pub struct OutputNoteSpec {
+    pub note_type: Option<NoteType>,
+    pub sender: Option<AccountId>,
+    pub assets: Option<Vec<Asset>>,
+}
+
+/// Returns `true` if at least one output note in `tx` matches `spec`.
+#[doc(hidden)]
+pub fn check_output_note_created(tx: &ExecutedTransaction, spec: &OutputNoteSpec) -> bool {
+    tx.output_notes().iter().any(|note| {
+        if let Some(expected) = spec.note_type
+            && note.metadata().note_type() != expected
+        {
+            return false;
+        }
+        if let Some(expected) = spec.sender
+            && note.metadata().sender() != expected
+        {
+            return false;
+        }
+        if let Some(expected) = spec.assets.as_ref() {
+            let actual = note.assets();
+            if actual.num_assets() != expected.len() {
+                return false;
+            }
+            // Each actual matches at most once (otherwise [A,A] would match [A,B]).
+            let mut consumed = vec![false; expected.len()];
+            let matched = expected.iter().all(|exp| {
+                let slot = actual.iter().enumerate().find(|(i, a)| !consumed[*i] && *a == exp);
+                if let Some((i, _)) = slot {
+                    consumed[i] = true;
+                    true
+                } else {
+                    false
+                }
+            });
+            if !matched {
+                return false;
+            }
+        }
+        true
+    })
+}
+
+/// Asserts the tx emitted a note matching the spec. Fields are optional; unset ones are skipped.
+///
+/// # Example
+/// ```ignore
+/// use miden_testing::assert_note_created;
+/// use miden_protocol::note::NoteType;
+///
+/// assert_note_created!(
+///     executed_tx,
+///     note_type: NoteType::Public,
+///     sender: faucet.id(),
+///     assets: [FungibleAsset::new(faucet.id(), amount)?.into()],
+/// );
+/// ```
+#[macro_export]
+macro_rules! assert_note_created {
+    ($tx:expr $(, $key:ident : $val:expr)* $(,)?) => {{
+        #[allow(unused_mut)]
+        let mut spec = $crate::asserts::OutputNoteSpec::default();
+        $(
+            $crate::__assert_note_created_field!(spec, $key, $val);
+        )*
+        let tx: &::miden_protocol::transaction::ExecutedTransaction = &$tx;
+        assert!(
+            $crate::asserts::check_output_note_created(tx, &spec),
+            "no output note matches spec: {:?}\n  tx produced {} output note(s)",
+            spec,
+            tx.output_notes().num_notes(),
+        );
+    }};
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __assert_note_created_field {
+    ($spec:ident,note_type, $val:expr) => {
+        $spec.note_type = ::core::option::Option::Some($val);
+    };
+    ($spec:ident,sender, $val:expr) => {
+        $spec.sender = ::core::option::Option::Some($val);
+    };
+    ($spec:ident,assets, $val:expr) => {
+        $spec.assets = ::core::option::Option::Some(
+            ::core::iter::IntoIterator::into_iter($val)
+                .map(::core::convert::Into::into)
+                .collect::<::alloc::vec::Vec<::miden_protocol::asset::Asset>>(),
+        );
+    };
+    ($spec:ident, $key:ident, $val:expr) => {
+        ::core::compile_error!(concat!(
+            "unknown field in assert_note_created!: `",
+            stringify!($key),
+            "`. Supported fields: note_type, sender, assets",
+        ));
+    };
+}