Merge branch 'next' into merge-train/barretenberg

Author: AztecBot

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

@@ -91,6 +91,23 @@ FPCs that use only Fee Juice still work on all networks, since FeeJuice is a pro
 
 Similarly, the `fpc-public` and `fpc-private` CLI wallet payment methods use the reference Token-based FPC and will not work on public networks. Use `fee_juice` for direct Fee Juice payment, or `fpc-sponsored` on devnet and local network.
 
+### [aztec.js] `EmbeddedWalletOptions` now uses a unified `pxe` field
+
+The `pxeConfig` and `pxeOptions` fields on `EmbeddedWalletOptions` have been deprecated in favor of a single `pxe` field that accepts both PXE configuration and dependency overrides (custom prover, store, simulator):
+
+```diff
+const wallet = await EmbeddedWallet.create(nodeUrl, {
+-  pxeConfig: { proverEnabled: true },
+-  pxeOptions: { proverOrOptions: myCustomProver },
++  pxe: {
++    proverEnabled: true,
++    proverOrOptions: myCustomProver,
++  },
+});
+```
+
+The old fields still work but will be removed in a future release.
+
 ### [Aztec.nr] Domain-separated tags on log emission
 
 All logs emitted through the Aztec.nr framework now include a domain-separated tag at `fields[0]`. Each log category uses its own domain separator via `compute_log_tag(raw_tag, dom_sep)`:

noir-projects/noir-contracts/contracts/test/note_getter_contract/src/main.nr

@@ -1,4 +1,5 @@
 use aztec::macros::aztec;
+mod packed_note;
 
 /// Used to test note getter in e2e_note_getter.test.ts
 #[aztec]
@@ -16,9 +17,12 @@ pub contract NoteGetter {
 
     use field_note::FieldNote;
 
+    use crate::packed_note::PackedNote;
+
     #[storage]
     struct Storage<Context> {
         set: Owned<PrivateSet<FieldNote, Context>, Context>,
+        packed_set: Owned<PrivateSet<PackedNote, Context>, Context>,
     }
 
     #[external("private")]
@@ -42,4 +46,42 @@ pub contract NoteGetter {
         ));
         notes.map(|note| note.value)
     }
+
+    #[external("private")]
+    fn insert_packed_note(high: u8, low: u8) {
+        let owner = self.msg_sender();
+        let note = PackedNote { high, low };
+
+        self.storage.packed_set.at(owner).insert(note).deliver(MessageDelivery.ONCHAIN_CONSTRAINED);
+    }
+
+    #[external("utility")]
+    unconstrained fn select_packed_notes_by_high(
+        owner: AztecAddress,
+        comparator: u8,
+        value: Field,
+    ) -> BoundedVec<[u8; 2], 10> {
+        let selector = PackedNote::high_selector();
+        let notes = self.storage.packed_set.at(owner).view_notes(NoteViewerOptions::new().select(
+            selector,
+            comparator,
+            value,
+        ));
+        notes.map(|note: PackedNote| [note.high, note.low])
+    }
+
+    #[external("utility")]
+    unconstrained fn select_packed_notes_by_low(
+        owner: AztecAddress,
+        comparator: u8,
+        value: Field,
+    ) -> BoundedVec<[u8; 2], 10> {
+        let selector = PackedNote::low_selector();
+        let notes = self.storage.packed_set.at(owner).view_notes(NoteViewerOptions::new().select(
+            selector,
+            comparator,
+            value,
+        ));
+        notes.map(|note: PackedNote| [note.high, note.low])
+    }
 }

noir-projects/noir-contracts/contracts/test/note_getter_contract/src/packed_note.nr

@@ -0,0 +1,61 @@
+use aztec::{
+    macros::notes::note,
+    note::note_getter_options::PropertySelector,
+    protocol::traits::{Deserialize, Packable, Serialize},
+};
+
+/// A note that packs two u8 fields (high, low) into a single Field.
+/// The layout in the packed Field is: (high << 8) + low.
+/// This means in the big-endian 32-byte representation:
+///   - low occupies offset=0, length=1 (the least significant byte)
+///   - high occupies offset=1, length=1 (the second least significant byte)
+#[derive(Deserialize, Eq, Serialize)]
+#[note]
+pub struct PackedNote {
+    pub high: u8,
+    pub low: u8,
+}
+
+impl Packable for PackedNote {
+    let N: u32 = 1;
+
+    fn pack(self) -> [Field; Self::N] {
+        [(self.high as Field) * 256 + (self.low as Field)]
+    }
+
+    fn unpack(packed: [Field; Self::N]) -> Self {
+        let low = packed[0] as u8;
+        let high = ((packed[0] - low as Field) / 256) as u8;
+        Self { high, low }
+    }
+}
+
+impl PackedNote {
+    pub fn high_selector() -> PropertySelector {
+        PropertySelector { index: 0, offset: 1, length: 1 }
+    }
+
+    pub fn low_selector() -> PropertySelector {
+        PropertySelector { index: 0, offset: 0, length: 1 }
+    }
+}
+
+mod test {
+    use super::{Packable, PackedNote};
+
+    #[test]
+    fn test_pack_unpack() {
+        let note = PackedNote { high: 42, low: 7 };
+        let unpacked = PackedNote::unpack(note.pack());
+        assert_eq(unpacked.high, 42);
+        assert_eq(unpacked.low, 7);
+    }
+
+    #[test]
+    fn test_pack_unpack_max() {
+        let note = PackedNote { high: 255, low: 255 };
+        let unpacked = PackedNote::unpack(note.pack());
+        assert_eq(unpacked.high, 255);
+        assert_eq(unpacked.low, 255);
+    }
+}

yarn-project/aztec.js/src/contract/contract_function_interaction.ts

@@ -130,8 +130,9 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     // docs:end:simulate
     if (this.functionDao.functionType == FunctionType.UTILITY) {
       const call = await this.getFunctionCall();
+      const scopes = [...(options.additionalScopes ?? [])];
       const utilityResult = await this.wallet.executeUtility(call, {
-        scopes: options.from === NO_FROM ? [] : [options.from],
+        scopes: options.from === NO_FROM ? scopes : [options.from, ...scopes],
         authWitnesses: options.authWitnesses,
       });
 

yarn-project/end-to-end/.gitignore

@@ -7,3 +7,4 @@ ultrahonk-bench-inputs
 web/main.js*
 consensys_web3signer_*
 scripts/ha/postgres_data/
+.legacy-contracts/

yarn-project/end-to-end/README.md

@@ -24,3 +24,30 @@ which will spawn the two processes.
 You can also run this by `docker-compose up` which will spawn 2 different containers for Anvil and the test runner.
 
 You can run a single test by running `yarn test:compose <test_name>`.
+
+## Running tests against legacy contract artifacts
+
+To verify that contracts deployed from a previous release still work against the current stack, set
+`CONTRACT_ARTIFACTS_VERSION` to a published version of `@aztec/noir-contracts.js` / `@aztec/noir-test-contracts.js`:
+
+```
+CONTRACT_ARTIFACTS_VERSION=4.1.3 yarn test:e2e src/e2e_amm.test.ts
+```
+
+Only the JSON artifact files (`.../artifacts/*.json`) are redirected. The TypeScript wrapper classes
+(e.g. `TokenContract`) continue to load from the current workspace and use the current `@aztec/aztec.js` — so this
+exercises whether a deployed contract's ABI / bytecode / notes still work through the *new* client, not whether the
+legacy wrapper code still imports cleanly.
+
+The first run downloads the pinned packages into `.legacy-contracts/<version>/node_modules/` (cached across runs). A
+startup banner and a per-redirect line are printed to stderr so you can confirm the legacy artifacts were actually
+loaded:
+
+```
+[legacy-contracts][jest] CONTRACT_ARTIFACTS_VERSION=4.1.3
+[legacy-contracts][jest] redirecting @aztec/noir-contracts.js/artifacts/*.json -> .legacy-contracts/4.1.3/...
+[legacy-contracts][jest] redirected token_contract-Token.json -> /abs/.../.legacy-contracts/4.1.3/.../token_contract-Token.json
+```
+
+When `CONTRACT_ARTIFACTS_VERSION` is unset the test run is byte-identical to the default behaviour. The cache is
+populated automatically on first use.

yarn-project/end-to-end/package.json

@@ -159,6 +159,7 @@
     "moduleNameMapper": {
       "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
     },
+    "resolver": "<rootDir>/legacy-jest-resolver.cjs",
     "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
     "rootDir": "./src",
     "testTimeout": 120000,

yarn-project/end-to-end/src/e2e_note_getter.test.ts

@@ -77,6 +77,72 @@ describe('e2e_note_getter', () => {
     });
   });
 
+  describe('sub-field property selector', () => {
+    let contract: NoteGetterContract;
+
+    beforeAll(async () => {
+      ({ contract } = await NoteGetterContract.deploy(wallet).send({ from: defaultAddress }));
+
+      // Insert packed notes with (high, low) pairs.
+      // PackedNote packs two u8s into one Field: (high << 8) + low.
+      // Sub-field selectors use Noir's LSB convention to extract individual u8 values.
+      await Promise.all([
+        contract.methods.insert_packed_note(1, 10).send({ from: defaultAddress }),
+        contract.methods.insert_packed_note(2, 10).send({ from: defaultAddress }),
+        contract.methods.insert_packed_note(1, 20).send({ from: defaultAddress }),
+        contract.methods.insert_packed_note(3, 30).send({ from: defaultAddress }),
+      ]);
+    });
+
+    it('filters by high sub-field', async () => {
+      // high occupies offset=1, length=1 in the packed Field (second LSB)
+      const { result } = await contract.methods
+        .select_packed_notes_by_high(defaultAddress, Comparator.EQ, 1)
+        .simulate({ from: defaultAddress });
+
+      const notes = boundedVecToArray(result) as bigint[][];
+      expect(notes).toHaveLength(2);
+      expect(notes.map(([h, l]) => [Number(h), Number(l)]).sort()).toEqual(
+        [
+          [1, 10],
+          [1, 20],
+        ].sort(),
+      );
+    });
+
+    it('filters by low sub-field', async () => {
+      // low occupies offset=0, length=1 in the packed Field (LSB)
+      const { result } = await contract.methods
+        .select_packed_notes_by_low(defaultAddress, Comparator.EQ, 10)
+        .simulate({ from: defaultAddress });
+
+      const notes = boundedVecToArray(result) as bigint[][];
+      expect(notes).toHaveLength(2);
+      expect(notes.map(([h, l]) => [Number(h), Number(l)]).sort()).toEqual(
+        [
+          [1, 10],
+          [2, 10],
+        ].sort(),
+      );
+    });
+
+    it('filters with GT comparator on sub-field', async () => {
+      // low > 10 should match (1,20) and (3,30)
+      const { result } = await contract.methods
+        .select_packed_notes_by_low(defaultAddress, Comparator.GT, 10)
+        .simulate({ from: defaultAddress });
+
+      const notes = boundedVecToArray(result) as bigint[][];
+      expect(notes).toHaveLength(2);
+      expect(notes.map(([h, l]) => [Number(h), Number(l)]).sort()).toEqual(
+        [
+          [1, 20],
+          [3, 30],
+        ].sort(),
+      );
+    });
+  });
+
   describe('status filter', () => {
     let contract: TestContract;
     let owner: AztecAddress;