From fe5e89b91b40ae363aaaf47d8374ef7a75f450c3 Mon Sep 17 00:00:00 2001
From: Andrey Khmuro <akhmuro@gmail.com>
Date: Fri, 26 Jun 2026 14:52:47 +0300
Subject: [PATCH 1/5] refactor: use Poseidon2 as a hash function during the
 proving benchmarks

---
 bin/bench-transaction/README.md               |  10 +-
 bin/bench-transaction/bench-tx.json           | 182 +++++++++---------
 .../src/time_counting_benchmarks/prove.rs     |  38 ++--
 crates/miden-tx/src/prover/mod.rs             |   8 +
 4 files changed, 121 insertions(+), 117 deletions(-)

diff --git a/bin/bench-transaction/README.md b/bin/bench-transaction/README.md
index ecca833441..cf8304d91c 100644
--- a/bin/bench-transaction/README.md
+++ b/bin/bench-transaction/README.md
@@ -44,22 +44,24 @@ Each of the above transactions is measured in two groups:
 - Benchmarking the transaction execution and proving.
   For each transaction in this group we measure how much time it takes to execute the transaction and to execute and prove the transaction.
 
+  Notice that the `Poseidon2` hash function is used during the proving process.
+
   This group uses the [Criterion.rs](https://github.com/bheisler/criterion.rs) to collect the elapsed time. Results of this benchmark group are printed to the terminal and look like so:
   ```zsh
-  Execute transaction/Execute transaction which consumes single P2ID note with Falcon signing
+  Execute transaction/single P2ID note (Falcon signing)
                         time:   [7.2611 ms 7.2772 ms 7.2929 ms]
                         change: [−0.9131% −0.5837% −0.3058%] (p = 0.00 < 0.05)
                         Change within noise threshold.
-  Execute transaction/Execute transaction which consumes two P2ID notes
+  Execute transaction/two P2ID notes
                         time:   [8.8279 ms 8.8442 ms 8.8633 ms]
                         change: [−1.2256% −0.7611% −0.3355%] (p = 0.00 < 0.05)
                         Change within noise threshold.
 
-  Execute and prove transaction/Execute and prove transaction which consumes single P2ID note with Falcon signing
+  Execute and prove transaction/single P2ID note (Falcon signing)
                         time:   [698.96 ms 703.92 ms 708.70 ms]
                         change: [−2.3061% −0.4274% +0.9653%] (p = 0.70 > 0.05)
                         No change in performance detected.
-  Execute and prove transaction/Execute and prove transaction which consumes two P2ID notes
+  Execute and prove transaction/two P2ID notes
                         time:   [706.52 ms 710.91 ms 715.66 ms]
                         change: [−7.4641% −5.0278% −2.9437%] (p = 0.00 < 0.05)
                         Performance has improved.
diff --git a/bin/bench-transaction/bench-tx.json b/bin/bench-transaction/bench-tx.json
index e277d65dcf..14c9ab0449 100644
--- a/bin/bench-transaction/bench-tx.json
+++ b/bin/bench-transaction/bench-tx.json
@@ -7,18 +7,18 @@
     },
     "tx_script_processing": 42,
     "epilogue": {
-      "total": 73562,
-      "auth_procedure": 71653,
-      "after_tx_cycles_obtained": 687
+      "total": 73755,
+      "auth_procedure": 71671,
+      "after_tx_cycles_obtained": 0
     },
     "trace": {
-      "core_rows": 79141,
-      "chiplets_rows": 62347,
-      "range_rows": 20451,
+      "core_rows": 79334,
+      "chiplets_rows": 62532,
+      "range_rows": 20439,
       "chiplets_shape": {
-        "hasher_rows": 59264,
-        "bitwise_rows": 696,
-        "memory_rows": 2330,
+        "hasher_rows": 59456,
+        "bitwise_rows": 656,
+        "memory_rows": 2363,
         "kernel_rom_rows": 56,
         "ace_rows": 0
       }
@@ -32,18 +32,18 @@
     },
     "tx_script_processing": 42,
     "epilogue": {
-      "total": 5570,
-      "auth_procedure": 3661,
-      "after_tx_cycles_obtained": 687
+      "total": 5763,
+      "auth_procedure": 3679,
+      "after_tx_cycles_obtained": 0
     },
     "trace": {
-      "core_rows": 11149,
-      "chiplets_rows": 20091,
-      "range_rows": 1281,
+      "core_rows": 11342,
+      "chiplets_rows": 20276,
+      "range_rows": 1229,
       "chiplets_shape": {
-        "hasher_rows": 18640,
-        "bitwise_rows": 696,
-        "memory_rows": 698,
+        "hasher_rows": 18832,
+        "bitwise_rows": 656,
+        "memory_rows": 731,
         "kernel_rom_rows": 56,
         "ace_rows": 0
       }
@@ -58,18 +58,18 @@
     },
     "tx_script_processing": 42,
     "epilogue": {
-      "total": 73510,
-      "auth_procedure": 71627,
-      "after_tx_cycles_obtained": 687
+      "total": 73677,
+      "auth_procedure": 71645,
+      "after_tx_cycles_obtained": 0
     },
     "trace": {
-      "core_rows": 82253,
-      "chiplets_rows": 65149,
-      "range_rows": 20389,
+      "core_rows": 82420,
+      "chiplets_rows": 65286,
+      "range_rows": 20387,
       "chiplets_shape": {
-        "hasher_rows": 61664,
-        "bitwise_rows": 1000,
-        "memory_rows": 2428,
+        "hasher_rows": 61808,
+        "bitwise_rows": 960,
+        "memory_rows": 2461,
         "kernel_rom_rows": 56,
         "ace_rows": 0
       }
@@ -81,143 +81,143 @@
     "note_execution": {},
     "tx_script_processing": 1777,
     "epilogue": {
-      "total": 74817,
-      "auth_procedure": 72000,
-      "after_tx_cycles_obtained": 687
+      "total": 74988,
+      "auth_procedure": 72020,
+      "after_tx_cycles_obtained": 0
     },
     "trace": {
-      "core_rows": 78480,
-      "chiplets_rows": 60946,
-      "range_rows": 20207,
+      "core_rows": 78651,
+      "chiplets_rows": 61243,
+      "range_rows": 20209,
       "chiplets_shape": {
-        "hasher_rows": 57936,
-        "bitwise_rows": 672,
-        "memory_rows": 2281,
+        "hasher_rows": 58240,
+        "bitwise_rows": 632,
+        "memory_rows": 2314,
         "kernel_rom_rows": 56,
         "ace_rows": 0
       }
     }
   },
   "consume CLAIM note (L1 to Miden)": {
-    "prologue": 3121,
+    "prologue": 3311,
     "notes_processing": 28891,
     "note_execution": {
-      "0x3238c24911d58231d7bda2fd3e26eb625c1a21a172f321f1b8b54cd6e9734dda": 28851
+      "0x82ef59cb60ce27ea5d339ef99d79dc2de73a84a6a8d970b8b331874935499d99": 28851
     },
     "tx_script_processing": 42,
     "epilogue": {
-      "total": 5720,
-      "auth_procedure": 1809,
-      "after_tx_cycles_obtained": 687
+      "total": 8668,
+      "auth_procedure": 1836,
+      "after_tx_cycles_obtained": 0
     },
     "trace": {
-      "core_rows": 37818,
-      "chiplets_rows": 45994,
-      "range_rows": 2491,
+      "core_rows": 40956,
+      "chiplets_rows": 46986,
+      "range_rows": 2581,
       "chiplets_shape": {
-        "hasher_rows": 39824,
-        "bitwise_rows": 2752,
-        "memory_rows": 3361,
+        "hasher_rows": 40528,
+        "bitwise_rows": 2712,
+        "memory_rows": 3689,
         "kernel_rom_rows": 56,
         "ace_rows": 0
       }
     }
   },
   "consume CLAIM note (L2 to Miden)": {
-    "prologue": 3121,
+    "prologue": 3311,
     "notes_processing": 41104,
     "note_execution": {
-      "0xc562329e136d746aa2b69fd0c124dede46c35c4afc7df5bda28ad9e040e8d13b": 41064
+      "0x83f11d328db1b05ab00d81399156cd704992135f70fbf4d2716fbd8b6dcf1f87": 41064
     },
     "tx_script_processing": 42,
     "epilogue": {
-      "total": 5720,
-      "auth_procedure": 1809,
-      "after_tx_cycles_obtained": 687
+      "total": 8668,
+      "auth_procedure": 1836,
+      "after_tx_cycles_obtained": 0
     },
     "trace": {
-      "core_rows": 50031,
-      "chiplets_rows": 52200,
-      "range_rows": 2723,
+      "core_rows": 53169,
+      "chiplets_rows": 53192,
+      "range_rows": 2801,
       "chiplets_shape": {
-        "hasher_rows": 44544,
-        "bitwise_rows": 3008,
-        "memory_rows": 4591,
+        "hasher_rows": 45248,
+        "bitwise_rows": 2968,
+        "memory_rows": 4919,
         "kernel_rom_rows": 56,
         "ace_rows": 0
       }
     }
   },
   "consume B2AGG note (bridge-out)": {
-    "prologue": 4042,
+    "prologue": 4232,
     "notes_processing": 115765,
     "note_execution": {
-      "0x834e0fd024a73952937b8b2383b7a6e5dc452397ba7e3bfb100911757f5a392a": 115725
+      "0xf8fd7ccd98de47d014f4b4c0c21612a1e586c2f848b44eb93bc16ff06138c727": 115725
     },
     "tx_script_processing": 42,
     "epilogue": {
-      "total": 15476,
-      "auth_procedure": 1809,
-      "after_tx_cycles_obtained": 687
+      "total": 27509,
+      "auth_procedure": 1836,
+      "after_tx_cycles_obtained": 0
     },
     "trace": {
-      "core_rows": 135369,
-      "chiplets_rows": 165022,
-      "range_rows": 4001,
+      "core_rows": 147592,
+      "chiplets_rows": 169998,
+      "range_rows": 4119,
       "chiplets_shape": {
-        "hasher_rows": 151920,
-        "bitwise_rows": 3464,
-        "memory_rows": 9581,
+        "hasher_rows": 155600,
+        "bitwise_rows": 3424,
+        "memory_rows": 10917,
         "kernel_rom_rows": 56,
         "ace_rows": 0
       }
     }
   },
   "consume B2AGG note (bridge-out, 2^31 leaves)": {
-    "prologue": 4042,
+    "prologue": 4232,
     "notes_processing": 114080,
     "note_execution": {
-      "0x834e0fd024a73952937b8b2383b7a6e5dc452397ba7e3bfb100911757f5a392a": 114040
+      "0xf8fd7ccd98de47d014f4b4c0c21612a1e586c2f848b44eb93bc16ff06138c727": 114040
     },
     "tx_script_processing": 42,
     "epilogue": {
-      "total": 15188,
-      "auth_procedure": 1809,
-      "after_tx_cycles_obtained": 687
+      "total": 26933,
+      "auth_procedure": 1836,
+      "after_tx_cycles_obtained": 0
     },
     "trace": {
-      "core_rows": 133396,
-      "chiplets_rows": 165371,
-      "range_rows": 4019,
+      "core_rows": 145331,
+      "chiplets_rows": 170251,
+      "range_rows": 4099,
       "chiplets_shape": {
-        "hasher_rows": 152400,
-        "bitwise_rows": 3464,
-        "memory_rows": 9450,
+        "hasher_rows": 156016,
+        "bitwise_rows": 3424,
+        "memory_rows": 10754,
         "kernel_rom_rows": 56,
         "ace_rows": 0
       }
     }
   },
   "consume B2AGG note (bridge-out, 2^31-1 leaves)": {
-    "prologue": 4042,
+    "prologue": 4232,
     "notes_processing": 60091,
     "note_execution": {
-      "0x834e0fd024a73952937b8b2383b7a6e5dc452397ba7e3bfb100911757f5a392a": 60051
+      "0xf8fd7ccd98de47d014f4b4c0c21612a1e586c2f848b44eb93bc16ff06138c727": 60051
     },
     "tx_script_processing": 42,
     "epilogue": {
-      "total": 6548,
-      "auth_procedure": 1809,
-      "after_tx_cycles_obtained": 687
+      "total": 9653,
+      "auth_procedure": 1836,
+      "after_tx_cycles_obtained": 0
     },
     "trace": {
-      "core_rows": 70767,
-      "chiplets_rows": 72065,
-      "range_rows": 2801,
+      "core_rows": 74062,
+      "chiplets_rows": 73345,
+      "range_rows": 2839,
       "chiplets_shape": {
-        "hasher_rows": 63024,
-        "bitwise_rows": 3464,
-        "memory_rows": 5520,
+        "hasher_rows": 64000,
+        "bitwise_rows": 3424,
+        "memory_rows": 5864,
         "kernel_rom_rows": 56,
         "ace_rows": 0
       }
diff --git a/bin/bench-transaction/src/time_counting_benchmarks/prove.rs b/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
index 7749bab4bf..a8f720df30 100644
--- a/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
+++ b/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
@@ -19,32 +19,26 @@ use miden_tx::LocalTransactionProver;
 // BENCHMARK NAMES
 // ================================================================================================
 
+// The benchmark labels below deliberately omit the group-name prefix (e.g. "Execute
+// transaction"). Criterion already prints results as `<group>/<label>` and truncates the
+// directory name derived from the label to 64 characters.
 const BENCH_GROUP_EXECUTE: &str = "Execute transaction";
-const BENCH_EXECUTE_TX_CONSUME_SINGLE_P2ID_FALCON: &str =
-    "Execute transaction which consumes single P2ID note with Falcon signing";
-const BENCH_EXECUTE_TX_CONSUME_SINGLE_P2ID_ECDSA: &str =
-    "Execute transaction which consumes single P2ID note with ECDSA signing";
-const BENCH_EXECUTE_TX_CONSUME_TWO_P2ID: &str = "Execute transaction which consumes two P2ID notes";
-const BENCH_EXECUTE_TX_CONSUME_CLAIM_L1: &str =
-    "Execute transaction which consumes CLAIM note (L1 to Miden)";
-const BENCH_EXECUTE_TX_CONSUME_CLAIM_L2: &str =
-    "Execute transaction which consumes CLAIM note (L2 to Miden)";
-const BENCH_EXECUTE_TX_CONSUME_B2AGG: &str =
-    "Execute transaction which consumes B2AGG note (bridge-out)";
+const BENCH_EXECUTE_TX_CONSUME_SINGLE_P2ID_FALCON: &str = "single P2ID note (Falcon signing)";
+const BENCH_EXECUTE_TX_CONSUME_SINGLE_P2ID_ECDSA: &str = "single P2ID note (ECDSA signing)";
+const BENCH_EXECUTE_TX_CONSUME_TWO_P2ID: &str = "two P2ID notes";
+const BENCH_EXECUTE_TX_CONSUME_CLAIM_L1: &str = "CLAIM note (L1 to Miden)";
+const BENCH_EXECUTE_TX_CONSUME_CLAIM_L2: &str = "CLAIM note (L2 to Miden)";
+const BENCH_EXECUTE_TX_CONSUME_B2AGG: &str = "B2AGG note (bridge-out)";
 
 const BENCH_GROUP_EXECUTE_AND_PROVE: &str = "Execute and prove transaction";
 const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_SINGLE_P2ID_FALCON: &str =
-    "Execute and prove transaction which consumes single P2ID note with Falcon signing";
+    "single P2ID note (Falcon signing)";
 const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_SINGLE_P2ID_ECDSA: &str =
-    "Execute and prove transaction which consumes single P2ID note with ECDSA signing";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_TWO_P2ID: &str =
-    "Execute and prove transaction which consumes two P2ID notes";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_CLAIM_L1: &str =
-    "Execute and prove transaction which consumes CLAIM note (L1 to Miden)";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_CLAIM_L2: &str =
-    "Execute and prove transaction which consumes CLAIM note (L2 to Miden)";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_B2AGG: &str =
-    "Execute and prove transaction which consumes B2AGG note (bridge-out)";
+    "single P2ID note (ECDSA signing)";
+const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_TWO_P2ID: &str = "two P2ID notes";
+const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_CLAIM_L1: &str = "CLAIM note (L1 to Miden)";
+const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_CLAIM_L2: &str = "CLAIM note (L2 to Miden)";
+const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_B2AGG: &str = "B2AGG note (bridge-out)";
 
 // CORE PROVING BENCHMARKS
 // ================================================================================================
@@ -215,7 +209,7 @@ fn core_benchmarks(c: &mut Criterion) {
 async fn prove_transaction(executed_transaction: ExecutedTransaction) -> Result<()> {
     let executed_transaction_id = executed_transaction.id();
     let proven_transaction: ProvenTransaction =
-        LocalTransactionProver::default().prove(executed_transaction).await?;
+        LocalTransactionProver::with_poseidon2().prove(executed_transaction).await?;
 
     assert_eq!(proven_transaction.id(), executed_transaction_id);
     Ok(())
diff --git a/crates/miden-tx/src/prover/mod.rs b/crates/miden-tx/src/prover/mod.rs
index afd020e9f9..2c4e96b018 100644
--- a/crates/miden-tx/src/prover/mod.rs
+++ b/crates/miden-tx/src/prover/mod.rs
@@ -12,6 +12,7 @@ use miden_protocol::transaction::{
     TransactionOutputs,
     TxAccountUpdate,
 };
+use miden_prover::HashFunction::Poseidon2;
 pub use miden_prover::ProvingOptions;
 use miden_prover::{ExecutionProof, Word, prove};
 
@@ -43,6 +44,13 @@ impl LocalTransactionProver {
         Self { proof_options }
     }
 
+    /// Creates a new [LocalTransactionProver] instance with the [`Poseidon2`] hash function.
+    pub fn with_poseidon2() -> Self {
+        Self {
+            proof_options: ProvingOptions::new(Poseidon2),
+        }
+    }
+
     fn build_proven_transaction(
         &self,
         input_notes: &InputNotes<InputNote>,

From 164a08ec5e01ab029dd6a2ad9296e4734f9a7a4b Mon Sep 17 00:00:00 2001
From: Andrey Khmuro <akhmuro@gmail.com>
Date: Fri, 26 Jun 2026 15:17:18 +0300
Subject: [PATCH 2/5] chore: update changelog

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 16320e4d27..ff5b69bfaa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,7 @@
 ## v0.16.0 (TBD)
 
 ### Changes
+- Replaced `BLAKE3` hash function to `Poseidon2` hash function in the proving pipeline of the time counting benchmarks ([#3152](https://github.com/0xMiden/protocol/pull/3152)).
 - [BREAKING] Replaced the `P2idNote` marker type and its `P2idNote::create` factory with a `P2idNote` struct built via a `bon` typestate builder (`P2idNote::builder()`). P2ID notes must now carry at least one asset; a `P2idNote` converts into a `Note` via `Note::from`, and the builder offers `.asset()`/`.assets()`, `.attachment()`/`.attachments()`, and `.generate_serial_number()` ([#2283](https://github.com/0xMiden/protocol/issues/2283)).
 - [BREAKING] Replaced the `P2ideNote` marker type and its `P2ideNote::create` factory with a `P2ideNote` struct built via a `bon` typestate builder (`P2ideNote::builder()`). P2IDE notes must now carry at least one asset; the optional `reclaim_height`/`timelock_height` are set via the builder, `P2ideNoteStorage::into_recipient` is now infallible, and a `P2ideNote` converts into a `Note` via `Note::from` ([#2283](https://github.com/0xMiden/protocol/issues/2283)).
 - Added a skeleton batch kernel ([#1122](https://github.com/0xMiden/protocol/issues/1122)) wired through `LocalBatchProver::prove` and attached to `ProvenBatch` as an `ExecutionProof`. It does not yet perform any verification.

From 6ff5dfe780db49db1a2c7af3e84fc3ae28269db7 Mon Sep 17 00:00:00 2001
From: "Claude (Opus)" <noreply@anthropic.com>
Date: Sun, 28 Jun 2026 19:33:55 +0300
Subject: [PATCH 3/5] fix: add ECDSA benchmark variants and restructure
 time-counting IDs

Addresses PR #3152 review feedback:
- Add ECDSA variants for every signature-authenticated benchmark (two P2ID,
  create P2ID) in both the cycle-counting and time-counting suites; single P2ID
  already had both. CLAIM/B2AGG authenticate the bridge account via network auth
  (no signature), so they keep a single variant.
- Build the time-counting Criterion IDs programmatically so they encode the
  signing scheme and the proving hash function, e.g.
  'Execute and prove transaction/poseidon2-falcon/single-p2id-note' and
  'Execute and prove transaction/poseidon2/claim-note-l1'.
- Regenerate bench-tx.json, refresh README examples, update CHANGELOG and the
  trace-contract test expectations.
---
 CHANGELOG.md                                  |   2 +-
 bin/bench-transaction/README.md               |  20 +-
 bin/bench-transaction/bench-tx.json           |  53 +++++-
 bin/bench-transaction/src/context_setups.rs   |  32 ++--
 .../src/cycle_counting_benchmarks/mod.rs      |  20 +-
 .../src/cycle_counting_benchmarks/utils.rs    |  14 +-
 bin/bench-transaction/src/main.rs             |  22 ++-
 .../src/time_counting_benchmarks/prove.rs     | 180 ++++++++++++------
 8 files changed, 258 insertions(+), 85 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ff5b69bfaa..9896bd0dcb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,7 +3,7 @@
 ## v0.16.0 (TBD)
 
 ### Changes
-- Replaced `BLAKE3` hash function to `Poseidon2` hash function in the proving pipeline of the time counting benchmarks ([#3152](https://github.com/0xMiden/protocol/pull/3152)).
+- Replaced `BLAKE3` hash function to `Poseidon2` hash function in the proving pipeline of the time counting benchmarks, added ECDSA variants for every signature-authenticated transaction benchmark, and restructured the time counting benchmark IDs to encode the signing scheme and proving hash function (e.g. `poseidon2-falcon/single-p2id-note`) ([#3152](https://github.com/0xMiden/protocol/pull/3152)).
 - [BREAKING] Replaced the `P2idNote` marker type and its `P2idNote::create` factory with a `P2idNote` struct built via a `bon` typestate builder (`P2idNote::builder()`). P2ID notes must now carry at least one asset; a `P2idNote` converts into a `Note` via `Note::from`, and the builder offers `.asset()`/`.assets()`, `.attachment()`/`.attachments()`, and `.generate_serial_number()` ([#2283](https://github.com/0xMiden/protocol/issues/2283)).
 - [BREAKING] Replaced the `P2ideNote` marker type and its `P2ideNote::create` factory with a `P2ideNote` struct built via a `bon` typestate builder (`P2ideNote::builder()`). P2IDE notes must now carry at least one asset; the optional `reclaim_height`/`timelock_height` are set via the builder, `P2ideNoteStorage::into_recipient` is now infallible, and a `P2ideNote` converts into a `Note` via `Note::from` ([#2283](https://github.com/0xMiden/protocol/issues/2283)).
 - Added a skeleton batch kernel ([#1122](https://github.com/0xMiden/protocol/issues/1122)) wired through `LocalBatchProver::prove` and attached to `ProvenBatch` as an `ExecutionProof`. It does not yet perform any verification.
diff --git a/bin/bench-transaction/README.md b/bin/bench-transaction/README.md
index cf8304d91c..d1f9d02d2d 100644
--- a/bin/bench-transaction/README.md
+++ b/bin/bench-transaction/README.md
@@ -6,8 +6,8 @@ Below we describe how to benchmark Miden transactions.
 
 The following transactions are benchmarked:
 
-- **P2ID notes**: Consume single P2ID notes with Falcon or ECDSA signing, consume two P2ID
-  notes, create single P2ID note
+- **P2ID notes**: Consume single P2ID notes, consume two P2ID notes, and create single P2ID
+  note - each with both Falcon and ECDSA signing
 - **CLAIM notes (agglayer bridge-in)**: Consume CLAIM note for L1-to-Miden bridging and L2-to-Miden bridging
 - **B2AGG note (agglayer bridge-out)**: Consume B2AGG note for Miden-to-AggLayer bridging
 
@@ -46,22 +46,26 @@ Each of the above transactions is measured in two groups:
 
   Notice that the `Poseidon2` hash function is used during the proving process.
 
-  This group uses the [Criterion.rs](https://github.com/bheisler/criterion.rs) to collect the elapsed time. Results of this benchmark group are printed to the terminal and look like so:
+  This group uses the [Criterion.rs](https://github.com/bheisler/criterion.rs) to collect the
+  elapsed time. The benchmark ID encodes what was measured: the signing scheme of the
+  benchmarked account (`falcon`/`ecdsa`) and, for the proving group, the hash function used
+  during proving (`poseidon2`). Network-authenticated transactions (CLAIM, B2AGG) carry no
+  signing scheme. Results are printed to the terminal and look like so:
   ```zsh
-  Execute transaction/single P2ID note (Falcon signing)
+  Execute transaction/falcon/single-p2id-note
                         time:   [7.2611 ms 7.2772 ms 7.2929 ms]
                         change: [−0.9131% −0.5837% −0.3058%] (p = 0.00 < 0.05)
                         Change within noise threshold.
-  Execute transaction/two P2ID notes
+  Execute transaction/ecdsa/two-p2id-notes
                         time:   [8.8279 ms 8.8442 ms 8.8633 ms]
                         change: [−1.2256% −0.7611% −0.3355%] (p = 0.00 < 0.05)
                         Change within noise threshold.
 
-  Execute and prove transaction/single P2ID note (Falcon signing)
+  Execute and prove transaction/poseidon2-falcon/single-p2id-note
                         time:   [698.96 ms 703.92 ms 708.70 ms]
                         change: [−2.3061% −0.4274% +0.9653%] (p = 0.70 > 0.05)
                         No change in performance detected.
-  Execute and prove transaction/two P2ID notes
+  Execute and prove transaction/poseidon2/claim-note-l1
                         time:   [706.52 ms 710.91 ms 715.66 ms]
                         change: [−7.4641% −5.0278% −2.9437%] (p = 0.00 < 0.05)
                         Performance has improved.
@@ -105,7 +109,7 @@ equality:
 - `padded_chiplets  = max(64, next_pow2(chiplets_rows))`
 
 These two can land in different brackets on the same workload (e.g.
-`consume two P2ID notes` has `padded_core_side = 131072` but
+`consume two P2ID notes with Falcon signing` has `padded_core_side = 131072` but
 `padded_chiplets = 262144`).
 
 To feed the snapshot into `miden-vm`, regenerate `bench-tx.json` here and copy
diff --git a/bin/bench-transaction/bench-tx.json b/bin/bench-transaction/bench-tx.json
index 14c9ab0449..24a90be724 100644
--- a/bin/bench-transaction/bench-tx.json
+++ b/bin/bench-transaction/bench-tx.json
@@ -49,7 +49,7 @@
       }
     }
   },
-  "consume two P2ID notes": {
+  "consume two P2ID notes with Falcon signing": {
     "prologue": 4863,
     "notes_processing": 3794,
     "note_execution": {
@@ -75,7 +75,33 @@
       }
     }
   },
-  "create single P2ID note": {
+  "consume two P2ID notes with ECDSA signing": {
+    "prologue": 4863,
+    "notes_processing": 3794,
+    "note_execution": {
+      "0x5153234001bf2a836f22dd97a65c0b196e4c1d65eecfbe50492cfda75592c69c": 1949,
+      "0x77a169617f76d8ce94eb21a95c128e7921e1d42ab1c2a685d6e3755f8e5643b8": 1796
+    },
+    "tx_script_processing": 42,
+    "epilogue": {
+      "total": 5685,
+      "auth_procedure": 3653,
+      "after_tx_cycles_obtained": 0
+    },
+    "trace": {
+      "core_rows": 14428,
+      "chiplets_rows": 23030,
+      "range_rows": 1145,
+      "chiplets_shape": {
+        "hasher_rows": 21184,
+        "bitwise_rows": 960,
+        "memory_rows": 829,
+        "kernel_rom_rows": 56,
+        "ace_rows": 0
+      }
+    }
+  },
+  "create single P2ID note with Falcon signing": {
     "prologue": 1810,
     "notes_processing": 32,
     "note_execution": {},
@@ -98,6 +124,29 @@
       }
     }
   },
+  "create single P2ID note with ECDSA signing": {
+    "prologue": 1810,
+    "notes_processing": 32,
+    "note_execution": {},
+    "tx_script_processing": 1777,
+    "epilogue": {
+      "total": 6996,
+      "auth_procedure": 4028,
+      "after_tx_cycles_obtained": 0
+    },
+    "trace": {
+      "core_rows": 10659,
+      "chiplets_rows": 18971,
+      "range_rows": 1011,
+      "chiplets_shape": {
+        "hasher_rows": 17600,
+        "bitwise_rows": 632,
+        "memory_rows": 682,
+        "kernel_rom_rows": 56,
+        "ace_rows": 0
+      }
+    }
+  },
   "consume CLAIM note (L1 to Miden)": {
     "prologue": 3311,
     "notes_processing": 28891,
diff --git a/bin/bench-transaction/src/context_setups.rs b/bin/bench-transaction/src/context_setups.rs
index d998176cf0..df4f9a2981 100644
--- a/bin/bench-transaction/src/context_setups.rs
+++ b/bin/bench-transaction/src/context_setups.rs
@@ -29,17 +29,21 @@ use rand::Rng;
 // P2ID NOTE SETUPS
 // ================================================================================================
 
+pub fn tx_create_single_p2id_note_falcon() -> Result<TransactionContext> {
+    tx_create_single_p2id_note_with_auth(AuthScheme::Falcon512Poseidon2)
+}
+
+pub fn tx_create_single_p2id_note_ecdsa() -> Result<TransactionContext> {
+    tx_create_single_p2id_note_with_auth(AuthScheme::EcdsaK256Keccak)
+}
+
 /// Returns the transaction context which could be used to run the transaction which creates a
 /// single P2ID note.
-pub fn tx_create_single_p2id_note() -> Result<TransactionContext> {
+fn tx_create_single_p2id_note_with_auth(auth_scheme: AuthScheme) -> Result<TransactionContext> {
     let mut builder = MockChain::builder();
     let fungible_asset = FungibleAsset::mock(150);
-    let account = builder.add_existing_wallet_with_assets(
-        Auth::BasicAuth {
-            auth_scheme: AuthScheme::Falcon512Poseidon2,
-        },
-        [fungible_asset],
-    )?;
+    let account = builder
+        .add_existing_wallet_with_assets(Auth::BasicAuth { auth_scheme }, [fungible_asset])?;
 
     let output_note = builder.add_p2id_note(
         ACCOUNT_ID_SENDER.try_into().unwrap(),
@@ -130,14 +134,20 @@ fn tx_consume_single_p2id_note_with_auth(auth_scheme: AuthScheme) -> Result<Tran
         .build()
 }
 
+pub fn tx_consume_two_p2id_notes_falcon() -> Result<TransactionContext> {
+    tx_consume_two_p2id_notes_with_auth(AuthScheme::Falcon512Poseidon2)
+}
+
+pub fn tx_consume_two_p2id_notes_ecdsa() -> Result<TransactionContext> {
+    tx_consume_two_p2id_notes_with_auth(AuthScheme::EcdsaK256Keccak)
+}
+
 /// Returns the transaction context which could be used to run the transaction which consumes two
 /// P2ID notes into an existing basic wallet.
-pub fn tx_consume_two_p2id_notes() -> Result<TransactionContext> {
+fn tx_consume_two_p2id_notes_with_auth(auth_scheme: AuthScheme) -> Result<TransactionContext> {
     let mut builder = MockChain::builder();
 
-    let account = builder.add_existing_wallet(Auth::BasicAuth {
-        auth_scheme: AuthScheme::Falcon512Poseidon2,
-    })?;
+    let account = builder.add_existing_wallet(Auth::BasicAuth { auth_scheme })?;
     let fungible_asset_1: Asset = FungibleAsset::mock(100);
     let fungible_asset_2: Asset = FungibleAsset::mock(23);
 
diff --git a/bin/bench-transaction/src/cycle_counting_benchmarks/mod.rs b/bin/bench-transaction/src/cycle_counting_benchmarks/mod.rs
index 31fccbca26..b18ee0bbaa 100644
--- a/bin/bench-transaction/src/cycle_counting_benchmarks/mod.rs
+++ b/bin/bench-transaction/src/cycle_counting_benchmarks/mod.rs
@@ -8,8 +8,10 @@ pub mod utils;
 pub enum ExecutionBenchmark {
     ConsumeSingleP2IDFalcon,
     ConsumeSingleP2IDEcdsa,
-    ConsumeTwoP2ID,
-    CreateSingleP2ID,
+    ConsumeTwoP2IDFalcon,
+    ConsumeTwoP2IDEcdsa,
+    CreateSingleP2IDFalcon,
+    CreateSingleP2IDEcdsa,
     ConsumeClaimNoteL1ToMiden,
     ConsumeClaimNoteL2ToMiden,
     ConsumeB2AggNote,
@@ -26,8 +28,18 @@ impl fmt::Display for ExecutionBenchmark {
             ExecutionBenchmark::ConsumeSingleP2IDEcdsa => {
                 write!(f, "consume single P2ID note with ECDSA signing")
             },
-            ExecutionBenchmark::ConsumeTwoP2ID => write!(f, "consume two P2ID notes"),
-            ExecutionBenchmark::CreateSingleP2ID => write!(f, "create single P2ID note"),
+            ExecutionBenchmark::ConsumeTwoP2IDFalcon => {
+                write!(f, "consume two P2ID notes with Falcon signing")
+            },
+            ExecutionBenchmark::ConsumeTwoP2IDEcdsa => {
+                write!(f, "consume two P2ID notes with ECDSA signing")
+            },
+            ExecutionBenchmark::CreateSingleP2IDFalcon => {
+                write!(f, "create single P2ID note with Falcon signing")
+            },
+            ExecutionBenchmark::CreateSingleP2IDEcdsa => {
+                write!(f, "create single P2ID note with ECDSA signing")
+            },
             ExecutionBenchmark::ConsumeClaimNoteL1ToMiden => {
                 write!(f, "consume CLAIM note (L1 to Miden)")
             },
diff --git a/bin/bench-transaction/src/cycle_counting_benchmarks/utils.rs b/bin/bench-transaction/src/cycle_counting_benchmarks/utils.rs
index 7159925b0e..d0cb1b3983 100644
--- a/bin/bench-transaction/src/cycle_counting_benchmarks/utils.rs
+++ b/bin/bench-transaction/src/cycle_counting_benchmarks/utils.rs
@@ -211,15 +211,25 @@ mod tests {
             padded_chiplets: 32_768,
         },
         ScenarioExpectation {
-            name: "consume two P2ID notes",
+            name: "consume two P2ID notes with Falcon signing",
             padded_core_side: 131_072,
             padded_chiplets: 65_536,
         },
         ScenarioExpectation {
-            name: "create single P2ID note",
+            name: "consume two P2ID notes with ECDSA signing",
+            padded_core_side: 16_384,
+            padded_chiplets: 32_768,
+        },
+        ScenarioExpectation {
+            name: "create single P2ID note with Falcon signing",
             padded_core_side: 131_072,
             padded_chiplets: 65_536,
         },
+        ScenarioExpectation {
+            name: "create single P2ID note with ECDSA signing",
+            padded_core_side: 16_384,
+            padded_chiplets: 32_768,
+        },
         ScenarioExpectation {
             name: "consume CLAIM note (L1 to Miden)",
             padded_core_side: 65_536,
diff --git a/bin/bench-transaction/src/main.rs b/bin/bench-transaction/src/main.rs
index 18b3526a01..0defbf0257 100644
--- a/bin/bench-transaction/src/main.rs
+++ b/bin/bench-transaction/src/main.rs
@@ -11,8 +11,10 @@ use context_setups::{
     tx_consume_claim_note,
     tx_consume_single_p2id_note_ecdsa,
     tx_consume_single_p2id_note_falcon,
-    tx_consume_two_p2id_notes,
-    tx_create_single_p2id_note,
+    tx_consume_two_p2id_notes_ecdsa,
+    tx_consume_two_p2id_notes_falcon,
+    tx_create_single_p2id_note_ecdsa,
+    tx_create_single_p2id_note_falcon,
 };
 
 mod cycle_counting_benchmarks;
@@ -49,8 +51,20 @@ async fn main() -> Result<()> {
             tx_consume_single_p2id_note_ecdsa()?,
         )
         .await?,
-        run_scenario(ExecutionBenchmark::ConsumeTwoP2ID, tx_consume_two_p2id_notes()?).await?,
-        run_scenario(ExecutionBenchmark::CreateSingleP2ID, tx_create_single_p2id_note()?).await?,
+        run_scenario(ExecutionBenchmark::ConsumeTwoP2IDFalcon, tx_consume_two_p2id_notes_falcon()?)
+            .await?,
+        run_scenario(ExecutionBenchmark::ConsumeTwoP2IDEcdsa, tx_consume_two_p2id_notes_ecdsa()?)
+            .await?,
+        run_scenario(
+            ExecutionBenchmark::CreateSingleP2IDFalcon,
+            tx_create_single_p2id_note_falcon()?,
+        )
+        .await?,
+        run_scenario(
+            ExecutionBenchmark::CreateSingleP2IDEcdsa,
+            tx_create_single_p2id_note_ecdsa()?,
+        )
+        .await?,
         run_scenario(
             ExecutionBenchmark::ConsumeClaimNoteL1ToMiden,
             tx_consume_claim_note(ClaimDataSource::L1ToMiden).await?,
diff --git a/bin/bench-transaction/src/time_counting_benchmarks/prove.rs b/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
index a8f720df30..fb2c40ae8b 100644
--- a/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
+++ b/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
@@ -9,36 +9,65 @@ use bench_transaction::context_setups::{
     tx_consume_claim_note,
     tx_consume_single_p2id_note_ecdsa,
     tx_consume_single_p2id_note_falcon,
-    tx_consume_two_p2id_notes,
+    tx_consume_two_p2id_notes_ecdsa,
+    tx_consume_two_p2id_notes_falcon,
 };
 use criterion::{BatchSize, Bencher, Criterion, SamplingMode, criterion_group, criterion_main};
 use miden_protocol::transaction::{ExecutedTransaction, ProvenTransaction};
 use miden_testing::TransactionContext;
 use miden_tx::LocalTransactionProver;
 
-// BENCHMARK NAMES
+// BENCHMARK IDS
 // ================================================================================================
 
-// The benchmark labels below deliberately omit the group-name prefix (e.g. "Execute
-// transaction"). Criterion already prints results as `<group>/<label>` and truncates the
-// directory name derived from the label to 64 characters.
+// Criterion prints results as `<group>/<id>` and truncates the directory name derived from the
+// `<id>` to 64 characters. We build the `<id>` programmatically so it always records what was
+// measured: the signing scheme of the benchmarked account's authentication and, for the proving
+// group, the hash function used during proving. Network-authenticated transactions (CLAIM, B2AGG)
+// carry no signing scheme.
 const BENCH_GROUP_EXECUTE: &str = "Execute transaction";
-const BENCH_EXECUTE_TX_CONSUME_SINGLE_P2ID_FALCON: &str = "single P2ID note (Falcon signing)";
-const BENCH_EXECUTE_TX_CONSUME_SINGLE_P2ID_ECDSA: &str = "single P2ID note (ECDSA signing)";
-const BENCH_EXECUTE_TX_CONSUME_TWO_P2ID: &str = "two P2ID notes";
-const BENCH_EXECUTE_TX_CONSUME_CLAIM_L1: &str = "CLAIM note (L1 to Miden)";
-const BENCH_EXECUTE_TX_CONSUME_CLAIM_L2: &str = "CLAIM note (L2 to Miden)";
-const BENCH_EXECUTE_TX_CONSUME_B2AGG: &str = "B2AGG note (bridge-out)";
-
 const BENCH_GROUP_EXECUTE_AND_PROVE: &str = "Execute and prove transaction";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_SINGLE_P2ID_FALCON: &str =
-    "single P2ID note (Falcon signing)";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_SINGLE_P2ID_ECDSA: &str =
-    "single P2ID note (ECDSA signing)";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_TWO_P2ID: &str = "two P2ID notes";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_CLAIM_L1: &str = "CLAIM note (L1 to Miden)";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_CLAIM_L2: &str = "CLAIM note (L2 to Miden)";
-const BENCH_EXECUTE_AND_PROVE_TX_CONSUME_B2AGG: &str = "B2AGG note (bridge-out)";
+
+// Scenario base names shared by both groups.
+const SCENARIO_SINGLE_P2ID: &str = "single-p2id-note";
+const SCENARIO_TWO_P2ID: &str = "two-p2id-notes";
+const SCENARIO_CLAIM_L1: &str = "claim-note-l1";
+const SCENARIO_CLAIM_L2: &str = "claim-note-l2";
+const SCENARIO_B2AGG: &str = "b2agg-note";
+
+/// Signing scheme used by the benchmarked account's authentication procedure.
+#[derive(Clone, Copy)]
+enum Signing {
+    Falcon,
+    Ecdsa,
+}
+
+impl Signing {
+    fn as_str(self) -> &'static str {
+        match self {
+            Signing::Falcon => "falcon",
+            Signing::Ecdsa => "ecdsa",
+        }
+    }
+}
+
+/// Builds the Criterion ID for the execute-only group, e.g. `falcon/single-p2id-note`.
+/// Network-authenticated scenarios pass `None` and get the bare scenario name.
+fn execute_id(signing: Option<Signing>, scenario: &str) -> String {
+    match signing {
+        Some(signing) => format!("{}/{scenario}", signing.as_str()),
+        None => scenario.to_string(),
+    }
+}
+
+/// Builds the Criterion ID for the execute-and-prove group, prefixing the proving hash function,
+/// e.g. `poseidon2-falcon/single-p2id-note` or `poseidon2/claim-note-l1`.
+fn prove_id(signing: Option<Signing>, scenario: &str) -> String {
+    match signing {
+        Some(signing) => format!("poseidon2-{}/{scenario}", signing.as_str()),
+        None => format!("poseidon2/{scenario}"),
+    }
+}
 
 // CORE PROVING BENCHMARKS
 // ================================================================================================
@@ -55,7 +84,7 @@ fn core_benchmarks(c: &mut Criterion) {
         .warm_up_time(Duration::from_millis(1000))
         .measurement_time(Duration::from_secs(30));
 
-    execute_group.bench_function(BENCH_EXECUTE_TX_CONSUME_SINGLE_P2ID_FALCON, |b| {
+    execute_group.bench_function(execute_id(Some(Signing::Falcon), SCENARIO_SINGLE_P2ID), |b| {
         b.to_async(tokio::runtime::Builder::new_current_thread().build().unwrap())
             .iter_batched(
                 || {
@@ -67,7 +96,7 @@ fn core_benchmarks(c: &mut Criterion) {
             );
     });
 
-    execute_group.bench_function(BENCH_EXECUTE_TX_CONSUME_SINGLE_P2ID_ECDSA, |b| {
+    execute_group.bench_function(execute_id(Some(Signing::Ecdsa), SCENARIO_SINGLE_P2ID), |b| {
         b.to_async(tokio::runtime::Builder::new_current_thread().build().unwrap())
             .iter_batched(
                 || {
@@ -79,12 +108,28 @@ fn core_benchmarks(c: &mut Criterion) {
             );
     });
 
-    execute_group.bench_function(BENCH_EXECUTE_TX_CONSUME_TWO_P2ID, |b| {
+    execute_group.bench_function(execute_id(Some(Signing::Falcon), SCENARIO_TWO_P2ID), |b| {
+        b.to_async(tokio::runtime::Builder::new_current_thread().build().unwrap())
+            .iter_batched(
+                || {
+                    // prepare the transaction context
+                    tx_consume_two_p2id_notes_falcon()
+                        .expect("failed to create a context which consumes two P2ID notes")
+                },
+                |tx_context| async move {
+                    // benchmark the transaction execution
+                    black_box(tx_context.execute().await)
+                },
+                BatchSize::SmallInput,
+            );
+    });
+
+    execute_group.bench_function(execute_id(Some(Signing::Ecdsa), SCENARIO_TWO_P2ID), |b| {
         b.to_async(tokio::runtime::Builder::new_current_thread().build().unwrap())
             .iter_batched(
                 || {
                     // prepare the transaction context
-                    tx_consume_two_p2id_notes()
+                    tx_consume_two_p2id_notes_ecdsa()
                         .expect("failed to create a context which consumes two P2ID notes")
                 },
                 |tx_context| async move {
@@ -95,15 +140,15 @@ fn core_benchmarks(c: &mut Criterion) {
             );
     });
 
-    execute_group.bench_function(BENCH_EXECUTE_TX_CONSUME_CLAIM_L1, |b| {
+    execute_group.bench_function(execute_id(None, SCENARIO_CLAIM_L1), |b| {
         bench_async_execute(b, || tx_consume_claim_note(ClaimDataSource::L1ToMiden));
     });
 
-    execute_group.bench_function(BENCH_EXECUTE_TX_CONSUME_CLAIM_L2, |b| {
+    execute_group.bench_function(execute_id(None, SCENARIO_CLAIM_L2), |b| {
         bench_async_execute(b, || tx_consume_claim_note(ClaimDataSource::L2ToMiden));
     });
 
-    execute_group.bench_function(BENCH_EXECUTE_TX_CONSUME_B2AGG, |b| {
+    execute_group.bench_function(execute_id(None, SCENARIO_B2AGG), |b| {
         bench_async_execute(b, || tx_consume_b2agg_note(None));
     });
 
@@ -121,7 +166,7 @@ fn core_benchmarks(c: &mut Criterion) {
         .measurement_time(Duration::from_secs(30));
 
     execute_and_prove_group.bench_function(
-        BENCH_EXECUTE_AND_PROVE_TX_CONSUME_SINGLE_P2ID_FALCON,
+        prove_id(Some(Signing::Falcon), SCENARIO_SINGLE_P2ID),
         |b| {
             b.to_async(tokio::runtime::Builder::new_current_thread().build().unwrap())
                 .iter_batched(
@@ -145,7 +190,7 @@ fn core_benchmarks(c: &mut Criterion) {
     );
 
     execute_and_prove_group.bench_function(
-        BENCH_EXECUTE_AND_PROVE_TX_CONSUME_SINGLE_P2ID_ECDSA,
+        prove_id(Some(Signing::Ecdsa), SCENARIO_SINGLE_P2ID),
         |b| {
             b.to_async(tokio::runtime::Builder::new_current_thread().build().unwrap())
                 .iter_batched(
@@ -168,38 +213,67 @@ fn core_benchmarks(c: &mut Criterion) {
         },
     );
 
-    execute_and_prove_group.bench_function(BENCH_EXECUTE_AND_PROVE_TX_CONSUME_TWO_P2ID, |b| {
-        b.to_async(tokio::runtime::Builder::new_current_thread().build().unwrap())
-            .iter_batched(
-                || {
-                    tx_consume_two_p2id_notes()
-                        .expect("failed to create a context which consumes two P2ID notes")
-                },
-                |tx_context| async move {
-                    // benchmark the transaction execution and proving
-                    black_box(
-                        prove_transaction(
-                            tx_context
-                                .execute()
-                                .await
-                                .expect("execution of the two P2ID note consumption tx failed"),
+    execute_and_prove_group.bench_function(
+        prove_id(Some(Signing::Falcon), SCENARIO_TWO_P2ID),
+        |b| {
+            b.to_async(tokio::runtime::Builder::new_current_thread().build().unwrap())
+                .iter_batched(
+                    || {
+                        tx_consume_two_p2id_notes_falcon()
+                            .expect("failed to create a context which consumes two P2ID notes")
+                    },
+                    |tx_context| async move {
+                        // benchmark the transaction execution and proving
+                        black_box(
+                            prove_transaction(
+                                tx_context
+                                    .execute()
+                                    .await
+                                    .expect("execution of the two P2ID note consumption tx failed"),
+                            )
+                            .await,
                         )
-                        .await,
-                    )
-                },
-                BatchSize::SmallInput,
-            );
-    });
+                    },
+                    BatchSize::SmallInput,
+                );
+        },
+    );
+
+    execute_and_prove_group.bench_function(
+        prove_id(Some(Signing::Ecdsa), SCENARIO_TWO_P2ID),
+        |b| {
+            b.to_async(tokio::runtime::Builder::new_current_thread().build().unwrap())
+                .iter_batched(
+                    || {
+                        tx_consume_two_p2id_notes_ecdsa()
+                            .expect("failed to create a context which consumes two P2ID notes")
+                    },
+                    |tx_context| async move {
+                        // benchmark the transaction execution and proving
+                        black_box(
+                            prove_transaction(
+                                tx_context
+                                    .execute()
+                                    .await
+                                    .expect("execution of the two P2ID note consumption tx failed"),
+                            )
+                            .await,
+                        )
+                    },
+                    BatchSize::SmallInput,
+                );
+        },
+    );
 
-    execute_and_prove_group.bench_function(BENCH_EXECUTE_AND_PROVE_TX_CONSUME_CLAIM_L1, |b| {
+    execute_and_prove_group.bench_function(prove_id(None, SCENARIO_CLAIM_L1), |b| {
         bench_async_execute_and_prove(b, || tx_consume_claim_note(ClaimDataSource::L1ToMiden));
     });
 
-    execute_and_prove_group.bench_function(BENCH_EXECUTE_AND_PROVE_TX_CONSUME_CLAIM_L2, |b| {
+    execute_and_prove_group.bench_function(prove_id(None, SCENARIO_CLAIM_L2), |b| {
         bench_async_execute_and_prove(b, || tx_consume_claim_note(ClaimDataSource::L2ToMiden));
     });
 
-    execute_and_prove_group.bench_function(BENCH_EXECUTE_AND_PROVE_TX_CONSUME_B2AGG, |b| {
+    execute_and_prove_group.bench_function(prove_id(None, SCENARIO_B2AGG), |b| {
         bench_async_execute_and_prove(b, || tx_consume_b2agg_note(None));
     });
 

From b5a5ea25f7af62806c7b871f947accb11bd38646 Mon Sep 17 00:00:00 2001
From: "Claude (Opus)" <noreply@anthropic.com>
Date: Sun, 28 Jun 2026 19:53:25 +0300
Subject: [PATCH 4/5] fix: make Poseidon2 the default LocalTransactionProver
 hash function

Addresses PR #3152 review: instead of a Poseidon2-specific convenience
constructor, change the prover default itself. Remove the with_poseidon2()
and with_blake3() constructors and give LocalTransactionProver a manual
Default impl that uses Poseidon2; the benchmark now proves via
LocalTransactionProver::default().
---
 CHANGELOG.md                                     |  2 +-
 .../src/time_counting_benchmarks/prove.rs        |  2 +-
 crates/miden-tx/src/prover/mod.rs                | 16 ++++++++--------
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9896bd0dcb..4b425176f6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,7 +3,7 @@
 ## v0.16.0 (TBD)
 
 ### Changes
-- Replaced `BLAKE3` hash function to `Poseidon2` hash function in the proving pipeline of the time counting benchmarks, added ECDSA variants for every signature-authenticated transaction benchmark, and restructured the time counting benchmark IDs to encode the signing scheme and proving hash function (e.g. `poseidon2-falcon/single-p2id-note`) ([#3152](https://github.com/0xMiden/protocol/pull/3152)).
+- Changed the default `LocalTransactionProver` hash function from `BLAKE3` to `Poseidon2`, added ECDSA variants for every signature-authenticated transaction benchmark, and restructured the time counting benchmark IDs to encode the signing scheme and proving hash function (e.g. `poseidon2-falcon/single-p2id-note`) ([#3152](https://github.com/0xMiden/protocol/pull/3152)).
 - [BREAKING] Replaced the `P2idNote` marker type and its `P2idNote::create` factory with a `P2idNote` struct built via a `bon` typestate builder (`P2idNote::builder()`). P2ID notes must now carry at least one asset; a `P2idNote` converts into a `Note` via `Note::from`, and the builder offers `.asset()`/`.assets()`, `.attachment()`/`.attachments()`, and `.generate_serial_number()` ([#2283](https://github.com/0xMiden/protocol/issues/2283)).
 - [BREAKING] Replaced the `P2ideNote` marker type and its `P2ideNote::create` factory with a `P2ideNote` struct built via a `bon` typestate builder (`P2ideNote::builder()`). P2IDE notes must now carry at least one asset; the optional `reclaim_height`/`timelock_height` are set via the builder, `P2ideNoteStorage::into_recipient` is now infallible, and a `P2ideNote` converts into a `Note` via `Note::from` ([#2283](https://github.com/0xMiden/protocol/issues/2283)).
 - Added a skeleton batch kernel ([#1122](https://github.com/0xMiden/protocol/issues/1122)) wired through `LocalBatchProver::prove` and attached to `ProvenBatch` as an `ExecutionProof`. It does not yet perform any verification.
diff --git a/bin/bench-transaction/src/time_counting_benchmarks/prove.rs b/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
index fb2c40ae8b..2282a1b388 100644
--- a/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
+++ b/bin/bench-transaction/src/time_counting_benchmarks/prove.rs
@@ -283,7 +283,7 @@ fn core_benchmarks(c: &mut Criterion) {
 async fn prove_transaction(executed_transaction: ExecutedTransaction) -> Result<()> {
     let executed_transaction_id = executed_transaction.id();
     let proven_transaction: ProvenTransaction =
-        LocalTransactionProver::with_poseidon2().prove(executed_transaction).await?;
+        LocalTransactionProver::default().prove(executed_transaction).await?;
 
     assert_eq!(proven_transaction.id(), executed_transaction_id);
     Ok(())
diff --git a/crates/miden-tx/src/prover/mod.rs b/crates/miden-tx/src/prover/mod.rs
index 2c4e96b018..43e3484dd0 100644
--- a/crates/miden-tx/src/prover/mod.rs
+++ b/crates/miden-tx/src/prover/mod.rs
@@ -33,24 +33,24 @@ pub use mast_store::TransactionMastStore;
 /// Each `prove()` call creates a fresh [`TransactionMastStore`] loaded with only the current
 /// transaction's account code, ensuring no state accumulates across calls. This is important
 /// in WASM environments where accumulated MAST forests fragment the linear memory.
-#[derive(Default)]
 pub struct LocalTransactionProver {
     proof_options: ProvingOptions,
 }
 
+impl Default for LocalTransactionProver {
+    fn default() -> Self {
+        Self {
+            proof_options: ProvingOptions::new(Poseidon2),
+        }
+    }
+}
+
 impl LocalTransactionProver {
     /// Creates a new [LocalTransactionProver] instance.
     pub fn new(proof_options: ProvingOptions) -> Self {
         Self { proof_options }
     }
 
-    /// Creates a new [LocalTransactionProver] instance with the [`Poseidon2`] hash function.
-    pub fn with_poseidon2() -> Self {
-        Self {
-            proof_options: ProvingOptions::new(Poseidon2),
-        }
-    }
-
     fn build_proven_transaction(
         &self,
         input_notes: &InputNotes<InputNote>,

From caab5be7bff6cc58a2ec92d3a06209bdd88f35a0 Mon Sep 17 00:00:00 2001
From: Andrey Khmuro <akhmuro@gmail.com>
Date: Mon, 29 Jun 2026 14:57:45 +0300
Subject: [PATCH 5/5] chore: update changelog

---
 CHANGELOG.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6e3a873815..78e717ac77 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,6 @@
 
 ### Changes
 - Changed the default `LocalTransactionProver` hash function from `BLAKE3` to `Poseidon2`, added ECDSA variants for every signature-authenticated transaction benchmark, and restructured the time counting benchmark IDs to encode the signing scheme and proving hash function (e.g. `poseidon2-falcon/single-p2id-note`) ([#3152](https://github.com/0xMiden/protocol/pull/3152)).
-
 - [BREAKING] Replaced the `P2idNote` marker type and its `P2idNote::create` factory with a `P2idNote` struct built via a `bon` typestate builder (`P2idNote::builder()`). P2ID notes must now carry at least one asset; a `P2idNote` converts into a `Note` via `Note::from`, and the builder offers `.asset()`/`.assets()`, `.attachment()`/`.attachments()`, and `.generate_serial_number()` ([#2283](https://github.com/0xMiden/protocol/issues/2283)).
 - [BREAKING] Replaced the `MintNote` marker type and its `MintNote::create` factory with a struct built via a `bon` typestate builder (`MintNote::builder()`); a `MintNote` converts into a `Note` via `Note::from` ([#2283](https://github.com/0xMiden/protocol/issues/2283)).
 - [BREAKING] Replaced the `BurnNote` marker type and its `BurnNote::create` factory with a struct built via a `bon` typestate builder (`BurnNote::builder()`); a `BurnNote` converts into a `Note` via `Note::from` ([#2283](https://github.com/0xMiden/protocol/issues/2283)).