@aztec/stdlib 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/abi/function_signature_decoder.ts

@@ -0,0 +1,77 @@
+import type { ABIParameter, ABIVariable, AbiType } from './abi.js';
+
+/**
+ * Decodes the signature of a function from the name and parameters.
+ */
+export class FunctionSignatureDecoder {
+  private separator: string;
+  constructor(
+    private name: string,
+    private parameters: ABIParameter[],
+    private includeNames = false,
+  ) {
+    this.separator = includeNames ? ', ' : ',';
+  }
+
+  /**
+   * Decodes a single function parameter type for the function signature.
+   * @param param - The parameter type to decode.
+   * @returns A string representing the parameter type.
+   */
+  private getParameterType(param: AbiType): string {
+    switch (param.kind) {
+      case 'field':
+        return 'Field';
+      case 'integer':
+        return param.sign === 'signed' ? `i${param.width}` : `u${param.width}`;
+      case 'boolean':
+        return 'bool';
+      case 'array':
+        return `[${this.getParameterType(param.type)};${param.length}]`;
+      case 'string':
+        return `str<${param.length}>`;
+      case 'struct':
+        return `(${param.fields.map(field => `${this.decodeParameter(field)}`).join(this.separator)})`;
+      default:
+        throw new Error(`Unsupported type: ${param.kind}`);
+    }
+  }
+
+  /**
+   * Decodes a single function parameter for the function signature.
+   * @param param - The parameter to decode.
+   * @returns A string representing the parameter type and optionally its name.
+   */
+  private decodeParameter(param: ABIVariable): string {
+    const type = this.getParameterType(param.type);
+    return this.includeNames ? `${param.name}: ${type}` : type;
+  }
+
+  /**
+   * Decodes all the parameters and build the function signature
+   * @returns The function signature.
+   */
+  public decode(): string {
+    return `${this.name}(${this.parameters.map(param => this.decodeParameter(param)).join(this.separator)})`;
+  }
+}
+
+/**
+ * Decodes a function signature from the name and parameters.
+ * @param name - The name of the function.
+ * @param parameters - The parameters of the function.
+ * @returns - The function signature.
+ */
+export function decodeFunctionSignature(name: string, parameters: ABIParameter[]) {
+  return new FunctionSignatureDecoder(name, parameters).decode();
+}
+
+/**
+ * Decodes a function signature from the name and parameters including parameter names.
+ * @param name - The name of the function.
+ * @param parameters - The parameters of the function.
+ * @returns - The user-friendly function signature.
+ */
+export function decodeFunctionSignatureWithParameterNames(name: string, parameters: ABIParameter[]) {
+  return new FunctionSignatureDecoder(name, parameters, true).decode();
+}

package/src/abi/index.ts

@@ -1,6 +1,7 @@
 export * from './abi.js';
 export * from './buffer.js';
 export * from './decoder.js';
+export * from './function_signature_decoder.js';
 export * from './encoder.js';
 export * from './authorization_selector.js';
 export * from './event_metadata_definition.js';

package/src/abi/note_selector.ts

@@ -1,24 +1,18 @@
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-import { randomInt } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { hexSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, TypeRegistry } from '@aztec/foundation/serialize';
+import { BufferReader } from '@aztec/foundation/serialize';
 
 import { Selector } from './selector.js';
 
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-/** Note selector branding */
-export interface NoteSelector {
-  /** Brand. */
-  _branding: 'NoteSelector';
-}
-
 /**
  * A note selector is a 7 bit long value that identifies a note type within a contract.
  * TODO(#10952): Encoding of note type id can be reduced to 7 bits.
  */
 export class NoteSelector extends Selector {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'NoteSelector';
   /**
    * Deserializes from a buffer or reader, corresponding to a write in cpp.
    * @param buffer - Buffer  or BufferReader to read from.
@@ -73,6 +67,3 @@ export class NoteSelector extends Selector {
     return hexSchemaFor(NoteSelector);
   }
 }
-
-// For deserializing JSON.
-TypeRegistry.register('NoteSelector', NoteSelector);

package/src/abi/selector.ts

@@ -1,10 +1,10 @@
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferToHex } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 
-/** A selector is the first 4 bytes of the hash of a signature. */
+/** A selector is the low 4 bytes of the poseidon2 hash of a signature. */
 export abstract class Selector {
   /** The size of the selector in bytes. */
   public static SIZE = 4;

package/src/abi/utils.ts

@@ -49,6 +49,25 @@ export function isWrappedFieldStruct(abiType: AbiType) {
   );
 }
 
+/**
+ * Returns whether the ABI type is a PublicKeys struct from Aztec.nr.
+ * @param abiType - Type to check.
+ * @returns A boolean indicating whether the ABI type is a PublicKeys struct.
+ */
+export function isPublicKeysStruct(abiType: AbiType) {
+  return (
+    abiType.kind === 'struct' &&
+    abiType.path === 'aztec::protocol_types::public_keys::PublicKeys' &&
+    abiType.fields.length === 6 &&
+    abiType.fields[0].name === 'npk_m_hash' &&
+    abiType.fields[1].name === 'ivpk_m' &&
+    abiType.fields[2].name === 'ovpk_m_hash' &&
+    abiType.fields[3].name === 'tpk_m_hash' &&
+    abiType.fields[4].name === 'mspk_m_hash' &&
+    abiType.fields[5].name === 'fbpk_m_hash'
+  );
+}
+
 /**
  * Returns whether the ABI type is a BoundedVec struct from Noir's std::collections::bounded_vec.
  * @param abiType - Type to check.
@@ -64,6 +83,31 @@ export function isBoundedVecStruct(abiType: AbiType) {
   );
 }
 
+/**
+ * Returns whether the ABI type is Noir's std::option::Option lowered to a struct.
+ * @param abiType - Type to check.
+ * @returns A boolean indicating whether the ABI type is an Option struct.
+ */
+export function isOptionStruct(abiType: AbiType) {
+  return (
+    abiType.kind === 'struct' &&
+    abiType.path === 'std::option::Option' &&
+    abiType.fields.length === 2 &&
+    abiType.fields[0].name === '_is_some' &&
+    abiType.fields[1].name === '_value'
+  );
+}
+
+/**
+ * Returns whether `null` or `undefined` can be mapped to a valid ABI value for this type.
+ *
+ * @param abiType - Type to check.
+ * @returns A boolean indicating whether nullish values are valid shorthand for this ABI type.
+ */
+export function canBeMappedFromNullOrUndefined(abiType: AbiType) {
+  return isOptionStruct(abiType);
+}
+
 /**
  * Returns a bigint by parsing a serialized 2's complement signed int.
  * @param b - The signed int as a buffer

package/src/auth_witness/auth_witness.ts

@@ -1,6 +1,6 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { DomainSeparator } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
@@ -61,7 +61,7 @@ export class AuthWitness {
  * @returns The inner hash for the witness
  */
 export const computeInnerAuthWitHash = (args: Fr[]) => {
-  return poseidon2HashWithSeparator(args, GeneratorIndex.AUTHWIT_INNER);
+  return poseidon2HashWithSeparator(args, DomainSeparator.AUTHWIT_INNER);
 };
 
 /**
@@ -77,5 +77,5 @@ export const computeInnerAuthWitHash = (args: Fr[]) => {
  * @returns The outer hash for the witness
  */
 export const computeOuterAuthWitHash = (consumer: AztecAddress, chainId: Fr, version: Fr, innerHash: Fr) => {
-  return poseidon2HashWithSeparator([consumer.toField(), chainId, version, innerHash], GeneratorIndex.AUTHWIT_OUTER);
+  return poseidon2HashWithSeparator([consumer.toField(), chainId, version, innerHash], DomainSeparator.AUTHWIT_OUTER);
 };

package/src/avm/avm.ts

@@ -1,5 +1,5 @@
 import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
 
 import { z } from 'zod';
@@ -15,6 +15,7 @@ import { GasSettings } from '../gas/gas_settings.js';
 import { GasUsed } from '../gas/gas_used.js';
 import { PublicKeys } from '../keys/public_keys.js';
 import { DebugLog } from '../logs/debug_log.js';
+import { PublicLog } from '../logs/public_log.js';
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { NullishToUndefined, type ZodFor, schemas } from '../schemas/schemas.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
@@ -33,6 +34,7 @@ import { TxExecutionPhase } from '../tx/processed_tx.js';
 import { WorldStateRevision } from '../world-state/world_state_revision.js';
 import { AvmCircuitPublicInputs } from './avm_circuit_public_inputs.js';
 import { serializeWithMessagePack } from './message_pack.js';
+import { PublicDataWrite } from './public_data_write.js';
 import { RevertCode } from './revert_code.js';
 
 ////////////////////////////////////////////////////////////////////////////
@@ -128,6 +130,7 @@ export class AvmContractInstanceHint {
     public readonly currentContractClassId: Fr,
     public readonly originalContractClassId: Fr,
     public readonly initializationHash: Fr,
+    public readonly immutablesHash: Fr,
     public readonly publicKeys: PublicKeys,
   ) {}
 
@@ -141,6 +144,7 @@ export class AvmContractInstanceHint {
         currentContractClassId: schemas.Fr,
         originalContractClassId: schemas.Fr,
         initializationHash: schemas.Fr,
+        immutablesHash: schemas.Fr,
         publicKeys: PublicKeys.schema,
       })
       .transform(
@@ -152,6 +156,7 @@ export class AvmContractInstanceHint {
           currentContractClassId,
           originalContractClassId,
           initializationHash,
+          immutablesHash,
           publicKeys,
         }) =>
           new AvmContractInstanceHint(
@@ -162,6 +167,7 @@ export class AvmContractInstanceHint {
             currentContractClassId,
             originalContractClassId,
             initializationHash,
+            immutablesHash,
             publicKeys,
           ),
       );
@@ -186,6 +192,7 @@ export class AvmContractInstanceHint {
       Fr.fromPlainObject(obj.currentContractClassId),
       Fr.fromPlainObject(obj.originalContractClassId),
       Fr.fromPlainObject(obj.initializationHash),
+      Fr.fromPlainObject(obj.immutablesHash),
       PublicKeys.fromPlainObject(obj.publicKeys),
     );
   }
@@ -1145,8 +1152,8 @@ export class CallStackMetadata {
 
     const { stack, leaf } = failingCall;
     const aztecCallStack = stack.map(call => ({
-      contractAddress: AztecAddress.fromField(call.contractAddress),
-      functionSelector: call.calldata.length > 0 ? FunctionSelector.fromField(call.calldata[0]) : undefined,
+      contractAddress: AztecAddress.fromFieldUnsafe(call.contractAddress),
+      functionSelector: call.calldata.length > 0 ? FunctionSelector.fromFieldOrUndefined(call.calldata[0]) : undefined,
     }));
 
     // The Noir call stack is the internal call stack at exit of the failing call
@@ -1160,17 +1167,103 @@ export class CallStackMetadata {
     );
   }
 
+  /**
+   * Finds the "rightmost deepest" revert in the call tree.
+   *
+   * At each level, we select the LAST (rightmost) reverted call, then recurse into its
+   * nested calls to find the deepest reverted leaf along that path. The chain stops
+   * when we encounter a non-reverted call (since you can choose not to rethrow).
+   *
+   * Examples (X = reverted, O = passed):
+   *
+   * 1. [X, X, X] at depth 1 -> returns the last X (rightmost)
+   *
+   * 2. [X(depth2), X, X] where first X has a nested revert -> returns the last X at depth 1,
+   *    NOT the deeper revert in the first X (rightmost takes priority over depth)
+   *
+   * 3. X -> X -> X -> O -> O -> X (nested chain)
+   *    Returns the 3rd X, because the O's break the reverted chain (they didn't rethrow)
+   *
+   * @param calls - Array of call metadata at the current level
+   * @param parentStack - Accumulated stack of parent calls (for building the result)
+   * @returns The deepest reverted call along the rightmost reverted path, or undefined if none
+   */
   private findDeepestRevert(
     calls: CallStackMetadata[],
     parentStack: CallStackMetadata[] = [],
   ): { stack: CallStackMetadata[]; leaf: CallStackMetadata } | undefined {
-    for (const call of calls) {
-      if (call.reverted) {
-        const nested = this.findDeepestRevert(call.nested, [...parentStack, call]);
-        return nested || { stack: [...parentStack, call], leaf: call };
-      }
+    const lastReverted = calls.findLast(call => call.reverted);
+    if (!lastReverted) {
+      return undefined;
     }
-    return undefined;
+    const currentStack = [...parentStack, lastReverted];
+    return this.findDeepestRevert(lastReverted.nested, currentStack) || { stack: currentStack, leaf: lastReverted };
+  }
+}
+
+export class PublicTxEffect {
+  constructor(
+    public transactionFee: Fr,
+    public noteHashes: Fr[],
+    public nullifiers: Fr[],
+    public l2ToL1Msgs: ScopedL2ToL1Message[],
+    public publicLogs: PublicLog[],
+    public publicDataWrites: PublicDataWrite[],
+  ) {}
+
+  static empty() {
+    return new PublicTxEffect(Fr.ZERO, [], [], [], [], []);
+  }
+
+  static get schema(): ZodFor<PublicTxEffect> {
+    return z
+      .object({
+        transactionFee: Fr.schema,
+        noteHashes: Fr.schema.array(),
+        nullifiers: Fr.schema.array(),
+        l2ToL1Msgs: ScopedL2ToL1Message.schema.array(),
+        publicLogs: PublicLog.schema.array(),
+        publicDataWrites: PublicDataWrite.schema.array(),
+      })
+      .transform(PublicTxEffect.from);
+  }
+
+  static from(obj: any): PublicTxEffect {
+    return new PublicTxEffect(
+      obj.transactionFee,
+      obj.noteHashes,
+      obj.nullifiers,
+      obj.l2ToL1Msgs,
+      obj.publicLogs,
+      obj.publicDataWrites,
+    );
+  }
+
+  static fromPlainObject(obj: any): PublicTxEffect {
+    return new PublicTxEffect(
+      Fr.fromPlainObject(obj.transactionFee),
+      obj.noteHashes.map((h: any) => Fr.fromPlainObject(h)),
+      obj.nullifiers.map((n: any) => Fr.fromPlainObject(n)),
+      obj.l2ToL1Msgs.map((m: any) => ScopedL2ToL1Message.fromPlainObject(m)),
+      obj.publicLogs.map((l: any) => PublicLog.fromPlainObject(l)),
+      obj.publicDataWrites.map((w: any) => PublicDataWrite.fromPlainObject(w)),
+    );
+  }
+
+  equals(other: PublicTxEffect): boolean {
+    return (
+      this.transactionFee.equals(other.transactionFee) &&
+      this.noteHashes.length === other.noteHashes.length &&
+      this.noteHashes.every((h, i) => h.equals(other.noteHashes[i])) &&
+      this.nullifiers.length === other.nullifiers.length &&
+      this.nullifiers.every((h, i) => h.equals(other.nullifiers[i])) &&
+      this.l2ToL1Msgs.length === other.l2ToL1Msgs.length &&
+      this.l2ToL1Msgs.every((m, i) => m.equals(other.l2ToL1Msgs[i])) &&
+      this.publicLogs.length === other.publicLogs.length &&
+      this.publicLogs.every((l, i) => l.equals(other.publicLogs[i])) &&
+      this.publicDataWrites.length === other.publicDataWrites.length &&
+      this.publicDataWrites.every((w, i) => w.equals(other.publicDataWrites[i]))
+    );
   }
 }
 
@@ -1179,6 +1272,7 @@ export class PublicTxResult {
     // Simulation result.
     public gasUsed: GasUsed,
     public revertCode: RevertCode,
+    public publicTxEffect: PublicTxEffect,
     // These are only guaranteed to be present if the simulator is configured to collect them.
     // TODO(fcarreiro): Remove NestedProcessReturnValues[] once we migrate to the C++ simulator.
     public callStackMetadata:
@@ -1187,7 +1281,7 @@ export class PublicTxResult {
     public logs: DebugLog[] | undefined,
     // For the proving request.
     public hints: AvmExecutionHints | undefined,
-    public publicInputs: AvmCircuitPublicInputs,
+    public publicInputs: AvmCircuitPublicInputs | undefined,
   ) {}
 
   static empty() {
@@ -1199,6 +1293,7 @@ export class PublicTxResult {
         billedGas: Gas.empty(),
       },
       RevertCode.OK,
+      PublicTxEffect.empty(),
       /*callStackMetadata=*/ [] as CallStackMetadata[],
       /*logs=*/ [],
       /*hints=*/ AvmExecutionHints.empty(),
@@ -1212,15 +1307,24 @@ export class PublicTxResult {
         gasUsed: schemas.GasUsed,
         revertCode: RevertCode.schema,
         revertReason: NullishToUndefined(SimulationError.schema),
+        publicTxEffect: PublicTxEffect.schema,
         callStackMetadata: z.union([CallStackMetadata.schema.array(), NestedProcessReturnValues.schema.array()]),
         logs: NullishToUndefined(DebugLog.schema.array()),
         // For the proving request.
-        publicInputs: AvmCircuitPublicInputs.schema,
+        publicInputs: NullishToUndefined(AvmCircuitPublicInputs.schema),
         hints: NullishToUndefined(AvmExecutionHints.schema),
       })
       .transform(
-        ({ gasUsed, revertCode, callStackMetadata, logs, hints, publicInputs }) =>
-          new PublicTxResult(gasUsed, revertCode as RevertCode, callStackMetadata, logs, hints, publicInputs),
+        ({ gasUsed, revertCode, publicTxEffect, callStackMetadata, logs, hints, publicInputs }) =>
+          new PublicTxResult(
+            gasUsed,
+            revertCode as RevertCode,
+            publicTxEffect,
+            callStackMetadata,
+            logs,
+            hints,
+            publicInputs,
+          ),
       );
   }
 
@@ -1235,10 +1339,11 @@ export class PublicTxResult {
     return new PublicTxResult(
       GasUsed.fromPlainObject(obj.gasUsed),
       RevertCode.fromPlainObject(obj.revertCode),
+      PublicTxEffect.fromPlainObject(obj.publicTxEffect),
       obj.callStackMetadata.map(CallStackMetadata.fromPlainObject), // Always CallStackMetadata[] from MessagePack.
       obj.logs?.map(DebugLog.fromPlainObject),
       obj.hints ? AvmExecutionHints.fromPlainObject(obj.hints) : undefined,
-      AvmCircuitPublicInputs.fromPlainObject(obj.publicInputs),
+      obj.publicInputs ? AvmCircuitPublicInputs.fromPlainObject(obj.publicInputs) : undefined,
     );
   }
 
@@ -1336,6 +1441,7 @@ export class PublicSimulatorConfig {
     public readonly skipFeeEnforcement: boolean,
     public readonly collectCallMetadata: boolean, // appLogicReturnValues.
     public readonly collectHints: boolean, // hints.
+    public readonly collectPublicInputs: boolean, // public inputs.
     public readonly collectDebugLogs: boolean, // logs.
     public readonly collectStatistics: boolean, // timings etc.
     public readonly collectionLimits: CollectionLimitsConfig,
@@ -1347,6 +1453,7 @@ export class PublicSimulatorConfig {
       obj.skipFeeEnforcement ?? false,
       obj.collectCallMetadata ?? false,
       obj.collectHints ?? false,
+      obj.collectPublicInputs ?? false,
       obj.collectDebugLogs ?? false,
       obj.collectStatistics ?? false,
       obj.collectionLimits ?? CollectionLimitsConfig.empty(),
@@ -1364,6 +1471,7 @@ export class PublicSimulatorConfig {
         skipFeeEnforcement: z.boolean(),
         collectCallMetadata: z.boolean(),
         collectHints: z.boolean(),
+        collectPublicInputs: z.boolean(),
         collectDebugLogs: z.boolean(),
         collectStatistics: z.boolean(),
         collectionLimits: CollectionLimitsConfig.schema,

package/src/avm/avm_accumulated_data.ts

@@ -7,7 +7,7 @@ import {
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import {
   BufferReader,

package/src/avm/avm_circuit_public_inputs.ts

@@ -1,6 +1,6 @@
 import { MAX_ENQUEUED_CALLS_PER_TX } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, type Tuple, assertLength, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/avm/index.ts

@@ -3,10 +3,5 @@ export * from './avm_accumulated_data.js';
 export * from './avm_circuit_public_inputs.js';
 export * from './revert_code.js';
 export * from './public_data_write.js';
-export * from './public_data_update_request.js';
-export * from './contract_storage_update_request.js';
-export * from './contract_storage_read.js';
-export * from './public_inner_call_request.js';
-export * from './public_call_stack_item_compressed.js';
 export * from './avm_proving_request.js';
 export * from './message_pack.js';

package/src/avm/message_pack.ts

@@ -1,5 +1,6 @@
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fq, Fr, Point } from '@aztec/foundation/fields';
 
 import { strict as assert } from 'assert';
 import { Decoder, Encoder, addExtension } from 'msgpackr';
@@ -63,13 +64,22 @@ function setUpMessagePackExtensions() {
   addExtension({
     Class: Point,
     write: (p: Point) => {
-      assert(!p.inf, 'Cannot serialize infinity');
-      // TODO: should these be Frs?
+      // TODO: Now that we use a 2 elt point representation, we should be able to handle infs here.
+      // However this opens possible bad paths with public keys and requires sanitised conversion between
+      // BB's inf representation (see below), and ours/Noir's (0, 0), and empty points from BB, when inf
+      // does not actually pass through.
+      assert(!p.isInfinite, 'Cannot serialize infinity');
       return { x: new Fq(p.x.toBigInt()), y: new Fq(p.y.toBigInt()) };
     },
     read: (data: { x: Fq; y: Fq }) => {
+      // Note: BB encodes infinity as x == y == Buffer of all ones.
+      // Infinity should never pass through here, but for correctness:
+      const ALL_ONES = (1n << 256n) - 1n;
+      if (data.x.toBigInt() === ALL_ONES && data.y.toBigInt() === ALL_ONES) {
+        return Point.INFINITY;
+      }
       // Convert Fq back to Fr for Point constructor
-      return new Point(new Fr(data.x.toBigInt()), new Fr(data.y.toBigInt()), false);
+      return new Point(new Fr(data.x.toBigInt()), new Fr(data.y.toBigInt()));
     },
   });
   // EthAddress is a class that has a buffer in TS, but is itself just a field in C++.

package/src/avm/public_data_read.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 /**

package/src/avm/public_data_write.ts

@@ -1,5 +1,5 @@
 import { PUBLIC_DATA_WRITE_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';