Merge branch 'v5-next' into chore/merge-public-v5-next

Author: alexghr

.github/ci3_labels_to_env.sh

@@ -127,6 +127,9 @@ function main {
     echo "WARNING: Skipping main CI because Chonk input refresh was requested; the update step will run after this step succeeds." >&2
     ci_mode="skip"
   elif has_label "ci-release-pr"; then
+    # Release-PR mode creates and pushes a release tag for this PR's head (ci3.sh::handle_release_pr).
+    # In the private repo that tag triggers a private release via the safety gate below — this is the
+    # manual way to cut a private release from a PR, alongside the nightly tag cron.
     ci_mode="release-pr"
   elif has_label "ci-full"; then
     ci_mode="full"
@@ -141,6 +144,9 @@ function main {
   elif has_label "ci-barretenberg" || [ "$target_branch" == "merge-train/barretenberg" ]; then
     ci_mode="barretenberg"
   elif [[ "${GITHUB_REF:-}" == refs/tags/v* ]]; then
+    # A pushed semver tag is a release; REF_NAME is the tag (see ci3/source_refname). In the private
+    # repo this is the nightly path (nightly-release-tag*.yml push v<ver>-nightly.<date> tags on next and
+    # v5-next); the private-repo safety gate below routes it to the internal Artifact Registry.
     ci_mode="release"
   else
     ci_mode="fast"
@@ -149,6 +155,17 @@ function main {
   echo "CI_MODE=$ci_mode" >> $GITHUB_ENV
   echo "CI mode: $ci_mode"
 
+  # Private-repo safety gate. The release flow can publish to DockerHub/npmjs/crates.io/github; that
+  # MUST NEVER run in the private fork. So whenever this repo would release — for ANY trigger (a pushed
+  # nightly tag, a ci-release-pr tag, anything future) — force the private path: publish only the docker
+  # image and npm packages to our internal Artifact Registry (bootstrap.sh::private_release). Keyed on
+  # the repo name (case-insensitive) so it can't be reached in the public repo.
+  if [ "$ci_mode" = "release" ] &&
+     [ "$(printf '%s' "${GITHUB_REPOSITORY:-}" | tr 'A-Z' 'a-z')" = "aztecprotocol/aztec-packages-private" ]; then
+    echo "PRIVATE_RELEASE=1" >> $GITHUB_ENV
+    echo "SKIP_COMPAT_E2E=1" >> $GITHUB_ENV
+  fi
+
   # Determine if benchmarks should be uploaded (merge-queue, full, or full-no-test-cache modes)
   if [[ "$ci_mode" == "merge-queue" || "$ci_mode" == "merge-queue-heavy" || "$ci_mode" == "full" || "$ci_mode" == "full-no-test-cache" ]]; then
     echo "SHOULD_UPLOAD_BENCHMARKS=1" >> $GITHUB_ENV

.github/workflows/ci3.yml

@@ -7,6 +7,8 @@ name: CI3
 on:
   workflow_dispatch:
   push:
+    branches:
+      - next
     tags:
       - "v*"
   pull_request:
@@ -115,6 +117,9 @@ jobs:
           EXTERNAL_ETHEREUM_CONSENSUS_HOST_API_KEY: ${{ secrets.GCP_SEPOLIA_API_KEY }}
           EXTERNAL_ETHEREUM_CONSENSUS_HOST_API_KEY_HEADER: "X-goog-api-key"
           GCP_PROJECT_ID: ${{ secrets.GCP_PROJECT_ID }}
+          # Internal GCP Artifact Registry the private repo's release pushes the docker image to (see
+          # bootstrap.sh::private_release). Empty in the public repo, where releases publish normally.
+          INTERNAL_DOCKER_REGISTRY: ${{ vars.INTERNAL_DOCKER_REGISTRY }}
           MERGE_GROUP_BASE_REF: ${{ github.event.merge_group.base_ref }}
           PR_BASE_REF: ${{ github.event.pull_request.base.ref }}
           PR_HEAD_REF: ${{ github.event.pull_request.head.ref }}

.github/workflows/docs-typesense.yml

@@ -39,6 +39,11 @@ jobs:
         run: |
           set -euo pipefail
 
+          if [ -z "$TYPESENSE_API_KEY" ] || [ -z "$TYPESENSE_HOST" ]; then
+            echo "Typesense secrets are not configured; skipping docs search reindex."
+            exit 0
+          fi
+
           docker run \
             -e "TYPESENSE_API_KEY=$TYPESENSE_API_KEY" \
             -e "TYPESENSE_HOST=$TYPESENSE_HOST" \

…orkflows/nightly-release-tag-v4-next.yml …orkflows/nightly-release-tag-v5-next.yml.github/workflows/nightly-release-tag-v4-next.yml renamed to .github/workflows/nightly-release-tag-v5-next.yml .github/workflows/nightly-release-tag-v4-next.yml renamed to .github/workflows/nightly-release-tag-v5-next.yml

@@ -1,4 +1,4 @@
-name: Nightly Release Tag (v4-next)
+name: Nightly Release Tag (v5-next)
 on:
   schedule:
     # Run the workflow every night at 5:00 AM UTC.
@@ -9,24 +9,24 @@ permissions:
   contents: write
 
 concurrency:
-  group: ${{ github.workflow }}-v4-next
+  group: ${{ github.workflow }}-v5-next
 
 jobs:
-  nightly-release-tag-v4-next:
+  nightly-release-tag-v5-next:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
-          ref: v4-next
+          ref: v5-next
           token: ${{ secrets.AZTEC_BOT_GITHUB_TOKEN }}
 
-      - name: Create v4-next Nightly Tag
+      - name: Create v5-next Nightly Tag
         run: |
           git config --global user.email "tech@aztecprotocol.com"
           git config --global user.name "AztecBot"
           current_version=$(jq -r '."."' .release-please-manifest.json)
           echo "Current version: $current_version"
           nightly_tag="v${current_version}-nightly.$(date -u +%Y%m%d)"
-          echo "v4-next nightly tag: $nightly_tag"
+          echo "v5-next nightly tag: $nightly_tag"
           git tag -a "$nightly_tag" -m "$nightly_tag"
           git push origin "$nightly_tag"

.github/workflows/public-next-pr-body.yml

@@ -0,0 +1,34 @@
+name: Public Next PR Body
+
+on:
+  push:
+    branches:
+      - next
+      - public-next
+  workflow_dispatch:
+
+concurrency:
+  group: public-next-pr-body
+  cancel-in-progress: true
+
+jobs:
+  update-public-next-pr-body:
+    name: Update next to public-next PR body
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - name: Checkout public-next workflow scripts
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          ref: public-next
+          fetch-depth: 0
+          token: ${{ secrets.AZTEC_BOT_GITHUB_TOKEN }}
+
+      - name: Update holding PR body
+        env:
+          GH_TOKEN: ${{ secrets.AZTEC_BOT_GITHUB_TOKEN }}
+          BASE_BRANCH: public-next
+          HEAD_BRANCH: next
+        run: ./scripts/merge-train/update-public-next-pr-body.sh

.github/workflows/public-next-to-next.yml

@@ -0,0 +1,37 @@
+name: Public Next Auto-Pull
+
+on:
+  push:
+    branches:
+      - public-next
+  workflow_dispatch:
+
+concurrency:
+  group: public-next-to-next
+  cancel-in-progress: false
+
+jobs:
+  merge-to-next:
+    name: Merge public-next to next
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout public-next automation
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          ref: public-next
+          fetch-depth: 0
+          token: ${{ secrets.AZTEC_BOT_GITHUB_TOKEN }}
+          persist-credentials: true
+
+      - name: Configure Git
+        run: |
+          git config user.name AztecBot
+          git config user.email tech@aztecprotocol.com
+
+      - name: Merge public-next into next
+        env:
+          GH_TOKEN: ${{ secrets.AZTEC_BOT_GITHUB_TOKEN }}
+          SOURCE_BRANCH: public-next
+          TARGET_BRANCH: next
+          CONFLICT_EXIT_CODE: 1
+        run: ./scripts/merge-train/merge-public-next.sh

.github/workflows/release-canary-pr-update.yml

@@ -125,10 +125,10 @@ jobs:
 
             # Add labels based on what changed
             labels=""
-            if [[ "${{ steps.detect.outputs.release_pr }}" == "true" ]]; then
+            if [[ "${{ github.repository }}" != "AztecProtocol/aztec-packages-private" && "${{ steps.detect.outputs.release_pr }}" == "true" ]]; then
               labels="$labels --add-label ci-release-pr"
             fi
-            if [[ "${{ steps.detect.outputs.network_kind }}" == "true" ]]; then
+            if [[ "${{ github.repository }}" != "AztecProtocol/aztec-packages-private" && "${{ steps.detect.outputs.network_kind }}" == "true" ]]; then
               labels="$labels --add-label ci-network-kind"
             fi
             if [[ -n "$labels" ]]; then

.github/workflows/sync-upstream-next.yml

@@ -0,0 +1,34 @@
+# Sync public-next to upstream next while preserving private automation.
+#
+# Uses AZTEC_BOT_GITHUB_TOKEN (PAT) because GITHUB_TOKEN cannot push
+# commits that modify .github/workflows/ files.
+name: Sync Upstream Next
+
+on:
+  schedule:
+    - cron: "*/15 * * * *"
+  workflow_dispatch:
+
+jobs:
+  sync:
+    name: Sync public-next
+    runs-on: ubuntu-latest
+    concurrency:
+      group: sync-public-next
+      cancel-in-progress: false
+    steps:
+      - name: Checkout public-next
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          ref: public-next
+          fetch-depth: 0
+          token: ${{ secrets.AZTEC_BOT_GITHUB_TOKEN }}
+          persist-credentials: true
+
+      - name: Configure Git
+        run: |
+          git config user.name "AztecBot"
+          git config user.email "tech@aztecprotocol.com"
+
+      - name: Sync public-next with upstream
+        run: ./scripts/merge-train/sync-public-next.sh

avm-transpiler/src/procedures/msm.rs

@@ -29,7 +29,7 @@ OUTER_BODY:     MUL d6, d13, d16; Compute the pointer to the point
                 EQ i17, d8, d19; Check if the scalar lo is zero
                 EQ i18, d8, d20; Check if the scalar hi is zero
                 AND d19, d20, d19; Check if both scalars are zero
-                JUMPI d19, OUTER_INC; If both scalar limbs are zero, continue
+                JUMPI d19, VALIDATE_ZERO_SCALAR_POINT; If both scalar limbs are zero, validate the point then continue
                 ; Decompose the scalars to an array of 254 bits
                 ; Allocate a 254 bit array
                 MOV $1, d19; Move the free memory pointer to d19, where we'll store the bits
@@ -75,6 +75,15 @@ OUTER_INC:      ADD d6, $2, d6; Increment the outer loop variable
                 JUMP OUTER_HEAD
                 ; After the outer loop we have computed the msm. We can return since we wrote the result in i3, i4
 OUTER_END:      INTERNALRETURN
+
+                ; A zero scalar skips the loop where point validation takes place (inside ECADD), but Brillig/native validates /before/ the loop. 
+                ; To mirror this we perform a 'dummy' ECADD (P + O = P) which throws if the point is not on the curve.
+VALIDATE_ZERO_SCALAR_POINT: MOV i16, d22; x
+                ADD d16, $2, d25; pointer to y
+                MOV i25, d23; y
+                ; Note: d8 (=0) used as the (0,0) infinity coords here - if the infinity rep changes, update this.
+                ECADD d22, d23, d8, d8, /*not indirect, so the result (= point) is stored in d22, d23*/ d22; Add the original point to infinity
+                JUMP OUTER_INC; Skip this zero-scalar term
 ";
 
 #[cfg(test)]

avm-transpiler/src/transpile.rs

@@ -324,37 +324,29 @@ pub fn brillig_to_avm(brillig_bytecode: &[BrilligOpcode<FieldElement>]) -> (Vec<
                 ));
             }
             BrilligOpcode::ConditionalMov { destination, source_a, source_b, condition } => {
-                // Move source_a to destination, if condition is true jump to the next brillig opcode, else move source_b to destination
-                avm_instrs.push(generate_mov_instruction(
-                    Some(
-                        AddressingModeBuilder::default()
-                            .direct_operand(source_a)
-                            .direct_operand(destination)
-                            .build(),
-                    ),
-                    source_a.to_u32(),
-                    destination.to_u32(),
-                ));
-
-                unresolved_jumps.insert(
-                    UnresolvedPCLocation {
-                        instruction_index: avm_instrs.len(),
-                        immediate_index: 0,
-                    },
-                    Label::BrilligPC { pc: brillig_pcs_to_avm_pcs.len() as u32 }, // We want to jump to the next brillig opcode
-                );
-
-                avm_instrs.push(AvmInstruction {
+                // Alias-safe lowering of the atomic `destination = condition ? source_a : source_b`.
+                //
+                //         JUMPI condition, then
+                //         MOV   source_b -> destination   ; false branch
+                //         JUMP  end
+                //   then: MOV   source_a -> destination   ; true branch
+                //   end:  (next brillig opcode)
+                //
+                // `destination` is written exactly once, on the branch actually taken, after
+                // `condition` has been read.
+
+                // JUMPI condition, then
+                let mut jumpi = AvmInstruction {
                     opcode: AvmOpcode::JUMPI_32,
                     addressing_mode: Some(
                         AddressingModeBuilder::default().direct_operand(condition).build(),
                     ),
                     operands: vec![make_operand(16, &condition.to_u32())],
                     immediates: vec![make_unresolved_pc()],
                     ..Default::default()
-                });
-
-                avm_instrs.push(generate_mov_instruction(
+                };
+                // MOV source_b -> destination
+                let mov_b = generate_mov_instruction(
                     Some(
                         AddressingModeBuilder::default()
                             .direct_operand(source_b)
@@ -363,7 +355,36 @@ pub fn brillig_to_avm(brillig_bytecode: &[BrilligOpcode<FieldElement>]) -> (Vec<
                     ),
                     source_b.to_u32(),
                     destination.to_u32(),
-                ));
+                );
+                // JUMP end
+                let mut jump_end = AvmInstruction {
+                    opcode: AvmOpcode::JUMP_32,
+                    immediates: vec![make_unresolved_pc()],
+                    ..Default::default()
+                };
+                // MOV source_a -> destination
+                let mov_a = generate_mov_instruction(
+                    Some(
+                        AddressingModeBuilder::default()
+                            .direct_operand(source_a)
+                            .direct_operand(destination)
+                            .build(),
+                    ),
+                    source_a.to_u32(),
+                    destination.to_u32(),
+                );
+
+                // Calculate jump pc targets
+                let then_pc = current_avm_pc + jumpi.size() + mov_b.size() + jump_end.size();
+                let end_pc = then_pc + mov_a.size();
+                // Update immediates with correct jump targets
+                jumpi.immediates = vec![AvmOperand::U32 { value: then_pc as u32 }];
+                jump_end.immediates = vec![AvmOperand::U32 { value: end_pc as u32 }];
+
+                avm_instrs.push(jumpi);
+                avm_instrs.push(mov_b);
+                avm_instrs.push(jump_end);
+                avm_instrs.push(mov_a);
             }
             BrilligOpcode::Load { destination, source_pointer } => {
                 avm_instrs.push(generate_mov_instruction(