@aztec/txe 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

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

@@ -0,0 +1,44 @@
+/* eslint-disable camelcase */
+import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import type { Logger } from '@aztec/foundation/log';
+import type { ApiSchemaFor } from '@aztec/foundation/schemas';
+import { zodFor } from '@aztec/stdlib/schemas';
+
+import { z } from 'zod';
+
+import { ForeignCallArgsSchema, type ForeignCallResult, ForeignCallResultSchema } from '../../utils/encoding.js';
+import { TXE_ORACLE_REGISTRY } from '../txe_oracle_registry.js';
+import { type OracleTestCallInput, OracleTestResolver } from './resolver.js';
+
+const OracleTestCallInputSchema = zodFor<OracleTestCallInput>()(
+  z.object({
+    session_id: z.number().nonnegative(),
+    function: z.string(),
+    root_path: z.string(),
+    package_name: z.string(),
+    inputs: ForeignCallArgsSchema,
+  }),
+);
+
+/** Narrowed interface exposing only the RPC method. */
+interface OracleTestRpcHandler {
+  resolve_foreign_call(callData: OracleTestCallInput): Promise<ForeignCallResult>;
+}
+
+const OracleTestRpcHandlerSchema: ApiSchemaFor<OracleTestRpcHandler> = {
+  resolve_foreign_call: z.function({
+    input: z.tuple([OracleTestCallInputSchema]),
+    output: ForeignCallResultSchema,
+  }),
+};
+
+/** Creates an RPC server backed by the oracle test resolver. */
+export function createOracleTestRpcServer(logger: Logger) {
+  const resolver = OracleTestResolver.fromRegistry(TXE_ORACLE_REGISTRY, logger);
+  const server = createSafeJsonRpcServer<OracleTestRpcHandler>(resolver, OracleTestRpcHandlerSchema, {
+    http200OnError: true,
+  });
+  return { server, resolver };
+}
+
+export { OracleTestResolver } from './resolver.js';

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

@@ -0,0 +1,245 @@
+/* eslint-disable camelcase */
+import type { Logger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
+import { withoutHexPrefix } from '@aztec/foundation/string';
+import { BOUNDED_VEC, BoundedVec, Option, type OracleRegistryEntry, U8, makeEntry } from '@aztec/pxe/simulator';
+
+import type { ForeignCallArgs, ForeignCallResult } from '../../utils/encoding.js';
+import { toInputSlots } from '../txe_oracle_registry.js';
+import { synthesizeDefaultFixtures } from './default_fixtures.js';
+
+/** Name of the meta-oracle that Noir tests call to announce the next call's scenario by name. */
+const SET_SCENARIO_ORACLE = 'aztec_oracle_test_set_scenario';
+export const SET_SCENARIO_ENTRY = makeEntry({ params: [{ name: 'name', type: BOUNDED_VEC(U8) }] });
+
+export type OracleTestCallInput = {
+  session_id: number;
+  function: string;
+  root_path: string;
+  package_name: string;
+  inputs: ForeignCallArgs;
+};
+
+/**
+ * One test case for an oracle: the expected deserialized `inputs`, the `output` to serialize back to Noir, and the
+ * `scenario` name (`some`/`none`) the matching Noir test announces. Single-scenario oracles leave `scenario` undefined
+ * and are selected automatically.
+ */
+export interface OracleTestScenario {
+  scenario?: string;
+  inputs: Record<string, unknown>;
+  output: unknown;
+}
+
+/**
+ * Oracle resolver for serialization tests. Selects a fixture scenario, verifies that the received inputs match, and
+ * returns the corresponding fixture output.
+ *
+ * For oracles with a single scenario, it is selected automatically. For oracles with multiple scenarios, the Noir test
+ * announces the scenario by name via the `aztec_oracle_test_set_scenario` meta-oracle before calling the real oracle.
+ */
+export class OracleTestResolver {
+  private readonly calledOracles = new Set<string>();
+  private readonly pendingScenario = new Map<number, string>();
+  private readonly logger: Logger;
+
+  constructor(
+    private readonly registry: Record<string, OracleRegistryEntry>,
+    private readonly fixtures: Record<string, OracleTestScenario[]>,
+    logger?: Logger,
+  ) {
+    this.logger = logger ?? createLogger('txe:test-resolver');
+  }
+
+  /**
+   * Builds a resolver whose fixtures are the default scenarios synthesized from the registry's type mappings. The
+   * matching Noir serialization tests are auto-generated by `#[generate_oracle_tests]` from the same convention.
+   */
+  static fromRegistry(registry: Record<string, OracleRegistryEntry>, logger?: Logger): OracleTestResolver {
+    return new OracleTestResolver(registry, synthesizeDefaultFixtures(registry), logger);
+  }
+
+  // eslint-disable-next-line require-await
+  async resolve_foreign_call(callData: OracleTestCallInput): Promise<ForeignCallResult> {
+    const oracleName = callData.function;
+    this.logger.debug('Resolving oracle', { oracleName });
+
+    if (oracleName === SET_SCENARIO_ORACLE) {
+      return this.#handleSetScenario(callData);
+    }
+
+    if (!(oracleName in this.registry)) {
+      throw new Error(`Oracle '${oracleName}' not found in registry`);
+    }
+    const entry = this.registry[oracleName];
+
+    const scenarios = this.fixtures[oracleName];
+    if (!scenarios || scenarios.length === 0) {
+      throw new Error(`No fixture defined for oracle '${oracleName}'`);
+    }
+
+    const match = this.#selectScenario(callData.session_id, oracleName, scenarios);
+    this.#verifyInputs(callData.inputs, entry, match, oracleName);
+    this.calledOracles.add(oracleName);
+
+    this.logger.debug('Verified scenario for oracle', { oracleName });
+
+    const outputSlots = entry.serializeReturn(match.output);
+    return {
+      values: outputSlots.map(slot => (Array.isArray(slot) ? slot.map(withoutHexPrefix) : withoutHexPrefix(slot))),
+    };
+  }
+
+  /** Returns oracles that have a fixture defined but were never called during testing. */
+  getUncalledFixtures(): string[] {
+    return Object.keys(this.fixtures).filter(name => !this.calledOracles.has(name));
+  }
+
+  /** Returns oracles in the registry that have no fixture defined at all. */
+  getMissingFixtures(): string[] {
+    return Object.keys(this.registry).filter(name => !(name in this.fixtures));
+  }
+
+  /**
+   * Records the scenario name for the session's next oracle call. A test announces once per multi-scenario position
+   * (param or return), so successive announcements accumulate joined with `+`, matching the names the fixture
+   * synthesizer builds (e.g. `some+some`).
+   */
+  #handleSetScenario(callData: { session_id: number; inputs: ForeignCallArgs }): ForeignCallResult {
+    const name = decodeScenarioName(callData.inputs);
+    const existing = this.pendingScenario.get(callData.session_id);
+    const scenario = existing !== undefined ? `${existing}+${name}` : name;
+
+    this.logger.debug('Setting scenario for next oracle call', { sessionId: callData.session_id, scenario });
+    this.pendingScenario.set(callData.session_id, scenario);
+
+    return { values: [] };
+  }
+
+  /** Selects the fixture by the announced scenario name (for multi-scenario oracles) or returns the single fixture. */
+  #selectScenario(sessionId: number, oracleName: string, fixtures: OracleTestScenario[]): OracleTestScenario {
+    const announced = this.pendingScenario.get(sessionId);
+
+    if (announced !== undefined) {
+      this.pendingScenario.delete(sessionId);
+      const match = fixtures.find(s => s.scenario === announced);
+      if (!match) {
+        const available = fixtures.map(s => s.scenario ?? '<default>').join(', ');
+        throw new Error(`No scenario '${announced}' for oracle '${oracleName}'. Available: ${available}`);
+      }
+      return match;
+    }
+
+    if (fixtures.length === 1) {
+      return fixtures[0];
+    }
+
+    throw new Error(`Oracle '${oracleName}' has ${fixtures.length} scenarios but none was announced before the call.`);
+  }
+
+  /** Deserializes actual inputs and verifies they match the scenario's expected inputs. */
+  #verifyInputs(
+    rawInputs: ForeignCallArgs,
+    entry: OracleRegistryEntry,
+    fixture: OracleTestScenario,
+    oracleName: string,
+  ): void {
+    const expectedInputs = fixture.inputs;
+    if (Object.keys(expectedInputs).length === 0) {
+      return;
+    }
+
+    const scenarioLabel = fixture.scenario ? ` (scenario '${fixture.scenario}')` : '';
+    const named = entry.deserializeParams(toInputSlots(rawInputs));
+
+    for (const param of named) {
+      if (!(param.name in expectedInputs)) {
+        throw new Error(
+          `Unexpected param '${param.name}' for oracle '${oracleName}'. ` +
+            `Expected: ${Object.keys(expectedInputs).join(', ')}`,
+        );
+      }
+      if (!valuesEqual(param.value, expectedInputs[param.name])) {
+        throw new Error(
+          `Input mismatch for oracle '${oracleName}'${scenarioLabel}: ` +
+            `param '${param.name}' expected ${String(expectedInputs[param.name])} ` +
+            `but got ${String(param.value)}. ${versionBumpHint(oracleName)}`,
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Decodes the scenario name announced by `set_oracle_test_scenario`, whose argument is a `BoundedVec<u8, N>`
+ */
+function decodeScenarioName(inputs: ForeignCallArgs): string {
+  const [{ value }] = SET_SCENARIO_ENTRY.deserializeParams(toInputSlots(inputs));
+  return String.fromCharCode(...value.data);
+}
+
+function valuesEqual(actual: unknown, expected: unknown): boolean {
+  if (!isNonNullObject(actual) || !isNonNullObject(expected)) {
+    // Primitive scalars; String() bridges bigint vs number representations of the same seed. A primitive compared
+    // against an object is never equal.
+    return isNonNullObject(actual) === isNonNullObject(expected) && String(actual) === String(expected);
+  }
+  if (actual instanceof Option && expected instanceof Option) {
+    return actual.equals(expected, valuesEqual);
+  }
+  if (actual instanceof BoundedVec && expected instanceof BoundedVec) {
+    return actual.equals(expected, valuesEqual);
+  }
+  if (Array.isArray(actual) && Array.isArray(expected)) {
+    return actual.length === expected.length && actual.every((v, i) => valuesEqual(v, expected[i]));
+  }
+  if (isPlainObject(actual) && isPlainObject(expected)) {
+    const expectedKeys = Object.keys(expected);
+    return (
+      Object.keys(actual).length === expectedKeys.length &&
+      expectedKeys.every(key => valuesEqual(actual[key], expected[key]))
+    );
+  }
+  if (actual.constructor !== expected.constructor) {
+    return false;
+  }
+  if (hasEquals(actual)) {
+    return actual.equals(expected);
+  }
+  const actualStr = customStringForm(actual);
+  const expectedStr = customStringForm(expected);
+  if (actualStr !== undefined && expectedStr !== undefined) {
+    return actualStr === expectedStr;
+  }
+  // Comparing blindly here could pass vacuously (e.g. two '[object Object]' strings), so refuse instead.
+  throw new Error(
+    `valuesEqual cannot compare a '${actual.constructor?.name}' against a '${expected.constructor?.name}'. Add a branch for the type.`,
+  );
+}
+
+function isNonNullObject(value: unknown): value is object {
+  return typeof value === 'object' && value !== null;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return isNonNullObject(value) && value.constructor === Object;
+}
+
+function hasEquals(value: object): value is { equals(other: unknown): boolean } {
+  return typeof (value as { equals?: unknown }).equals === 'function';
+}
+
+/** The value's string form when its class overrides `toString` (a meaningful representation), undefined otherwise. */
+function customStringForm(value: object): string | undefined {
+  const { toString } = value;
+  if (typeof toString !== 'function' || toString === Object.prototype.toString) {
+    return undefined;
+  }
+  return toString.call(value);
+}
+
+function versionBumpHint(oracle: string): string {
+  return oracle.startsWith('aztec_txe_') || oracle.startsWith('aztec_avm_')
+    ? 'If you changed this oracle, consider bumping the TXE oracle version in yarn-project/txe/src/oracle/txe_oracle_version.ts.'
+    : 'If you changed this oracle, consider bumping the PXE oracle version in yarn-project/pxe/src/oracle_version.ts.';
+}