doc: update miden in rust to v13 & some adjustment to the migration

guide

Author: BrianSeong99

docs/builder/migration/02-account-changes.md

@@ -16,11 +16,11 @@ Replace numeric indices with `StorageSlotName`:
 
 ```rust title="src/account.rs"
 // Before
-let value = account.storage().get_slot(0)?;
+let value = account.storage().get_item(0)?;
 
 // After
-let slot_name = StorageSlotName::new("my_slot")?;
-let value = account.storage().get_slot(&slot_name)?;
+let slot_name = StorageSlotName::new("my_component::my_slot")?;
+let value = account.storage().get_item(&slot_name)?;
 ```
 
 ---
@@ -33,26 +33,27 @@ Replace index-based storage access with `StorageSlotName` identifiers.
 
 ```diff title="src/account.rs"
 - // Before: access by numeric index
-- let value = account.storage().get_slot(0)?;
-- account.storage_mut().set_slot(0, new_value)?;
+- let value = account.storage().get_item(0)?;
+- let _old_value = account.storage_mut().set_item(0, new_value)?;
 
 + // After: access by name
-+ let slot_name = StorageSlotName::new("my_slot")?;
-+ let value = account.storage().get_slot(&slot_name)?;
-+ account.storage_mut().set_slot(&slot_name, new_value)?;
++ let slot_name = StorageSlotName::new("my_component::my_slot")?;
++ let value = account.storage().get_item(&slot_name)?;
++ let _old_value = account.storage_mut().set_item(&slot_name, new_value)?;
 ```
 
 ### MASM Updates
 
-The `set_map_item` procedure now takes slot IDs and returns only old values:
+The `native_account::set_map_item` procedure now takes slot IDs and returns only old values:
 
 ```diff title="src/contract.masm"
 - # Before
-- exec.account::set_map_item
+- exec.native_account::set_map_item
 - # Returns: [OLD_MAP_ROOT, OLD_VALUE, ...]
 
 + # After
-+ exec.account::set_map_item
++ # Inputs: [slot_id_prefix, slot_id_suffix, KEY, NEW_VALUE]
++ exec.native_account::set_map_item
 + # Returns: [OLD_VALUE, ...]
 ```
 
@@ -80,16 +81,13 @@ Remove RNG generics from `FilesystemKeyStore`:
 
 Web component compilation now requires `AccountComponentCode` from `CodeBuilder`:
 
-```diff title="src/component.rs"
+```diff title="src/component.ts"
 - // Before
-- let component = AccountComponent::compile(source)?;
+- const component = AccountComponent.compile(accountCode, builder, [slot]);
 
 + // After
-+ use miden_protocol::code::CodeBuilder;
-+ let code = CodeBuilder::new()
-+     .with_source(source)
-+     .build()?;
-+ let component = AccountComponent::new(code)?;
++ const componentCode = builder.compileAccountComponentCode(accountCode);
++ const component = AccountComponent.compile(componentCode, [slot]);
 ```
 
 ---
@@ -102,11 +100,22 @@ Replace `AccountComponentTemplate` with metadata-driven `StorageSchema`:
 - use miden_lib::AccountComponentTemplate;
 - let template = AccountComponentTemplate::new(slots)?;
 
-+ use miden_standards::StorageSchema;
-+ let schema = StorageSchema::builder()
-+     .add_slot("balance", StorageSlotType::Value)
-+     .add_slot("metadata", StorageSlotType::Map)
-+     .build()?;
++ use miden_protocol::account::component::{SchemaTypeId, StorageSchema, StorageSlotSchema};
++ use miden_protocol::account::StorageSlotName;
++ let schema = StorageSchema::new([
++     (
++         StorageSlotName::new("my_component::balance")?,
++         StorageSlotSchema::value("balance", SchemaTypeId::native_word()),
++     ),
++     (
++         StorageSlotName::new("my_component::metadata")?,
++         StorageSlotSchema::map(
++             "metadata",
++             SchemaTypeId::native_word(),
++             SchemaTypeId::native_word(),
++         ),
++     ),
++ ])?;
 ```
 
 ---
@@ -116,11 +125,11 @@ Replace `AccountComponentTemplate` with metadata-driven `StorageSchema`:
 Use `AccountProcedureRoot` instead of `AccountProcedureInfo`:
 
 ```diff title="src/procedure.rs"
-- use miden_objects::accounts::AccountProcedureInfo;
+- use miden_objects::account::AccountProcedureInfo;
 - let info = AccountProcedureInfo::new(digest, storage_offset)?;
 
-+ use miden_protocol::accounts::AccountProcedureRoot;
-+ let root = AccountProcedureRoot::new(digest)?;
++ use miden_protocol::account::AccountProcedureRoot;
++ let root = AccountProcedureRoot::from_raw(digest);
 ```
 
 ---
@@ -141,6 +150,6 @@ Use `AccountProcedureRoot` instead of `AccountProcedureInfo`:
 
 | Error | Cause | Fix |
 |-------|-------|-----|
-| `no method named 'get_slot' taking u32` | API changed to names | Use `StorageSlotName` |
+| `expected &StorageSlotName, found u8` | API changed to names | Use `StorageSlotName` |
 | `FilesystemKeyStore expects 0 type parameters` | RNG generic removed | Remove type parameter |
 | `AccountComponentTemplate not found` | Renamed | Use `StorageSchema` |

docs/builder/migration/03-note-changes.md

@@ -14,12 +14,15 @@ The note system has been redesigned. `NoteMetadata` no longer stores `aux` or `N
 
 ```rust title="src/note.rs"
 // Before
-let metadata = NoteMetadata::new(sender, note_type, tag, aux, execution_hint)?;
+let metadata = NoteMetadata::new(sender, note_type, tag, execution_hint, aux)?;
 
 // After
-let metadata = NoteMetadata::new(sender, note_type, tag)?;
-let attachment = NoteAttachment::new(aux_data, execution_hint)?;
-let note = Note::new(metadata, script, inputs, attachment)?;
+let attachment_word = Word::from([aux, execution_hint.into(), felt!(0), felt!(0)]);
+let attachment = NoteAttachment::new_word(NoteAttachmentScheme::none(), attachment_word);
+let metadata = NoteMetadata::new(sender, note_type)
+    .with_tag(tag)
+    .with_attachment(attachment);
+let note = Note::new(assets, metadata, recipient);
 ```
 
 ---
@@ -34,14 +37,17 @@ let note = Note::new(metadata, script, inputs, attachment)?;
 -     sender,
 -     note_type,
 -     tag,
--     aux,                    // No longer here
 -     execution_hint,         // No longer here
+-     aux,                    // No longer here
 - )?;
 
 + // After: use attachments
-+ let metadata = NoteMetadata::new(sender, note_type, tag)?;
-+ let attachment = NoteAttachment::new(aux_data, execution_hint)?;
-+ let note = Note::new(metadata, script, inputs, attachment)?;
++ let attachment_word = Word::from([aux, execution_hint.into(), felt!(0), felt!(0)]);
++ let attachment = NoteAttachment::new_word(NoteAttachmentScheme::none(), attachment_word);
++ let metadata = NoteMetadata::new(sender, note_type)
++     .with_tag(tag)
++     .with_attachment(attachment);
++ let note = Note::new(assets, metadata, recipient);
 ```
 
 :::info Good to know
@@ -52,15 +58,17 @@ This separation makes note metadata more lightweight and allows attachments to b
 
 ## Tag Semantics
 
-`NoteTag` is now a plain `u32`. Use `with_account_target()` for account targeting:
+`NoteTag::from_account_id` was removed. Use `NoteTag::new()` for explicit values and
+`NoteTag::with_account_target()` for account targeting:
 
 ```diff title="src/note.rs"
 - // Before: tag with embedded target
-- let tag = NoteTag::from_account_id(target_account)?;
-
-+ // After: plain tag with explicit targeting
-+ let tag: u32 = 12345;
-+ let note = note.with_account_target(target_account)?;
+- let tag = NoteTag::from_account_id(target_account);
+-
++ // After: use tag constructors
++ let tag = NoteTag::new(12345);
++ let target_tag = NoteTag::with_account_target(target_account);
++ let metadata = metadata.with_tag(target_tag);
 ```
 
 ---
@@ -70,34 +78,55 @@ This separation makes note metadata more lightweight and allows attachments to b
 Implement `NetworkAccountTarget` attachment for network-account notes:
 
 ```rust title="src/network_note.rs"
-use miden_protocol::notes::NetworkAccountTarget;
+use miden_protocol::note::NoteAttachment;
+use miden_standards::note::NetworkAccountTarget;
 
-let target = NetworkAccountTarget::new(account_id, network_id)?;
-let note = note.with_attachment(target)?;
+let target = NetworkAccountTarget::new(account_id, execution_hint)?;
+let attachment = NoteAttachment::from(target);
+let metadata = metadata.with_attachment(attachment);
 ```
 
 ---
 
 ## MINT Notes
 
-New `MintNoteInputs` enum supports private and public output notes:
+`MintNoteStorage` supports private and public output notes:
 
 ```diff title="src/mint.rs"
 - // Before
-- let mint_note = MintNote::new(amount, recipient)?;
+- use miden_lib::note::create_mint_note;
+- let mint_note = create_mint_note(
+-     faucet_id,
+-     sender,
+-     recipient_digest,
+-     output_note_tag,
+-     amount,
+-     aux,
+-     output_note_aux,
+-     rng,
+- )?;
 
 + // After: explicit private/public choice
-+ use miden_standards::notes::MintNoteInputs;
++ use miden_standards::note::{MintNote, MintNoteStorage};
++ use miden_protocol::note::NoteAttachment;
 +
-+ // For private notes
-+ let inputs = MintNoteInputs::Private { amount, recipient };
++ // For private output notes
++ let mint_storage = MintNoteStorage::new_private(recipient_digest, amount, output_note_tag);
 +
-+ // For public notes
-+ let inputs = MintNoteInputs::Public { amount, recipient, metadata };
++ // For public output notes
++ let mint_storage = MintNoteStorage::new_public(recipient, amount, output_note_tag)?;
++ let mint_note = MintNote::create(
++     faucet_id,
++     sender,
++     mint_storage,
++     NoteAttachment::default(),
++     rng,
++ )?;
 ```
 
 :::tip
-Choose `MintNoteInputs::Private` for most use cases. Use `Public` only when the note contents should be visible on-chain.
+Choose `MintNoteStorage::new_private` for most use cases. Use `new_public` only when the note
+contents should be visible on-chain.
 :::
 
 ---
@@ -108,13 +137,15 @@ Unified interface accepts full `Note` objects instead of IDs:
 
 ```diff title="src/transaction.rs"
 - // Before: separate authenticated/unauthenticated lists
-- let tx = TransactionRequest::new()
+- let tx = TransactionRequestBuilder::new()
 -     .with_authenticated_input_notes(auth_note_ids)
--     .with_unauthenticated_input_notes(unauth_note_ids)?;
+-     .with_unauthenticated_input_notes(unauth_note_ids)
+-     .build()?;
 
 + // After: unified input notes
-+ let tx = TransactionRequest::new()
-+     .with_input_notes(notes)?;  // Full Note objects
++ let tx = TransactionRequestBuilder::new()
++     .input_notes(notes) // Full Note objects
++     .build()?;
 ```
 
 ---
@@ -125,11 +156,11 @@ Private notes now carry `NoteHeader`; public notes expose `note` and `inclusionP
 
 ```rust title="src/fetch.rs"
 match fetched_note {
-    FetchedNote::Private { header, .. } => {
+    FetchedNote::Private(header, _) => {
         // Access header fields
         let note_id = header.id();
     }
-    FetchedNote::Public { note, inclusion_proof } => {
+    FetchedNote::Public(note, inclusion_proof) => {
         // Access full note and proof
         let inputs = note.inputs();
     }
@@ -142,10 +173,10 @@ match fetched_note {
 
 1. Remove `aux` and `execution_hint` from `NoteMetadata` constructors
 2. Create `NoteAttachment` objects for aux data and hints
-3. Update `NoteTag` usage to plain `u32` values
+3. Update `NoteTag` usage to `NoteTag::new()` / `NoteTag::with_account_target()`
 4. Use `with_account_target()` for targeted notes
 5. Implement `NetworkAccountTarget` for network notes
-6. Update mint note creation to use `MintNoteInputs` enum
+6. Update mint note creation to use `MintNoteStorage`
 7. Refactor input notes to pass full `Note` objects
 8. Update `FetchedNote` handling for new structure
 
@@ -155,6 +186,6 @@ match fetched_note {
 
 | Error | Cause | Fix |
 |-------|-------|-----|
-| `NoteMetadata::new takes 3 arguments` | aux/hint removed | Use `NoteAttachment` |
+| `NoteMetadata::new takes 2 arguments` | aux/hint removed | Use `NoteAttachment` |
 | `NoteTag::from_account_id not found` | API changed | Use `with_account_target()` |
 | `with_authenticated_input_notes not found` | API unified | Use `with_input_notes()` |

docs/builder/smart-contracts/rust/accounts/account-operations.md

@@ -98,7 +98,7 @@ let new_nonce: Felt = native_account::incr_nonce();
 ```
 
 :::warning
-The nonce must be incremented for any transaction that modifies account state. Without it, the same transaction could be replayed. The `#[component]` macro handles this automatically for most cases.
+The nonce must be incremented for any transaction that modifies account state. Without it, the same transaction could be replayed.
 :::
 
 ### Transaction tracking
@@ -139,8 +139,8 @@ impl MyAccount {
 | `add_asset` | `fn add_asset(&mut self, asset: Asset) -> Asset` |
 | `remove_asset` | `fn remove_asset(&mut self, asset: Asset) -> Asset` |
 | `incr_nonce` | `fn incr_nonce(&mut self) -> Felt` |
-| `compute_delta_commitment` | `fn compute_delta_commitment(&mut self) -> Word` |
-| `was_procedure_called` | `fn was_procedure_called(&mut self, proc_root: Word) -> bool` |
+| `compute_delta_commitment` | `fn compute_delta_commitment(&self) -> Word` |
+| `was_procedure_called` | `fn was_procedure_called(&self, proc_root: Word) -> bool` |
 
 ### ActiveAccount methods (on `&self`)
 

docs/builder/smart-contracts/rust/accounts/components.md

@@ -41,7 +41,7 @@ impl CounterContract {
 The macro generates:
 
 1. **WIT interface definition** describing the component's public API
-2. **Storage metadata** mapping field names to slot indices
+2. **Storage metadata** mapping slot names to slot IDs (derived from the component package + field name)
 3. **Export bindings** for the Miden runtime
 
 ## Struct definition
@@ -71,13 +71,15 @@ field_name: Value,
 field_name: StorageMap,
 ```
 
-The `description` is required and becomes part of the generated metadata. Slots are assigned sequentially starting from 0 unless explicitly specified with `slot(N)`:
+The `description` is optional but recommended and becomes part of the generated metadata. Slot IDs are derived from the component package name (from `[package.metadata.component]`) and the field name, so **renaming a field changes the slot ID**. Ordering does not matter, and `slot(N)` is not supported.
+
+Use `#[storage(description = "...")]` on each storage field:
 
 ```rust
-#[storage(slot(0), description = "initialized flag")]
+#[storage(description = "initialized flag")]
 initialized: Value,
 
-#[storage(slot(1), description = "balances map")]
+#[storage(description = "balances map")]
 balances: StorageMap,
 ```
 
@@ -157,7 +159,7 @@ Public methods can use these types in their signatures:
 
 The `#[component]` macro automatically provides methods on `self` through the `NativeAccount` and `ActiveAccount` traits.
 
-### Always available (via `NativeAccount` trait on `&mut self`)
+### Always available (via `NativeAccount` trait; mutating methods require `&mut self`)
 
 ```rust
 // Add an asset to the account vault
@@ -169,10 +171,10 @@ self.remove_asset(asset: Asset) -> Asset
 // Increment the account nonce (replay protection)
 self.incr_nonce() -> Felt
 
-// Compute commitment of account state changes
+// Compute commitment of account state changes (read-only)
 self.compute_delta_commitment() -> Word
 
-// Check if a procedure was called during this transaction
+// Check if a procedure was called during this transaction (read-only)
 self.was_procedure_called(proc_root: Word) -> bool
 ```