Implement AccountComponents

CHANGELOG.md

@@ -31,11 +31,7 @@
 - [BREAKING] Changed type of `EMPTY_STORAGE_MAP_ROOT` constant to `RpoDigst`, which references constant from `miden-crypto` (#916).
 - Added `RemoteTransactionProver` struct to `miden-tx-prover` (#921).
 - [BREAKING] Migrated to v0.11 version of Miden VM (#929).
-- Added a proxy server for the `miden-tx-prover` service (#930).
-- Added `TransactionExecutor::load_account_code()` method to support foreign procedure invocation (#936).
-- Changed `RemoteTransactionProver` to lazily connect on prove (#937).
-- [BREAKING] Made `TransactionMastForest` and `BasicAuthenticator` be `Send`, `Sync`; made scripts lazily initialize (#939).
-- Added account codes to `TransactionWitness` (#946).
+- [BREAKING] Introduce a new way to build `Account`s from `AccountComponent`s (#941).
 
 ## 0.5.1 (2024-08-28) - `miden-objects` crate only
 

bin/bench-tx/src/main.rs

@@ -20,7 +20,7 @@ use vm_processor::ONE;
 
 mod utils;
 use utils::{
-    get_account_with_default_account_code, get_new_pk_and_authenticator,
+    get_account_with_basic_authenticated_wallet, get_new_pk_and_authenticator,
     write_bench_results_to_json, ACCOUNT_ID_FUNGIBLE_FAUCET_ON_CHAIN,
     ACCOUNT_ID_REGULAR_ACCOUNT_UPDATABLE_CODE_OFF_CHAIN, ACCOUNT_ID_SENDER, DEFAULT_AUTH_SCRIPT,
 };
@@ -98,7 +98,7 @@ pub fn benchmark_p2id() -> Result<TransactionMeasurements, String> {
     let (target_pub_key, falcon_auth) = get_new_pk_and_authenticator();
 
     let target_account =
-        get_account_with_default_account_code(target_account_id, target_pub_key, None);
+        get_account_with_basic_authenticated_wallet(target_account_id, target_pub_key, None);
 
     // Create the note
     let note = create_p2id_note(

bin/bench-tx/src/utils.rs

@@ -2,11 +2,11 @@ extern crate alloc;
 pub use alloc::{collections::BTreeMap, string::String};
 use std::sync::Arc;
 
-use miden_lib::transaction::TransactionKernel;
+use miden_lib::accounts::{auth::RpoFalcon512, wallets::BasicWallet};
 use miden_objects::{
-    accounts::{Account, AccountCode, AccountId, AccountStorage, AuthSecretKey, StorageSlot},
+    accounts::{Account, AccountId, AuthSecretKey},
     assets::{Asset, AssetVault},
-    crypto::dsa::rpo_falcon512::SecretKey,
+    crypto::dsa::rpo_falcon512::{PublicKey, SecretKey},
     transaction::TransactionMeasurements,
     Felt, Word,
 };
@@ -31,13 +31,6 @@ pub const DEFAULT_AUTH_SCRIPT: &str = "
     end
 ";
 
-pub const DEFAULT_ACCOUNT_CODE: &str = "
-    export.::miden::contracts::wallets::basic::receive_asset
-    export.::miden::contracts::wallets::basic::create_note
-    export.::miden::contracts::wallets::basic::move_asset_to_note
-    export.::miden::contracts::auth::basic::auth_tx_rpo_falcon512
-";
-
 // MEASUREMENTS PRINTER
 // ================================================================================================
 
@@ -68,16 +61,16 @@ impl From<TransactionMeasurements> for MeasurementsPrinter {
 // HELPER FUNCTIONS
 // ================================================================================================
 
-pub fn get_account_with_default_account_code(
+pub fn get_account_with_basic_authenticated_wallet(
     account_id: AccountId,
     public_key: Word,
     assets: Option<Asset>,
 ) -> Account {
-    let account_code_src = DEFAULT_ACCOUNT_CODE;
-    let assembler = TransactionKernel::assembler();
-
-    let account_code = AccountCode::compile(account_code_src, assembler, false).unwrap();
-    let account_storage = AccountStorage::new(vec![StorageSlot::Value(public_key)]).unwrap();
+    let (account_code, account_storage) = Account::initialize_from_components(
+        account_id.account_type(),
+        &[BasicWallet.into(), RpoFalcon512::new(PublicKey::new(public_key)).into()],
+    )
+    .unwrap();
 
     let account_vault = match assets {
         Some(asset) => AssetVault::new(&[asset]).unwrap(),

miden-lib/asm/kernels/transaction/lib/account.masm

@@ -365,9 +365,8 @@ end
 #! - All storage offsets and sizes are in bounds
 #! - All storage offsets adhere to account type specific rules
 #! - All procedures not accessing storage have offset and size set to 0
-#!
-#! Notes:
-#! - For faucets checks that no storage offset is 0 (preventing reserved storage slot access)
+#! - No storage offset of a faucet account's procedure is 0 with a size != 0
+#!   (to prevent access to the reserved storage slot)
 #!
 #! Stack: []
 #! Output: []
@@ -387,41 +386,40 @@ export.validate_procedure_metadata
     # we do not check if num_account_procedures == 0 here because a valid
     # account has between 1 and 256 procedures with associated offsets
     if.true
+        # This branch handles procedures from faucet accounts.
         while.true
             # get storage offset and size from memory
             dup exec.get_procedure_metadata
             # => [storage_offset, storage_size, index, num_storage_slots, num_account_procedures]
 
-            # assert that storage offset is not 0
-            dup push.0 neq assert.err=ERR_FAUCET_INVALID_STORAGE_OFFSET
+            # Procedures that do not access storage are defined with (offset, size) = (0, 0).
+            # But we want to fail on tuples defined with a zero size but non-zero offset, since that is a logic error.
+            # We want to panic when we see this condition, so we use assertz rather than assert.
+            # So we can assert this with: (size == 0 && offset != 0) == 0.
+            dup.1 eq.0 dup.1 eq.0 not and assertz.err=ERR_ACCOUNT_INVALID_STORAGE_OFFSET_FOR_SIZE
+            # => [storage_offset, storage_size, index, num_storage_slots, num_account_procedures]
+
+            # No procedure should access the reserved faucet slot (slot 0). However (0, 0) should
+            # still be allowed per the above.
+            # We want to panic when we see this condition, so we use assertz rather than assert.
+            # So we can assert this with: (offset == 0 && size != 0) == 0.
+            dup.1 eq.0 not dup.1 eq.0 and assertz.err=ERR_FAUCET_INVALID_STORAGE_OFFSET
+            # => [storage_offset, storage_size, index, num_storage_slots, num_account_procedures]
+
+            # assert that storage offset is in bounds
+            dup dup.4 lt assert.err=ERR_STORAGE_SLOT_INDEX_OUT_OF_BOUNDS
             # => [storage_offset, storage_size, index, num_storage_slots, num_account_procedures]
 
-            # TODO: This is a temporary check for faucets. We add 1 to all faucet offsets
-            # to prevent access to the reserved faucet data slot. When the assembler
-            # will support storage offsets and sizes remove this check.
-            # check if the storage offset and the number of storage slots are 1
-            dup dup.4 eq.1 swap eq.1 and
-            # => [both_1, storage_offset, storage_size, index, num_storage_slots, num_account_procedures]
-
-            if.true
-                # clean stack
-                drop drop
-                # => [index, num_storage_slots, num_account_procedures]
-            else
-                # assert that storage offset is in bounds
-                dup dup.4 lt assert.err=ERR_STORAGE_SLOT_INDEX_OUT_OF_BOUNDS
-                # => [storage_offset, storage_size, index, num_storage_slots, num_account_procedures]
-
-                # assert that storage limit is in bounds
-                add dup.2 lte assert.err=ERR_STORAGE_SLOT_INDEX_OUT_OF_BOUNDS
-                # => [index, num_storage_slots, num_account_procedures]
-            end
+            # assert that storage limit is in bounds
+            add dup.2 lte assert.err=ERR_STORAGE_SLOT_INDEX_OUT_OF_BOUNDS
+            # => [index, num_storage_slots, num_account_procedures]
 
             # check if we should continue looping
             add.1 dup dup.3 lt
             # => [should_loop, index, num_storage_slots, num_account_procedures]
         end
     else
+        # This branch handles procedures from regular accounts.
         while.true
             # get storage offset and size from memory
             dup exec.get_procedure_metadata
@@ -431,12 +429,11 @@ export.validate_procedure_metadata
             dup dup.4 lt assert.err=ERR_STORAGE_SLOT_INDEX_OUT_OF_BOUNDS
             # => [storage_offset, storage_size, index, num_storage_slots, num_account_procedures]
 
-            # TODO: Find a way to remove this `if` statement
-            # assert that if size is 0 then offset is 0
-            dup.1 eq.0
-            if.true
-                dup eq.0 assert.err=ERR_ACCOUNT_INVALID_STORAGE_OFFSET_FOR_SIZE
-            end
+            # Procedures that do not access storage are defined with (offset, size) = (0, 0).
+            # But we want to fail on tuples defined with a zero size but non-zero offset, since that is a logic error.
+            # We want to panic when we see this condition, so we use assertz rather than assert.
+            # So we can assert this with: (size == 0 && offset != 0) == 0.
+            dup.1 eq.0 dup.1 eq.0 not and assertz.err=ERR_ACCOUNT_INVALID_STORAGE_OFFSET_FOR_SIZE
             # => [storage_offset, storage_size, index, num_storage_slots, num_account_procedures]
 
             # assert that storage limit is in bounds

miden-lib/asm/miden/contracts/auth/basic.masm

@@ -5,7 +5,7 @@ use.std::crypto::dsa::rpo_falcon512
 # CONSTANTS
 # =================================================================================================
 
-# Slot in account storage at which the public key is stored.
+# The slot in this component's storage layout where the public key is stored.
 const.PUBLIC_KEY_SLOT=0
 
 #! Authenticate a transaction using the Falcon signature scheme

miden-lib/asm/miden/contracts/faucets/basic_fungible.masm

@@ -26,8 +26,8 @@ const.ERR_FUNGIBLE_ASSET_DISTRIBUTE_WOULD_CAUSE_MAX_SUPPLY_TO_BE_EXCEEDED=0x0002
 # CONSTANTS
 # =================================================================================================
 
-# Slot in account storage at which the metadata is stored.
-const.METADATA_SLOT=1
+# The slot in this component's storage layout where the metadata is stored.
+const.METADATA_SLOT=0
 
 # Basic authentication for the faucet owner.
 export.basic::auth_tx_rpo_falcon512

miden-lib/build.rs

@@ -21,6 +21,7 @@ const ASSETS_DIR: &str = "assets";
 const ASM_DIR: &str = "asm";
 const ASM_MIDEN_DIR: &str = "miden";
 const ASM_NOTE_SCRIPTS_DIR: &str = "note_scripts";
+const ASM_ACCOUNT_COMPONENTS_DIR: &str = "account_components";
 const ASM_TX_KERNEL_DIR: &str = "kernels/transaction";
 const KERNEL_V0_RS_FILE: &str = "src/transaction/procedures/kernel_v0.rs";
 
@@ -61,9 +62,12 @@ fn main() -> Result<()> {
     compile_note_scripts(
         &source_dir.join(ASM_NOTE_SCRIPTS_DIR),
         &target_dir.join(ASM_NOTE_SCRIPTS_DIR),
-        assembler,
+        assembler.clone(),
     )?;
 
+    // compile account components
+    compile_account_components(&target_dir.join(ASM_ACCOUNT_COMPONENTS_DIR), assembler)?;
+
     Ok(())
 }
 
@@ -299,6 +303,41 @@ fn compile_note_scripts(source_dir: &Path, target_dir: &Path, assembler: Assembl
     Ok(())
 }
 
+// COMPILE DEFAULT ACCOUNT COMPONENTS
+// ================================================================================================
+
+const BASIC_WALLET_CODE: &str = "
+    export.::miden::contracts::wallets::basic::receive_asset
+    export.::miden::contracts::wallets::basic::create_note
+    export.::miden::contracts::wallets::basic::move_asset_to_note
+";
+
+const RPO_FALCON_AUTH_CODE: &str = "
+    export.::miden::contracts::auth::basic::auth_tx_rpo_falcon512
+";
+
+const BASIC_FUNGIBLE_FAUCET_CODE: &str = "
+    export.::miden::contracts::faucets::basic_fungible::distribute
+    export.::miden::contracts::faucets::basic_fungible::burn
+";
+
+/// Compiles the default account components into a MASL library and stores the complied files in
+/// `target_dir`.
+fn compile_account_components(target_dir: &Path, assembler: Assembler) -> Result<()> {
+    for (component_name, component_code) in [
+        ("basic_wallet", BASIC_WALLET_CODE),
+        ("rpo_falcon_512", RPO_FALCON_AUTH_CODE),
+        ("basic_fungible_faucet", BASIC_FUNGIBLE_FAUCET_CODE),
+    ] {
+        let component_library = assembler.clone().assemble_library([component_code])?;
+        let component_file_path =
+            target_dir.join(component_name).with_extension(Library::LIBRARY_EXTENSION);
+        component_library.write_to_file(component_file_path).into_diagnostic()?;
+    }
+
+    Ok(())
+}
+
 // HELPER FUNCTIONS
 // ================================================================================================
 

miden-lib/src/accounts/auth/mod.rs

@@ -0,0 +1,36 @@
+use miden_objects::{
+    accounts::{AccountComponent, StorageSlot},
+    crypto::dsa::rpo_falcon512::PublicKey,
+};
+
+use crate::accounts::components::rpo_falcon_512_library;
+
+/// An [`AccountComponent`] implementing the RpoFalcon512 signature scheme for authentication of
+/// transactions.
+///
+/// Its exported procedures are:
+/// - `auth_tx_rpo_falcon512`, which can be used to verify a signature provided via the advice stack
+///   to authenticate a transaction.
+///
+/// This component supports all account types.
+pub struct RpoFalcon512 {
+    public_key: PublicKey,
+}
+
+impl RpoFalcon512 {
+    /// Creates a new [`RpoFalcon512`] component with the given `public_key`.
+    pub fn new(public_key: PublicKey) -> Self {
+        Self { public_key }
+    }
+}
+
+impl From<RpoFalcon512> for AccountComponent {
+    fn from(falcon: RpoFalcon512) -> Self {
+        AccountComponent::new(
+            rpo_falcon_512_library(),
+            vec![StorageSlot::Value(falcon.public_key.into())],
+        )
+        .expect("falcon component should satisfy the requirements of a valid account component")
+        .with_supports_all_types()
+    }
+}

miden-lib/src/accounts/components/mod.rs

@@ -0,0 +1,42 @@
+use miden_objects::{
+    assembly::Library,
+    utils::{sync::LazyLock, Deserializable},
+};
+
+// Initialize the Basic Wallet library only once.
+static BASIC_WALLET_LIBRARY: LazyLock<Library> = LazyLock::new(|| {
+    let bytes =
+        include_bytes!(concat!(env!("OUT_DIR"), "/assets/account_components/basic_wallet.masl"));
+    Library::read_from_bytes(bytes).expect("Shipped Basic Wallet library is well-formed")
+});
+
+// Initialize the Rpo Falcon 512 library only once.
+static RPO_FALCON_512_LIBRARY: LazyLock<Library> = LazyLock::new(|| {
+    let bytes =
+        include_bytes!(concat!(env!("OUT_DIR"), "/assets/account_components/rpo_falcon_512.masl"));
+    Library::read_from_bytes(bytes).expect("Shipped Rpo Falcon 512 library is well-formed")
+});
+
+// Initialize the Basic Fungible Faucet library only once.
+static BASIC_FUNGIBLE_FAUCET_LIBRARY: LazyLock<Library> = LazyLock::new(|| {
+    let bytes = include_bytes!(concat!(
+        env!("OUT_DIR"),
+        "/assets/account_components/basic_fungible_faucet.masl"
+    ));
+    Library::read_from_bytes(bytes).expect("Shipped Basic Fungible Faucet library is well-formed")
+});
+
+/// Returns the Basic Wallet Library.
+pub fn basic_wallet_library() -> Library {
+    BASIC_WALLET_LIBRARY.clone()
+}
+
+/// Returns the Rpo Falcon 512 Library.
+pub fn rpo_falcon_512_library() -> Library {
+    RPO_FALCON_512_LIBRARY.clone()
+}
+
+/// Returns the Basic Fungible Faucet Library.
+pub fn basic_fungible_faucet_library() -> Library {
+    BASIC_FUNGIBLE_FAUCET_LIBRARY.clone()
+}