@aztec/txe 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/index.ts

@@ -1,24 +1,12 @@
-import { type NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js/abi';
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import {
-  type ContractInstanceWithAddress,
-  getContractInstanceFromInstantiationParams,
-} from '@aztec/aztec.js/contracts';
 import { Fr } from '@aztec/aztec.js/fields';
-import { PublicKeys, deriveKeys } from '@aztec/aztec.js/keys';
 import type { Logger } from '@aztec/foundation/log';
 import { cloneEphemeralStoreFrom } from '@aztec/kv-store/lmdb-v2';
 import type { ProtocolContractName } from '@aztec/protocol-contracts';
 import { ContractStore } from '@aztec/pxe/client/lazy';
-import { computeArtifactHash } from '@aztec/stdlib/contract';
-import type { ContractArtifactWithHash } from '@aztec/stdlib/contract';
 import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
 import { zodFor } from '@aztec/stdlib/schemas';
 
-import { createHash } from 'crypto';
-import { createReadStream } from 'fs';
-import { readFile, readdir } from 'fs/promises';
-import { join, parse } from 'path';
+import { join } from 'path';
 import { z } from 'zod';
 
 // Side-effect import: registers the msgpackr Fr extension for the bundled `Fr` class. Must
@@ -28,64 +16,19 @@ import { type TXEOracleFunctionName, TXESession } from './txe_session.js';
 import {
   type ForeignCallArgs,
   ForeignCallArgsSchema,
-  type ForeignCallArray,
   type ForeignCallResult,
   ForeignCallResultSchema,
-  type ForeignCallSingle,
-  addressFromSingle,
-  fromArray,
-  fromSingle,
-  toSingle,
 } 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>();
 
-/**
- * Cache + in-flight map pair. Lookup hits the cache, then awaits an in-flight `compute()` if one
- * exists, otherwise starts one and stores it. Guarantees `compute()` runs at most once per `key`
- * across concurrent callers, which matters because `computeArtifactHash` is expensive.
- */
-class AsyncCache<K, V> {
-  private readonly cache = new Map<K, V>();
-  private readonly inFlight = new Map<K, Promise<V>>();
-
-  getOrCompute(key: K, compute: () => Promise<V>): Promise<V> {
-    const cached = this.cache.get(key);
-    if (cached !== undefined) {
-      return Promise.resolve(cached);
-    }
-    let pending = this.inFlight.get(key);
-    if (!pending) {
-      pending = (async () => {
-        try {
-          const value = await compute();
-          this.cache.set(key, value);
-          return value;
-        } finally {
-          this.inFlight.delete(key);
-        }
-      })();
-      this.inFlight.set(key, pending);
-    }
-    return pending;
-  }
-}
-
-// Full deploys (artifact + computed instance), keyed by the full deploy context (contract +
-// constructor args + publicKeys + salt + deployer). Hits on repeated identical deploys.
-const TXEDeploymentsCache = new AsyncCache<
-  string,
-  { artifact: ContractArtifactWithHash; instance: ContractInstanceWithAddress }
->();
-
-// Loaded + hashed contract artifact, keyed by compiled-bytecode hash. Hits across deploys of the
-// same contract when constructor args / salt / deployer differ.
-const TXEArtifactsCache = new AsyncCache<string, ContractArtifactWithHash>();
-
 export type TXEForeignCallInput = {
   session_id: number;
   function: TXEOracleFunctionName;
@@ -94,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
@@ -119,15 +62,16 @@ export interface TXEDispatcherOptions {
    */
   contractStoreSourceDir: string;
   /**
-   * Class id (hex) of the SchnorrAccount artifact pre-registered in the shared LMDB. When set,
-   * `#processAddAccountInputs` looks the artifact up from the cloned store instead of
-   * recomputing it via `getSchnorrAccountContractArtifact()` + `computeArtifactHash()`.
+   * Class id (hex) of the SchnorrAccount artifact pre-registered in the shared LMDB. The
+   * {@link TXEArtifactResolver} looks the artifact up from the cloned store via this class id
+   * instead of recomputing it via `getSchnorrAccountContractArtifact()` + `computeArtifactHash()`.
    */
   schnorrClassId: string;
 }
 
 export class TXEDispatcher {
   private contractStore!: ContractStore;
+  private artifactResolver!: TXEArtifactResolver;
   private readonly contractStoreSourceDir: string;
   private readonly schnorrClassId: Fr;
 
@@ -156,146 +100,25 @@ export class TXEDispatcher {
       2,
     );
     this.contractStore = new ContractStore(kvStore);
+    this.artifactResolver = new TXEArtifactResolver(this.contractStore, this.schnorrClassId);
     this.logger.debug('Cloned shared protocol-contracts store', { totalMs: Date.now() - t0 });
   }
 
-  private fastHashFile(path: string): Promise<string> {
-    return new Promise(resolve => {
-      const fd = createReadStream(path);
-      const hash = createHash('sha1');
-      hash.setEncoding('hex');
-
-      fd.on('end', function () {
-        hash.end();
-        resolve(hash.read() as string);
-      });
-
-      fd.pipe(hash);
-    });
-  }
-
-  async #processDeployInputs({ inputs, root_path: rootPath, package_name: packageName }: TXEForeignCallInput) {
-    const [contractPath, initializer] = inputs.slice(0, 2).map(input =>
-      fromArray(input as ForeignCallArray)
-        .map(char => String.fromCharCode(char.toNumber()))
-        .join(''),
-    );
-
-    const decodedArgs = fromArray(inputs[3] as ForeignCallArray);
-    const secret = fromSingle(inputs[4] as ForeignCallSingle);
-    const salt = fromSingle(inputs[5] as ForeignCallSingle);
-    const deployer = addressFromSingle(inputs[6] as ForeignCallSingle);
-    const publicKeys = secret.equals(Fr.ZERO) ? PublicKeys.default() : (await deriveKeys(secret)).publicKeys;
-    const publicKeysHash = await publicKeys.hash();
-
-    let artifactPath = '';
-    const { dir: contractDirectory, base: contractFilename } = parse(contractPath);
-    if (contractDirectory) {
-      if (contractDirectory.includes('@')) {
-        // We're deploying a contract that belongs in a workspace
-        // env.deploy("../path/to/workspace/root@packageName/contractName")
-        const [workspace, pkg] = contractDirectory.split('@');
-        const targetPath = join(rootPath, workspace, '/target');
-        this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
-        artifactPath = join(targetPath, `${pkg}-${contractFilename}.json`);
-      } else {
-        // We're deploying a standalone external contract
-        // env.deploy("../path/to/contract/root/contractName")
-        const targetPath = join(rootPath, contractDirectory, '/target');
-        this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
-        [artifactPath] = (await readdir(targetPath)).filter(file => file.endsWith(`-${contractFilename}.json`));
-      }
-    } else {
-      // We're deploying a local contract
-      // env.deploy("contractName")
-      artifactPath = join(rootPath, './target', `${packageName}-${contractFilename}.json`);
-    }
-
-    const fileHash = await this.fastHashFile(artifactPath);
-
-    const cacheKey = `${contractDirectory ?? ''}-${contractFilename}-${initializer}-${decodedArgs
-      .map(arg => arg.toString())
-      .join('-')}-${publicKeysHash}-${salt}-${deployer}-${fileHash}`;
-
-    const { artifact, instance } = await TXEDeploymentsCache.getOrCompute(cacheKey, async () => {
-      this.logger.debug(`Loading compiled artifact ${artifactPath}`);
-      // Inner cache: artifact load + hash depends only on the compiled bytecode (`fileHash`), so
-      // subsequent deploys of the same contract — regardless of constructor args / deployer /
-      // salt — reuse the same `ContractArtifactWithHash`.
-      const computedArtifact = await TXEArtifactsCache.getOrCompute(fileHash, async () => {
-        const artifactJSON = JSON.parse(await readFile(artifactPath, 'utf-8')) as NoirCompiledContract;
-        const artifactWithoutHash = loadContractArtifact(artifactJSON);
-        return { ...artifactWithoutHash, artifactHash: await computeArtifactHash(artifactWithoutHash) };
-      });
-      this.logger.debug(
-        `Deploy ${computedArtifact.name} with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`,
-      );
-      const computedInstance = await getContractInstanceFromInstantiationParams(computedArtifact, {
-        constructorArgs: decodedArgs,
-        skipArgsDecoding: true,
-        salt,
-        publicKeys,
-        constructorArtifact: initializer ? initializer : undefined,
-        deployer,
-      });
-      return { artifact: computedArtifact, instance: computedInstance };
-    });
-
-    inputs.splice(0, 1, artifact, instance, toSingle(secret));
-  }
-
-  async #processAddAccountInputs({ inputs }: TXEForeignCallInput) {
-    const secret = fromSingle(inputs[0] as ForeignCallSingle);
-
-    const cacheKey = `SchnorrAccountContract-${secret}`;
-
-    const { artifact, instance } = await TXEDeploymentsCache.getOrCompute(cacheKey, async () => {
-      const [artifactFromStore, classWithPreimage] = await Promise.all([
-        this.contractStore.getContractArtifact(this.schnorrClassId),
-        this.contractStore.getContractClassWithPreimage(this.schnorrClassId),
-      ]);
-      if (!artifactFromStore || !classWithPreimage) {
-        throw new Error(
-          `SchnorrAccount not found in shared contract store at class id ${this.schnorrClassId.toString()}`,
-        );
-      }
-      const computedArtifact = { ...artifactFromStore, artifactHash: classWithPreimage.artifactHash };
-      const keys = await deriveKeys(secret);
-      const args = [keys.publicKeys.ivpkM.x, keys.publicKeys.ivpkM.y];
-      const computedInstance = await getContractInstanceFromInstantiationParams(computedArtifact, {
-        constructorArgs: args,
-        skipArgsDecoding: true,
-        salt: Fr.ONE,
-        publicKeys: keys.publicKeys,
-        constructorArtifact: 'constructor',
-        deployer: AztecAddress.ZERO,
-      });
-      return { artifact: computedArtifact, instance: computedInstance };
-    });
-
-    inputs.splice(0, 0, artifact, instance);
-  }
-
   // eslint-disable-next-line camelcase
   async resolve_foreign_call(callData: TXEForeignCallInput): Promise<ForeignCallResult> {
-    const { session_id: sessionId, function: functionName, inputs } = callData;
+    const {
+      session_id: sessionId,
+      function: functionName,
+      inputs,
+      root_path: rootPath,
+      package_name: packageName,
+    } = callData;
     this.logger.debug(`Calling ${functionName} on session ${sessionId}`);
 
     if (!sessions.has(sessionId)) {
       this.logger.debug(`Creating new session ${sessionId}`);
       await this.warmUp();
-      sessions.set(sessionId, await TXESession.init(this.contractStore));
-    }
-
-    switch (functionName) {
-      case 'aztec_txe_deploy': {
-        await this.#processDeployInputs(callData);
-        break;
-      }
-      case 'aztec_txe_addAccount': {
-        await this.#processAddAccountInputs(callData);
-        break;
-      }
+      sessions.set(sessionId, await TXESession.init(this.contractStore, this.artifactResolver, rootPath, packageName));
     }
 
     return await sessions.get(sessionId)!.processFunction(functionName, inputs);

package/src/oracle/interfaces.ts

@@ -1,9 +1,10 @@
-import type { ContractArtifact } from '@aztec/aztec.js/abi';
 import { CompleteAddress } from '@aztec/aztec.js/addresses';
-import type { ContractInstanceWithAddress } from '@aztec/aztec.js/contracts';
 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';
@@ -38,11 +39,15 @@ export interface IAvmExecutionOracle {
   nullifierExists(siloedNullifier: Fr): Promise<boolean>;
   storageWrite(slot: Fr, value: Fr): Promise<void>;
   storageRead(slot: Fr, contractAddress: AztecAddress): Promise<Fr>;
-  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>;
 }
 
 /**
@@ -56,10 +61,30 @@ export interface ITxeExecutionOracle {
   getNextBlockTimestamp(): Promise<UInt64>;
   advanceBlocksBy(blocks: number): Promise<void>;
   advanceTimestampBy(duration: UInt64): void;
-  deploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, foreignSecret: Fr): Promise<void>;
-  createAccount(secret: Fr): Promise<CompleteAddress>;
-  addAccount(artifact: ContractArtifact, instance: ContractInstanceWithAddress, secret: Fr): Promise<CompleteAddress>;
+  deploy(
+    contractPath: string,
+    initializer: string,
+    args: Fr[],
+    secret: Fr,
+    salt: Fr,
+    deployer: AztecAddress,
+  ): Promise<Fr[]>;
+  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;
@@ -81,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/labs/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;
+}