@aztec/txe 5.0.0-private.20260319 → 5.0.0-rc.2

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

@@ -0,0 +1,226 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BlockNumber } 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,
+  ETH_ADDRESS,
+  FIELD,
+  FUNCTION_SELECTOR,
+  NOTE_SELECTOR,
+  Option,
+  type OracleRegistryEntry,
+  type TypeMapping,
+  U32,
+} from '@aztec/pxe/simulator';
+import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import { BlockHash } from '@aztec/stdlib/block';
+
+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, or `Option`s of them. The matching Noir serialization tests are auto-generated by
+ * `#[auto_serialization_test]` 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 `OracleTestValue` trait exactly
+ * (`noir-projects/aztec-nr/.../macros/oracle_testing.nr`).
+ */
+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))),
+  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,
+      }),
+    ),
+  ]),
+];
+
+/**
+ * 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 `impl OracleTestValue<N> for T`: `match` selects the type and
+ * `scenarios` yields its [`Scenario`]s for `seed`, one per serialization shape, like Noir's
+ * `oracle_test_value(seed) -> [Scenario<Self>; N]`.
+ */
+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 [`Scenario`]s for `type` at `seed`, one per serialization *shape*, mirroring the Noir
+ * `OracleTestValue::oracle_test_value(seed) -> [Scenario<Self>; N]`. 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>) {
+    super(`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 (structs, ephemeral arrays).
+ */
+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`), discriminated by `kind`. The combinators attach `kind`
+ * plus the inner mapping 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 CompositeMapping = ArrayMapping | BoundedVecMapping | OptionMapping;
+
+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';
+}

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,198 @@
+/* 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, BYTE, BoundedVec, Option, type OracleRegistryEntry, 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(BYTE) }] });
+
+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 `#[auto_serialization_test]` 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 (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]));
+  }
+  return String(actual) === String(expected);
+}
+
+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.';
+}

package/src/oracle/txe_oracle_public_context.ts

@@ -1,9 +1,11 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { ContractStore } from '@aztec/pxe/server';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2Block } from '@aztec/stdlib/block';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 import {
   MerkleTreeId,
@@ -29,6 +31,7 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
     private forkedWorldTrees: MerkleTreeWriteOperations,
     private txRequestHash: Fr,
     private globalVariables: GlobalVariables,
+    private contractStore: ContractStore,
   ) {
     this.logger = createLogger('txe:public_context');
 
@@ -122,6 +125,63 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
     return value;
   }
 
+  getContractInstanceDeployer(address: AztecAddress): Promise<{ member: Fr; exists: boolean }> {
+    return this.getContractInstanceMember(address, i => i.deployer.toField());
+  }
+
+  getContractInstanceClassId(address: AztecAddress): Promise<{ member: Fr; exists: boolean }> {
+    return this.getContractInstanceMember(address, i => i.currentContractClassId);
+  }
+
+  getContractInstanceInitializationHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }> {
+    return this.getContractInstanceMember(address, i => i.initializationHash);
+  }
+
+  getContractInstanceImmutablesHash(address: AztecAddress): Promise<{ member: Fr; exists: boolean }> {
+    return this.getContractInstanceMember(address, i => i.immutablesHash);
+  }
+
+  private async getContractInstanceMember(
+    address: AztecAddress,
+    accessor: (instance: ContractInstanceWithAddress) => Fr,
+  ): Promise<{ member: Fr; exists: boolean }> {
+    const instance = await this.contractStore.getContractInstance(address);
+    if (!instance) {
+      return { member: Fr.ZERO, exists: false };
+    }
+    return { member: accessor(instance), exists: true };
+  }
+
+  returndataSize(): Promise<Fr> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
+  returndataCopy(_rdOffset: number, _copySize: number): Promise<Fr[]> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
+  call(_l2Gas: number, _daGas: number, _address: AztecAddress, _argsLength: number, _args: Fr[]): Promise<void> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
+  staticCall(_l2Gas: number, _daGas: number, _address: AztecAddress, _argsLength: number, _args: Fr[]): Promise<void> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
+  successCopy(): Promise<boolean> {
+    throw new Error(
+      'Contract calls are forbidden inside a `TestEnvironment::public_context`, use `public_call` instead',
+    );
+  }
+
   async close(): Promise<L2Block> {
     this.logger.debug('Exiting Public Context, building block with collected side effects', {
       blockNumber: this.globalVariables.blockNumber,