@aztec/txe 5.0.0-rc.1 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/txe",
-  "version": "5.0.0-rc.1",
+  "version": "5.0.0",
   "type": "module",
   "exports": {
     "./server": {
@@ -69,22 +69,22 @@
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "5.0.0-rc.1",
-    "@aztec/archiver": "5.0.0-rc.1",
-    "@aztec/aztec-node": "5.0.0-rc.1",
-    "@aztec/aztec.js": "5.0.0-rc.1",
-    "@aztec/bb-prover": "5.0.0-rc.1",
-    "@aztec/bb.js": "5.0.0-rc.1",
-    "@aztec/constants": "5.0.0-rc.1",
-    "@aztec/foundation": "5.0.0-rc.1",
-    "@aztec/key-store": "5.0.0-rc.1",
-    "@aztec/kv-store": "5.0.0-rc.1",
-    "@aztec/protocol-contracts": "5.0.0-rc.1",
-    "@aztec/pxe": "5.0.0-rc.1",
-    "@aztec/simulator": "5.0.0-rc.1",
-    "@aztec/standard-contracts": "5.0.0-rc.1",
-    "@aztec/stdlib": "5.0.0-rc.1",
-    "@aztec/world-state": "5.0.0-rc.1",
+    "@aztec/accounts": "5.0.0",
+    "@aztec/archiver": "5.0.0",
+    "@aztec/aztec-node": "5.0.0",
+    "@aztec/aztec.js": "5.0.0",
+    "@aztec/bb-prover": "5.0.0",
+    "@aztec/bb.js": "5.0.0",
+    "@aztec/constants": "5.0.0",
+    "@aztec/foundation": "5.0.0",
+    "@aztec/key-store": "5.0.0",
+    "@aztec/kv-store": "5.0.0",
+    "@aztec/protocol-contracts": "5.0.0",
+    "@aztec/pxe": "5.0.0",
+    "@aztec/simulator": "5.0.0",
+    "@aztec/standard-contracts": "5.0.0",
+    "@aztec/stdlib": "5.0.0",
+    "@aztec/world-state": "5.0.0",
     "msgpackr": "^1.11.2",
     "zod": "^4"
   },

package/src/bin/oracle_test_server.ts

@@ -5,8 +5,8 @@ import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
 import { createOracleTestRpcServer } from '../oracle/test-resolver/index.js';
 
 /**
- * Starts an HTTP RPC server that resolves oracle foreign calls using hardcoded fixture scenarios.
- * Used by `nargo test --oracle-resolver` to run `#[oracle_test]` roundtrip tests with a dedicated oracle resolver.
+ * Starts an HTTP RPC server that resolves oracle foreign calls using auto-synthesized fixture scenarios. Used by
+ * `nargo test --oracle-resolver` to run `#[generate_oracle_tests]` serialization tests against a dedicated resolver.
  * Logs fixture coverage on shutdown.
  */
 async function main() {

package/src/constants.ts

@@ -1,7 +1,7 @@
 import { PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-export const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
+export const DEFAULT_ADDRESS = AztecAddress.fromNumberUnsafe(42);
 
 // This is MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN
 export const MAX_PRIVATE_EVENT_LEN = 10;

package/src/index.ts

@@ -21,9 +21,11 @@ import {
 } from './utils/encoding.js';
 import { TXEArtifactResolver } from './utils/txe_artifact_resolver.js';
 
-// Protocol contracts TXE registers in its contract store. Only AuthRegistry is needed for the
-// current test suites; add a contract here if a lookup against a `0x000…00X` address fails.
-export const TXE_REQUIRED_PROTOCOL_CONTRACTS: ProtocolContractName[] = [];
+export const TXE_REQUIRED_PROTOCOL_CONTRACTS: ProtocolContractName[] = [
+  'ContractClassRegistry',
+  'ContractInstanceRegistry',
+  'FeeJuice',
+];
 
 const sessions = new Map<number, TXESession>();
 

package/src/oracle/interfaces.ts

@@ -2,6 +2,9 @@ import { CompleteAddress } from '@aztec/aztec.js/addresses';
 import { TxHash } from '@aztec/aztec.js/tx';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { TaggingSecretStrategy } from '@aztec/pxe/server';
+import type { Option } from '@aztec/pxe/simulator';
 import type { EventSelector, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
@@ -36,15 +39,15 @@ export interface IAvmExecutionOracle {
   nullifierExists(siloedNullifier: Fr): Promise<boolean>;
   storageWrite(slot: Fr, value: Fr): Promise<void>;
   storageRead(slot: Fr, contractAddress: AztecAddress): Promise<Fr>;
-  getContractInstanceDeployer(address: AztecAddress): Promise<{ member: Fr; exists: boolean }>;
-  getContractInstanceClassId(address: AztecAddress): Promise<{ member: Fr; exists: boolean }>;
-  getContractInstanceInitializationHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }>;
-  getContractInstanceImmutablesHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }>;
-  returndataSize(): Promise<Fr>;
+  getContractInstanceDeployer(address: AztecAddress): Promise<{ member: Fr; exists: boolean }[]>;
+  getContractInstanceClassId(address: AztecAddress): Promise<{ member: Fr; exists: boolean }[]>;
+  getContractInstanceInitializationHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }[]>;
+  getContractInstanceImmutablesHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }[]>;
+  returndataSize(): Promise<number>;
   returndataCopy(rdOffset: number, copySize: number): Promise<Fr[]>;
-  call(l2Gas: number, daGas: number, address: AztecAddress, argsLength: number, args: Fr[]): Promise<Fr[]>;
-  staticCall(l2Gas: number, daGas: number, address: AztecAddress, argsLength: number, args: Fr[]): Promise<Fr[]>;
-  successCopy(): Promise<Fr>;
+  call(l2Gas: number, daGas: number, address: AztecAddress, argsLength: number, args: Fr[]): Promise<void>;
+  staticCall(l2Gas: number, daGas: number, address: AztecAddress, argsLength: number, args: Fr[]): Promise<void>;
+  successCopy(): Promise<boolean>;
 }
 
 /**
@@ -69,6 +72,15 @@ export interface ITxeExecutionOracle {
   createAccount(secret: Fr): Promise<CompleteAddress>;
   addAccount(secret: Fr): Promise<CompleteAddress>;
   addAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
+  sendL1ToL2Message(content: Fr, secretHash: Fr, sender: EthAddress, recipient: AztecAddress): Promise<Fr>;
+  /**
+   * Configures the tagging secret strategy the test's simulated wallet resolves for each delivery mode. A `none`
+   * clears that mode, so it falls back to the default strategy (or, when both modes end up unset, to no hook at all).
+   */
+  setTaggingSecretStrategies(
+    unconstrainedStrategy: Option<TaggingSecretStrategy>,
+    constrainedStrategy: Option<TaggingSecretStrategy>,
+  ): void;
   getLastBlockTimestamp(): Promise<bigint>;
   getLastTxEffects(): Promise<{
     txHash: TxHash;
@@ -90,6 +102,7 @@ export interface ITxeExecutionOracle {
     gasSettings: GasSettings,
   ): Promise<{ returnValues: Fr[]; offchainEffects: Fr[][] }>;
   executeUtilityFunction(
+    from: AztecAddress | undefined,
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     args: Fr[],

package/src/oracle/tagging_secret_strategy.ts

@@ -0,0 +1,25 @@
+import {
+  DEFAULT_TAGGING_SECRET_STRATEGY,
+  type ResolveTaggingSecretStrategy,
+  type TaggingSecretStrategy,
+} from '@aztec/pxe/server';
+import type { AppTaggingSecretKind } from '@aztec/stdlib/logs';
+
+/** The tagging secret strategies a TXE test has configured, keyed by delivery mode. Absence means "not configured". */
+export type TXETaggingSecretStrategies = Map<AppTaggingSecretKind, TaggingSecretStrategy>;
+
+/**
+ * Builds the `resolveTaggingSecretStrategy` hook backing the `aztec_txe_setTaggingSecretStrategies` oracle. Returns
+ * `undefined` when no strategy is configured, so PXE's own no-hook default path is exercised. When at least one mode
+ * is configured, modes without an entry resolve to {@link DEFAULT_TAGGING_SECRET_STRATEGY}, matching what PXE would
+ * apply without a hook.
+ */
+export function makeResolveTaggingSecretStrategyHook(
+  strategies: TXETaggingSecretStrategies,
+): ResolveTaggingSecretStrategy | undefined {
+  if (strategies.size === 0) {
+    return undefined;
+  }
+
+  return ({ deliveryMode }) => Promise.resolve(strategies.get(deliveryMode) ?? DEFAULT_TAGGING_SECRET_STRATEGY);
+}

package/src/oracle/test-resolver/default_fixtures.ts

@@ -0,0 +1,282 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import {
+  AZTEC_ADDRESS,
+  BIGINT,
+  BLOCK_HASH,
+  BLOCK_NUMBER,
+  BOOL,
+  BYTE,
+  BoundedVec,
+  DELIVERY_MODE,
+  ETH_ADDRESS,
+  FIELD,
+  FUNCTION_SELECTOR,
+  NOTE_SELECTOR,
+  Option,
+  type OracleRegistryEntry,
+  SLOT_NUMBER,
+  type StructField,
+  type TypeMapping,
+  U32,
+  tryFieldWidth,
+} from '@aztec/pxe/simulator';
+import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import { BlockHash } from '@aztec/stdlib/block';
+import { AppTaggingSecretKind } from '@aztec/stdlib/logs';
+
+import type { OracleTestScenario } from './resolver.js';
+
+/**
+ * Synthesizes fixture scenarios for every oracle in the registry whose parameters and return are built from scalars,
+ * arrays/bounded vecs of them, `Option`s of them, or `STRUCT`s over them. The matching Noir serialization tests are
+ * auto-generated by `#[generate_oracle_tests]` from the same seed/scenario convention.
+ */
+export function synthesizeDefaultFixtures(
+  registry: Record<string, OracleRegistryEntry>,
+): Record<string, OracleTestScenario[]> {
+  const synthesized: Record<string, OracleTestScenario[]> = {};
+
+  for (const [name, entry] of Object.entries(registry)) {
+    const scenarios = synthesizeScenarios(entry);
+    if (scenarios !== undefined) {
+      synthesized[name] = scenarios;
+    }
+  }
+
+  return synthesized;
+}
+
+/**
+ * The test-value implementations, one per oracle type, mirroring the Noir synthesizer tables (`scalars` and
+ * `synthesizers` in `noir-projects/aztec-nr/.../macros/oracle_testing.nr`) exactly.
+ */
+const TEST_VALUE_IMPLS: TestValueImpl[] = [
+  scalar(FIELD, seed => new Fr(seed)),
+  scalar(U32, seed => seed),
+  scalar(BLOCK_NUMBER, seed => BlockNumber(seed)),
+  scalar(BIGINT, seed => BigInt(seed)),
+  scalar(BYTE, seed => seed),
+  scalar(BOOL, seed => seed % 2 !== 0),
+  scalar(AZTEC_ADDRESS, seed => AztecAddress.fromNumberUnsafe(seed)),
+  scalar(ETH_ADDRESS, seed => EthAddress.fromField(new Fr(seed))),
+  scalar(FUNCTION_SELECTOR, seed => FunctionSelector.fromField(new Fr(seed))),
+  scalar(NOTE_SELECTOR, seed => NoteSelector.fromField(new Fr(seed))),
+  scalar(BLOCK_HASH, seed => new BlockHash(new Fr(seed))),
+  scalar(SLOT_NUMBER, seed => SlotNumber(seed)),
+  // Only two delivery modes are valid for tagging, so the seed alternates between them, matching the Noir impl.
+  scalar(DELIVERY_MODE, seed =>
+    seed % 2 === 0 ? AppTaggingSecretKind.UNCONSTRAINED : AppTaggingSecretKind.CONSTRAINED,
+  ),
+  composite(isOption, (type, seed) => [
+    named(Option.some(firstValue(type.inner, seed)), 'some'),
+    named(Option.none(firstValue(type.inner, seed)), 'none'),
+  ]),
+  composite(isArray, (type, seed) => [unnamed(collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH))]),
+  composite(isBoundedVec, (type, seed) => [
+    unnamed(
+      BoundedVec.from({
+        data: collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH),
+        maxLength: BOUNDED_VEC_MAX_LENGTH,
+      }),
+    ),
+  ]),
+  composite(isStruct, (type, seed) => [unnamed(structValue(type, seed))]),
+  // A fixed-length array uses its real (signature) length, unlike the generic-length ARRAY which is pinned to
+  // DEFAULT_ARRAY_LENGTH.
+  composite(isFixedArray, (type, seed) => [unnamed(collectionData(type.inner, seed, type.length))]),
+  // Same for a fixed-capacity bounded vec: real capacity, DEFAULT_ARRAY_LENGTH elements (its value type is a plain
+  // element array, unlike the two-slot BOUNDED_VEC), clamped to the capacity so small vecs stay valid.
+  composite(isFixedBoundedVec, (type, seed) => [
+    unnamed(collectionData(type.inner, seed, Math.min(DEFAULT_ARRAY_LENGTH, type.maxLength))),
+  ]),
+];
+
+/**
+ * The base every seed is offset by, applied once where a parameter's position becomes its seed, so generated values
+ * stay clear of 0. Must match `SEED_BASE` in the Noir `oracle_testing.nr`.
+ */
+const SEED_BASE = 10;
+
+/** Elements per synthesized array and bounded vec. Must match `TEST_COLLECTION_LEN` in the Noir `oracle_testing.nr`. */
+const DEFAULT_ARRAY_LENGTH = 3;
+
+/**
+ * Capacity of synthesized bounded vecs, deliberately larger than the data length so padding is exercised. Must match
+ * `TEST_BOUNDED_VEC_CAP` in the Noir `oracle_testing.nr`.
+ */
+const BOUNDED_VEC_MAX_LENGTH = 5;
+
+/**
+ * One canonical test case for a type: the `value` to put on the wire (or expect back), and the `name` of the
+ * serialization shape it exercises (unset for single-scenario types). Mirrors the Noir `Scenario<T>`.
+ */
+interface Scenario {
+  value: unknown;
+  name?: string;
+}
+
+function unnamed(value: unknown): Scenario {
+  return { value };
+}
+function named(value: unknown, name: string): Scenario {
+  return { value, name };
+}
+
+/**
+ * One type's test-value implementation, mirroring a Noir `TestValueSynthesizer` entry: `match` selects the type and
+ * `scenarios` yields its [`Scenario`]s for `seed`, one per serialization shape, like the Noir entry's `scenarios`
+ * function.
+ */
+interface TestValueImpl {
+  match: (type: TypeMapping<any>) => boolean;
+  scenarios: (type: TypeMapping<any>, seed: number) => Scenario[];
+}
+
+/** A scalar impl: matches the singleton `type` by identity and yields a single unnamed scenario. */
+function scalar(type: TypeMapping<any>, value: (seed: number) => unknown): TestValueImpl {
+  return { match: t => t === type, scenarios: (_type, seed) => [unnamed(value(seed))] };
+}
+
+/** A composite impl: selected by the `kind` type guard, recursing through its element/inner mapping. */
+function composite<K extends CompositeMapping>(
+  guard: (type: TypeMapping<any>) => type is K,
+  scenarios: (type: K, seed: number) => Scenario[],
+): TestValueImpl {
+  return { match: guard, scenarios: (type, seed) => scenarios(type as K, seed) };
+}
+
+/** Synthesized element values for a collection. */
+function collectionData(element: TypeMapping<any>, seed: number, length: number): unknown[] {
+  return Array.from({ length }, (_, i) => firstValue(element, seed + i));
+}
+
+/**
+ * The synthesized prop bag for a struct: each field's first scenario, seeded at the field's flat wire offset so the
+ * values depend on the wire layout rather than on how each side groups its fields. Mirrors the Noir reflected impls.
+ */
+function structValue(type: StructMapping, seed: number): Record<string, unknown> {
+  const value: Record<string, unknown> = {};
+  let offset = 0;
+  for (const field of type.fields) {
+    value[field.name] = firstValue(field.type, seed + offset);
+    const width = tryFieldWidth(field.type.shape);
+    if (width === undefined) {
+      // A variable-width field has no flat offset to seed the next field at, so only this oracle is unsynthesizable.
+      throw new UnsynthesizableTypeError(field.type, `struct field '${field.name}' has a variable-width shape`);
+    }
+    offset += width;
+  }
+  return value;
+}
+
+/**
+ * The [`Scenario`]s for `type` at `seed`, one per serialization *shape*, mirroring the Noir `scenarios_for`
+ * dispatcher. Throws if the type has no matching impl.
+ */
+function scenariosForType(type: TypeMapping<any>, seed: number): Scenario[] {
+  const impl = TEST_VALUE_IMPLS.find(i => i.match(type));
+  if (!impl) {
+    throw new UnsynthesizableTypeError(type);
+  }
+  return impl.scenarios(type, seed);
+}
+
+/** The first (representative) test value of `type`, used for collection elements and `Option` inners. */
+function firstValue(type: TypeMapping<any>, seed: number): unknown {
+  return scenariosForType(type, seed)[0].value;
+}
+
+class UnsynthesizableTypeError extends Error {
+  constructor(type: TypeMapping<any>, detail?: string) {
+    super(detail ?? `No test-value impl for type: ${JSON.stringify(Object.keys(type))}`);
+    this.name = 'UnsynthesizableTypeError';
+  }
+}
+
+/**
+ * Synthesizes the scenarios for one oracle by zipping every position's [`Scenario`] list to one case per test (a
+ * shorter list wraps around via mod), mirroring the Noir macro. Returns `undefined` if any param or return type is
+ * unsynthesizable (ephemeral arrays, structs with a variable-width field).
+ */
+function synthesizeScenarios(entry: OracleRegistryEntry): OracleTestScenario[] | undefined {
+  try {
+    return synthesizeScenariosOrThrow(entry);
+  } catch (e) {
+    if (e instanceof UnsynthesizableTypeError) {
+      return undefined;
+    }
+    throw e;
+  }
+}
+
+function synthesizeScenariosOrThrow(entry: OracleRegistryEntry): OracleTestScenario[] {
+  const params = entry.params.map((param, index) => ({
+    name: param.name,
+    scenarios: scenariosForType(param.type, SEED_BASE + index),
+  }));
+  // The return's seed is the slot right after the last parameter, so its value is distinct from every parameter.
+  const returnScenarios =
+    entry.returnType === undefined ? undefined : scenariosForType(entry.returnType, SEED_BASE + entry.params.length);
+
+  // Positions with more than one scenario drive the test count; their names are zipped together (joined with `+`) per
+  // test, matching the announcements the Noir tests emit and the resolver joins.
+  const positions = [...params.map(p => p.scenarios), ...(returnScenarios !== undefined ? [returnScenarios] : [])];
+  const namedPositions = positions.filter(s => s.length > 1);
+  const testCount = Math.max(1, ...positions.map(s => s.length));
+
+  const scenarios: OracleTestScenario[] = [];
+  for (let index = 0; index < testCount; index++) {
+    const inputs: Record<string, unknown> = {};
+    for (const { name, scenarios: cases } of params) {
+      inputs[name] = cases[index % cases.length].value;
+    }
+    const output = returnScenarios === undefined ? undefined : returnScenarios[index % returnScenarios.length].value;
+    const scenario =
+      namedPositions.length === 0
+        ? undefined
+        : namedPositions.map(cases => cases[index % cases.length].name!).join('+');
+    scenarios.push({ scenario, inputs, output });
+  }
+  return scenarios;
+}
+
+/**
+ * The composite `TypeMapping`s (`ARRAY`/`BOUNDED_VEC`/`OPTION`/`STRUCT`/`FIXED_ARRAY`/`FIXED_BOUNDED_VEC`),
+ * discriminated by `kind`. The combinators attach `kind` plus the inner mapping(s) at construction; the registry
+ * erases params to the base `TypeMapping`, so the guards below recover the structure for recursion.
+ */
+type ArrayMapping = TypeMapping & { kind: 'array'; inner: TypeMapping };
+type BoundedVecMapping = TypeMapping & { kind: 'bounded-vec'; inner: TypeMapping };
+type OptionMapping = TypeMapping & { kind: 'option'; inner: TypeMapping };
+type StructMapping = TypeMapping & { kind: 'struct'; fields: readonly StructField[] };
+type FixedArrayMapping = TypeMapping & { kind: 'fixed-array'; inner: TypeMapping; length: number };
+type FixedBoundedVecMapping = TypeMapping & { kind: 'fixed-bounded-vec'; inner: TypeMapping; maxLength: number };
+type CompositeMapping =
+  | ArrayMapping
+  | BoundedVecMapping
+  | OptionMapping
+  | StructMapping
+  | FixedArrayMapping
+  | FixedBoundedVecMapping;
+
+function isArray(type: TypeMapping<any>): type is ArrayMapping {
+  return 'kind' in type && type.kind === 'array';
+}
+function isBoundedVec(type: TypeMapping<any>): type is BoundedVecMapping {
+  return 'kind' in type && type.kind === 'bounded-vec';
+}
+function isOption(type: TypeMapping<any>): type is OptionMapping {
+  return 'kind' in type && type.kind === 'option';
+}
+function isStruct(type: TypeMapping<any>): type is StructMapping {
+  return 'kind' in type && type.kind === 'struct';
+}
+function isFixedArray(type: TypeMapping<any>): type is FixedArrayMapping {
+  return 'kind' in type && type.kind === 'fixed-array';
+}
+function isFixedBoundedVec(type: TypeMapping<any>): type is FixedBoundedVecMapping {
+  return 'kind' in type && type.kind === 'fixed-bounded-vec';
+}

package/src/oracle/test-resolver/index.ts

@@ -8,7 +8,6 @@ import { z } from 'zod';
 
 import { ForeignCallArgsSchema, type ForeignCallResult, ForeignCallResultSchema } from '../../utils/encoding.js';
 import { TXE_ORACLE_REGISTRY } from '../txe_oracle_registry.js';
-import { ORACLE_TEST_FIXTURES } from './fixtures.js';
 import { type OracleTestCallInput, OracleTestResolver } from './resolver.js';
 
 const OracleTestCallInputSchema = zodFor<OracleTestCallInput>()(
@@ -35,7 +34,7 @@ const OracleTestRpcHandlerSchema: ApiSchemaFor<OracleTestRpcHandler> = {
 
 /** Creates an RPC server backed by the oracle test resolver. */
 export function createOracleTestRpcServer(logger: Logger) {
-  const resolver = new OracleTestResolver(TXE_ORACLE_REGISTRY, ORACLE_TEST_FIXTURES, logger);
+  const resolver = OracleTestResolver.fromRegistry(TXE_ORACLE_REGISTRY, logger);
   const server = createSafeJsonRpcServer<OracleTestRpcHandler>(resolver, OracleTestRpcHandlerSchema, {
     http200OnError: true,
   });