fix(docs): enhance tutorials with Noir Language Server tips and update versioning sections

## Summary

This PR updates the developer documentation tutorials to use the latest Aztec syntax and improves overall tutorial quality:

### Tutorial Updates

**Counter Contract Tutorial**
- Migrated dependencies from `aztec-packages` monorepo to the standalone `aztec-nr` repository
- Replaced deprecated `easy_private_state`/`EasyPrivateUint` with `balance_set`/`BalanceSet`
- Updated import explanations for new patterns (`MessageDelivery`, `debug_log_format`, `Owned`)
- Fixed function descriptions to reflect constrained message delivery patterns

**Token Contract Tutorial**
- Added explicit `mkdir` and `cd` commands for clearer project setup
- Migrated dependencies to `aztec-nr` repository
- Updated to use `BalanceSet` instead of `EasyPrivateUint`
- Added instruction to start local network before deployment

**Aztec.js Getting Started Tutorial**
- Refactored to use `#include_code` macros instead of inline code blocks
- Added `@aztec/test-wallet` dependency
- Created companion example at `docs/examples/ts/aztecjs_getting_started/`
- Improved step-by-step flow with numbered instructions

**Token Bridge Tutorial**
- Added tip about Noir Language Server VS Code extension
- Updated dependency references to `aztec-nr` repository
- Fixed `#[private]` to `#[external("private")]` annotation
- Corrected command syntax from `aztec new --contract` to `aztec new`
- Updated terminology from "constrained event" to "constrained message delivery"

**Local Network Tutorial**
- Updated table of contents with detailed navigation
- Fixed `aztec-up` command to include version placeholder

### Example Code Updates

- Created new `aztecjs_getting_started/` example with full working code
- Fixed `bob_token_contract/index.ts`: added missing `await` and removed unused variable
- Updated `bootstrap.sh` to handle examples using only pre-built packages (no custom contracts)
- Updated NFT bridge contracts with modern Aztec syntax (`self.call()`, `Owned` wrapper, proper imports)
- Fixed relative paths in example `Nargo.toml` files
- Applied `noir fmt` formatting to contract examples

## Test plan

- [ ] Verify tutorials build correctly with `yarn build`
- [ ] Confirm example TypeScript projects pass validation with `bootstrap.sh`
- [ ] Test that code snippets in tutorials match the example source files

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: critesjosh

docs/Nargo.toml

@@ -1,5 +1,7 @@
 [workspace]
 members = [
     "examples/contracts/counter_contract",
-    "examples/contracts/bob_token_contract"
+    "examples/contracts/bob_token_contract",
+    "examples/tutorials/token_bridge_contract/contracts/aztec/nft",
+    "examples/tutorials/token_bridge_contract/contracts/aztec/nft_bridge"
 ]

docs/docs-developers/docs/tutorials/contract_tutorials/counter_contract.md

@@ -40,9 +40,8 @@ Add the following dependencies to `Nargo.toml` under the autogenerated content:
 
 ```toml
 [dependencies]
-aztec = { git="https://github.com/AztecProtocol/aztec-packages/", tag="#include_aztec_version", directory="noir-projects/aztec-nr/aztec" }
-value_note = { git="https://github.com/AztecProtocol/aztec-packages/", tag="#include_aztec_version", directory="noir-projects/aztec-nr/value-note"}
-easy_private_state = { git="https://github.com/AztecProtocol/aztec-packages/", tag="#include_aztec_version", directory="noir-projects/aztec-nr/easy-private-state"}
+aztec = { git="https://github.com/AztecProtocol/aztec-nr/", tag="#include_aztec_version", directory="aztec" }
+balance_set = { git="https://github.com/AztecProtocol/aztec-nr/", tag="#include_aztec_version", directory="balance-set" }
 ```
 
 ## Define the functions
@@ -70,21 +69,27 @@ pub contract Counter {
 
 #include_code imports /docs/examples/contracts/counter_contract/src/main.nr rust
 
-- `use aztec::macros::{functions::{external, initializer}, storage::storage},`
+- `macros::{functions::{external, initializer}, storage::storage}`
   Imports the macros needed to define function types (`external`, `initializer`) and the `storage` macro for declaring contract storage structures.
 
-- `protocol_types::{address::AztecAddress, traits::ToField},`
-  Brings in `AztecAddress` (used to identify accounts/contracts) and traits for converting values to and from field elements, necessary for serialization and formatting inside Aztec.
+- `messages::message_delivery::MessageDelivery`
+  Imports `MessageDelivery` for specifying how note delivery should be handled (e.g., constrained onchain delivery).
 
-- `state_vars::Map,`
-  Brings in `Map`, used for creating state mappings, like our counters.
+- `oracle::debug_log::debug_log_format`
+  Imports a debug logging utility for printing formatted messages during contract execution.
 
-- `use easy_private_state::EasyPrivateUint;`
-  Imports a wrapper to manage private integer-like state variables (ie our counter), abstracting away notes.
+- `protocol_types::{address::AztecAddress, traits::ToField}`
+  Brings in `AztecAddress` (used to identify accounts/contracts) and traits for converting values to field elements, necessary for serialization and formatting inside Aztec.
+
+- `state_vars::Owned`
+  Brings in `Owned`, a wrapper for state variables that have a single owner.
+
+- `use balance_set::BalanceSet`
+  Imports `BalanceSet` from the `balance_set` dependency, which provides functionality for managing private balances (used for our counter).
 
 ## Declare storage
 
-Add this below the imports. It declares the storage variables for our contract. We are going to store a mapping of values for each `AztecAddress`.
+Add this below the imports. It declares the storage variables for our contract. We use an `Owned` state variable wrapping a `BalanceSet` to manage private balances for each owner.
 
 #include_code storage_struct /docs/examples/contracts/counter_contract/src/main.nr rust
 
@@ -96,41 +101,41 @@ Let’s create a constructor method to run on deployment that assigns an initial
 
 #include_code constructor /docs/examples/contracts/counter_contract/src/main.nr rust
 
-This function accesses the counts from storage. Then it assigns the passed initial counter to the `owner`'s counter privately using `at().add()`.
+This function accesses the counters from storage. It adds the `headstart` value to the `owner`'s counter using `at().add()`, then calls `.deliver(MessageDelivery.CONSTRAINED_ONCHAIN)` to ensure the note is delivered onchain.
 
 We have annotated this and other functions with `#[external("private")]` which are ABI macros so the compiler understands it will handle private inputs.
 
 ## Incrementing our counter
 
-Now let’s implement the `increment` function we defined in the first step.
+Now let's implement an `increment` function to increase the counter.
 
 #include_code increment /docs/examples/contracts/counter_contract/src/main.nr rust
 
-The `increment` function works very similarly to the `constructor`, but instead directly adds 1 to the counter rather than passing in an initial count parameter.
+The `increment` function works similarly to the `initialize` function. It logs a debug message, then adds 1 to the owner's counter and delivers the note onchain.
 
 ## Getting a counter
 
-The last thing we need to implement is the function in order to retrieve a counter. In the `getCounter` we defined in the first step, write this:
+The last thing we need to implement is a function to retrieve a counter value.
 
 #include_code get_counter /docs/examples/contracts/counter_contract/src/main.nr rust
 
-This is a `utility` function which is used to obtain the counter information outside of a transaction. We retrieve a reference to the `owner`'s `counter` from the `counters` Map. The `get_balance` function then operates on the owner's counter. This yields a private counter that only the private key owner can decrypt.
+This is a `utility` function used to obtain the counter value outside of a transaction. We access the `owner`'s balance from the `counters` storage variable using `at(owner)`, then call `balance_of()` to retrieve the current count. This yields a private counter that only the owner can decrypt.
 
 ## Compile
 
 Now we've written a simple Aztec.nr smart contract, we can compile it.
 
 ### Compile the smart contract
 
-In `./counter/` directory, run these commands:
+In the `./counter/` directory, run:
 
 ```bash
-aztec compile # compiles the contract
+aztec compile
 ```
 
-The first command compiles your Noir contract and creates a `target` folder with a `.json` artifact inside. The second command processes these artifacts for use with Aztec (transpiling for the AVM and generating verification keys). Do not worry if you see some warnings - Aztec is in fast development and it is likely you will see some irrelevant warning messages.
+This command compiles your Noir contract and creates a `target` folder with a `.json` artifact inside.
 
-After compiling and processing, you can generate a typescript class using `aztec codegen` command.
+After compiling, you can generate a TypeScript class using the `aztec codegen` command.
 
 In the same directory, run this:
 

docs/docs-developers/docs/tutorials/contract_tutorials/token_contract.md

@@ -38,6 +38,8 @@ We'll create BOB tokens with:
 Let's create a simple yarn + aztec.nr project:
 
 ```bash
+mkdir bob_token_contract
+cd bob_token_contract
 yarn init
 # This is to ensure yarn uses node_modules instead of pnp for dependency installation
 yarn config set nodeLinker node-modules
@@ -55,7 +57,7 @@ We have a messy, but working structure. In `src/main.nr` we even have a proto-co
 }
 ```
 
-The `#[aztec]` macro transforms our contract code to work with Aztec's privacy protocol. We'll rename it from `StarterToken` to `BobToken` to reflect our use case.
+The `#[aztec]` macro transforms our contract code to work with Aztec's privacy protocol.
 
 Let's import the Aztec.nr library by adding it to our dependencies in `Nargo.toml`:
 
@@ -65,7 +67,7 @@ name = "bob_token_contract"
 type = "contract"
 
 [dependencies]
-aztec = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "#include_aztec_version", directory = "noir-projects/aztec-nr/aztec" }
+aztec = { git = "https://github.com/AztecProtocol/aztec-nr/", tag = "#include_aztec_version", directory = "aztec" }
 ```
 
 Since we're here, let's import more specific stuff from this library:
@@ -184,7 +186,11 @@ You should now have a nice typescript interface in a new `artifacts` folder. Pre
 
 ### Deploy and Test
 
-Create `index.ts`. We will connect to our running local network and its wallet, then deploy the test accounts and get three wallets out of it.
+Create `index.ts`. We will connect to our running local network and its wallet, then deploy the test accounts and get three wallets out of it. Ensure that your local network is running:
+
+```bash
+aztec start --local-network
+```
 
 Then we will use the `giggleWallet` to deploy our contract, mint 100 BOB to Alice, then transfer 10 of those to Bob's Clinic publicly... for now. Let's go:
 
@@ -251,18 +257,19 @@ For something like balances, you can use a simple library called `easy_private_s
 
 ```toml
 [dependencies]
-easy_private_state = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "#include_aztec_version", directory = "noir-projects/aztec-nr/easy-private-state" }
+aztec = { git="https://github.com/AztecProtocol/aztec-nr", tag="#include_aztec_version", directory="aztec" }
+balance_set = { git = "https://github.com/AztecProtocol/aztec-nr/", tag = "#include_aztec_version", directory = "balance-set" }
 ```
 
-Then import `EasyPrivateUint` in our contract:
+Then import `BalanceSet` in our contract:
 
 ```rust
 use aztec::macros::aztec;
 
 #[aztec]
 pub contract BobToken {
     // ... other imports
-    use easy_private_state::EasyPrivateUint;
+    use balance_set::BalanceSet;
     // ...
 }
 ```
@@ -271,7 +278,7 @@ We need to update the contract storage to have private balances as well:
 
 #include_code storage /docs/examples/contracts/bob_token_contract/src/main.nr rust
 
-The `private_balances` use `EasyPrivateUint` which manages encrypted notes automatically.
+The `private_balances` use `BalanceSet` which manages encrypted notes automatically.
 
 ### Moving Tokens to Privateland
 

docs/docs-developers/docs/tutorials/js_tutorials/aztecjs-getting-started.md

@@ -12,7 +12,15 @@ Before starting, make sure to be running Aztec local network at version #include
 
 ## Set up the project
 
-Let's initialize a yarn project first. You can init it with the dependencies we need:
+First, create a new directory for your project and initialize it with yarn:
+
+```sh
+mkdir token-tutorial
+cd token-tutorial
+yarn init -y
+```
+
+Next, add the TypeScript dependencies:
 
 ```sh
 yarn add typescript @types/node tsx
@@ -27,7 +35,7 @@ Never heard of `tsx`? Well, it will just run `typescript` with reasonable defaul
 Let's also import the Aztec dependencies for this tutorial:
 
 ```sh
-yarn add @aztec/aztec.js@#include_version_without_prefix @aztec/accounts@#include_version_without_prefix @aztec/noir-contracts.js@#include_version_without_prefix
+yarn add @aztec/aztec.js@#include_version_without_prefix @aztec/accounts@#include_version_without_prefix @aztec/noir-contracts.js@#include_version_without_prefix @aztec/test-wallet@#include_version_without_prefix
 ```
 
 Aztec.js assumes your project is using ESM, so make sure you add `"type": "module"` to `package.json`. You probably also want at least a `start` script. For example:
@@ -43,105 +51,69 @@ Aztec.js assumes your project is using ESM, so make sure you add `"type": "modul
 
 ### Connecting to the local network
 
-We want to [connect to our running local network](../../aztec-js/how_to_connect_to_local_network.md) and import the test accounts into a new wallet. Let's call them Alice and Bob (of course). Create an `index.ts` with it:
+Now let's connect to the Aztec local network and set up test accounts.
 
-```typescript
-import { createAztecNodeClient } from "@aztec/aztec.js/node";
-import { TestWallet } from "@aztec/test-wallet/server";
-import { getInitialTestAccountsData } from "@aztec/accounts/testing";
+**Step 1: Start the Aztec Local Network**
 
-const nodeUrl = "http://localhost:8080";
-const node = createAztecNodeClient(nodeUrl);
-const wallet = await TestWallet.create(node);
+In a separate terminal, run:
 
-const [alice, bob] = await getInitialTestAccountsData();
-await wallet.createSchnorrAccount(alice.secret, alice.salt);
-await wallet.createSchnorrAccount(bob.secret, bob.salt);
+```sh
+aztec start --local-network
 ```
 
-## Deploy the token contract
+Keep this terminal running throughout the tutorial.
 
-Now that we have our accounts loaded, let's move on to deploy our pre-compiled token smart contract. You can find the full code for the contract [here (GitHub link)](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts/app/token_contract/src).
+**Step 2: Create the index.ts file**
 
-Let's import the interface directly, and make Alice the admin:
+Create an `index.ts` file in the root of your project with the following code. This connects to the local network and imports test accounts (Alice and Bob):
 
-```typescript
-import { TokenContract } from "@aztec/noir-contracts.js/Token";
+#include_code setup /docs/examples/ts/aztecjs_getting_started/index.ts typescript
 
-const token = await TokenContract.deploy(
-  wallet,
-  alice.address,
-  "TokenName",
-  "TKN",
-  18
-)
-  .send({ from: alice.address })
-  .deployed();
+**Step 3: Verify the script runs**
+
+Run the script to make sure everything is set up correctly:
+
+```sh
+yarn start
 ```
 
+If there are no errors, you're ready to continue. For more details on connecting to the local network, see [this guide](../../aztec-js/how_to_connect_to_local_network.md).
+
+## Deploy the token contract
+
+Now that we have our accounts loaded, let's deploy a pre-compiled token contract from the Aztec library. You can find the full code for the contract [here (GitHub link)](https://github.com/AztecProtocol/aztec-packages/tree/#include_aztec_version/noir-projects/noir-contracts/contracts/app/token_contract/src).
+
+Add the following to `index.ts` to import the contract and deploy it with Alice as the admin:
+
+#include_code deploy /docs/examples/ts/aztecjs_getting_started/index.ts typescript
+
 ## Mint and transfer
 
 Let's go ahead and have Alice mint herself some tokens, in private:
 
-```typescript
-await token.methods
-  .mint_to_private(alice.address, 100)
-  .send({ from: alice.address })
-  .wait();
-```
+#include_code mint /docs/examples/ts/aztecjs_getting_started/index.ts typescript
 
 Let's check both Alice's and Bob's balances now:
 
-```typescript
-let aliceBalance = await token.methods
-  .balance_of_private(alice.address)
-  .simulate({ from: alice.address });
-console.log(`Alice's balance: ${aliceBalance}`); // whoooaa 100 tokens
-let bobBalance = await token.methods
-  .balance_of_private(bob.address)
-  .simulate({ from: bob.address });
-console.log(`Bob's balance: ${bobBalance}`); // you get nothin' 🥹
-```
+#include_code check_balances /docs/examples/ts/aztecjs_getting_started/index.ts typescript
+
+Alice should have 100 tokens, while Bob has none yet.
 
 Great! Let's have Alice transfer some tokens to Bob, also in private:
 
-```typescript
-await token.methods
-  .transfer(bob.address, 10)
-  .send({ from: alice.address })
-  .wait();
-bobBalance = await token.methods
-  .balance_of_private(bob.address)
-  .simulate({ from: bob.address });
-console.log(`Bob's balance: ${bobBalance}`);
-```
+#include_code transfer /docs/examples/ts/aztecjs_getting_started/index.ts typescript
 
-Nice, Bob should now see 10 tokens in his balance! Thanks Alice!
+Bob should now see 10 tokens in his balance.
 
 ## Other cool things
 
 Say that Alice is nice and wants to set Bob as a minter. Even though it's a public function, it can be called in a similar way:
 
-```typescript
-await token.methods
-  .set_minter(bob.address, true)
-  .send({ from: alice.address })
-  .wait();
-```
+#include_code set_minter /docs/examples/ts/aztecjs_getting_started/index.ts typescript
 
-Bob is now the minter, so he can mint some tokens to himself, notice that for the time being, you need to bind `token` to Bob's wallet with `withWallet(bob)`:
-
-```typescript
-await token
-  .withWallet(bob)
-  .methods.mint_to_private(bob.address, 100)
-  .send({ from: bob.address })
-  .wait();
-bobBalance = await token.methods
-  .balance_of_private(bob.address)
-  .simulate({ from: bob.address });
-console.log(`Bob's balance: ${bobBalance}`);
-```
+Bob is now the minter, so he can mint some tokens to himself:
+
+#include_code bob_mints /docs/examples/ts/aztecjs_getting_started/index.ts typescript
 
 :::info