chore(release): merge v5-next into v5 for v5.1.0 (#24897)

Promotes `v5-next` onto `v5` for the **v5.1.0** release.

- Merges `v5-next` into `v5`; the resulting tree is **identical to
`v5-next`** and `.release-please-manifest.json` is set to **5.1.0** (the
only merge conflict was the manifest — v5 held 5.0.1, resolved to
v5-next's 5.1.0).
- Merge via **merge commit** (v5 ruleset allows `merge` only).
- After this merges, `v5` HEAD is tagged `v5.1.0`.

Does not include #24840 (json-rpc result key), which is still on
`merge-train/spartan-v5` and not in `v5-next`.

Author: aminsammara

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "5.0.1"
+  ".": "5.1.0"
 }

CLAUDE.md

@@ -57,6 +57,10 @@ When staging files, prefer `git add -u` or name specific files rather than `git
 Never bulk-update lockfiles (`Cargo.lock`, `yarn.lock`). Use targeted updates only: `cargo update --precise <version> --package <name>` for Rust, and `yarn up <package>@<version>` in the relevant workspace for TypeScript. Bulk updates drag in unrelated transitive changes that make review impossible and frequently break reproducibility.
 </lockfile_discipline>
 
+<standard_contract_repin>
+Never run `noir-projects/noir-contracts/bootstrap.sh pin-standard-build` on your own initiative. The pin exists so ordinary source or bytecode changes do NOT move the standard contracts' canonical addresses, and CI does not fail when the bytecode drifts. A re-pin is a deliberate redeploy decision for a human to make: if a change seems to need one, leave the pin, rebuild against it, and ask. See the comment on `pin-standard-build` for why re-pinning is breaking.
+</standard_contract_repin>
+
 </git_workflow>
 
 <code_formatting>

barretenberg/cpp/scripts/chonk-inputs.hash

@@ -1 +1 @@
-30325f8d3e30771a
+f19b76f7fa0ff0cd

barretenberg/cpp/src/barretenberg/circuit_checker/ultra_circuit_builder_lookup.test.cpp

@@ -4,6 +4,7 @@
 
 #include <gtest/gtest.h>
 #include <unordered_map>
+#include <unordered_set>
 
 using namespace bb;
 
@@ -121,6 +122,47 @@ TEST_F(UltraCircuitBuilderLookup, DifferentTablesGetUniqueIndices)
     EXPECT_EQ(builder.get_num_lookup_tables(), 3UL);
 }
 
+// Every basic table reachable through any MultiTable must receive a unique, positive circuit-local
+// table_index. The LogDeriv lookup relation identifies a table solely by table_index (not BasicTableId),
+// so a generator that stores anything other than the builder-assigned index silently collapses distinct tables to one
+// identity. This sweeps the whole table space so any such generator is caught.
+TEST_F(UltraCircuitBuilderLookup, AllMultiTableBasicTablesGetUniquePositiveIndices)
+{
+    Builder builder;
+    for (size_t mt = 0; mt < static_cast<size_t>(plookup::MultiTableId::NUM_MULTI_TABLES); ++mt) {
+        const auto& multitable = plookup::get_multitable(static_cast<plookup::MultiTableId>(mt));
+        for (const auto id : multitable.basic_table_ids) {
+            builder.get_table(id);
+        }
+    }
+
+    std::unordered_set<size_t> seen;
+    for (const auto& table : builder.get_lookup_tables()) {
+        EXPECT_GT(table.table_index, 0UL) << "non-positive index for basic table id " << static_cast<size_t>(table.id);
+        EXPECT_TRUE(seen.insert(table.table_index).second)
+            << "duplicate table_index " << table.table_index << " for basic table id " << static_cast<size_t>(table.id);
+    }
+    EXPECT_NO_THROW(builder.finalize_circuit());
+}
+
+TEST_F(UltraCircuitBuilderLookup, FinalizationRejectsDuplicateTableIndices)
+{
+    Builder builder;
+    builder.get_table(plookup::BasicTableId::UINT_XOR_SLICE_6_ROTATE_0);
+    builder.get_table(plookup::BasicTableId::UINT_AND_SLICE_6_ROTATE_0);
+    builder.get_lookup_tables()[1].table_index = builder.get_lookup_tables()[0].table_index;
+
+    EXPECT_THROW_OR_ABORT(builder.finalize_circuit(), "Lookup table indices must be unique within a circuit");
+}
+
+TEST_F(UltraCircuitBuilderLookup, FinalizationRejectsZeroTableIndex)
+{
+    Builder builder;
+    builder.get_table(plookup::BasicTableId::UINT_XOR_SLICE_6_ROTATE_0).table_index = 0;
+
+    EXPECT_THROW_OR_ABORT(builder.finalize_circuit(), "Lookup table indices must be positive");
+}
+
 // Verifies correct behavior when key_b_index is not provided (2-to-1 lookup without second index)
 TEST_F(UltraCircuitBuilderLookup, NoKeyBIndex)
 {

barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/plookup_tables/plookup_tables.cpp

@@ -285,22 +285,22 @@ BasicTable create_basic_table(const BasicTableId id, const size_t index)
     if (id_var >= static_cast<size_t>(SECP256R1_FIXED_BASE_XLO_0) &&
         id_var < static_cast<size_t>(SECP256R1_FIXED_BASE_XHI_0)) {
         return secp256r1_fixed_base::table::generate_basic_table_runtime<secp256r1_fixed_base::table::AXIS_XLO>(
-            id, id_var - static_cast<size_t>(SECP256R1_FIXED_BASE_XLO_0));
+            id, id_var - static_cast<size_t>(SECP256R1_FIXED_BASE_XLO_0), index);
     }
     if (id_var >= static_cast<size_t>(SECP256R1_FIXED_BASE_XHI_0) &&
         id_var < static_cast<size_t>(SECP256R1_FIXED_BASE_YLO_0)) {
         return secp256r1_fixed_base::table::generate_basic_table_runtime<secp256r1_fixed_base::table::AXIS_XHI>(
-            id, id_var - static_cast<size_t>(SECP256R1_FIXED_BASE_XHI_0));
+            id, id_var - static_cast<size_t>(SECP256R1_FIXED_BASE_XHI_0), index);
     }
     if (id_var >= static_cast<size_t>(SECP256R1_FIXED_BASE_YLO_0) &&
         id_var < static_cast<size_t>(SECP256R1_FIXED_BASE_YHI_0)) {
         return secp256r1_fixed_base::table::generate_basic_table_runtime<secp256r1_fixed_base::table::AXIS_YLO>(
-            id, id_var - static_cast<size_t>(SECP256R1_FIXED_BASE_YLO_0));
+            id, id_var - static_cast<size_t>(SECP256R1_FIXED_BASE_YLO_0), index);
     }
     if (id_var >= static_cast<size_t>(SECP256R1_FIXED_BASE_YHI_0) &&
         id_var < static_cast<size_t>(SECP256R1_FIXED_BASE_END)) {
         return secp256r1_fixed_base::table::generate_basic_table_runtime<secp256r1_fixed_base::table::AXIS_YHI>(
-            id, id_var - static_cast<size_t>(SECP256R1_FIXED_BASE_YHI_0));
+            id, id_var - static_cast<size_t>(SECP256R1_FIXED_BASE_YHI_0), index);
     }
     switch (id) {
     case AES_SPARSE_MAP: {

barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/plookup_tables/secp256r1_fixed_base.cpp

@@ -143,17 +143,18 @@ template <table::AxisIndex axis> generate_fn_ptr generate_fn_for_window(size_t w
 }
 } // namespace
 
-template <table::AxisIndex axis> BasicTable table::generate_basic_table_runtime(BasicTableId id, size_t window_idx)
+template <table::AxisIndex axis>
+BasicTable table::generate_basic_table_runtime(BasicTableId id, size_t window_idx, size_t table_index)
 {
     BB_ASSERT_LT(window_idx, NUM_WINDOWS);
-    return generate_fn_for_window<axis>(window_idx)(id, window_idx);
+    return generate_fn_for_window<axis>(window_idx)(id, table_index);
 }
 
 // Explicit instantiations for the four axes.
-template BasicTable table::generate_basic_table_runtime<table::AXIS_XLO>(BasicTableId, size_t);
-template BasicTable table::generate_basic_table_runtime<table::AXIS_XHI>(BasicTableId, size_t);
-template BasicTable table::generate_basic_table_runtime<table::AXIS_YLO>(BasicTableId, size_t);
-template BasicTable table::generate_basic_table_runtime<table::AXIS_YHI>(BasicTableId, size_t);
+template BasicTable table::generate_basic_table_runtime<table::AXIS_XLO>(BasicTableId, size_t, size_t);
+template BasicTable table::generate_basic_table_runtime<table::AXIS_XHI>(BasicTableId, size_t, size_t);
+template BasicTable table::generate_basic_table_runtime<table::AXIS_YLO>(BasicTableId, size_t, size_t);
+template BasicTable table::generate_basic_table_runtime<table::AXIS_YHI>(BasicTableId, size_t, size_t);
 
 namespace {
 // Returns `&table::get_values<axis, window_idx>` for a runtime (axis, window_idx). The per-axis 32-entry

barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/plookup_tables/secp256r1_fixed_base.hpp

@@ -116,10 +116,11 @@ class table : public Secp256r1FixedBaseParams {
     static BasicTable generate_basic_table(BasicTableId id, size_t table_index);
 
     /**
-     * @brief Runtime dispatch helper used by plookup_tables.cpp::create_basic_table. Given an axis and a
-     * runtime window_idx ∈ [0, NUM_WINDOWS), instantiate the corresponding generator.
+     * @brief Runtime dispatch helper used by plookup_tables.cpp::create_basic_table. Selects table contents using
+     * window_idx and assigns the independently supplied circuit-local table_index.
      */
-    template <AxisIndex axis> static BasicTable generate_basic_table_runtime(BasicTableId id, size_t table_index);
+    template <AxisIndex axis>
+    static BasicTable generate_basic_table_runtime(BasicTableId id, size_t window_idx, size_t table_index);
 
     /**
      * @brief Construct one of the 10 MultiTables described in the file-header docstring.

barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.cpp

@@ -51,6 +51,13 @@ template <typename ExecutionTrace> void UltraCircuitBuilder_<ExecutionTrace>::fi
      * our circuit is finalized, and we must not to execute these functions again.
      */
     if (!this->circuit_finalized) {
+        std::unordered_set<size_t> table_indices;
+        for (const auto& table : lookup_tables) {
+            BB_ASSERT_GT(table.table_index, 0U, "Lookup table indices must be positive");
+            BB_ASSERT(table_indices.insert(table.table_index).second,
+                      "Lookup table indices must be unique within a circuit");
+        }
+
         process_non_native_field_multiplications();
 #ifndef ULTRA_FUZZ
         this->rom_ram_logic.process_ROM_arrays(this);

docs/docs-developers/docs/resources/migration_notes.md

@@ -9,6 +9,22 @@ Aztec is in active development. Each version may introduce breaking changes that
 
 ## TBD
 
+### [Aztec.nr] Canonical HandshakeRegistry re-pinned at a new address
+
+The canonical `HandshakeRegistry` has been re-pinned so that it includes the owner's address in its `PrivateMutable` initialization nullifiers, keeping the handshake state of accounts that share keys independent. The registry moves to a new address. Handshakes established with the previous registry instance are not visible to the new one and must be re-established. The other standard contracts keep their addresses.
+
+### [Aztec.nr] Note property selectors are typed and use packed-layout indices
+
+The selectors in the generated `properties()` used the field's position in the note struct declaration, which pointed at the wrong packed field for any note with an earlier field packing to more than one `Field` (a `Point`, an array, a nested struct). Selector indices are now the field's offset in the note's packed representation, so `select`/`sort` criteria constrain the field they name.
+
+Breaking changes:
+
+- `PropertySelector<T>` carries the selected property's type. Hand-constructed literals need a type annotation, e.g. `let selector: PropertySelector<Field> = PropertySelector { index: 0, offset: 0, length: 32 };`.
+- `select`/`sort` reject properties that pack to more than one `Field` at compile time.
+- `select` takes its value typed as the property's type. Cast the value if a mixed-type comparison was intentional.
+- `properties()` cannot be used with a custom `Packable` layout. Define property selectors manually for such notes.
+- Every note field type must implement `Packable`, even when the note's own `Packable` is hand-written.
+
 ### [Aztec.nr] History note nullification helpers renamed and restricted to own-contract notes
 
 The `history::note` helpers that recompute a note's nullifier have been renamed with a `local_` prefix and now assert that the note belongs to the executing contract:

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

@@ -24,7 +24,7 @@ yarn init -y
 Next, add the TypeScript dependencies:
 
 ```sh
-yarn add typescript @types/node tsx
+yarn add "typescript@^5.3.3" @types/node tsx
 ```
 
 :::tip