docs: align counter scaffold with tutorial and run example TXE tests in CI

- Fix the `aztec init` counter scaffold so `increment()` reads
  `self.msg_sender()` instead of taking an `owner` param, matching the
  tutorial's auth fix. The CLI no longer scaffolds the "anyone can increment
  anyone's counter" default. Updates the scaffold's test to match.
- Rename the docs counter example's initializer from `initialize`/`headstart`
  to `constructor`/`initial_value` to match the scaffold; update the tutorial
  prose and TXE tests accordingly, and fix a stale `aztec(initializer)` comment.
- Tighten the tutorial's privacy claim (drop the inaccurate "no one knows when
  you increment") and explain why only `increment` derives the owner from the
  caller while `constructor` and `get_counter` take an explicit owner.
- Wire the example TXE test packages (counter_contract_test,
  logging_example_test) into docs CI via a new `test-contracts` step that
  starts a TXE and runs `nargo test`; drop the unused `balance_set` dependency.

Author: critesjosh

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

@@ -7,7 +7,7 @@ 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.
 
@@ -120,6 +120,8 @@ Now let's implement an `increment` function to increase the counter.
 
 The `increment` function uses `self.msg_sender()` so each caller can only increment the counter mapped to their own address. It logs a debug message, then adds 1 to that counter and delivers the note onchain.
 
+Only this mutating action derives the owner from the caller. The one-time `constructor` and the `get_counter` read still take an explicit `owner`: the constructor can seed a chosen account, and a read selects which counter to view (only its owner can decrypt it).
+
 ## Getting a counter
 
 The last thing we need to implement is a function to retrieve a counter value.

docs/examples/bootstrap.sh

@@ -209,8 +209,53 @@ 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 {
   echo "$hash:ONLY_TERM_PARENT=1 docs/examples/bootstrap.sh execute"
+  echo "$hash:ONLY_TERM_PARENT=1 docs/examples/bootstrap.sh test-contracts"
 }
 
 function test {
@@ -390,6 +435,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

@@ -6,5 +6,4 @@ type = "lib"
 
 [dependencies]
 aztec = { path = "../../../../noir-projects/aztec-nr/aztec" }
-balance_set = { path = "../../../../noir-projects/aztec-nr/balance-set" }
 counter_contract = { path = "../counter_contract" }

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

@@ -1,48 +1,55 @@
 use counter_contract::Counter;
 use aztec::{protocol::address::AztecAddress, test::helpers::test_environment::TestEnvironment};
 
-pub unconstrained fn setup(headstart: u128) -> (TestEnvironment, AztecAddress, AztecAddress) {
+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().initialize(headstart, owner);
+    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_initialize_sets_headstart() {
-    let headstart = 5;
-    let (env, contract_address, owner) = setup(headstart);
+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 == headstart, f"Expected {headstart} but got {value}");
+    assert(value == initial_value, f"Expected {initial_value} but got {value}");
 }
 
 #[test]
 unconstrained fn test_increment_increases_caller_counter() {
-    let headstart = 5;
-    let (mut env, contract_address, owner) = setup(headstart);
+    let initial_value = 5;
+    let (mut env, contract_address, owner) = setup(initial_value);
 
     env.call_private(owner, Counter::at(contract_address).increment());
 
-    let expected = headstart + 1;
+    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}");
 }
 
 #[test]
-unconstrained fn test_increment_does_not_affect_other_account() {
-    let headstart = 5;
-    let (mut env, contract_address, owner) = setup(headstart);
-    let other = env.create_light_account();
+unconstrained fn test_stranger_increment_does_not_affect_owner() {
+    let initial_value = 5;
+    let (mut env, contract_address, owner) = setup(initial_value);
+    let stranger = env.create_light_account();
 
-    env.call_private(other, Counter::at(contract_address).increment());
+    // `increment` derives the owner from msg_sender, so a different caller can
+    // only ever touch its own counter, never the owner's.
+    env.call_private(stranger, Counter::at(contract_address).increment());
 
+    // The stranger's increment lands on their own counter, which started at 0.
+    let stranger_value = env.execute_utility(Counter::at(contract_address).get_counter(stranger));
+    assert(stranger_value == 1, f"Expected stranger counter at 1 but got {stranger_value}");
+
+    // The owner's counter is untouched by another account's increment.
     let owner_value = env.execute_utility(Counter::at(contract_address).get_counter(owner));
     assert(
-        owner_value == headstart,
-        f"Expected owner counter unchanged at {headstart} but got {owner_value}",
+        owner_value == initial_value,
+        f"Expected owner counter unchanged at {initial_value} but got {owner_value}",
     );
 }

yarn-project/aztec/scripts/templates/counter/contract/src/main.nr

@@ -31,9 +31,13 @@ pub contract Counter {
         );
     }
 
-    // Adds 1 to the owner's counter.
+    // Adds 1 to the caller's own counter.
+    //
+    // The owner is read from self.msg_sender(), so a caller can only ever
+    // increment the counter mapped to their own address.
     #[external("private")]
-    fn increment(owner: AztecAddress) {
+    fn increment() {
+        let owner = self.msg_sender();
         self.storage.counters.at(owner).add(1).deliver(MessageDelivery.ONCHAIN_CONSTRAINED);
     }
 

yarn-project/aztec/scripts/templates/counter/test/src/lib.nr

@@ -25,7 +25,7 @@ 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));
+    env.call_private(owner, Counter::at(contract_address).increment());
 
     let counter = env.execute_utility(Counter::at(contract_address).get_counter(owner));
     assert_eq(counter, initial_value + 1);