@aztec/txe 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

package/package.json

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

package/src/bin/check_txe_oracle_version.ts

@@ -1,32 +1,29 @@
 import { keccak256String } from '@aztec/foundation/crypto/keccak';
-import { getOracleInterfaceSignature, readNumericGlobal } from '@aztec/pxe/bin';
+import { getOracleRegistrySignature, readNumericGlobal } from '@aztec/pxe/bin';
+import { ORACLE_REGISTRY, type OracleRegistryEntry } from '@aztec/pxe/simulator';
 
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 
+import { TXE_ORACLE_REGISTRY } from '../oracle/txe_oracle_registry.js';
 import { TXE_ORACLE_INTERFACE_HASH, TXE_ORACLE_VERSION_MAJOR } from '../oracle/txe_oracle_version.js';
 
 /**
  * Verifies that the TXE oracle interfaces match the expected interface hash.
  *
  * The TXE oracle interfaces need to be versioned to ensure compatibility between Aztec.nr tests and TXE. This function
- * computes a hash of the TXE oracle interfaces and compares it against a known hash. If they don't match, it means an
+ * computes a hash of the TXE-specific entries in `TXE_ORACLE_REGISTRY` (the shared PXE entries are covered by the PXE
+ * oracle version check) and compares it against a known hash. If they don't match, it means an
  * interface has changed and the TXE oracle version needs to be bumped:
  *   - If the change is backward-breaking (e.g. removing/renaming an oracle), bump TXE_ORACLE_VERSION_MAJOR.
  *   - If the change is an oracle addition (non-breaking), bump TXE_ORACLE_VERSION_MINOR.
  */
 function assertTxeOracleInterfaceMatches(): void {
-  const currentDir = dirname(fileURLToPath(import.meta.url));
-  const packageRoot = dirname(dirname(currentDir));
-  const interfacesSourcePath = join(packageRoot, 'src/oracle/interfaces.ts');
-
-  const targets = ['IAvmExecutionOracle', 'ITxeExecutionOracle'];
-  // Not an oracle foreign call handler (see TODO(F-335) in interfaces.ts).
-  const excludedMembers = ['syncContractNonOracleMethod'];
-
-  const txeOracleInterfaceSignature = getOracleInterfaceSignature(interfacesSourcePath, targets, excludedMembers);
+  const txeOnlyEntries: Record<string, OracleRegistryEntry> = Object.fromEntries(
+    Object.entries(TXE_ORACLE_REGISTRY).filter(([name]) => !(name in ORACLE_REGISTRY)),
+  );
 
-  const txeOracleInterfaceHash = keccak256String(txeOracleInterfaceSignature);
+  const txeOracleInterfaceHash = keccak256String(getOracleRegistrySignature(txeOnlyEntries));
   if (txeOracleInterfaceHash !== TXE_ORACLE_INTERFACE_HASH) {
     throw new Error(
       `The TXE oracle interface has changed. Update TXE_ORACLE_INTERFACE_HASH to ${txeOracleInterfaceHash} in txe/src/oracle/txe_oracle_version.ts and bump the TXE oracle version (TXE_ORACLE_VERSION_MAJOR for breaking changes, TXE_ORACLE_VERSION_MINOR for oracle additions).`,

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/dispatcher_pool.ts

@@ -4,7 +4,8 @@ import type { Logger } from '@aztec/foundation/log';
 import { openEphemeralStore } from '@aztec/kv-store/lmdb-v2';
 import { LazyProtocolContractsProvider } from '@aztec/protocol-contracts/providers/lazy';
 import { ContractStore } from '@aztec/pxe/client/lazy';
-import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
+import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry/lazy';
+import { getStandardHandshakeRegistry } from '@aztec/standard-contracts/handshake-registry/lazy';
 import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 
 import { existsSync } from 'node:fs';
@@ -21,7 +22,7 @@ void BarretenbergSync.initSingleton({ backend: BackendType.Wasm });
 
 /**
  * Opens a fresh LMDB in a tmp dir and writes the protocol contracts in
- * {@link TXE_REQUIRED_PROTOCOL_CONTRACTS} plus the standard AuthRegistry and the SchnorrAccount artifact,
+ * {@link TXE_REQUIRED_PROTOCOL_CONTRACTS} plus the standard AuthRegistry, HandshakeRegistry, and the SchnorrAccount artifact,
  * returning the directory path and the SchnorrAccount class id (hex). The store handle is intentionally kept
  * alive: closing it would trigger the ephemeral-store cleanup hook and remove the tmp
  * directory, so any worker that has not yet cloned would find it missing.
@@ -33,7 +34,7 @@ export async function buildSharedContractStore(): Promise<{ dataDir: string; sch
   const provider = new LazyProtocolContractsProvider();
   const [protocolContracts, standardContracts, schnorrArtifact] = await Promise.all([
     Promise.all(TXE_REQUIRED_PROTOCOL_CONTRACTS.map(name => provider.getProtocolContractArtifact(name))),
-    Promise.all([getStandardAuthRegistry()]),
+    Promise.all([getStandardAuthRegistry(), getStandardHandshakeRegistry()]),
     getSchnorrAccountContractArtifact(),
   ]);
   const schnorrClass = await getContractClassFromArtifact(schnorrArtifact);

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>();
 
@@ -35,7 +37,7 @@ export type TXEForeignCallInput = {
   inputs: ForeignCallArgs;
 };
 
-export const TXEForeignCallInputSchema = zodFor<TXEForeignCallInput>()(
+export const TXEForeignCallInputSchema: z.ZodType<TXEForeignCallInput> = zodFor<TXEForeignCallInput>()(
   z.object({
     // Nargo generates session_id as a u64, which may exceed Number.MAX_SAFE_INTEGER.
     // Zod 4's `.int()` enforces the safe-integer bound, so we drop it here and only require

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>;
 }
 
 /**
@@ -66,9 +69,22 @@ export interface ITxeExecutionOracle {
     salt: Fr,
     deployer: AztecAddress,
   ): Promise<Fr[]>;
-  createAccount(secret: Fr): Promise<CompleteAddress>;
+  createAccount(secret: Fr, partialAddress: 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;
+  /**
+   * Configures whether the test's simulated wallet authorizes every cross-contract utility call target.
+   */
+  setAuthorizeAllUtilityCallTargets(authorizeAll: boolean): void;
   getLastBlockTimestamp(): Promise<bigint>;
   getLastTxEffects(): Promise<{
     txHash: TxHash;
@@ -90,6 +106,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,271 @@
+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,
+  BoundedVec,
+  type CompositeMapping,
+  DELIVERY_MODE,
+  ETH_ADDRESS,
+  FIELD,
+  FUNCTION_SELECTOR,
+  LEAF_INDEX,
+  NOTE_SELECTOR,
+  Option,
+  type OracleRegistryEntry,
+  SLOT_NUMBER,
+  type StructMapping,
+  type TypeMapping,
+  U8,
+  U32,
+  U64,
+  U128,
+  isArrayMapping,
+  isBoundedVecMapping,
+  isFixedArrayMapping,
+  isFixedBoundedVecMapping,
+  isOptionMapping,
+  isStructMapping,
+  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 scalar test-value implementations, mirroring the Noir synthesizer's `scalars` table in
+ * `noir-projects/aztec-nr/.../macros/oracle_testing.nr` exactly.
+ */
+const SCALAR_IMPLS: ScalarImpl[] = [
+  scalar(FIELD, seed => new Fr(seed)),
+  scalar(U32, seed => seed),
+  scalar(BLOCK_NUMBER, seed => BlockNumber(seed)),
+  scalar(BIGINT, seed => BigInt(seed)),
+  scalar(U64, seed => BigInt(seed)),
+  scalar(U128, seed => BigInt(seed)),
+  scalar(LEAF_INDEX, seed => seed),
+  scalar(U8, 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,
+  ),
+];
+
+/**
+ * The composite test-value implementations, one per combinator, mirroring the Noir synthesizer's `synthesizers` table.
+ */
+const COMPOSITE_IMPLS: CompositeImpl[] = [
+  composite(isOptionMapping, (type, seed) => [
+    named(Option.some(testValueFor(type.inner, seed)), 'some'),
+    named(Option.none(testValueFor(type.inner, seed)), 'none'),
+  ]),
+  composite(isArrayMapping, (type, seed) => [unnamed(collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH))]),
+  composite(isBoundedVecMapping, (type, seed) => [
+    unnamed(
+      BoundedVec.from({
+        data: collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH),
+        maxLength: BOUNDED_VEC_MAX_LENGTH,
+      }),
+    ),
+  ]),
+  composite(isStructMapping, (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(isFixedArrayMapping, (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(isFixedBoundedVecMapping, (type, seed) => [
+    unnamed(collectionData(type.inner, seed, Math.min(DEFAULT_ARRAY_LENGTH, type.maxLength))),
+  ]),
+];
+
+/** The scalar mappings with a registered test-value impl. */
+export const SCALAR_MAPPINGS: TypeMapping<any>[] = SCALAR_IMPLS.map(impl => impl.mapping);
+
+/**
+ * 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 };
+}
+
+/** An impl for the single scalar `mapping` it synthesizes for. */
+type ScalarImpl = {
+  mapping: TypeMapping<any>;
+  scenarios: (type: TypeMapping<any>, seed: number) => Scenario[];
+};
+
+/** An impl for a whole family of composite mappings, selected by its `kind` type guard. */
+type CompositeImpl = {
+  match: (type: TypeMapping<any>) => boolean;
+  scenarios: (type: TypeMapping<any>, seed: number) => Scenario[];
+};
+
+/** A scalar impl yielding a single unnamed scenario. */
+function scalar(mapping: TypeMapping<any>, value: (seed: number) => unknown): ScalarImpl {
+  return { mapping, scenarios: (_type, seed) => [unnamed(value(seed))] };
+}
+
+/** A composite impl, recursing through the matched mapping's element/inner mapping. */
+function composite<K extends CompositeMapping>(
+  guard: (type: TypeMapping<any>) => type is K,
+  scenarios: (type: K, seed: number) => Scenario[],
+): CompositeImpl {
+  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) => testValueFor(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] = testValueFor(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 = SCALAR_IMPLS.find(i => i.mapping === type) ?? COMPOSITE_IMPLS.find(i => i.match(type));
+  if (!impl) {
+    throw new UnsynthesizableTypeError(type);
+  }
+  return impl.scenarios(type, seed);
+}
+
+/**
+ * The test value of `type` at `seed`, matching what the Noir synthesizer produces for the same type and seed. Throws
+ * for types without a test-value impl.
+ */
+export function testValueFor(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;
+}

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,
   });