docs: align counter tutorial example with the aztec init template and add TXE tests (#23517)

## Summary

Align the counter contract tutorial's example with the canonical `aztec
init` counter template, add TXE tests, and run them in docs CI.

- **Naming aligned with the template.** The docs example's initializer
is renamed from `initialize`/`headstart` to
`constructor`/`initial_value` to match the counter scaffold that `aztec
init` generates (`yarn-project/aztec/scripts/templates/counter/`). The
`increment(owner)` and `get_counter(owner)` signatures already match the
template and are unchanged. This PR does not modify the CLI template
itself; the docs example follows it.
- **TXE tests.** Adds a `counter_contract_test` package (mirroring
`logging_example_test`) with tests for the constructor and increment,
matching the template's test layout.
- **CI.** A new `test-contracts` step in `docs/examples/bootstrap.sh`
starts a TXE and runs `nargo test` for both `counter_contract_test` and
`logging_example_test`, so these tests run in docs CI rather than
sitting unexecuted.
- **Tutorial polish.** Sentence-case headings, a more accurate privacy
description (the count is confidential; dropped the overstated "no one
knows when you increment"), and prose updated for the `constructor`
naming.

## What's not in scope

- No change to the `aztec init` counter template; the docs example is
aligned to it.
- No change to the example's authorization model: `increment(owner)`
matches the template.

## Test plan

- CI's `docs/examples/bootstrap.sh compile` builds `counter_contract`
against the `constructor` signature.
- The new `docs/examples/bootstrap.sh test-contracts` step runs `nargo
test` for `counter_contract_test` and `logging_example_test` against a
TXE. This could not be run locally (stale in-repo nargo, and the step
needs a built `yarn-project/txe`), so the first real validation is this
PR's CI run.
- Docusaurus dev build renders the updated tutorial without
`#include_code` errors.

Author: critesjosh

docs/Nargo.toml

@@ -2,6 +2,7 @@
 members = [
     "examples/circuits/hello_circuit",
     "examples/contracts/counter_contract",
+    "examples/contracts/counter_contract_test",
     "examples/contracts/bob_token_contract",
     "examples/contracts/nft",
     "examples/contracts/nft_bridge",

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

@@ -1,13 +1,13 @@
 ---
-title: Counter Contract
+title: Counter contract
 description: Code-along tutorial for creating a simple counter contract on Aztec.
 sidebar_position: 0
 references: ["docs/examples/contracts/counter_contract/src/main.nr"]
 ---
 
 import Image from "@theme/IdealImage";
 
-In this guide, we will create our first Aztec.nr smart contract. We will build a simple private counter, where you can keep your own private counter - so no one knows what ID you are at or when you increment! This contract will get you started with the basic setup and syntax of Aztec.nr, but doesn't showcase all of the awesome stuff Aztec is capable of.
+In this guide, we will create our first Aztec.nr smart contract. We will build a simple private counter, where each account keeps its own counter as encrypted private state, so the count stays known only to you. This contract will get you started with the basic setup and syntax of Aztec.nr, but doesn't showcase all of the awesome stuff Aztec is capable of.
 
 This tutorial is compatible with the Aztec version `#include_aztec_version`. Install the correct version with `VERSION=#include_version_without_prefix bash -i <(curl -sL https://install.aztec.network/#include_version_without_prefix)`. Or if you'd like to use a different version, you can find the relevant tutorial by clicking the version dropdown at the top of the page.
 
@@ -104,11 +104,11 @@ Add this below the imports. It declares the storage variables for our contract.
 
 Now we’ve got a mechanism for storing our private state, we can start using it to ensure the privacy of balances.
 
-Let’s create a constructor method to run on deployment that assigns an initial count to a specified owner. This function is called `initialize`, but behaves like a constructor. It is the `#[initializer]` decorator that specifies that this function behaves like a constructor. Write this:
+Let’s create a constructor method to run on deployment that assigns an initial count to a specified owner. We name it `constructor` here, but the name is arbitrary; it is the `#[initializer]` decorator that marks it to run once when the contract is deployed. Write this:
 
 #include_code constructor /docs/examples/contracts/counter_contract/src/main.nr rust
 
-This function accesses the counters from storage. It adds the `headstart` value to the `owner`'s counter using `at().add()`, then calls `.deliver(MessageDelivery::onchain_constrained())` to ensure the note is delivered onchain.
+This function accesses the counters from storage. It adds the `initial_value` to the `owner`'s counter using `at().add()`, then calls `.deliver(MessageDelivery::onchain_constrained())` 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.
 
@@ -118,7 +118,7 @@ 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 similarly to the `initialize` function. It logs a debug message, then adds 1 to the owner's counter and delivers the note onchain.
+The `increment` function works similarly to the `constructor`. It logs a debug message, then adds 1 to the `owner`'s counter and delivers the note onchain.
 
 ## Getting a counter
 
@@ -152,8 +152,8 @@ aztec codegen -o src/artifacts target
 
 You can now use the artifact and/or the TS class in your Aztec.js!
 
-## Next Steps
+## Next steps
 
-### Optional: Learn more about concepts mentioned here
+### Optional: learn more about concepts mentioned here
 
 - [Functions and annotations like `#[external("private")]`](../../aztec-nr/framework-description/functions/function_transforms.md#private-functions)

docs/examples/bootstrap.sh

@@ -209,11 +209,56 @@ function execute-examples {
   run_compose_test "docs_examples" "docs-examples" "$COMPOSE_DIR"
 }
 
+# Runs the Noir TXE tests for the example test packages (the type = "lib" packages
+# that the `compile` step skips). A local TXE server resolves the foreign calls the
+# tests make: account creation, deployment, and private/utility execution.
+function test-contracts {
+  echo_header "Testing example contracts (TXE)"
+  local test_packages=("counter_contract_test" "logging_example_test")
+  local txe_port=${TXE_PORT:-14745}
+
+  # Run in a subshell so the EXIT trap that stops the TXE is scoped to this step.
+  (
+    set -euo pipefail
+    if command -v check_port >/dev/null 2>&1; then
+      check_port "$txe_port" || {
+        echo_stderr "Cannot start TXE: port $txe_port is already in use."
+        exit 1
+      }
+    fi
+    cd "$REPO_ROOT/yarn-project/txe"
+    UV_THREADPOOL_SIZE=8 LOG_LEVEL=silent TXE_PORT="$txe_port" yarn start >/dev/null &
+    txe_pid=$!
+    trap 'kill "$txe_pid" &>/dev/null || true' EXIT
+
+    echo_stderr "Waiting for TXE to start on port $txe_port..."
+    j=0
+    while ! nc -z 127.0.0.1 "$txe_port" &>/dev/null; do
+      [ "$j" -ge 60 ] && {
+        echo_stderr "TXE failed to start on port $txe_port after 60s."
+        exit 1
+      }
+      sleep 1
+      j=$((j + 1))
+    done
+
+    export RAYON_NUM_THREADS=1
+    export NARGO_FOREIGN_CALL_TIMEOUT=300000
+    cd "$REPO_ROOT/docs"
+    for pkg in "${test_packages[@]}"; do
+      echo_stderr "Running $pkg..."
+      $NARGO test --silence-warnings --skip-brillig-constraints-check \
+        --oracle-resolver "http://127.0.0.1:$txe_port" --package "$pkg"
+    done
+  )
+}
+
 function test_cmds {
   # Bumped from the default 600s by ~50% (now 15m) to absorb cumulative-runtime growth
   # under merge-queue load — example_swap's `wait-for-proven` poll was tipping SIGTERM
   # near the old limit. See PR #23253 dequeue log http://ci.aztec-labs.com/b08ac48286302949.
   echo "$hash:ONLY_TERM_PARENT=1:TIMEOUT=15m docs/examples/bootstrap.sh execute"
+  echo "$hash:ONLY_TERM_PARENT=1 docs/examples/bootstrap.sh test-contracts"
 }
 
 function test {
@@ -393,6 +438,9 @@ case "$cmd" in
   execute)
     execute-examples
     ;;
+  test-contracts)
+    test-contracts
+    ;;
   *)
     default_cmd_handler "$@"
     ;;

docs/examples/contracts/counter_contract/src/main.nr

@@ -25,9 +25,9 @@ pub contract Counter {
     // docs:start:constructor
     #[initializer]
     #[external("private")]
-    // We can name our initializer anything we want as long as it's marked as aztec(initializer)
-    fn initialize(headstart: u128, owner: AztecAddress) {
-        self.storage.counters.at(owner).add(headstart).deliver(
+    // We can name our initializer anything we want as long as it's marked as #[initializer]
+    fn constructor(initial_value: u128, owner: AztecAddress) {
+        self.storage.counters.at(owner).add(initial_value).deliver(
             MessageDelivery::onchain_constrained(),
         );
     }

docs/examples/contracts/counter_contract_test/Nargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "counter_contract_test"
+authors = [""]
+compiler_version = ">=0.25.0"
+type = "lib"
+
+[dependencies]
+aztec = { path = "../../../../noir-projects/aztec-nr/aztec" }
+counter_contract = { path = "../counter_contract" }

docs/examples/contracts/counter_contract_test/src/lib.nr

@@ -0,0 +1,33 @@
+use counter_contract::Counter;
+use aztec::{protocol::address::AztecAddress, test::helpers::test_environment::TestEnvironment};
+
+pub unconstrained fn setup(initial_value: u128) -> (TestEnvironment, AztecAddress, AztecAddress) {
+    let mut env = TestEnvironment::new();
+    let owner = env.create_light_account();
+
+    let initializer = Counter::interface().constructor(initial_value, owner);
+    let contract_address =
+        env.deploy("@counter_contract/Counter").with_private_initializer(owner, initializer);
+    (env, contract_address, owner)
+}
+
+#[test]
+unconstrained fn test_constructor_sets_initial_value() {
+    let initial_value = 5;
+    let (env, contract_address, owner) = setup(initial_value);
+
+    let value = env.execute_utility(Counter::at(contract_address).get_counter(owner));
+    assert(value == initial_value, f"Expected {initial_value} but got {value}");
+}
+
+#[test]
+unconstrained fn test_increment() {
+    let initial_value = 5;
+    let (mut env, contract_address, owner) = setup(initial_value);
+
+    env.call_private(owner, Counter::at(contract_address).increment(owner));
+
+    let expected = initial_value + 1;
+    let value = env.execute_utility(Counter::at(contract_address).get_counter(owner));
+    assert(value == expected, f"Expected {expected} but got {value}");
+}

docs/examples/contracts/logging_example_test/src/lib.nr

@@ -24,7 +24,7 @@ unconstrained fn test_public_logging() {
 #[test]
 unconstrained fn test_all_log_levels() {
     let (env, contract_address, owner) = setup();
-    env.call_private(owner, LoggingExample::at(contract_address).log_all_levels());
+    env.call_private(owner, LoggingExample::at(contract_address).log_all_levels(42));
 }
 
 #[test]