refactor: Change way of providing code and inputs to executor

Author: igamigo

CHANGELOG.md

@@ -32,6 +32,7 @@
 - [BREAKING] Enable timestamp customization on `MockChain::seal_block` (#1208).
 - [BREAKING] Renamed constants and comments: `OnChain` -> `Public` and `OffChain` -> `Private` (#1218).
 - [BREAKING] Replace "hash" with "commitment" in `BlockHeader::{prev_hash, chain_root, kernel_root, tx_hash, proof_hash, sub_hash, hash}` (#1209, #1221, #1226).
+- [BREAKING] Split `DataStore` API and refactored `TransactionExecutor` API (#1229).
 
 ## 0.7.2 (2025-01-28) - `miden-objects` crate only
 

bin/bench-tx/src/main.rs

@@ -3,6 +3,7 @@ use std::{
     fs::{read_to_string, write, File},
     io::Write,
     path::Path,
+    sync::Arc,
 };
 
 use miden_lib::{note::create_p2id_note, transaction::TransactionKernel};
@@ -59,6 +60,7 @@ fn main() -> Result<(), String> {
 // ================================================================================================
 
 /// Runs the default transaction with empty transaction script and two default notes.
+#[allow(clippy::arc_with_non_send_sync)]
 pub fn benchmark_default_tx() -> Result<TransactionMeasurements, String> {
     let tx_context = TransactionContextBuilder::with_standard_account(ONE)
         .with_mock_notes_preserved()
@@ -67,23 +69,20 @@ pub fn benchmark_default_tx() -> Result<TransactionMeasurements, String> {
     let account_id = tx_context.account().id();
 
     let block_ref = tx_context.tx_inputs().block_header().block_num();
-    let note_ids = tx_context
-        .tx_inputs()
-        .input_notes()
-        .iter()
-        .map(|note| note.id())
-        .collect::<Vec<_>>();
-
+    let tx_args = tx_context.tx_args().clone();
+    let notes = tx_context.tx_inputs().input_notes().clone();
+    let mast_store = tx_context.get_mast_store();
     let executor: TransactionExecutor =
-        TransactionExecutor::new(tx_context.get_data_store(), None).with_tracing();
+        TransactionExecutor::new(Arc::new(tx_context), mast_store, None).with_tracing();
     let executed_transaction = executor
-        .execute_transaction(account_id, block_ref, &note_ids, tx_context.tx_args().clone())
+        .execute_transaction(account_id, block_ref, notes, tx_args)
         .map_err(|e| e.to_string())?;
 
     Ok(executed_transaction.into())
 }
 
 /// Runs the transaction which consumes a P2ID note into a basic wallet.
+#[allow(clippy::arc_with_non_send_sync)]
 pub fn benchmark_p2id() -> Result<TransactionMeasurements, String> {
     // Create assets
     let faucet_id = AccountId::try_from(ACCOUNT_ID_PUBLIC_FUNGIBLE_FAUCET).unwrap();
@@ -116,17 +115,14 @@ pub fn benchmark_p2id() -> Result<TransactionMeasurements, String> {
     let tx_context = TransactionContextBuilder::new(target_account.clone())
         .input_notes(vec![note.clone()])
         .build();
+    let block_ref = tx_context.tx_inputs().block_header().block_num();
 
-    let executor = TransactionExecutor::new(tx_context.get_data_store(), Some(falcon_auth.clone()))
-        .with_tracing();
+    let notes = tx_context.tx_inputs().input_notes().clone();
+    let mast_store = tx_context.get_mast_store();
 
-    let block_ref = tx_context.tx_inputs().block_header().block_num();
-    let note_ids = tx_context
-        .tx_inputs()
-        .input_notes()
-        .iter()
-        .map(|note| note.id())
-        .collect::<Vec<_>>();
+    let executor =
+        TransactionExecutor::new(Arc::new(tx_context), mast_store, Some(falcon_auth.clone()))
+            .with_tracing();
 
     let tx_script_target =
         TransactionScript::compile(DEFAULT_AUTH_SCRIPT, [], TransactionKernel::assembler())
@@ -135,7 +131,7 @@ pub fn benchmark_p2id() -> Result<TransactionMeasurements, String> {
 
     // execute transaction
     let executed_transaction = executor
-        .execute_transaction(target_account.id(), block_ref, &note_ids, tx_args_target)
+        .execute_transaction(target_account.id(), block_ref, notes, tx_args_target)
         .unwrap();
 
     Ok(executed_transaction.into())

crates/miden-objects/src/note/note_tag.rs

@@ -324,7 +324,7 @@ mod tests {
             ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE,
             ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE_2,
             ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_UPDATABLE_CODE,
-            ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_UPDATABLE_CODE_ON_2, ACCOUNT_ID_SENDER,
+            ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_UPDATABLE_CODE_ON_CHAIN_2, ACCOUNT_ID_SENDER,
         },
         NoteError,
     };
@@ -342,7 +342,8 @@ mod tests {
             AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE).unwrap(),
             AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE_2).unwrap(),
             AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_UPDATABLE_CODE).unwrap(),
-            AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_UPDATABLE_CODE_ON_2).unwrap(),
+            AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_UPDATABLE_CODE_ON_CHAIN_2)
+                .unwrap(),
             AccountId::try_from(ACCOUNT_ID_PUBLIC_FUNGIBLE_FAUCET).unwrap(),
             AccountId::try_from(ACCOUNT_ID_PUBLIC_FUNGIBLE_FAUCET_1).unwrap(),
             AccountId::try_from(ACCOUNT_ID_PUBLIC_FUNGIBLE_FAUCET_2).unwrap(),

crates/miden-objects/src/testing/account_id.rs

@@ -37,7 +37,7 @@ pub const ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_UPDATABLE_CODE: u128 = account_id(
     AccountStorageMode::Public,
     0xacdd_eefc,
 );
-pub const ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_UPDATABLE_CODE_ON_2: u128 = account_id(
+pub const ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_UPDATABLE_CODE_ON_CHAIN_2: u128 = account_id(
     AccountType::RegularAccountUpdatableCode,
     AccountStorageMode::Public,
     0xeeff_ccdd,

crates/miden-tx/src/errors/mod.rs

@@ -18,6 +18,8 @@ pub enum TransactionExecutorError {
     TransactionProgramExecutionFailed(#[source] ExecutionError),
     #[error("failed to fetch transaction inputs from the data store")]
     FetchTransactionInputsFailed(#[source] DataStoreError),
+    #[error("failed to create transaction inputs")]
+    InvalidTransactionInputs(#[source] TransactionInputError),
     #[error("input account ID {input_id} does not match output account ID {output_id}")]
     InconsistentAccountId {
         input_id: AccountId,
@@ -113,8 +115,6 @@ pub enum DataStoreError {
     AccountNotFound(AccountId),
     #[error("block with number {0} not found in data store")]
     BlockNotFound(BlockNumber),
-    #[error("failed to create transaction inputs")]
-    InvalidTransactionInput(#[source] TransactionInputError),
     #[error("note with id {0} is already consumed")]
     NoteAlreadyConsumed(NoteId),
     #[error("not with id {0} not found in data store")]

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

@@ -1,9 +1,13 @@
 #[cfg(feature = "async")]
 use alloc::boxed::Box;
+use alloc::collections::BTreeSet;
 
 use miden_objects::{
-    account::AccountId, block::BlockNumber, note::NoteId, transaction::TransactionInputs,
+    account::{Account, AccountId},
+    block::{BlockHeader, BlockNumber},
+    transaction::ChainMmr,
 };
+use vm_processor::Word;
 use winter_maybe_async::*;
 
 use crate::DataStoreError;
@@ -15,26 +19,36 @@ use crate::DataStoreError;
 /// required for transaction execution.
 #[maybe_async_trait]
 pub trait DataStore {
-    /// Returns account, chain, and input note data required to execute a transaction against
-    /// the account with the specified ID and consuming the set of specified input notes.
+    /// Returns blockchain-related data required to execute a transaction against a specific
+    /// account, that consumes specific notes.
     ///
-    /// block_ref must be the block number of the block by which all of the input notes have been
-    /// recorded in the chain. In general, it is recommended that bock_ref corresponds to the
-    /// latest block available in the data store.
+    /// The returned [`ChainMmr`] is expected to contain the complete set of requested
+    /// block numbers (`ref_blocks`).
     ///
     /// # Errors
     /// Returns an error if:
-    /// - The account with the specified ID could not be found in the data store.
     /// - The block with the specified number could not be found in the data store.
-    /// - Any of the notes with the specified IDs could not be found in the data store.
-    /// - Any of the notes with the specified IDs were already consumed.
     /// - The combination of specified inputs resulted in a transaction input error.
     /// - The data store encountered some internal error
     #[maybe_async]
-    fn get_transaction_inputs(
+    fn get_chain_inputs(
+        &self,
+        ref_blocks: BTreeSet<BlockNumber>,
+        block_header: BlockNumber,
+    ) -> Result<(ChainMmr, BlockHeader), DataStoreError>;
+
+    /// Returns account data required to execute a transaction.
+    ///
+    /// For a new [`Account`], the corresponding seed should be returned as the second element
+    /// of the return tuple.
+    ///
+    /// # Errors
+    /// Returns an error if:
+    /// - The account with the specified ID could not be found in the data store.
+    /// - The data store encountered some internal error.
+    #[maybe_async]
+    fn get_account_inputs(
         &self,
         account_id: AccountId,
-        block_ref: BlockNumber,
-        notes: &[NoteId],
-    ) -> Result<TransactionInputs, DataStoreError>;
+    ) -> Result<(Account, Option<Word>), DataStoreError>;
 }

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

@@ -3,14 +3,16 @@ use alloc::{collections::BTreeSet, sync::Arc, vec::Vec};
 use miden_lib::transaction::TransactionKernel;
 use miden_objects::{
     account::{AccountCode, AccountId},
-    assembly::Library,
     block::BlockNumber,
-    note::NoteId,
-    transaction::{ExecutedTransaction, TransactionArgs, TransactionInputs, TransactionScript},
+    note::NoteLocation,
+    transaction::{
+        ExecutedTransaction, InputNote, InputNotes, TransactionArgs, TransactionInputs,
+        TransactionScript,
+    },
     vm::StackOutputs,
     Felt, MAX_TX_EXECUTION_CYCLES, MIN_TX_EXECUTION_CYCLES, ZERO,
 };
-use vm_processor::{AdviceInputs, ExecutionOptions, Process, RecAdviceProvider};
+use vm_processor::{AdviceInputs, ExecutionOptions, MastForestStore, Process, RecAdviceProvider};
 use winter_maybe_async::{maybe_async, maybe_await};
 
 use super::{TransactionExecutorError, TransactionHost};
@@ -36,7 +38,7 @@ pub use mast_store::TransactionMastStore;
 /// [TransactionAuthenticator], allowing it to be used with different backend implementations.
 pub struct TransactionExecutor {
     data_store: Arc<dyn DataStore>,
-    mast_store: Arc<TransactionMastStore>,
+    mast_forest_store: Arc<dyn MastForestStore>,
     authenticator: Option<Arc<dyn TransactionAuthenticator>>,
     /// Holds the code of all accounts loaded into this transaction executor via the
     /// [Self::load_account_code()] method.
@@ -52,13 +54,14 @@ impl TransactionExecutor {
     /// [TransactionAuthenticator].
     pub fn new(
         data_store: Arc<dyn DataStore>,
+        mast_forest_store: Arc<dyn MastForestStore>,
         authenticator: Option<Arc<dyn TransactionAuthenticator>>,
     ) -> Self {
         const _: () = assert!(MIN_TX_EXECUTION_CYCLES <= MAX_TX_EXECUTION_CYCLES);
 
         Self {
             data_store,
-            mast_store: Arc::new(TransactionMastStore::new()),
+            mast_forest_store,
             authenticator,
             exec_options: ExecutionOptions::new(
                 Some(MAX_TX_EXECUTION_CYCLES),
@@ -91,27 +94,6 @@ impl TransactionExecutor {
         self
     }
 
-    // STATE MUTATORS
-    // --------------------------------------------------------------------------------------------
-
-    /// Loads the provided account code into the internal MAST forest store and adds the commitment
-    /// of the provided code to the commitments set.
-    pub fn load_account_code(&mut self, code: &AccountCode) {
-        // load the code mast forest to the mast store
-        self.mast_store.load_account_code(code);
-
-        // store the commitment of the foreign account code in the set
-        self.account_codes.insert(code.clone());
-    }
-
-    /// Loads the provided library code into the internal MAST forest store.
-    ///
-    /// TODO: this is a work-around to support accounts which were complied with user-defined
-    /// libraries. Once Miden Assembler supports library vendoring, this should go away.
-    pub fn load_library(&mut self, library: &Library) {
-        self.mast_store.insert(library.mast_forest().clone());
-    }
-
     // TRANSACTION EXECUTION
     // --------------------------------------------------------------------------------------------
 
@@ -130,24 +112,36 @@ impl TransactionExecutor {
         &self,
         account_id: AccountId,
         block_ref: BlockNumber,
-        notes: &[NoteId],
+        notes: InputNotes<InputNote>,
         tx_args: TransactionArgs,
     ) -> Result<ExecutedTransaction, TransactionExecutorError> {
-        let tx_inputs =
-            maybe_await!(self.data_store.get_transaction_inputs(account_id, block_ref, notes))
-                .map_err(TransactionExecutorError::FetchTransactionInputsFailed)?;
+        // TODO: Check that the reference block is not listed here, or otherwise
+        // change the DataStore/executor API so that returning a ChainMmr with the reference
+        // block works anyway.
+        let ref_blocks: BTreeSet<BlockNumber> = notes
+            .iter()
+            .filter_map(InputNote::location)
+            .map(NoteLocation::block_num)
+            .collect();
+
+        let (account, seed) = maybe_await!(self.data_store.get_account_inputs(account_id))
+            .map_err(TransactionExecutorError::FetchTransactionInputsFailed)?;
+
+        let (mmr, header) = maybe_await!(self.data_store.get_chain_inputs(ref_blocks, block_ref))
+            .map_err(TransactionExecutorError::FetchTransactionInputsFailed)?;
+
+        let tx_inputs = TransactionInputs::new(account, seed, header, mmr, notes)
+            .map_err(TransactionExecutorError::InvalidTransactionInputs)?;
 
         let (stack_inputs, advice_inputs) =
             TransactionKernel::prepare_inputs(&tx_inputs, &tx_args, None);
-        let advice_recorder: RecAdviceProvider = advice_inputs.into();
 
-        // load note script MAST into the MAST store
-        self.mast_store.load_transaction_code(&tx_inputs, &tx_args);
+        let advice_recorder: RecAdviceProvider = advice_inputs.into();
 
         let mut host = TransactionHost::new(
             tx_inputs.account().into(),
             advice_recorder,
-            self.mast_store.clone(),
+            self.mast_forest_store.clone(),
             self.authenticator.clone(),
             self.account_codes.iter().map(|code| code.commitment()).collect(),
         )
@@ -202,23 +196,26 @@ impl TransactionExecutor {
         tx_script: TransactionScript,
         advice_inputs: AdviceInputs,
     ) -> Result<[Felt; 16], TransactionExecutorError> {
-        let tx_inputs =
-            maybe_await!(self.data_store.get_transaction_inputs(account_id, block_ref, &[]))
+        let (account, seed) = maybe_await!(self.data_store.get_account_inputs(account_id))
+            .map_err(TransactionExecutorError::FetchTransactionInputsFailed)?;
+
+        let (mmr, header) =
+            maybe_await!(self.data_store.get_chain_inputs(Default::default(), block_ref))
                 .map_err(TransactionExecutorError::FetchTransactionInputsFailed)?;
 
+        let tx_inputs = TransactionInputs::new(account, seed, header, mmr, Default::default())
+            .map_err(TransactionExecutorError::InvalidTransactionInputs)?;
+
         let tx_args = TransactionArgs::new(Some(tx_script.clone()), None, Default::default());
 
         let (stack_inputs, advice_inputs) =
             TransactionKernel::prepare_inputs(&tx_inputs, &tx_args, Some(advice_inputs));
         let advice_recorder: RecAdviceProvider = advice_inputs.into();
 
-        // load transaction script MAST into the MAST store
-        self.mast_store.load_transaction_code(&tx_inputs, &tx_args);
-
         let mut host = TransactionHost::new(
             tx_inputs.account().into(),
             advice_recorder,
-            self.mast_store.clone(),
+            self.mast_forest_store.clone(),
             self.authenticator.clone(),
             self.account_codes.iter().map(|code| code.commitment()).collect(),
         )

crates/miden-tx/src/host/mod.rs

@@ -38,9 +38,7 @@ use note_builder::OutputNoteBuilder;
 mod tx_progress;
 pub use tx_progress::TransactionProgress;
 
-use crate::{
-    auth::TransactionAuthenticator, errors::TransactionHostError, executor::TransactionMastStore,
-};
+use crate::{auth::TransactionAuthenticator, errors::TransactionHostError};
 
 // TRANSACTION HOST
 // ================================================================================================
@@ -56,7 +54,7 @@ pub struct TransactionHost<A> {
     adv_provider: A,
 
     /// MAST store which contains the code required to execute the transaction.
-    mast_store: Arc<TransactionMastStore>,
+    mast_store: Arc<dyn MastForestStore>,
 
     /// Account state changes accumulated during transaction execution.
     ///
@@ -98,7 +96,7 @@ impl<A: AdviceProvider> TransactionHost<A> {
     pub fn new(
         account: AccountHeader,
         adv_provider: A,
-        mast_store: Arc<TransactionMastStore>,
+        mast_store: Arc<dyn MastForestStore>,
         authenticator: Option<Arc<dyn TransactionAuthenticator>>,
         mut account_code_commitments: BTreeSet<Digest>,
     ) -> Result<Self, TransactionHostError> {

crates/miden-tx/src/testing/tx_context/builder.rs

@@ -3,7 +3,7 @@
 
 use alloc::{collections::BTreeMap, vec::Vec};
 
-use miden_lib::transaction::TransactionKernel;
+use miden_lib::{transaction::TransactionKernel, utils::word_to_masm_push_string};
 use miden_objects::{
     account::{Account, AccountCode, AccountId},
     assembly::Assembler,
@@ -23,7 +23,6 @@ use miden_objects::{
         storage::prepare_assets,
     },
     transaction::{OutputNote, TransactionArgs, TransactionInputs, TransactionScript},
-    utils::word_to_masm_push_string,
     vm::AdviceMap,
     FieldElement,
 };