refactor: Change way of providing code and inputs to executor

CHANGELOG.md

@@ -6,6 +6,7 @@
 - [BREAKING] Hash keys in storage maps before insertion into the SMT (#1250).
 - Added getter for proof security level in `ProvenBatch` and `ProvenBlock` (#1259).
 - [BREAKING] Replaced the `ProvenBatch::new_unchecked` with the `ProvenBatch::new` method to initialize the struct with validations (#1260).
+- Added a retry strategy for worker's health check (#1255).
 - [BREAKING] Refactored how foreign account inputs are passed to `TransactionExecutor`, and upgraded Rust version to 1.86 (#1229).
 
 ## 0.8.1 (2025-03-26) - `miden-objects` and `miden-tx` crates only.

bin/bench-tx/src/main.rs

@@ -60,7 +60,6 @@ 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()
@@ -81,7 +80,6 @@ pub fn benchmark_default_tx() -> Result<TransactionMeasurements, String> {
 }
 
 /// 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();

crates/miden-lib/src/transaction/inputs.rs

@@ -1,7 +1,7 @@
 use alloc::vec::Vec;
 
 use miden_objects::{
-    Digest, EMPTY_WORD, Felt, FieldElement, WORD_SIZE, Word, ZERO,
+    Digest, EMPTY_WORD, Felt, FieldElement, TransactionInputError, WORD_SIZE, Word, ZERO,
     account::{Account, StorageSlot},
     transaction::{ChainMmr, InputNote, TransactionArgs, TransactionInputs, TransactionScript},
     vm::AdviceInputs,
@@ -22,7 +22,7 @@ pub(super) fn extend_advice_inputs(
     tx_inputs: &TransactionInputs,
     tx_args: &TransactionArgs,
     advice_inputs: &mut AdviceInputs,
-) {
+) -> Result<(), TransactionInputError> {
     // TODO: remove this value and use a user input instead
     let kernel_version = 0;
 
@@ -32,13 +32,13 @@ pub(super) fn extend_advice_inputs(
     add_kernel_commitments_to_advice_inputs(advice_inputs, kernel_version);
     add_chain_mmr_to_advice_inputs(tx_inputs.block_chain(), advice_inputs);
     add_account_to_advice_inputs(tx_inputs.account(), tx_inputs.account_seed(), advice_inputs);
-    add_input_notes_to_advice_inputs(tx_inputs, tx_args, advice_inputs);
+    add_input_notes_to_advice_inputs(tx_inputs, tx_args, advice_inputs)?;
     for foreign_account in tx_args.foreign_accounts() {
-        TransactionKernel::extend_advice_inputs_for_account(advice_inputs, foreign_account)
-            .unwrap();
+        TransactionKernel::extend_advice_inputs_for_account(advice_inputs, foreign_account)?;
     }
 
     advice_inputs.extend(tx_args.advice_inputs().clone());
+    Ok(())
 }
 
 // ADVICE STACK BUILDER
@@ -228,10 +228,10 @@ fn add_input_notes_to_advice_inputs(
     tx_inputs: &TransactionInputs,
     tx_args: &TransactionArgs,
     inputs: &mut AdviceInputs,
-) {
+) -> Result<(), TransactionInputError> {
     // if there are no input notes, nothing is added to the advice inputs
     if tx_inputs.input_notes().is_empty() {
-        return;
+        return Ok(());
     }
 
     let mut note_data = Vec::new();
@@ -288,7 +288,12 @@ fn add_input_notes_to_advice_inputs(
                             proof.location().node_index_in_block().into(),
                             note.commitment(),
                         )
-                        .unwrap(),
+                        .map_err(|err| {
+                            TransactionInputError::InvalidMerklePath(
+                                format!("input note ID {}", note.id()),
+                                err,
+                            )
+                        })?,
                 );
                 note_data.push(proof.location().block_num().into());
                 note_data.extend(note_block_header.sub_commitment());
@@ -305,6 +310,7 @@ fn add_input_notes_to_advice_inputs(
 
     // NOTE: keep map in sync with the `prologue::process_input_notes_data` kernel procedure
     inputs.extend_map([(tx_inputs.input_notes().commitment(), note_data)]);
+    Ok(())
 }
 
 // KERNEL COMMITMENTS INJECTOR

crates/miden-lib/src/transaction/mod.rs

@@ -1,11 +1,10 @@
 use alloc::{string::ToString, sync::Arc, vec::Vec};
 
 use miden_objects::{
-    Digest, EMPTY_WORD, Felt, TransactionOutputError, ZERO,
+    Digest, EMPTY_WORD, Felt, TransactionInputError, TransactionOutputError, ZERO,
     account::{AccountCode, AccountId},
     assembly::{Assembler, DefaultSourceManager, KernelLibrary},
     block::BlockNumber,
-    crypto::merkle::MerkleError,
     transaction::{
         ForeignAccountInputs, OutputNote, OutputNotes, TransactionArgs, TransactionInputs,
         TransactionOutputs,
@@ -115,7 +114,7 @@ impl TransactionKernel {
         tx_inputs: &TransactionInputs,
         tx_args: &TransactionArgs,
         init_advice_inputs: Option<AdviceInputs>,
-    ) -> (StackInputs, AdviceInputs) {
+    ) -> Result<(StackInputs, AdviceInputs), TransactionInputError> {
         let account = tx_inputs.account();
 
         let stack_inputs = TransactionKernel::build_input_stack(
@@ -127,9 +126,9 @@ impl TransactionKernel {
         );
 
         let mut advice_inputs = init_advice_inputs.unwrap_or_default();
-        inputs::extend_advice_inputs(tx_inputs, tx_args, &mut advice_inputs);
+        inputs::extend_advice_inputs(tx_inputs, tx_args, &mut advice_inputs)?;
 
-        (stack_inputs, advice_inputs)
+        Ok((stack_inputs, advice_inputs))
     }
 
     // ASSEMBLER CONSTRUCTOR
@@ -201,11 +200,11 @@ impl TransactionKernel {
     pub fn extend_advice_inputs_for_account(
         advice_inputs: &mut AdviceInputs,
         foreign_account_inputs: &ForeignAccountInputs,
-    ) -> Result<(), MerkleError> {
+    ) -> Result<(), TransactionInputError> {
         let account_header = foreign_account_inputs.account_header();
         let storage_header = foreign_account_inputs.storage_header();
         let account_code = foreign_account_inputs.account_code();
-        let merkle_path = foreign_account_inputs.merkle_proof();
+        let merkle_path = foreign_account_inputs.account_witness();
         let storage_proofs = foreign_account_inputs.storage_map_proofs();
 
         let account_id = account_header.id();
@@ -228,14 +227,29 @@ impl TransactionKernel {
         // Extend the advice inputs with Merkle store data
         advice_inputs.extend_merkle_store(
             // The prefix is the index in the account tree.
-            merkle_path.inner_nodes(account_id.prefix().as_u64(), account_header.commitment())?,
+            merkle_path
+                .inner_nodes(account_id.prefix().as_u64(), account_header.commitment())
+                .map_err(|err| {
+                    TransactionInputError::InvalidMerklePath(
+                        format!("foreign account ID {}", account_id),
+                        err,
+                    )
+                })?,
         );
 
         // Load merkle nodes for storage maps
         for proof in storage_proofs {
             // Extend the merkle store and map with the storage maps
             advice_inputs.extend_merkle_store(
-                proof.path().inner_nodes(proof.leaf().index().value(), proof.leaf().hash())?,
+                proof
+                    .path()
+                    .inner_nodes(proof.leaf().index().value(), proof.leaf().hash())
+                    .map_err(|err| {
+                        TransactionInputError::InvalidMerklePath(
+                            format!("foreign account ID {} storage proof", account_id),
+                            err,
+                        )
+                    })?,
             );
             // Populate advice map with Sparse Merkle Tree leaf nodes
             advice_inputs

crates/miden-objects/src/errors.rs

@@ -450,6 +450,8 @@ pub enum TransactionInputError {
     InputNoteNotInBlock(NoteId, BlockNumber),
     #[error("account ID computed from seed is invalid")]
     InvalidAccountIdSeed(#[source] AccountIdError),
+    #[error("merkle path for {0} is invalid")]
+    InvalidMerklePath(String, #[source] MerkleError),
     #[error(
         "total number of input notes is {0} which exceeds the maximum of {MAX_INPUT_NOTES_PER_TX}"
     )]

crates/miden-objects/src/transaction/inputs.rs

@@ -1,7 +1,7 @@
 use alloc::{collections::BTreeSet, vec::Vec};
 use core::fmt::Debug;
 
-use miden_crypto::merkle::{MerklePath, SmtProof};
+use miden_crypto::merkle::{MerkleError, MerklePath, SmtProof};
 
 use super::{BlockHeader, ChainMmr, Digest, Felt, Hasher, Word};
 use crate::{
@@ -549,7 +549,7 @@ pub struct ForeignAccountInputs {
     /// Code associated with the account.
     account_code: AccountCode,
     /// Merkle proof of the account's inclusion in the account tree.
-    merkle_proof: MerklePath,
+    account_witness: MerklePath,
     /// Storage SMT proof for storage map values that the transaction will access.
     storage_map_proofs: Vec<SmtProof>,
 }
@@ -567,7 +567,7 @@ impl ForeignAccountInputs {
             account_header,
             storage_header,
             account_code,
-            merkle_proof,
+            account_witness: merkle_proof,
             storage_map_proofs,
         }
     }
@@ -597,9 +597,15 @@ impl ForeignAccountInputs {
         &self.account_code
     }
 
-    /// Returns the account's proof.
-    pub fn merkle_proof(&self) -> &MerklePath {
-        &self.merkle_proof
+    /// Returns the account witness.
+    pub fn account_witness(&self) -> &MerklePath {
+        &self.account_witness
+    }
+
+    /// Computes account root based on the account witness.
+    pub fn compute_account_root(&self) -> Result<Digest, MerkleError> {
+        self.account_witness()
+            .compute_root(self.id().prefix().into(), self.account_header().commitment())
     }
 
     /// Extends the storage proofs with the input `smt_proofs` and returns the new structure
@@ -620,7 +626,7 @@ impl ForeignAccountInputs {
             self.account_header,
             self.storage_header,
             self.account_code,
-            self.merkle_proof,
+            self.account_witness,
             self.storage_map_proofs,
         )
     }
@@ -631,7 +637,7 @@ impl Serializable for ForeignAccountInputs {
         self.account_header.write_into(target);
         self.storage_header.write_into(target);
         self.account_code.write_into(target);
-        self.merkle_proof.write_into(target);
+        self.account_witness.write_into(target);
         self.storage_map_proofs.write_into(target);
     }
 }
@@ -654,3 +660,45 @@ impl Deserializable for ForeignAccountInputs {
         ))
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use miden_crypto::merkle::MerklePath;
+    use vm_core::{
+        Felt,
+        utils::{Deserializable, Serializable},
+    };
+
+    use super::ForeignAccountInputs;
+    use crate::{
+        account::{Account, AccountCode, AccountHeader, AccountId, AccountStorage},
+        asset::AssetVault,
+        testing::account_id::ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE,
+    };
+
+    #[test]
+    fn serde_roundtrip() {
+        let id = AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE).unwrap();
+        let code = AccountCode::mock();
+        let vault = AssetVault::new(&[]).unwrap();
+        let storage = AccountStorage::new(vec![]).unwrap();
+        let account = Account::from_parts(id, vault, storage, code, Felt::new(10));
+
+        let commitment = account.commitment();
+        let header: AccountHeader = account.clone().into();
+        let (_, _, storage, code, _) = account.into_parts();
+
+        let fpi_inputs = ForeignAccountInputs::new(
+            header,
+            storage.get_header(),
+            code,
+            MerklePath::new(vec![commitment]),
+            vec![],
+        );
+
+        let serialized = fpi_inputs.to_bytes();
+        let deserialized = ForeignAccountInputs::read_from_bytes(&serialized).unwrap();
+        assert_eq!(deserialized, fpi_inputs);
+    }
+}

crates/miden-objects/src/transaction/tx_args.rs

@@ -1,4 +1,8 @@
-use alloc::{collections::BTreeMap, sync::Arc, vec::Vec};
+use alloc::{
+    collections::{BTreeMap, BTreeSet},
+    sync::Arc,
+    vec::Vec,
+};
 
 use assembly::{Assembler, Compile};
 use miden_crypto::merkle::InnerNodeInfo;
@@ -107,6 +111,14 @@ impl TransactionArgs {
         &self.foreign_accounts
     }
 
+    /// Collects and returns a set containing all code commitments from foreign accounts.
+    pub fn foreign_account_code_commitments(&self) -> BTreeSet<Digest> {
+        self.foreign_accounts()
+            .iter()
+            .map(|acc| acc.account_code().commitment())
+            .collect()
+    }
+
     // STATE MUTATORS
     // --------------------------------------------------------------------------------------------
 
@@ -149,7 +161,7 @@ impl TransactionArgs {
         }
     }
 
-    /// Extends the provided [TransactionArgs] with the passed-in `advice_inputs`.
+    /// Extends the advice inputs in self with the provided ones.
     pub fn extend_advice_inputs(&mut self, advice_inputs: AdviceInputs) {
         self.advice_inputs.extend(advice_inputs);
     }

crates/miden-objects/src/transaction/tx_witness.rs

@@ -17,6 +17,11 @@ use crate::utils::serde::{ByteReader, Deserializable, DeserializationError, Seri
 ///   additional advice data to initialize the advice provide with prior to transaction execution.
 /// - Advice witness which contains all data requested by the VM from the advice provider while
 ///   executing the transaction program.
+///
+/// TODO: currently, the advice witness contains redundant and irrelevant data (e.g., tx inputs
+/// and tx outputs; account codes and a subset of that data in advice inputs).
+/// We should optimize it to contain only the minimum data required for executing/proving the
+/// transaction.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct TransactionWitness {
     pub tx_inputs: TransactionInputs,

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

@@ -3,21 +3,21 @@ use core::error::Error;
 
 use miden_objects::{
     AccountError, Felt, ProvenTransactionError, TransactionInputError, TransactionOutputError,
-    account::AccountId, block::BlockNumber,
+    account::AccountId, block::BlockNumber, note::NoteId,
 };
 use miden_verifier::VerificationError;
 use thiserror::Error;
-use vm_processor::ExecutionError;
+use vm_processor::{ExecutionError, crypto::MerkleError};
 
 // TRANSACTION EXECUTOR ERROR
 // ================================================================================================
 
 #[derive(Debug, Error)]
 pub enum TransactionExecutorError {
-    #[error("failed to execute transaction kernel program")]
-    TransactionProgramExecutionFailed(#[source] ExecutionError),
     #[error("failed to fetch transaction inputs from the data store")]
     FetchTransactionInputsFailed(#[source] DataStoreError),
+    #[error("foreign account inputs for ID {0} are not anchored on reference block")]
+    ForeignAccountNotAnchoredInReference(AccountId),
     #[error("failed to create transaction inputs")]
     InvalidTransactionInputs(#[source] TransactionInputError),
     #[error("input account ID {input_id} does not match output account ID {output_id}")]
@@ -30,10 +30,18 @@ pub enum TransactionExecutorError {
         expected: Option<Felt>,
         actual: Option<Felt>,
     },
-    #[error("failed to construct transaction outputs")]
-    TransactionOutputConstructionFailed(#[source] TransactionOutputError),
+    #[error("account witness provided for account ID {0} is invalid")]
+    InvalidAccountWitness(AccountId, #[source] MerkleError),
+    #[error(
+        "input note {0} was created in a block past the transaction reference block number ({1})"
+    )]
+    NoteBlockPastReferenceBlock(NoteId, BlockNumber),
     #[error("failed to create transaction host")]
     TransactionHostCreationFailed(#[source] TransactionHostError),
+    #[error("failed to construct transaction outputs")]
+    TransactionOutputConstructionFailed(#[source] TransactionOutputError),
+    #[error("failed to execute transaction kernel program")]
+    TransactionProgramExecutionFailed(#[source] ExecutionError),
 }
 
 // TRANSACTION PROVER ERROR
@@ -43,6 +51,8 @@ pub enum TransactionExecutorError {
 pub enum TransactionProverError {
     #[error("failed to apply account delta")]
     AccountDeltaApplyFailed(#[source] AccountError),
+    #[error("transaction inputs are not valid")]
+    InvalidTransactionInputs(#[source] TransactionInputError),
     #[error("failed to construct transaction outputs")]
     TransactionOutputConstructionFailed(#[source] TransactionOutputError),
     #[error("failed to build proven transaction")]