diff --git a/docs/builder/smart-contracts/index.md b/docs/builder/smart-contracts/index.md
index beffdb67..39de5f3f 100644
--- a/docs/builder/smart-contracts/index.md
+++ b/docs/builder/smart-contracts/index.md
@@ -1,16 +1,30 @@
---
title: "Miden Smart Contracts"
-description: "Reference documentation for building Miden smart contracts in Rust using the Miden SDK."
+description: "Build Miden smart contracts with Rust, Miden Assembly, and reusable Miden Standards."
pagination_prev: null
---
# Miden Smart Contracts
-This section is the complete reference for building smart contracts on Miden using Rust and the Miden SDK. If you're new to Miden, follow the hands-on [Miden Bank Tutorial](../tutorials/miden-bank/).
+This section covers the developer-facing paths for building smart contracts on Miden. Start with the overview for the execution model, use Rust for account, note, and transaction development, and use Miden Standards when you want reusable account components, note scripts, faucet policies, and protocol-compatible building blocks.
-All Miden Rust contracts compile under these constraints: `#![no_std]`, Rust 2024 edition.
+If you're new to Miden, follow the hands-on [Miden Bank Tutorial](../tutorials/miden-bank/).
-## Core concepts
+## Sections
+
+
+
+ Learn how accounts, notes, transactions, and components fit together.
+
+
+ Build accounts, notes, transactions, and reusable logic with the Rust-first workflow.
+
+
+ Use standard components, note scripts, faucet policies, and MASM modules.
+
+
+
+## Inside Rust
@@ -25,17 +39,17 @@ All Miden Rust contracts compile under these constraints: `#![no_std]`, Rust 202
Calling methods across account components and from note scripts.
-
-
-## Reference
-
-
Core types: Felt, Word, AccountId, NoteId, and more.
Access control, rate limiting, spending limits, and anti-patterns.
+
+
+## Reference
+
+
Complete API documentation for the miden crate.
diff --git a/docs/builder/smart-contracts/standards/account-components.md b/docs/builder/smart-contracts/standards/account-components.md
new file mode 100644
index 00000000..9951d708
--- /dev/null
+++ b/docs/builder/smart-contracts/standards/account-components.md
@@ -0,0 +1,96 @@
+---
+title: "Account Components"
+description: "Use standard account components for wallets, authentication, access control, faucets, and metadata."
+---
+
+# Account Components
+
+Standard account components are prebuilt modules you can compose into accounts. They give an account a recognizable interface, such as "can receive assets", "can authenticate with this signature scheme", "can mint fungible tokens", or "uses this access-control model".
+
+Use these components from Rust when you build accounts with the SDK, or import the underlying MASM modules when you are writing lower-level account code. The same standards surface is what note scripts and transaction scripts rely on when they call account procedures.
+
+## Common components
+
+| Component | Use it for | Rust module |
+|-----------|------------|-------------|
+| `BasicWallet` | Holding assets, receiving assets from standard notes, and moving assets into output notes. | `miden_standards::account::wallets` |
+| `FungibleFaucet` | Minting, sending, receiving, and burning fungible assets from faucet accounts. | `miden_standards::account::faucets` |
+| `AuthSingleSig` | Authenticating transactions with one supported signature scheme. | `miden_standards::account::auth` |
+| `AuthSingleSigAcl` | Single-signature authentication with an access-control list. | `miden_standards::account::auth` |
+| `AuthMultisig` / `AuthMultisigSmart` | Threshold or policy-aware multisig authentication. | `miden_standards::account::auth` |
+| `AuthGuardedMultisig` | Multisig guarded by a guardian configuration. | `miden_standards::account::auth` |
+| `AuthNetworkAccount` | Authentication for network-account flows. | `miden_standards::account::auth` |
+| `Ownable2Step` | Ownership transfer with an explicit accept step. | `miden_standards::account::access` |
+| `RoleBasedAccessControl` | Role-based authorization for standard policy management. | `miden_standards::account::access` |
+| `Authority` | Shared authority component used by policy-management standards. | `miden_standards::account::access` |
+
+These are building blocks. They do not prevent you from adding custom components to the same account.
+
+:::info v0.14 differences
+The v0.14 snapshot uses separate `BasicFungibleFaucet` and `NetworkFungibleFaucet` components and does not include RBAC, authority, guarded multisig, smart multisig, or network-account auth in the same form. Use the v0.14 versioned docs when building against the v0.14 crates.
+:::
+
+## Start with wallet and auth
+
+Most regular accounts need:
+
+- an authentication component, such as `AuthSingleSig` or `AuthMultisig`
+- a wallet component, usually `BasicWallet`
+
+`AuthSingleSig` controls transaction authorization. `BasicWallet` exposes the standard wallet procedures used by common notes, including the ability to receive assets and move assets into output notes.
+
+```rust title="Compose a regular account with standard auth and wallet components"
+use miden_protocol::Word;
+use miden_protocol::account::auth::{AuthScheme, PublicKeyCommitment};
+use miden_protocol::account::{AccountBuilder, AccountStorageMode, AccountType};
+use miden_standards::account::auth::AuthSingleSig;
+use miden_standards::account::wallets::BasicWallet;
+
+fn build_wallet_account() -> Result<(), Box> {
+ let public_key = PublicKeyCommitment::from(Word::from([1, 2, 3, 4u32]));
+
+ let account = AccountBuilder::new([1; 32])
+ .account_type(AccountType::RegularAccountImmutableCode)
+ .storage_mode(AccountStorageMode::Public)
+ .with_auth_component(AuthSingleSig::new(public_key, AuthScheme::Falcon512Poseidon2))
+ .with_component(BasicWallet)
+ .build()?;
+
+ assert_eq!(account.account_type(), AccountType::RegularAccountImmutableCode);
+ Ok(())
+}
+```
+
+For authentication details, see [Authentication](../accounts/authentication). For how component methods are authored in Rust, see [Components](../accounts/components).
+
+## Check note compatibility
+
+Standard notes assume the consuming account exposes the procedures they need. For example, P2ID and P2IDE notes need a wallet-compatible account that can receive assets. SWAP notes additionally need the wallet procedure that moves the requested asset into the payback note.
+
+At the builder level, the practical rule is:
+
+- Add `BasicWallet` to accounts that should receive standard asset-transfer notes.
+- Add `FungibleFaucet` to faucet accounts that should mint or burn fungible assets.
+- Add auth components to every account that must reject unauthorized transactions.
+
+If you write a custom wallet component instead of using `BasicWallet`, match the expected interface deliberately and test consumption of the relevant standard notes.
+
+## Rust and MASM entry points
+
+Rust APIs are the usual entry point for account composition. MASM modules are available when you need exact low-level behavior.
+
+| Area | Rust module | MASM module family |
+|------|-------------|--------------------|
+| Wallets | `miden_standards::account::wallets` | `miden::standards::wallets::*` |
+| Authentication | `miden_standards::account::auth` | `miden::standards::auth::*` |
+| Access control | `miden_standards::account::access` | `miden::standards::access::*` |
+| Faucets | `miden_standards::account::faucets` | `miden::standards::faucets::*` |
+| Metadata | `miden_standards::account::metadata` | `miden::standards::metadata::*` |
+
+Reach for MASM directly when you are implementing low-level behavior, integrating a custom component with a standard procedure, or verifying exact stack effects.
+
+## Related pages
+
+- [Standard notes](./standard-notes) - which account interfaces each standard note expects
+- [Faucets and policies](./faucets-and-policies) - using faucet and mint policy components
+- [`miden-standards` account source](https://github.com/0xMiden/protocol/tree/next/crates/miden-standards/src/account) - current implementation
diff --git a/docs/builder/smart-contracts/standards/faucets-and-policies.md b/docs/builder/smart-contracts/standards/faucets-and-policies.md
new file mode 100644
index 00000000..42ab7478
--- /dev/null
+++ b/docs/builder/smart-contracts/standards/faucets-and-policies.md
@@ -0,0 +1,143 @@
+---
+title: "Faucets and Policies"
+description: "Build fungible token faucets and choose standard mint, burn, send, and receive policies."
+---
+
+# Faucets and Policies
+
+In Miden, a token issuer is an account. A fungible faucet account can mint and burn the fungible asset identified by that faucet's account ID. The standard faucet components give builders a reusable way to create token issuers without hand-writing the entire faucet interface.
+
+Use this page when you need to create a faucet account, decide who can mint or burn, or understand how faucet behavior relates to standard notes.
+
+:::info v0.14 differences
+The current unstable standards surface uses a unified `FungibleFaucet` component and a richer `TokenPolicyManager`. The v0.14 snapshot uses separate `BasicFungibleFaucet` and `NetworkFungibleFaucet` components plus mint-policy components. Use the versioned docs if you are building against v0.14.
+:::
+
+## Faucet component
+
+The current standard fungible faucet component is `FungibleFaucet`.
+
+| Surface | Entry point |
+|---------|-------------|
+| Rust component | `miden_standards::account::faucets::FungibleFaucet` |
+| Rust builder/helper | `FungibleFaucetBuilder`, `create_fungible_faucet` |
+| MASM component | `miden::standards::faucets::fungible` |
+| Account type | `FungibleFaucet` account |
+
+Public storage is typical for shared token faucets because clients can discover faucet state and metadata. Private storage is possible, but it changes who can observe the faucet's state.
+
+```rust title="Create a fungible faucet with allow-all policies"
+use miden_protocol::Word;
+use miden_protocol::account::AccountStorageMode;
+use miden_protocol::account::auth::{AuthScheme, PublicKeyCommitment};
+use miden_protocol::asset::{AssetAmount, TokenSymbol};
+use miden_standards::AuthMethod;
+use miden_standards::account::access::AccessControl;
+use miden_standards::account::faucets::{
+ Description,
+ FungibleFaucet,
+ TokenName,
+ create_fungible_faucet,
+};
+use miden_standards::account::policies::{
+ BurnPolicyConfig,
+ MintPolicyConfig,
+ PolicyRegistration,
+ TokenPolicyManager,
+ TransferPolicy,
+};
+
+fn create_faucet_account() -> Result<(), Box> {
+ let public_key = PublicKeyCommitment::from(Word::from([1, 2, 3, 4u32]));
+
+ let faucet = FungibleFaucet::builder()
+ .name(TokenName::new("Example Token")?)
+ .symbol(TokenSymbol::new("EXT")?)
+ .decimals(6)
+ .max_supply(AssetAmount::from(1_000_000u32))
+ .description(Description::new("Example token")?)
+ .build()?;
+
+ let policies = TokenPolicyManager::new()
+ .with_mint_policy(MintPolicyConfig::AllowAll, PolicyRegistration::Active)?
+ .with_burn_policy(BurnPolicyConfig::AllowAll, PolicyRegistration::Active)?
+ .with_send_policy(TransferPolicy::AllowAll, PolicyRegistration::Active)?
+ .with_receive_policy(TransferPolicy::AllowAll, PolicyRegistration::Active)?;
+
+ let account = create_fungible_faucet(
+ [9; 32],
+ faucet,
+ AccountStorageMode::Public,
+ AuthMethod::SingleSig {
+ approver: (public_key, AuthScheme::Falcon512Poseidon2),
+ },
+ AccessControl::AuthControlled,
+ policies,
+ )?;
+
+ assert!(account.is_faucet());
+ Ok(())
+}
+```
+
+## Token identity
+
+A fungible asset is tied to its faucet account ID. The faucet's metadata describes the token, while the account ID identifies the asset issuer.
+
+| Field | Meaning |
+|-------|---------|
+| Symbol | Short token symbol. |
+| Decimals | Display precision for client UX. |
+| Max supply | Upper bound enforced by the faucet component. |
+| Metadata | Optional display fields such as token name, description, logo URI, and external link. |
+| Faucet account ID | The issuer ID used when constructing fungible assets and checking balances. |
+
+When an account checks its balance for a fungible token, it queries by the faucet account ID.
+
+## Choose policy modules
+
+Policy modules decide which operations are allowed for a token faucet.
+
+| Policy area | Current standard examples | Use it for |
+|-------------|---------------------------|------------|
+| Mint | `MintAllowAll`, `MintOwnerOnly` | Gate mint operations. |
+| Burn | `BurnAllowAll`, `BurnOwnerOnly` | Gate burn operations. |
+| Send | `TransferAllowAll`, `BasicBlocklist`, `OwnerControlledBlocklist` | Gate assets leaving accounts through notes. |
+| Receive | `TransferAllowAll`, `BasicBlocklist`, `OwnerControlledBlocklist` | Gate assets entering account vaults. |
+
+`TokenPolicyManager` owns the active policy roots and validates policy changes. Authority for changing policies comes from the account's access-control setup, such as owner-controlled or role-based authority.
+
+## Mint with notes
+
+Minting does not directly credit a recipient's account vault. A faucet creates a note carrying the minted asset, and the recipient consumes that note to receive the asset.
+
+For standard flows:
+
+- The faucet creates a mint note or a P2ID note containing the minted asset.
+- The recipient discovers and consumes the note.
+- The recipient's account must be able to receive the asset, usually by including `BasicWallet`.
+
+This is the same two-transaction note model described in [What are Notes?](../notes/introduction).
+
+## Burn returned assets
+
+Burning is also note-based. A burn note returns assets to the faucet and executes the standard burn behavior. Use `BurnNote` from `miden-standards` rather than hand-writing a burn script unless your protocol needs custom conditions.
+
+## When to write a custom faucet
+
+Use `FungibleFaucet` when supply, metadata, minting, burning, and transfer policies match the standard pattern.
+
+Write a custom faucet component when:
+
+- Minting depends on application state, proofs, allowlists, or rate limits.
+- Supply policy is more complex than a fixed max supply and a standard authority check.
+- You need custom public methods beyond the standard faucet interface.
+
+Even then, consider reusing standard auth, ownership, and wallet components where they fit. Custom faucet logic does not require custom authentication or custom note formats by default.
+
+## Related pages
+
+- [Account components](./account-components) - composing faucets with standard auth and ownership components
+- [Standard notes](./standard-notes) - mint and burn notes
+- [Assets, Vault, and Faucet migration notes](../../migration/asset-vault-faucet) - v0.14 asset and faucet changes
+- [`miden-standards` faucet source](https://github.com/0xMiden/protocol/tree/next/crates/miden-standards/src/account/faucets) - current implementation
diff --git a/docs/builder/smart-contracts/standards/index.md b/docs/builder/smart-contracts/standards/index.md
new file mode 100644
index 00000000..a2c81327
--- /dev/null
+++ b/docs/builder/smart-contracts/standards/index.md
@@ -0,0 +1,63 @@
+---
+title: "Miden Standards"
+description: "Use standard Miden account components, notes, faucets, and policies from Rust or Miden Assembly."
+---
+
+# Miden Standards
+
+Miden Standards are reusable building blocks for common smart-contract behavior: wallet interfaces, authentication components, token faucets, note scripts, and policy modules.
+
+Use them when you want your account, note, or transaction flow to interoperate with the rest of the Miden ecosystem instead of defining every interface from scratch.
+
+:::caution Current docs are unstable
+The current docs track the unstable standards line. The v0.14 snapshot has a different standards surface in a few important places, especially faucet and policy APIs. Use the version selector if you are building against v0.14.
+:::
+
+This section is a builder guide, not the canonical standards specification. It explains which standard to reach for, how it fits into the smart-contract model, and where to switch to reference docs when you need exact procedure names, storage schemas, or script roots.
+
+## How standards fit into smart contracts
+
+Smart Contracts is the domain. Rust and Miden Assembly are authoring paths inside that domain.
+
+| Layer | Role |
+|------|------|
+| Rust | Compose standard account components and construct standard notes through Rust APIs. |
+| Miden Assembly | Import and call standard MASM modules directly when writing low-level account, note, transaction, or library code. |
+| Miden Standards | Shared account components, note scripts, faucet policies, and helper modules used by both authoring paths. |
+
+## What this section covers
+
+
+
+ Use standard wallet, authentication, access-control, faucet, and metadata components.
+
+
+ Choose P2ID, P2IDE, SWAP, PSWAP, mint, and burn note scripts.
+
+
+ Build token faucets and choose mint, burn, send, and receive policy modules.
+
+
+
+## When to use standards
+
+Use a standard component or note when:
+
+- You want other accounts, note scripts, clients, or tooling to recognize your account interface.
+- Your behavior matches an existing pattern, such as holding assets, receiving a P2ID transfer, minting a fungible token, or verifying a single signature.
+- You need a stable building block before adding custom application logic.
+
+Write custom components or note scripts when:
+
+- The authorization rules are application-specific.
+- The note consumption condition is not covered by P2ID, P2IDE, SWAP, mint, or burn notes.
+- The account's state model needs custom storage and custom exported methods.
+
+You can mix both approaches. A typical application account starts with standard authentication and wallet components, then adds one or more custom components for protocol-specific logic.
+
+## Related pages
+
+- [Accounts](../accounts/) - components, storage, authentication, and account operations
+- [Notes](../notes/) - note model, note scripts, standard note types, and output notes
+- [Cross-component calls](../cross-component-calls) - calling component interfaces from scripts and components
+- [`miden-standards` source](https://github.com/0xMiden/protocol/tree/next/crates/miden-standards) - current standards implementation
diff --git a/docs/builder/smart-contracts/standards/standard-notes.md b/docs/builder/smart-contracts/standards/standard-notes.md
new file mode 100644
index 00000000..788f3add
--- /dev/null
+++ b/docs/builder/smart-contracts/standards/standard-notes.md
@@ -0,0 +1,107 @@
+---
+title: "Standard Notes"
+description: "Use standard Miden note scripts for transfers, expiring transfers, swaps, minting, and burning."
+---
+
+# Standard Notes
+
+Standard notes are prebuilt note scripts from `miden-standards`. They cover the common asset flows builders need before writing custom note scripts.
+
+Use the Rust APIs to construct standard notes in client or transaction-building code. The scripts themselves are MASM modules, so direct MASM authors can inspect or import the same standard scripts when they need exact procedure behavior.
+
+## Which note should I use?
+
+| Note | Use it when | Rust type | MASM module |
+|------|-------------|-----------|-------------|
+| P2ID | You are sending assets to a specific account ID. | `P2idNote` | `miden::standards::notes::p2id` |
+| P2IDE | You are sending to a specific account ID with a timelock and/or reclaim path. | `P2ideNote` | `miden::standards::notes::p2ide` |
+| SWAP | You are offering one asset and requiring a specific asset in return. | `SwapNote` | `miden::standards::notes::swap` |
+| PSWAP | You need a partially fillable swap note. | `PswapNote` | `miden::standards::notes::pswap` |
+| MINT | A faucet is minting fungible tokens into a note. | `MintNote` | `miden::standards::notes::mint` |
+| BURN | A faucet is burning fungible tokens returned through a note. | `BurnNote` | `miden::standards::notes::burn` |
+
+For the note model itself, start with [What are Notes?](../notes/introduction). This page focuses on how the standards fit into builder workflows.
+
+```rust title="Create a public P2ID note"
+use miden_protocol::Word;
+use miden_protocol::account::{AccountId, AccountIdVersion, AccountStorageMode, AccountType};
+use miden_protocol::asset::{Asset, FungibleAsset};
+use miden_protocol::crypto::rand::RandomCoin;
+use miden_protocol::note::{NoteAttachments, NoteType};
+use miden_standards::note::P2idNote;
+
+fn dummy_account(byte: u8, account_type: AccountType) -> AccountId {
+ let mut bytes = [0; 15];
+ bytes[0] = byte;
+ AccountId::dummy(
+ bytes,
+ AccountIdVersion::Version1,
+ account_type,
+ AccountStorageMode::Public,
+ )
+}
+
+fn create_p2id_note() -> Result<(), Box> {
+ let sender = dummy_account(1, AccountType::RegularAccountImmutableCode);
+ let target = dummy_account(2, AccountType::RegularAccountImmutableCode);
+ let faucet_id = dummy_account(3, AccountType::FungibleFaucet);
+ let asset: Asset = FungibleAsset::new(faucet_id, 100)?.into();
+ let mut rng = RandomCoin::new(Word::from([1, 2, 3, 4u32]));
+
+ let note = P2idNote::create(
+ sender,
+ target,
+ vec![asset],
+ NoteType::Public,
+ NoteAttachments::default(),
+ &mut rng,
+ )?;
+
+ assert_eq!(note.metadata().sender(), sender);
+ Ok(())
+}
+```
+
+:::info v0.14 differences
+PSWAP is part of the current unstable standards surface, but it is not available in the v0.14 standards snapshot. Use the v0.14 versioned docs if you are building against the v0.14 crates.
+:::
+
+## Account requirements
+
+Standard notes assume the consuming account exposes the procedures the note script calls.
+
+| Note | Consuming account needs |
+|------|-------------------------|
+| P2ID / P2IDE | A wallet-compatible receive procedure, usually from `BasicWallet`. |
+| SWAP / PSWAP | Wallet-compatible receive and asset-to-note procedures. |
+| MINT | A compatible faucet/account flow for mint authorization and recipient delivery. |
+| BURN | A compatible faucet burn procedure. |
+
+If you write a custom wallet or faucet component, test it against the standard notes you expect it to consume.
+
+## Attachments and execution hints
+
+Standard notes can use attachments and execution hints to help clients and indexers route notes and decide when a note might be consumable.
+
+| Helper | Use it for |
+|--------|------------|
+| `StandardNoteAttachment` | Standard attachment schemes for note metadata. |
+| `NetworkAccountTarget` | Attaching network-account targeting data to notes. |
+| `AccountTargetNetworkNote` | Wrapping notes known to target network accounts. |
+| `NetworkNoteExt` | Convenience helpers for network-targeted notes. |
+| `NoteExecutionHint` | Encoding when clients should attempt note execution. |
+
+Execution hints do not replace note-script checks. The note script still enforces consumption rules during transaction execution.
+
+## Rust and MASM entry points
+
+Rust constructors are the usual way to create standard notes in client-side code. Direct MASM authors should use the standard note modules as the source of truth for stack effects and script behavior.
+
+The Rust types live under `miden_standards::note`. The MASM scripts live under `miden::standards::notes::*`.
+
+## Related pages
+
+- [Standard Note Types](../notes/note-types) - more detail on P2ID, P2IDE, and SWAP
+- [Output Notes](../notes/output-notes) - creating output notes from transactions
+- [Note Scripts](../notes/note-scripts) - writing custom note scripts
+- [`miden-standards` note source](https://github.com/0xMiden/protocol/tree/next/crates/miden-standards/src/note) - current implementation
diff --git a/sidebars.ts b/sidebars.ts
index f5833aaf..cfc07b04 100644
--- a/sidebars.ts
+++ b/sidebars.ts
@@ -45,44 +45,66 @@ const sidebars: SidebarsConfig = {
"builder/smart-contracts/overview",
{
type: "category",
- label: "Accounts",
- link: { type: "generated-index", slug: "/builder/smart-contracts/accounts" },
+ label: "Rust",
+ link: {
+ type: "generated-index",
+ slug: "/builder/smart-contracts/rust",
+ title: "Rust Smart Contracts",
+ description: "Rust-first account, note, transaction, type, and composition docs.",
+ },
items: [
- "builder/smart-contracts/accounts/introduction",
- "builder/smart-contracts/accounts/components",
- "builder/smart-contracts/accounts/storage",
- "builder/smart-contracts/accounts/custom-types",
- "builder/smart-contracts/accounts/account-operations",
- "builder/smart-contracts/accounts/cryptography",
- "builder/smart-contracts/accounts/authentication",
- ],
- },
- {
- type: "category",
- label: "Notes",
- link: { type: "generated-index", slug: "/builder/smart-contracts/notes" },
- items: [
- "builder/smart-contracts/notes/introduction",
- "builder/smart-contracts/notes/note-scripts",
- "builder/smart-contracts/notes/note-types",
- "builder/smart-contracts/notes/reading-notes",
- "builder/smart-contracts/notes/output-notes",
+ {
+ type: "category",
+ label: "Accounts",
+ link: { type: "generated-index", slug: "/builder/smart-contracts/accounts" },
+ items: [
+ "builder/smart-contracts/accounts/introduction",
+ "builder/smart-contracts/accounts/components",
+ "builder/smart-contracts/accounts/storage",
+ "builder/smart-contracts/accounts/custom-types",
+ "builder/smart-contracts/accounts/account-operations",
+ "builder/smart-contracts/accounts/cryptography",
+ "builder/smart-contracts/accounts/authentication",
+ ],
+ },
+ {
+ type: "category",
+ label: "Notes",
+ link: { type: "generated-index", slug: "/builder/smart-contracts/notes" },
+ items: [
+ "builder/smart-contracts/notes/introduction",
+ "builder/smart-contracts/notes/note-scripts",
+ "builder/smart-contracts/notes/note-types",
+ "builder/smart-contracts/notes/reading-notes",
+ "builder/smart-contracts/notes/output-notes",
+ ],
+ },
+ {
+ type: "category",
+ label: "Transactions",
+ link: { type: "generated-index", slug: "/builder/smart-contracts/transactions" },
+ items: [
+ "builder/smart-contracts/transactions/introduction",
+ "builder/smart-contracts/transactions/transaction-context",
+ "builder/smart-contracts/transactions/transaction-scripts",
+ "builder/smart-contracts/transactions/advice-provider",
+ ],
+ },
+ "builder/smart-contracts/cross-component-calls",
+ "builder/smart-contracts/types",
+ "builder/smart-contracts/patterns",
],
},
{
type: "category",
- label: "Transactions",
- link: { type: "generated-index", slug: "/builder/smart-contracts/transactions" },
+ label: "Miden Standards",
+ link: { type: "doc", id: "builder/smart-contracts/standards/index" },
items: [
- "builder/smart-contracts/transactions/introduction",
- "builder/smart-contracts/transactions/transaction-context",
- "builder/smart-contracts/transactions/transaction-scripts",
- "builder/smart-contracts/transactions/advice-provider",
+ "builder/smart-contracts/standards/account-components",
+ "builder/smart-contracts/standards/standard-notes",
+ "builder/smart-contracts/standards/faucets-and-policies",
],
},
- "builder/smart-contracts/cross-component-calls",
- "builder/smart-contracts/types",
- "builder/smart-contracts/patterns",
],
},
{
diff --git a/versioned_docs/version-0.14/builder/smart-contracts/index.md b/versioned_docs/version-0.14/builder/smart-contracts/index.md
index beffdb67..39de5f3f 100644
--- a/versioned_docs/version-0.14/builder/smart-contracts/index.md
+++ b/versioned_docs/version-0.14/builder/smart-contracts/index.md
@@ -1,16 +1,30 @@
---
title: "Miden Smart Contracts"
-description: "Reference documentation for building Miden smart contracts in Rust using the Miden SDK."
+description: "Build Miden smart contracts with Rust, Miden Assembly, and reusable Miden Standards."
pagination_prev: null
---
# Miden Smart Contracts
-This section is the complete reference for building smart contracts on Miden using Rust and the Miden SDK. If you're new to Miden, follow the hands-on [Miden Bank Tutorial](../tutorials/miden-bank/).
+This section covers the developer-facing paths for building smart contracts on Miden. Start with the overview for the execution model, use Rust for account, note, and transaction development, and use Miden Standards when you want reusable account components, note scripts, faucet policies, and protocol-compatible building blocks.
-All Miden Rust contracts compile under these constraints: `#![no_std]`, Rust 2024 edition.
+If you're new to Miden, follow the hands-on [Miden Bank Tutorial](../tutorials/miden-bank/).
-## Core concepts
+## Sections
+
+
+
+ Learn how accounts, notes, transactions, and components fit together.
+
+
+ Build accounts, notes, transactions, and reusable logic with the Rust-first workflow.
+
+
+ Use standard components, note scripts, faucet policies, and MASM modules.
+
+
+
+## Inside Rust
@@ -25,17 +39,17 @@ All Miden Rust contracts compile under these constraints: `#![no_std]`, Rust 202
Calling methods across account components and from note scripts.
-
-
-## Reference
-
-
Core types: Felt, Word, AccountId, NoteId, and more.
Access control, rate limiting, spending limits, and anti-patterns.
+
+
+## Reference
+
+
Complete API documentation for the miden crate.
diff --git a/versioned_docs/version-0.14/builder/smart-contracts/standards/account-components.md b/versioned_docs/version-0.14/builder/smart-contracts/standards/account-components.md
new file mode 100644
index 00000000..1a57d256
--- /dev/null
+++ b/versioned_docs/version-0.14/builder/smart-contracts/standards/account-components.md
@@ -0,0 +1,91 @@
+---
+title: "Account Components"
+description: "Use v0.14 standard account components for wallets, authentication, faucets, ownership, and metadata."
+---
+
+# Account Components
+
+Standard account components are prebuilt modules you can compose into accounts. They give an account a recognizable interface, such as "can receive assets", "can authenticate with this signature scheme", or "can mint fungible tokens".
+
+Use these components from Rust when you build accounts with the SDK, or import the underlying MASM modules when you are writing lower-level account code. The same standards surface is what note scripts and transaction scripts rely on when they call account procedures.
+
+## Common components
+
+| Component | Use it for | Rust module |
+|-----------|------------|-------------|
+| `BasicWallet` | Holding assets, receiving assets from standard notes, and moving assets into output notes. | `miden_standards::account::wallets` |
+| `BasicFungibleFaucet` | Minting and burning fungible assets from a regular faucet account. | `miden_standards::account::faucets` |
+| `NetworkFungibleFaucet` | Minting and burning fungible assets from a network-account faucet flow. | `miden_standards::account::faucets` |
+| `AuthSingleSig` | Authenticating transactions with one supported signature scheme. | `miden_standards::account::auth` |
+| `AuthSingleSigAcl` | Single-signature authentication with an access-control list. | `miden_standards::account::auth` |
+| `AuthMultisig` | Threshold-based multisig authentication. | `miden_standards::account::auth` |
+| `AuthMultisigPsm` | Multisig with procedure-specific thresholds. | `miden_standards::account::auth` |
+| `NoAuth` | Accounts that intentionally skip transaction authentication. | `miden_standards::account::auth` |
+| `Ownable2Step` | Ownership transfer with an explicit accept step. | `miden_standards::account::access` |
+
+These are building blocks. They do not prevent you from adding custom components to the same account.
+
+## Start with wallet and auth
+
+Most regular accounts need:
+
+- an authentication component, such as `AuthSingleSig` or `AuthMultisig`
+- a wallet component, usually `BasicWallet`
+
+`AuthSingleSig` controls transaction authorization. `BasicWallet` exposes the standard wallet procedures used by common notes, including the ability to receive assets and move assets into output notes.
+
+```rust title="Compose a regular account with standard auth and wallet components"
+use miden_protocol::Word;
+use miden_protocol::account::auth::{AuthScheme, PublicKeyCommitment};
+use miden_protocol::account::{AccountBuilder, AccountStorageMode, AccountType};
+use miden_standards::account::auth::AuthSingleSig;
+use miden_standards::account::wallets::BasicWallet;
+
+fn build_wallet_account() -> Result<(), Box> {
+ let public_key = PublicKeyCommitment::from(Word::from([1, 2, 3, 4u32]));
+
+ let account = AccountBuilder::new([1; 32])
+ .account_type(AccountType::RegularAccountImmutableCode)
+ .storage_mode(AccountStorageMode::Public)
+ .with_auth_component(AuthSingleSig::new(public_key, AuthScheme::Falcon512Poseidon2))
+ .with_component(BasicWallet)
+ .build()?;
+
+ assert_eq!(account.account_type(), AccountType::RegularAccountImmutableCode);
+ Ok(())
+}
+```
+
+For authentication details, see [Authentication](../accounts/authentication). For how component methods are authored in Rust, see [Components](../accounts/components).
+
+## Check note compatibility
+
+Standard notes assume the consuming account exposes the procedures they need. For example, P2ID and P2IDE notes need a wallet-compatible account that can receive assets. SWAP notes additionally need the wallet procedure that moves the requested asset into the payback note.
+
+At the builder level, the practical rule is:
+
+- Add `BasicWallet` to accounts that should receive standard asset-transfer notes.
+- Add `BasicFungibleFaucet` or `NetworkFungibleFaucet` to faucet accounts that should mint or burn fungible assets.
+- Add auth components to every account that must reject unauthorized transactions.
+
+If you write a custom wallet component instead of using `BasicWallet`, match the expected interface deliberately and test consumption of the relevant standard notes.
+
+## Rust and MASM entry points
+
+Rust APIs are the usual entry point for account composition. MASM modules are available when you need exact low-level behavior.
+
+| Area | Rust module | MASM module family |
+|------|-------------|--------------------|
+| Wallets | `miden_standards::account::wallets` | `miden::standards::wallets::*` |
+| Authentication | `miden_standards::account::auth` | `miden::standards::auth::*` |
+| Access control | `miden_standards::account::access` | `miden::standards::access::*` |
+| Faucets | `miden_standards::account::faucets` | `miden::standards::faucets::*` |
+| Metadata | `miden_standards::account::metadata` | `miden::standards::metadata::*` |
+
+Reach for MASM directly when you are implementing low-level behavior, integrating a custom component with a standard procedure, or verifying exact stack effects.
+
+## Related pages
+
+- [Standard notes](./standard-notes) - which account interfaces each standard note expects
+- [Faucets and policies](./faucets-and-policies) - using faucet and mint policy components
+- [`miden-standards` v0.14.6 account API](https://docs.rs/miden-standards/0.14.6/miden_standards/account/) - exact Rust API for this version
diff --git a/versioned_docs/version-0.14/builder/smart-contracts/standards/faucets-and-policies.md b/versioned_docs/version-0.14/builder/smart-contracts/standards/faucets-and-policies.md
new file mode 100644
index 00000000..01cbee85
--- /dev/null
+++ b/versioned_docs/version-0.14/builder/smart-contracts/standards/faucets-and-policies.md
@@ -0,0 +1,110 @@
+---
+title: "Faucets and Policies"
+description: "Build v0.14 fungible token faucets and choose standard mint policy components."
+---
+
+# Faucets and Policies
+
+In Miden, a token issuer is an account. A fungible faucet account can mint and burn the fungible asset identified by that faucet's account ID. The standard faucet components give builders a reusable way to create token issuers without hand-writing the entire faucet interface.
+
+Use this page when you need to create a faucet account, decide who can mint, or understand how faucet behavior relates to standard notes.
+
+## Faucet components
+
+The v0.14 standards snapshot has two fungible faucet components.
+
+| Component | Use it for | Rust module |
+|-----------|------------|-------------|
+| `BasicFungibleFaucet` | A regular faucet account that mints and burns fungible assets. | `miden_standards::account::faucets` |
+| `NetworkFungibleFaucet` | A network-account faucet flow. | `miden_standards::account::faucets` |
+
+Public storage is typical for shared token faucets because clients can discover faucet state and metadata. Private storage is possible, but it changes who can observe the faucet's state.
+
+```rust title="Create a basic fungible faucet account"
+use miden_protocol::Word;
+use miden_protocol::account::AccountStorageMode;
+use miden_protocol::account::auth::{AuthScheme, PublicKeyCommitment};
+use miden_protocol::asset::TokenSymbol;
+use miden_protocol::Felt;
+use miden_standards::AuthMethod;
+use miden_standards::account::faucets::create_basic_fungible_faucet;
+
+fn create_faucet_account() -> Result<(), Box> {
+ let public_key = PublicKeyCommitment::from(Word::from([1, 2, 3, 4u32]));
+
+ let account = create_basic_fungible_faucet(
+ [9; 32],
+ TokenSymbol::new("EXT")?,
+ 6,
+ Felt::new(1_000_000),
+ AccountStorageMode::Public,
+ AuthMethod::SingleSig {
+ approver: (public_key, AuthScheme::Falcon512Poseidon2),
+ },
+ )?;
+
+ assert!(account.is_faucet());
+ Ok(())
+}
+```
+
+## Token identity
+
+A fungible asset is tied to its faucet account ID. The faucet's metadata describes the token, while the account ID identifies the asset issuer.
+
+| Field | Meaning |
+|-------|---------|
+| Symbol | Short token symbol. |
+| Decimals | Display precision for client UX. |
+| Max supply | Upper bound enforced by the faucet component. |
+| Faucet account ID | The issuer ID used when constructing fungible assets and checking balances. |
+
+The v0.14 faucet module exposes token metadata through the standard faucet component, including the symbol, decimals, and max supply fields clients need for display and balance handling.
+
+When an account checks its balance for a fungible token, it queries by the faucet account ID.
+
+## Choose a minting authority model
+
+Mint policy components decide which procedure is allowed to mint from the faucet.
+
+| Policy | Use it when |
+|--------|-------------|
+| `AuthControlled` | The account's transaction authentication should authorize minting. This is the simple owner-operated faucet pattern. |
+| `OwnerControlled` | Ownership should be managed separately, with owner-controlled policy procedures. |
+
+The v0.14 `miden-standards` crate exposes these under `miden_standards::account::mint_policies`.
+
+## Mint with notes
+
+Minting does not directly credit a recipient's account vault. A faucet creates a note carrying the minted asset, and the recipient consumes that note to receive the asset.
+
+For standard flows:
+
+- The faucet creates a mint note or a P2ID note containing the minted asset.
+- The recipient discovers and consumes the note.
+- The recipient's account must be able to receive the asset, usually by including `BasicWallet`.
+
+This is the same two-transaction note model described in [What are Notes?](../notes/introduction).
+
+## Burn returned assets
+
+Burning is also note-based. A burn note returns assets to the faucet and executes the standard burn behavior. Use `BurnNote` from `miden-standards` rather than hand-writing a burn script unless your protocol needs custom conditions.
+
+## When to write a custom faucet
+
+Use `BasicFungibleFaucet` or `NetworkFungibleFaucet` when supply, metadata, minting, and burning match the standard pattern.
+
+Write a custom faucet component when:
+
+- Minting depends on application state, proofs, allowlists, or rate limits.
+- Supply policy is more complex than a fixed max supply and a standard authority check.
+- You need custom public methods beyond the standard faucet interface.
+
+Even then, consider reusing standard auth, ownership, and wallet components where they fit. Custom faucet logic does not require custom authentication or custom note formats by default.
+
+## Related pages
+
+- [Account components](./account-components) - composing faucets with standard auth and ownership components
+- [Standard notes](./standard-notes) - mint and burn notes
+- [Assets, Vault, and Faucet migration notes](../../migration/asset-vault-faucet) - v0.14 asset and faucet changes
+- [`miden-standards` v0.14.6 faucet API](https://docs.rs/miden-standards/0.14.6/miden_standards/account/faucets/) - exact Rust API for this version
diff --git a/versioned_docs/version-0.14/builder/smart-contracts/standards/index.md b/versioned_docs/version-0.14/builder/smart-contracts/standards/index.md
new file mode 100644
index 00000000..c7a7ed37
--- /dev/null
+++ b/versioned_docs/version-0.14/builder/smart-contracts/standards/index.md
@@ -0,0 +1,63 @@
+---
+title: "Miden Standards"
+description: "Use v0.14 standard Miden account components, notes, faucets, and policies from Rust or Miden Assembly."
+---
+
+# Miden Standards
+
+Miden Standards are reusable building blocks for common smart-contract behavior: wallet interfaces, authentication components, token faucets, note scripts, and policy modules.
+
+Use them when you want your account, note, or transaction flow to interoperate with the rest of the Miden ecosystem instead of defining every interface from scratch.
+
+:::info Version scope
+This page describes the v0.14 standards surface. Current unstable docs include newer names and modules, including a unified `FungibleFaucet`, role-based access control, richer token policies, and PSWAP notes.
+:::
+
+This section is a builder guide, not the canonical standards specification. It explains which standard to reach for, how it fits into the smart-contract model, and where to switch to reference docs when you need exact procedure names, storage schemas, or script roots.
+
+## How standards fit into smart contracts
+
+Smart Contracts is the domain. Rust and Miden Assembly are authoring paths inside that domain.
+
+| Layer | Role |
+|------|------|
+| Rust | Compose standard account components and construct standard notes through Rust APIs. |
+| Miden Assembly | Import and call standard MASM modules directly when writing low-level account, note, transaction, or library code. |
+| Miden Standards | Shared account components, note scripts, faucet policies, and helper modules used by both authoring paths. |
+
+## What this section covers
+
+
+
+ Use standard wallet, authentication, faucet, ownership, and metadata components.
+
+
+ Choose P2ID, P2IDE, SWAP, mint, and burn note scripts.
+
+
+ Build token faucets and choose standard mint policy modules.
+
+
+
+## When to use standards
+
+Use a standard component or note when:
+
+- You want other accounts, note scripts, clients, or tooling to recognize your account interface.
+- Your behavior matches an existing pattern, such as holding assets, receiving a P2ID transfer, minting a fungible token, or verifying a single signature.
+- You need a stable building block before adding custom application logic.
+
+Write custom components or note scripts when:
+
+- The authorization rules are application-specific.
+- The note consumption condition is not covered by P2ID, P2IDE, SWAP, mint, or burn notes.
+- The account's state model needs custom storage and custom exported methods.
+
+You can mix both approaches. A typical application account starts with standard authentication and wallet components, then adds one or more custom components for protocol-specific logic.
+
+## Related pages
+
+- [Accounts](../accounts/) - components, storage, authentication, and account operations
+- [Notes](../notes/) - note model, note scripts, standard note types, and output notes
+- [Cross-component calls](../cross-component-calls) - calling component interfaces from scripts and components
+- [`miden-standards` v0.14.6 API reference](https://docs.rs/miden-standards/0.14.6/miden_standards/) - exact Rust API for this version
diff --git a/versioned_docs/version-0.14/builder/smart-contracts/standards/standard-notes.md b/versioned_docs/version-0.14/builder/smart-contracts/standards/standard-notes.md
new file mode 100644
index 00000000..e9977f0f
--- /dev/null
+++ b/versioned_docs/version-0.14/builder/smart-contracts/standards/standard-notes.md
@@ -0,0 +1,106 @@
+---
+title: "Standard Notes"
+description: "Use v0.14 standard Miden note scripts for transfers, expiring transfers, swaps, minting, and burning."
+---
+
+# Standard Notes
+
+Standard notes are prebuilt note scripts from `miden-standards`. They cover the common asset flows builders need before writing custom note scripts.
+
+Use the Rust APIs to construct standard notes in client or transaction-building code. The scripts themselves are MASM modules, so direct MASM authors can inspect or import the same standard scripts when they need exact procedure behavior.
+
+## Which note should I use?
+
+| Note | Use it when | Rust type | MASM module |
+|------|-------------|-----------|-------------|
+| P2ID | You are sending assets to a specific account ID. | `P2idNote` | `miden::standards::notes::p2id` |
+| P2IDE | You are sending to a specific account ID with a timelock and/or reclaim path. | `P2ideNote` | `miden::standards::notes::p2ide` |
+| SWAP | You are offering one asset and requiring a specific asset in return. | `SwapNote` | `miden::standards::notes::swap` |
+| MINT | A faucet is minting fungible tokens into a note. | `MintNote` | `miden::standards::notes::mint` |
+| BURN | A faucet is burning fungible tokens returned through a note. | `BurnNote` | `miden::standards::notes::burn` |
+
+:::info PSWAP availability
+PSWAP is not available in the v0.14 standards snapshot. It appears in the current unstable standards surface.
+:::
+
+For the note model itself, start with [What are Notes?](../notes/introduction). This page focuses on how the standards fit into builder workflows.
+
+```rust title="Create a public P2ID note"
+use miden_protocol::account::{AccountId, AccountIdVersion, AccountStorageMode, AccountType};
+use miden_protocol::asset::{Asset, FungibleAsset};
+use miden_protocol::crypto::rand::RandomCoin;
+use miden_protocol::note::{NoteAttachment, NoteType};
+use miden_protocol::Word;
+use miden_standards::note::P2idNote;
+
+fn dummy_account(byte: u8, account_type: AccountType) -> AccountId {
+ let mut bytes = [0; 15];
+ bytes[0] = byte;
+ AccountId::dummy(
+ bytes,
+ AccountIdVersion::Version0,
+ account_type,
+ AccountStorageMode::Public,
+ )
+}
+
+fn create_p2id_note() -> Result<(), Box> {
+ let sender = dummy_account(1, AccountType::RegularAccountImmutableCode);
+ let target = dummy_account(2, AccountType::RegularAccountImmutableCode);
+ let faucet_id = dummy_account(3, AccountType::FungibleFaucet);
+ let asset: Asset = FungibleAsset::new(faucet_id, 100)?.into();
+ let mut rng = RandomCoin::new(Word::from([1, 2, 3, 4u32]));
+
+ let note = P2idNote::create(
+ sender,
+ target,
+ vec![asset],
+ NoteType::Public,
+ NoteAttachment::default(),
+ &mut rng,
+ )?;
+
+ assert_eq!(note.metadata().sender(), sender);
+ Ok(())
+}
+```
+
+## Account requirements
+
+Standard notes assume the consuming account exposes the procedures the note script calls.
+
+| Note | Consuming account needs |
+|------|-------------------------|
+| P2ID / P2IDE | A wallet-compatible receive procedure, usually from `BasicWallet`. |
+| SWAP | Wallet-compatible receive and asset-to-note procedures. |
+| MINT | A compatible faucet/account flow for mint authorization and recipient delivery. |
+| BURN | A compatible faucet burn procedure. |
+
+If you write a custom wallet or faucet component, test it against the standard notes you expect it to consume.
+
+## Attachments and execution hints
+
+Standard notes can use attachments and execution hints to help clients and indexers route notes and decide when a note might be consumable.
+
+| Helper | Use it for |
+|--------|------------|
+| `StandardNoteAttachment` | Standard attachment schemes for note metadata. |
+| `NetworkAccountTarget` | Attaching network-account targeting data to notes. |
+| `AccountTargetNetworkNote` | Wrapping notes known to target network accounts. |
+| `NetworkNoteExt` | Convenience helpers for network-targeted notes. |
+| `NoteExecutionHint` | Encoding when clients should attempt note execution. |
+
+Execution hints do not replace note-script checks. The note script still enforces consumption rules during transaction execution.
+
+## Rust and MASM entry points
+
+Rust constructors are the usual way to create standard notes in client-side code. Direct MASM authors should use the standard note modules as the source of truth for stack effects and script behavior.
+
+The Rust types live under `miden_standards::note`. The MASM scripts live under `miden::standards::notes::*`.
+
+## Related pages
+
+- [Standard Note Types](../notes/note-types) - more detail on P2ID, P2IDE, and SWAP
+- [Output Notes](../notes/output-notes) - creating output notes from transactions
+- [Note Scripts](../notes/note-scripts) - writing custom note scripts
+- [`miden-standards` v0.14.6 note API](https://docs.rs/miden-standards/0.14.6/miden_standards/note/) - exact Rust API for this version
diff --git a/versioned_sidebars/version-0.14-sidebars.json b/versioned_sidebars/version-0.14-sidebars.json
index 1a79bf23..b2ccdbec 100644
--- a/versioned_sidebars/version-0.14-sidebars.json
+++ b/versioned_sidebars/version-0.14-sidebars.json
@@ -37,53 +37,78 @@
"builder/smart-contracts/overview",
{
"type": "category",
- "label": "Accounts",
+ "label": "Rust",
"link": {
"type": "generated-index",
- "slug": "/builder/smart-contracts/accounts"
+ "slug": "/builder/smart-contracts/rust",
+ "title": "Rust Smart Contracts",
+ "description": "Rust-first account, note, transaction, type, and composition docs."
},
"items": [
- "builder/smart-contracts/accounts/introduction",
- "builder/smart-contracts/accounts/components",
- "builder/smart-contracts/accounts/storage",
- "builder/smart-contracts/accounts/custom-types",
- "builder/smart-contracts/accounts/account-operations",
- "builder/smart-contracts/accounts/cryptography",
- "builder/smart-contracts/accounts/authentication"
- ]
- },
- {
- "type": "category",
- "label": "Notes",
- "link": {
- "type": "generated-index",
- "slug": "/builder/smart-contracts/notes"
- },
- "items": [
- "builder/smart-contracts/notes/introduction",
- "builder/smart-contracts/notes/note-scripts",
- "builder/smart-contracts/notes/note-types",
- "builder/smart-contracts/notes/reading-notes",
- "builder/smart-contracts/notes/output-notes"
+ {
+ "type": "category",
+ "label": "Accounts",
+ "link": {
+ "type": "generated-index",
+ "slug": "/builder/smart-contracts/accounts"
+ },
+ "items": [
+ "builder/smart-contracts/accounts/introduction",
+ "builder/smart-contracts/accounts/components",
+ "builder/smart-contracts/accounts/storage",
+ "builder/smart-contracts/accounts/custom-types",
+ "builder/smart-contracts/accounts/account-operations",
+ "builder/smart-contracts/accounts/cryptography",
+ "builder/smart-contracts/accounts/authentication"
+ ]
+ },
+ {
+ "type": "category",
+ "label": "Notes",
+ "link": {
+ "type": "generated-index",
+ "slug": "/builder/smart-contracts/notes"
+ },
+ "items": [
+ "builder/smart-contracts/notes/introduction",
+ "builder/smart-contracts/notes/note-scripts",
+ "builder/smart-contracts/notes/note-types",
+ "builder/smart-contracts/notes/reading-notes",
+ "builder/smart-contracts/notes/output-notes"
+ ]
+ },
+ {
+ "type": "category",
+ "label": "Transactions",
+ "link": {
+ "type": "generated-index",
+ "slug": "/builder/smart-contracts/transactions"
+ },
+ "items": [
+ "builder/smart-contracts/transactions/introduction",
+ "builder/smart-contracts/transactions/transaction-context",
+ "builder/smart-contracts/transactions/transaction-scripts",
+ "builder/smart-contracts/transactions/advice-provider"
+ ]
+ },
+ "builder/smart-contracts/cross-component-calls",
+ "builder/smart-contracts/types",
+ "builder/smart-contracts/patterns"
]
},
{
"type": "category",
- "label": "Transactions",
+ "label": "Miden Standards",
"link": {
- "type": "generated-index",
- "slug": "/builder/smart-contracts/transactions"
+ "type": "doc",
+ "id": "builder/smart-contracts/standards/index"
},
"items": [
- "builder/smart-contracts/transactions/introduction",
- "builder/smart-contracts/transactions/transaction-context",
- "builder/smart-contracts/transactions/transaction-scripts",
- "builder/smart-contracts/transactions/advice-provider"
+ "builder/smart-contracts/standards/account-components",
+ "builder/smart-contracts/standards/standard-notes",
+ "builder/smart-contracts/standards/faucets-and-policies"
]
- },
- "builder/smart-contracts/cross-component-calls",
- "builder/smart-contracts/types",
- "builder/smart-contracts/patterns"
+ }
]
},
{