Migrate batch kernel parts from miden-node

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - [BREAKING] Incremented minimum supported Rust version to 1.84.
 - [BREAKING] Moved `generated` module from `miden-proving-service-client` crate to `tx_prover::generated` hierarchy (#1102).
+- Implement transaction batch prover in Rust (#1112).
 
 ## 0.7.1 (2025-01-24) - `miden-objects` crate only
 

Cargo.toml

@@ -3,6 +3,7 @@ resolver = "2"
 members = [
     "bin/bench-tx",
     "bin/proving-service",
+    "crates/miden-tx-batch-prover",
     "crates/miden-lib",
     "crates/miden-objects",
     "crates/miden-proving-service-client",

crates/miden-objects/src/batch/account_update.rs

@@ -0,0 +1,144 @@
+use alloc::vec::Vec;
+
+use vm_core::utils::{ByteReader, ByteWriter, Deserializable, Serializable};
+use vm_processor::{DeserializationError, Digest};
+
+use crate::{
+    account::{delta::AccountUpdateDetails, AccountId},
+    errors::BatchAccountUpdateError,
+    transaction::{ProvenTransaction, TransactionId},
+};
+
+// BATCH ACCOUNT UPDATE
+// ================================================================================================
+
+/// Represents the changes made to an account resulting from executing a batch of transactions.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BatchAccountUpdate {
+    /// ID of the updated account.
+    account_id: AccountId,
+
+    /// Commitment to the state of the account before this update is applied.
+    ///
+    /// Equal to `Digest::default()` for new accounts.
+    initial_state_commitment: Digest,
+
+    /// Commitment to the state of the account after this update is applied.
+    final_state_commitment: Digest,
+
+    /// IDs of all transactions that updated the account.
+    transactions: Vec<TransactionId>,
+
+    /// A set of changes which can be applied to the previous account state (i.e. `initial_state`)
+    /// to get the new account state. For private accounts, this is set to
+    /// [`AccountUpdateDetails::Private`].
+    details: AccountUpdateDetails,
+}
+
+impl BatchAccountUpdate {
+    // CONSTRUCTORS
+    // --------------------------------------------------------------------------------------------
+
+    /// Creates a [`BatchAccountUpdate`] by cloning the update and other details from the provided
+    /// [`ProvenTransaction`].
+    pub fn from_transaction(transaction: &ProvenTransaction) -> Self {
+        Self {
+            account_id: transaction.account_id(),
+            initial_state_commitment: transaction.account_update().init_state_hash(),
+            final_state_commitment: transaction.account_update().final_state_hash(),
+            transactions: vec![transaction.id()],
+            details: transaction.account_update().details().clone(),
+        }
+    }
+
+    // PUBLIC ACCESSORS
+    // --------------------------------------------------------------------------------------------
+
+    /// Returns the ID of the updated account.
+    pub fn account_id(&self) -> AccountId {
+        self.account_id
+    }
+
+    /// Returns a commitment to the state of the account before this update is applied.
+    ///
+    /// This is equal to [`Digest::default()`] for new accounts.
+    pub fn initial_state_commitment(&self) -> Digest {
+        self.initial_state_commitment
+    }
+
+    /// Returns a commitment to the state of the account after this update is applied.
+    pub fn final_state_commitment(&self) -> Digest {
+        self.final_state_commitment
+    }
+
+    /// Returns a slice of [`TransactionId`]s that updated this account's state.
+    pub fn transactions(&self) -> &[TransactionId] {
+        &self.transactions
+    }
+
+    /// Returns the contained [`AccountUpdateDetails`].
+    ///
+    /// This update can be used to build the new account state from the previous account state.
+    pub fn details(&self) -> &AccountUpdateDetails {
+        &self.details
+    }
+
+    /// Returns `true` if the account update details are for a private account.
+    pub fn is_private(&self) -> bool {
+        self.details.is_private()
+    }
+
+    // MUTATORS
+    // --------------------------------------------------------------------------------------------
+
+    /// Merges the transaction's update into this account update.
+    pub fn merge_proven_tx(
+        &mut self,
+        tx: &ProvenTransaction,
+    ) -> Result<(), BatchAccountUpdateError> {
+        if self.account_id != tx.account_id() {
+            return Err(BatchAccountUpdateError::AccountUpdateIdMismatch {
+                transaction: tx.id(),
+                expected_account_id: self.account_id,
+                actual_account_id: tx.account_id(),
+            });
+        }
+
+        if self.final_state_commitment != tx.account_update().init_state_hash() {
+            return Err(BatchAccountUpdateError::AccountUpdateInitialStateMismatch(tx.id()));
+        }
+
+        self.details = self.details.clone().merge(tx.account_update().details().clone()).map_err(
+            |source_err| BatchAccountUpdateError::TransactionUpdateMergeError(tx.id(), source_err),
+        )?;
+        self.final_state_commitment = tx.account_update().final_state_hash();
+        self.transactions.push(tx.id());
+
+        Ok(())
+    }
+}
+
+// SERIALIZATION
+// ================================================================================================
+
+impl Serializable for BatchAccountUpdate {
+    fn write_into<W: ByteWriter>(&self, target: &mut W) {
+        self.account_id.write_into(target);
+        self.initial_state_commitment.write_into(target);
+        self.final_state_commitment.write_into(target);
+        self.transactions.write_into(target);
+        self.details.write_into(target);
+    }
+}
+
+impl Deserializable for BatchAccountUpdate {
+    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
+        Ok(Self {
+            account_id: AccountId::read_from(source)?,
+            initial_state_commitment: Digest::read_from(source)?,
+            final_state_commitment: Digest::read_from(source)?,
+            transactions: <Vec<TransactionId>>::read_from(source)?,
+            details: AccountUpdateDetails::read_from(source)?,
+        })
+    }
+}

crates/miden-objects/src/batch/batch_id.rs

@@ -0,0 +1,56 @@
+use alloc::{string::String, vec::Vec};
+
+use vm_core::{Felt, ZERO};
+use vm_processor::Digest;
+
+use crate::{transaction::ProvenTransaction, Hasher};
+
+// BATCH ID
+// ================================================================================================
+
+/// Uniquely identifies a batch of transactions, i.e. both
+/// [`ProposedBatch`](crate::batch::ProposedBatch) and [`ProvenBatch`](crate::batch::ProvenBatch).
+///
+/// This is a sequential hash of the tuple `(TRANSACTION_ID || [account_id_prefix,
+/// account_id_suffix, 0, 0])` of all transactions and the accounts their executed against in the
+/// batch.
+#[derive(Debug, Copy, Clone, Eq, Ord, PartialEq, PartialOrd)]
+pub struct BatchId(Digest);
+
+impl BatchId {
+    /// Calculates a batch ID from the given set of transactions.
+    pub fn compute<'tx, T>(txs: T) -> Self
+    where
+        T: Iterator<Item = &'tx ProvenTransaction>,
+    {
+        let mut elements: Vec<Felt> = Vec::new();
+        for tx in txs {
+            elements.extend_from_slice(tx.id().as_elements());
+            let [account_id_prefix, account_id_suffix] = <[Felt; 2]>::from(tx.account_id());
+            elements.extend_from_slice(&[account_id_prefix, account_id_suffix, ZERO, ZERO]);
+        }
+
+        Self(Hasher::hash_elements(&elements))
+    }
+
+    /// Returns the elements representation of this batch ID.
+    pub fn as_elements(&self) -> &[Felt] {
+        self.0.as_elements()
+    }
+
+    /// Returns the byte representation of this batch ID.
+    pub fn as_bytes(&self) -> [u8; 32] {
+        self.0.as_bytes()
+    }
+
+    /// Returns a big-endian, hex-encoded string.
+    pub fn to_hex(&self) -> String {
+        self.0.to_hex()
+    }
+}
+
+impl core::fmt::Display for BatchId {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}", self.to_hex())
+    }
+}

crates/miden-objects/src/batch/mod.rs

@@ -1,2 +1,14 @@
 mod note_tree;
 pub use note_tree::BatchNoteTree;
+
+mod batch_id;
+pub use batch_id::BatchId;
+
+mod account_update;
+pub use account_update::BatchAccountUpdate;
+
+mod proven_batch;
+pub use proven_batch::ProvenBatch;
+
+mod proposed_batch;
+pub use proposed_batch::ProposedBatch;

crates/miden-objects/src/batch/note_tree.rs

@@ -35,4 +35,9 @@ impl BatchNoteTree {
     pub fn root(&self) -> RpoDigest {
         self.0.root()
     }
+
+    /// Returns the number of non-empty leaves in this tree.
+    pub fn num_leaves(&self) -> usize {
+        self.0.num_leaves()
+    }
 }