feat: handle standards scripts directly in TransactionExecutorHost w/o DataStore query (0xMiden#2417)

* feat: handle standards scripts directly w/o DataStore query

* chore: no need to explicitly add standard scripts to tx context in tests

* changelog

* chore: add note to DataStore::get_note_script

* chore: clarify docs and add panics

Author: mmagician

CHANGELOG.md

@@ -15,6 +15,7 @@
 - [BREAKING] Added `get_asset` and `get_initial_asset` kernel procedures and removed `get_balance`, `get_initial_balance` and `has_non_fungible_asset` kernel procedures ([#2369](https://github.com/0xMiden/miden-base/pull/2369)).
 - Introduced `TokenMetadata` type to encapsulate fungible faucet metadata ([#2344](https://github.com/0xMiden/miden-base/issues/2344)).
 - Added `StandardNote::from_script_root()` and `StandardNote::name()` methods, and exposed `NoteType` `PUBLIC`/`PRIVATE` masks as public constants ([#2411](https://github.com/0xMiden/miden-base/pull/2411)).
+- Resolve standard note scripts directly in `TransactionExecutorHost` instead of querying the data store ([#2417](https://github.com/0xMiden/miden-base/pull/2417)).
 
 ### Changes
 

crates/miden-testing/tests/agglayer/bridge_in.rs

@@ -173,7 +173,6 @@ async fn test_bridge_in_claim_to_p2id() -> anyhow::Result<()> {
 
     let tx_context = mock_chain
         .build_tx_context(agglayer_faucet.id(), &[], &[claim_note])?
-        .add_note_script(p2id_script.clone())
         .foreign_accounts(vec![foreign_account_inputs])
         .build()?;
 

crates/miden-testing/tests/agglayer/bridge_out.rs

@@ -6,7 +6,7 @@ use miden_crypto::rand::FeltRng;
 use miden_protocol::Felt;
 use miden_protocol::account::{AccountId, AccountIdVersion, AccountStorageMode, AccountType};
 use miden_protocol::asset::{Asset, FungibleAsset};
-use miden_protocol::note::{NoteAssets, NoteScript, NoteTag, NoteType};
+use miden_protocol::note::{NoteAssets, NoteTag, NoteType};
 use miden_protocol::transaction::OutputNote;
 use miden_standards::account::faucets::TokenMetadata;
 use miden_standards::note::StandardNote;
@@ -68,14 +68,10 @@ async fn test_bridge_out_consumes_b2agg_note() -> anyhow::Result<()> {
     builder.add_output_note(OutputNote::Full(b2agg_note.clone()));
     let mut mock_chain = builder.build()?;
 
-    // Get BURN note script to add to the transaction context
-    let burn_note_script: NoteScript = StandardNote::BURN.script();
-
     // EXECUTE B2AGG NOTE AGAINST BRIDGE ACCOUNT (NETWORK TRANSACTION)
     // --------------------------------------------------------------------------------------------
     let tx_context = mock_chain
         .build_tx_context(bridge_account.id(), &[b2agg_note.id()], &[])?
-        .add_note_script(burn_note_script.clone())
         .build()?;
     let executed_transaction = tx_context.execute().await?;
 
@@ -116,7 +112,7 @@ async fn test_bridge_out_consumes_b2agg_note() -> anyhow::Result<()> {
     // Verify the BURN note uses the correct script
     assert_eq!(
         burn_note.recipient().script().root(),
-        burn_note_script.root(),
+        StandardNote::BURN.script_root(),
         "BURN note should use the BURN script"
     );
 

crates/miden-testing/tests/scripts/faucet.rs

@@ -1241,15 +1241,7 @@ async fn test_mint_note_output_note_types(#[case] note_type: NoteType) -> anyhow
     builder.add_output_note(OutputNote::Full(mint_note.clone()));
     let mut mock_chain = builder.build()?;
 
-    let mut tx_context_builder =
-        mock_chain.build_tx_context(faucet.id(), &[mint_note.id()], &[])?;
-
-    if note_type == NoteType::Public {
-        let p2id_script = StandardNote::P2ID.script();
-        tx_context_builder = tx_context_builder.add_note_script(p2id_script);
-    }
-
-    let tx_context = tx_context_builder.build()?;
+    let tx_context = mock_chain.build_tx_context(faucet.id(), &[mint_note.id()], &[])?.build()?;
     let executed_transaction = tx_context.execute().await?;
 
     assert_eq!(executed_transaction.output_notes().num_notes(), 1);

crates/miden-tx/src/executor/data_store.rs

@@ -76,6 +76,9 @@ pub trait DataStore: MastForestStore {
     /// If the script is not found, it returns `Ok(None)` rather than an error, as "not found"
     /// is a valid, expected outcome.
     ///
+    /// **Note:** Data store implementers do not need to handle standard note scripts (e.g. P2ID).
+    /// These are resolved directly by the transaction executor and will not trigger this method.
+    ///
     /// # Errors
     /// Returns an error if the data store encountered an internal error while attempting to
     /// retrieve the script.

crates/miden-tx/src/executor/exec_host.rs

@@ -26,7 +26,7 @@ use miden_protocol::assembly::{SourceFile, SourceManagerSync, SourceSpan};
 use miden_protocol::asset::{AssetVaultKey, AssetWitness, FungibleAsset};
 use miden_protocol::block::BlockNumber;
 use miden_protocol::crypto::merkle::smt::SmtProof;
-use miden_protocol::note::{NoteMetadata, NoteRecipient, NoteStorage};
+use miden_protocol::note::{NoteMetadata, NoteRecipient, NoteScript, NoteStorage};
 use miden_protocol::transaction::{
     InputNote,
     InputNotes,
@@ -36,6 +36,7 @@ use miden_protocol::transaction::{
 };
 use miden_protocol::vm::AdviceMap;
 use miden_protocol::{Felt, Hasher, Word};
+use miden_standards::note::StandardNote;
 
 use crate::auth::{SigningInputs, TransactionAuthenticator};
 use crate::errors::TransactionKernelError;
@@ -364,11 +365,22 @@ where
         Ok(asset_witnesses.into_iter().flat_map(asset_witness_to_advice_mutation).collect())
     }
 
-    /// Handles a request for a [`NoteScript`] by querying the [`DataStore`].
+    /// Handles a request for a [`NoteScript`] during transaction execution when the script is not
+    /// already in the advice provider.
     ///
-    /// The script is fetched from the data store and used to build a [`NoteRecipient`], which is
-    /// then used to create an [`OutputNoteBuilder`]. This function is only called for public notes
-    /// where the script is not already available in the advice provider.
+    /// Standard note scripts (P2ID, etc.) are resolved directly from [`StandardNote`], avoiding a
+    /// data store round-trip. Non-standard scripts are fetched from the [`DataStore`].
+    ///
+    /// The resolved script is used to build a [`NoteRecipient`], which is then used to create
+    /// an [`OutputNoteBuilder`]. This function is only called for notes where the script is not
+    /// already in the advice provider.
+    ///
+    /// # Errors
+    /// Returns an error if:
+    /// - The note is public and the script is not found in the data store.
+    /// - Constructing the recipient with the fetched script does not match the expected recipient
+    ///   digest.
+    /// - The data store returns an error when fetching the script.
     async fn on_note_script_requested(
         &mut self,
         note_idx: usize,
@@ -378,10 +390,21 @@ where
         note_storage: NoteStorage,
         serial_num: Word,
     ) -> Result<Vec<AdviceMutation>, TransactionKernelError> {
-        let note_script_result = self.base_host.store().get_note_script(script_root).await;
+        // Resolve standard note scripts directly, avoiding a data store round-trip.
+        let note_script: Option<NoteScript> =
+            if let Some(standard_note) = StandardNote::from_script_root(script_root) {
+                Some(standard_note.script())
+            } else {
+                self.base_host.store().get_note_script(script_root).await.map_err(|err| {
+                    TransactionKernelError::other_with_source(
+                        "failed to retrieve note script from data store",
+                        err,
+                    )
+                })?
+            };
 
-        match note_script_result {
-            Ok(Some(note_script)) => {
+        match note_script {
+            Some(note_script) => {
                 let script_felts: Vec<Felt> = (&note_script).into();
                 let recipient = NoteRecipient::new(serial_num, note_script, note_storage);
 
@@ -399,7 +422,7 @@ where
                     script_felts,
                 )]))])
             },
-            Ok(None) if metadata.is_private() => {
+            None if metadata.is_private() => {
                 self.base_host.output_note_from_recipient_digest(
                     note_idx,
                     metadata,
@@ -408,13 +431,9 @@ where
 
                 Ok(Vec::new())
             },
-            Ok(None) => Err(TransactionKernelError::other(format!(
+            None => Err(TransactionKernelError::other(format!(
                 "note script with root {script_root} not found in data store for public note"
             ))),
-            Err(err) => Err(TransactionKernelError::other_with_source(
-                "failed to retrieve note script from data store",
-                err,
-            )),
         }
     }