@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/kernel/hints/private_kernel_reset_hints.ts

@@ -3,15 +3,15 @@ import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/s
 import { KeyValidationHint } from './key_validation_hint.js';
 import { type NoteHashReadRequestHints, noteHashReadRequestHintsFromBuffer } from './note_hash_read_request_hints.js';
 import { type NullifierReadRequestHints, nullifierReadRequestHintsFromBuffer } from './nullifier_read_request_hints.js';
-import { TransientDataIndexHint } from './transient_data_index_hint.js';
+import { TransientDataSquashingHint } from './transient_data_squashing_hint.js';
 
 export class PrivateKernelResetHints<
   NH_RR_PENDING extends number,
   NH_RR_SETTLED extends number,
   NLL_RR_PENDING extends number,
   NLL_RR_SETTLED extends number,
-  KEY_VALIDATION_REQUESTS extends number,
-  NUM_TRANSIENT_DATA_INDEX_HINTS extends number,
+  KEY_VALIDATION_HINTS_LEN extends number,
+  TRANSIENT_DATA_HINTS_LEN extends number,
 > {
   constructor(
     /**
@@ -25,11 +25,11 @@ export class PrivateKernelResetHints<
     /**
      * Contains hints for key validation request.
      */
-    public keyValidationHints: Tuple<KeyValidationHint, KEY_VALIDATION_REQUESTS>,
+    public keyValidationHints: Tuple<KeyValidationHint, KEY_VALIDATION_HINTS_LEN>,
     /**
      * Contains hints for the transient note hashes to locate corresponding nullifiers.
      */
-    public transientDataIndexHints: Tuple<TransientDataIndexHint, NUM_TRANSIENT_DATA_INDEX_HINTS>,
+    public transientDataSquashingHints: Tuple<TransientDataSquashingHint, TRANSIENT_DATA_HINTS_LEN>,
     /**
      * The "final" minRevertibleSideEffectCounter of a tx, to split the data for squashing.
      * Not the minRevertibleSideEffectCounter at the point the reset circuit is run.
@@ -42,44 +42,35 @@ export class PrivateKernelResetHints<
       this.noteHashReadRequestHints,
       this.nullifierReadRequestHints,
       this.keyValidationHints,
-      this.transientDataIndexHints,
+      this.transientDataSquashingHints,
       this.validationRequestsSplitCounter,
     );
   }
 
-  trimToSizes<
-    NEW_NH_RR_PENDING extends number,
-    NEW_NH_RR_SETTLED extends number,
-    NEW_NLL_RR_PENDING extends number,
-    NEW_NLL_RR_SETTLED extends number,
-    NEW_KEY_VALIDATION_REQUESTS extends number,
-    NUM_TRANSIENT_DATA_INDEX_HINTS extends number,
-  >(
-    numNoteHashReadRequestPending: NEW_NH_RR_PENDING,
-    numNoteHashReadRequestSettled: NEW_NH_RR_SETTLED,
-    numNullifierReadRequestPending: NEW_NLL_RR_PENDING,
-    numNullifierReadRequestSettled: NEW_NLL_RR_SETTLED,
-    numKeyValidationRequests: NEW_KEY_VALIDATION_REQUESTS,
-    numTransientDataIndexHints: NUM_TRANSIENT_DATA_INDEX_HINTS,
-  ): PrivateKernelResetHints<
-    NEW_NH_RR_PENDING,
-    NEW_NH_RR_SETTLED,
-    NEW_NLL_RR_PENDING,
-    NEW_NLL_RR_SETTLED,
-    NEW_KEY_VALIDATION_REQUESTS,
-    NUM_TRANSIENT_DATA_INDEX_HINTS
-  > {
+  trimToSizes(
+    numNoteHashReadRequestPending: number,
+    numNoteHashReadRequestSettled: number,
+    numNullifierReadRequestPending: number,
+    numNullifierReadRequestSettled: number,
+    numKeyValidationHints: number,
+    numTransientDataSquashingHints: number,
+  ) {
+    // Noir does not allow empty arrays. So we make the minimum array size 1.
+    // There is a constant for each dimension, coded in the circuit that indicates how many hints should be applied.
+    // The circuit is selected based on the dimension sizes, not the hint array sizes created here.
+    const useSize = (num: number) => Math.max(num, 1);
+
     return new PrivateKernelResetHints(
-      this.noteHashReadRequestHints.trimToSizes(numNoteHashReadRequestPending, numNoteHashReadRequestSettled),
-      this.nullifierReadRequestHints.trimToSizes(numNullifierReadRequestPending, numNullifierReadRequestSettled),
-      this.keyValidationHints.slice(0, numKeyValidationRequests) as Tuple<
-        KeyValidationHint,
-        NEW_KEY_VALIDATION_REQUESTS
-      >,
-      this.transientDataIndexHints.slice(0, numTransientDataIndexHints) as Tuple<
-        TransientDataIndexHint,
-        NUM_TRANSIENT_DATA_INDEX_HINTS
-      >,
+      this.noteHashReadRequestHints.trimToSizes(
+        useSize(numNoteHashReadRequestPending),
+        useSize(numNoteHashReadRequestSettled),
+      ),
+      this.nullifierReadRequestHints.trimToSizes(
+        useSize(numNullifierReadRequestPending),
+        useSize(numNullifierReadRequestSettled),
+      ),
+      this.keyValidationHints.slice(0, useSize(numKeyValidationHints)),
+      this.transientDataSquashingHints.slice(0, useSize(numTransientDataSquashingHints)),
       this.validationRequestsSplitCounter,
     );
   }
@@ -93,23 +84,23 @@ export class PrivateKernelResetHints<
     NH_RR_SETTLED extends number,
     NLL_RR_PENDING extends number,
     NLL_RR_SETTLED extends number,
-    KEY_VALIDATION_REQUESTS extends number,
-    NUM_TRANSIENT_DATA_INDEX_HINTS extends number,
+    KEY_VALIDATION_HINTS_LEN extends number,
+    TRANSIENT_DATA_HINTS_LEN extends number,
   >(
     buffer: Buffer | BufferReader,
     numNoteHashReadRequestPending: NH_RR_PENDING,
     numNoteHashReadRequestSettled: NH_RR_SETTLED,
     numNullifierReadRequestPending: NLL_RR_PENDING,
     numNullifierReadRequestSettled: NLL_RR_SETTLED,
-    numNullifierKeys: KEY_VALIDATION_REQUESTS,
-    numTransientDataIndexHints: NUM_TRANSIENT_DATA_INDEX_HINTS,
+    numKeyValidationHints: KEY_VALIDATION_HINTS_LEN,
+    numTransientDataSquashingHints: TRANSIENT_DATA_HINTS_LEN,
   ): PrivateKernelResetHints<
     NH_RR_PENDING,
     NH_RR_SETTLED,
     NLL_RR_PENDING,
     NLL_RR_SETTLED,
-    KEY_VALIDATION_REQUESTS,
-    NUM_TRANSIENT_DATA_INDEX_HINTS
+    KEY_VALIDATION_HINTS_LEN,
+    TRANSIENT_DATA_HINTS_LEN
   > {
     const reader = BufferReader.asReader(buffer);
     return new PrivateKernelResetHints(
@@ -121,8 +112,8 @@ export class PrivateKernelResetHints<
         fromBuffer: buf =>
           nullifierReadRequestHintsFromBuffer(buf, numNullifierReadRequestPending, numNullifierReadRequestSettled),
       }),
-      reader.readArray(numNullifierKeys, KeyValidationHint),
-      reader.readArray(numTransientDataIndexHints, TransientDataIndexHint),
+      reader.readArray(numKeyValidationHints, KeyValidationHint),
+      reader.readArray(numTransientDataSquashingHints, TransientDataSquashingHint),
       reader.readNumber(),
     );
   }

package/src/kernel/hints/read_request.ts

@@ -71,7 +71,10 @@ export class ReadRequest {
  * ReadRequest with context of the contract emitting the request.
  */
 export class ScopedReadRequest {
-  constructor(public readRequest: ReadRequest, public contractAddress: AztecAddress) {}
+  constructor(
+    public readRequest: ReadRequest,
+    public contractAddress: AztecAddress,
+  ) {}
 
   get value() {
     return this.readRequest.value;

package/src/kernel/hints/read_request_hints.ts

@@ -2,39 +2,45 @@ import { makeTuple } from '@aztec/foundation/array';
 import { BufferReader, type Bufferable, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 
-export enum ReadRequestState {
-  NADA = 0,
-  PENDING = 1,
-  SETTLED = 2,
+export enum ReadRequestActionEnum {
+  SKIP = 0,
+  READ_AS_PENDING = 1,
+  READ_AS_SETTLED = 2,
 }
 
-export class ReadRequestStatus {
-  constructor(public state: ReadRequestState, public hintIndex: number) {}
+export class ReadRequestAction {
+  constructor(
+    public action: ReadRequestActionEnum,
+    public hintIndex: number,
+  ) {}
 
-  static nada() {
-    return new ReadRequestStatus(ReadRequestState.NADA, 0);
+  static skip() {
+    return new ReadRequestAction(ReadRequestActionEnum.SKIP, 0);
   }
 
-  static pending(hintIndex: number) {
-    return new ReadRequestStatus(ReadRequestState.PENDING, hintIndex);
+  static readAsPending(hintIndex: number) {
+    return new ReadRequestAction(ReadRequestActionEnum.READ_AS_PENDING, hintIndex);
   }
 
-  static settled(hintIndex: number) {
-    return new ReadRequestStatus(ReadRequestState.SETTLED, hintIndex);
+  static readAsSettled(hintIndex: number) {
+    return new ReadRequestAction(ReadRequestActionEnum.READ_AS_SETTLED, hintIndex);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new ReadRequestStatus(reader.readNumber(), reader.readNumber());
+    return new ReadRequestAction(reader.readNumber(), reader.readNumber());
   }
 
   toBuffer() {
-    return serializeToBuffer(this.state, this.hintIndex);
+    return serializeToBuffer(this.action, this.hintIndex);
   }
 }
 
 export class PendingReadHint {
-  constructor(public readRequestIndex: number, public pendingValueIndex: number) {}
+  constructor(
+    public readRequestIndex: number,
+    public pendingValueIndex: number,
+  ) {}
 
   static nada(readRequestLen: number) {
     return new PendingReadHint(readRequestLen, 0);
@@ -88,33 +94,39 @@ export class SettledReadHint<TREE_HEIGHT extends number, LEAF_PREIMAGE extends B
  */
 export class ReadRequestResetHints<
   READ_REQUEST_LEN extends number,
-  NUM_PENDING_READS extends number,
-  NUM_SETTLED_READS extends number,
+  PENDING_READ_HINTS_LEN extends number,
+  SETTLED_READ_HINTS_LEN extends number,
   TREE_HEIGHT extends number,
   LEAF_PREIMAGE extends Bufferable,
 > {
   constructor(
-    public readRequestStatuses: Tuple<ReadRequestStatus, READ_REQUEST_LEN>,
+    public readRequestActions: Tuple<ReadRequestAction, READ_REQUEST_LEN>,
     /**
      * The hints for read requests reading pending values.
      */
-    public pendingReadHints: Tuple<PendingReadHint, NUM_PENDING_READS>,
+    public pendingReadHints: Tuple<PendingReadHint, PENDING_READ_HINTS_LEN>,
     /**
      * The hints for read requests reading settled values.
      */
-    public settledReadHints: Tuple<SettledReadHint<TREE_HEIGHT, LEAF_PREIMAGE>, NUM_SETTLED_READS>,
+    public settledReadHints: Tuple<SettledReadHint<TREE_HEIGHT, LEAF_PREIMAGE>, SETTLED_READ_HINTS_LEN>,
   ) {}
 
-  trimToSizes<NEW_NUM_PENDING_READS extends number, NEW_NUM_SETTLED_READS extends number>(
-    numPendingReads: NEW_NUM_PENDING_READS,
-    numSettledReads: NEW_NUM_SETTLED_READS,
-  ): ReadRequestResetHints<READ_REQUEST_LEN, NEW_NUM_PENDING_READS, NEW_NUM_SETTLED_READS, TREE_HEIGHT, LEAF_PREIMAGE> {
+  trimToSizes<NEW_PENDING_READ_HINTS_LEN extends number, NEW_SETTLED_READ_HINTS_LEN extends number>(
+    numPendingReads: NEW_PENDING_READ_HINTS_LEN,
+    numSettledReads: NEW_SETTLED_READ_HINTS_LEN,
+  ): ReadRequestResetHints<
+    READ_REQUEST_LEN,
+    NEW_PENDING_READ_HINTS_LEN,
+    NEW_SETTLED_READ_HINTS_LEN,
+    TREE_HEIGHT,
+    LEAF_PREIMAGE
+  > {
     return new ReadRequestResetHints(
-      this.readRequestStatuses,
-      this.pendingReadHints.slice(0, numPendingReads) as Tuple<PendingReadHint, NEW_NUM_PENDING_READS>,
+      this.readRequestActions,
+      this.pendingReadHints.slice(0, numPendingReads) as Tuple<PendingReadHint, NEW_PENDING_READ_HINTS_LEN>,
       this.settledReadHints.slice(0, numSettledReads) as Tuple<
         SettledReadHint<TREE_HEIGHT, LEAF_PREIMAGE>,
-        NEW_NUM_SETTLED_READS
+        NEW_SETTLED_READ_HINTS_LEN
       >,
     );
   }
@@ -126,21 +138,27 @@ export class ReadRequestResetHints<
    */
   static fromBuffer<
     READ_REQUEST_LEN extends number,
-    NUM_PENDING_READS extends number,
-    NUM_SETTLED_READS extends number,
+    PENDING_READ_HINTS_LEN extends number,
+    SETTLED_READ_HINTS_LEN extends number,
     TREE_HEIGHT extends number,
     LEAF_PREIMAGE extends Bufferable,
   >(
     buffer: Buffer | BufferReader,
     readRequestLen: READ_REQUEST_LEN,
-    numPendingReads: NUM_PENDING_READS,
-    numSettledReads: NUM_SETTLED_READS,
+    numPendingReads: PENDING_READ_HINTS_LEN,
+    numSettledReads: SETTLED_READ_HINTS_LEN,
     treeHeight: TREE_HEIGHT,
     leafPreimageFromBuffer: { fromBuffer: (buffer: BufferReader) => LEAF_PREIMAGE },
-  ): ReadRequestResetHints<READ_REQUEST_LEN, NUM_PENDING_READS, NUM_SETTLED_READS, TREE_HEIGHT, LEAF_PREIMAGE> {
+  ): ReadRequestResetHints<
+    READ_REQUEST_LEN,
+    PENDING_READ_HINTS_LEN,
+    SETTLED_READ_HINTS_LEN,
+    TREE_HEIGHT,
+    LEAF_PREIMAGE
+  > {
     const reader = BufferReader.asReader(buffer);
     return new ReadRequestResetHints(
-      reader.readArray(readRequestLen, ReadRequestStatus),
+      reader.readArray(readRequestLen, ReadRequestAction),
       reader.readArray(numPendingReads, PendingReadHint),
       reader.readArray(numSettledReads, {
         fromBuffer: r => SettledReadHint.fromBuffer(r, treeHeight, leafPreimageFromBuffer),
@@ -149,16 +167,19 @@ export class ReadRequestResetHints<
   }
 
   toBuffer() {
-    return serializeToBuffer(this.readRequestStatuses, this.pendingReadHints, this.settledReadHints);
+    return serializeToBuffer(this.readRequestActions, this.pendingReadHints, this.settledReadHints);
   }
 }
 
-export class ReadRequestResetStates<NUM_READS extends number> {
-  constructor(public states: Tuple<ReadRequestState, NUM_READS>, public pendingReadHints: PendingReadHint[]) {}
+export class ReadRequestResetActions<NUM_READS extends number> {
+  constructor(
+    public actions: Tuple<ReadRequestActionEnum, NUM_READS>,
+    public pendingReadHints: PendingReadHint[],
+  ) {}
 
   static empty<NUM_READS extends number>(numReads: NUM_READS) {
-    return new ReadRequestResetStates(
-      makeTuple(numReads, () => ReadRequestState.NADA),
+    return new ReadRequestResetActions(
+      makeTuple(numReads, () => ReadRequestActionEnum.SKIP),
       [],
     );
   }

package/src/kernel/hints/{transient_data_index_hint.ts → transient_data_squashing_hint.ts}

@@ -3,8 +3,11 @@ import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/
 
 import { inspect } from 'util';
 
-export class TransientDataIndexHint {
-  constructor(public nullifierIndex: number, public noteHashIndex: number) {}
+export class TransientDataSquashingHint {
+  constructor(
+    public nullifierIndex: number,
+    public noteHashIndex: number,
+  ) {}
 
   toFields(): Fr[] {
     return [new Fr(this.nullifierIndex), new Fr(this.noteHashIndex)];
@@ -12,7 +15,7 @@ export class TransientDataIndexHint {
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new TransientDataIndexHint(reader.readU32(), reader.readU32());
+    return new TransientDataSquashingHint(reader.readU32(), reader.readU32());
   }
 
   isEmpty() {
@@ -20,7 +23,7 @@ export class TransientDataIndexHint {
   }
 
   static empty() {
-    return new TransientDataIndexHint(0, 0);
+    return new TransientDataSquashingHint(0, 0);
   }
 
   toBuffer(): Buffer {
@@ -29,7 +32,7 @@ export class TransientDataIndexHint {
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new TransientDataIndexHint(reader.readNumber(), reader.readNumber());
+    return new TransientDataSquashingHint(reader.readNumber(), reader.readNumber());
   }
 
   toString(): string {
@@ -37,6 +40,6 @@ export class TransientDataIndexHint {
   }
 
   [inspect.custom](): string {
-    return `TransientDataIndexHint { ${this.toString()} }`;
+    return `TransientDataSquashingHint { ${this.toString()} }`;
   }
 }

package/src/kernel/hints/tree_leaf_read_request.ts

@@ -2,7 +2,10 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 export class TreeLeafReadRequest {
-  constructor(public value: Fr, public leafIndex: Fr) {}
+  constructor(
+    public value: Fr,
+    public leafIndex: Fr,
+  ) {}
 
   toBuffer(): Buffer {
     return serializeToBuffer(this.value, this.leafIndex);

package/src/kernel/index.ts

@@ -1,5 +1,6 @@
+export * from './claimed_length_array.js';
+export * from './hiding_kernel_private_inputs.js';
 export * from './private_to_rollup_accumulated_data.js';
-export * from './combined_constant_data.js';
 export * from './private_to_rollup_kernel_circuit_public_inputs.js';
 export * from './private_accumulated_data.js';
 export * from './private_call_data.js';
@@ -26,5 +27,6 @@ export * from './note_hash.js';
 export * from './private_log_data.js';
 export * from './private_call_request.js';
 export * from './private_validation_requests.js';
-export * from './private_kernel_prover_profile_result.js';
 export * from './private_kernel_simulated_output.js';
+export * from './private_kernel_prover_output.js';
+export * from './padded_side_effects.js';

package/src/kernel/log_hash.ts

@@ -1,42 +1,49 @@
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import type { Ordered } from './utils/interfaces.js';
 
-export class LogHash implements Ordered {
-  constructor(public value: Fr, public counter: number, public length: number) {}
+export class LogHash {
+  constructor(
+    public value: Fr,
+    public length: number,
+  ) {}
+
+  static from(fields: FieldsOf<LogHash>) {
+    return new LogHash(fields.value, fields.length);
+  }
 
   toFields(): Fr[] {
-    return [this.value, new Fr(this.counter), new Fr(this.length)];
+    return [this.value, new Fr(this.length)];
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new LogHash(reader.readField(), reader.readU32(), reader.readU32());
+    return new LogHash(reader.readField(), reader.readU32());
   }
 
   isEmpty() {
-    return this.value.isZero() && !this.length && !this.counter;
+    return this.value.isZero() && !this.length;
   }
 
   static empty() {
-    return new LogHash(Fr.zero(), 0, 0);
+    return new LogHash(Fr.zero(), 0);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer(this.value, this.counter, this.length);
+    return serializeToBuffer(this.value, this.length);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new LogHash(Fr.fromBuffer(reader), reader.readNumber(), reader.readNumber());
+    return new LogHash(Fr.fromBuffer(reader), reader.readNumber());
   }
 
   toString(): string {
-    return `value=${this.value} counter=${this.counter} length=${this.length}`;
+    return `value=${this.value} length=${this.length}`;
   }
 
   scope(contractAddress: AztecAddress) {
@@ -48,13 +55,45 @@ export class LogHash implements Ordered {
   }
 }
 
-export class ScopedLogHash implements Ordered {
-  constructor(public logHash: LogHash, public contractAddress: AztecAddress) {}
+export class CountedLogHash {
+  constructor(
+    public logHash: LogHash,
+    public counter: number,
+  ) {}
+
+  toFields(): Fr[] {
+    return [...this.logHash.toFields(), new Fr(this.counter)];
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new CountedLogHash(reader.readObject(LogHash), reader.readU32());
+  }
+
+  isEmpty() {
+    return this.logHash.isEmpty() && !this.counter;
+  }
+
+  static empty() {
+    return new CountedLogHash(LogHash.empty(), 0);
+  }
 
-  get counter() {
-    return this.logHash.counter;
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.logHash, this.counter);
   }
 
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CountedLogHash(LogHash.fromBuffer(reader), reader.readNumber());
+  }
+}
+
+export class ScopedLogHash {
+  constructor(
+    public logHash: LogHash,
+    public contractAddress: AztecAddress,
+  ) {}
+
   get value() {
     return this.logHash.value;
   }
@@ -89,3 +128,36 @@ export class ScopedLogHash implements Ordered {
     return `logHash=${this.logHash} contractAddress=${this.contractAddress}`;
   }
 }
+
+export class ScopedCountedLogHash {
+  constructor(
+    public inner: CountedLogHash,
+    public contractAddress: AztecAddress,
+  ) {}
+
+  toFields(): Fr[] {
+    return [...this.inner.toFields(), this.contractAddress.toField()];
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new ScopedCountedLogHash(reader.readObject(CountedLogHash), AztecAddress.fromField(reader.readField()));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.inner, this.contractAddress);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new ScopedCountedLogHash(CountedLogHash.fromBuffer(reader), AztecAddress.fromBuffer(reader));
+  }
+
+  isEmpty() {
+    return this.inner.isEmpty() && this.contractAddress.isZero();
+  }
+
+  static empty() {
+    return new ScopedCountedLogHash(CountedLogHash.empty(), AztecAddress.ZERO);
+  }
+}

package/src/kernel/note_hash.ts

@@ -5,7 +5,10 @@ import { AztecAddress } from '../aztec-address/index.js';
 import type { Ordered } from './utils/interfaces.js';
 
 export class NoteHash {
-  constructor(public value: Fr, public counter: number) {}
+  constructor(
+    public value: Fr,
+    public counter: number,
+  ) {}
 
   toFields(): Fr[] {
     return [this.value, new Fr(this.counter)];
@@ -43,7 +46,10 @@ export class NoteHash {
 }
 
 export class ScopedNoteHash implements Ordered {
-  constructor(public noteHash: NoteHash, public contractAddress: AztecAddress) {}
+  constructor(
+    public noteHash: NoteHash,
+    public contractAddress: AztecAddress,
+  ) {}
 
   get counter() {
     return this.noteHash.counter;

package/src/kernel/nullifier.ts

@@ -5,36 +5,40 @@ import { AztecAddress } from '../aztec-address/index.js';
 import type { Ordered } from './utils/interfaces.js';
 
 export class Nullifier implements Ordered {
-  constructor(public value: Fr, public counter: number, public noteHash: Fr) {}
+  constructor(
+    public value: Fr,
+    public noteHash: Fr,
+    public counter: number,
+  ) {}
 
   toFields(): Fr[] {
-    return [this.value, new Fr(this.counter), this.noteHash];
+    return [this.value, this.noteHash, new Fr(this.counter)];
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new Nullifier(reader.readField(), reader.readU32(), reader.readField());
+    return new Nullifier(reader.readField(), reader.readField(), reader.readU32());
   }
 
   isEmpty() {
-    return this.value.isZero() && !this.counter && this.noteHash.isZero();
+    return this.value.isZero() && this.noteHash.isZero() && !this.counter;
   }
 
   static empty() {
-    return new Nullifier(Fr.zero(), 0, Fr.zero());
+    return new Nullifier(Fr.zero(), Fr.zero(), 0);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer(this.value, this.counter, this.noteHash);
+    return serializeToBuffer(this.value, this.noteHash, this.counter);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new Nullifier(Fr.fromBuffer(reader), reader.readNumber(), Fr.fromBuffer(reader));
+    return new Nullifier(Fr.fromBuffer(reader), Fr.fromBuffer(reader), reader.readNumber());
   }
 
   toString(): string {
-    return `value=${this.value} counter=${this.counter} noteHash=${this.noteHash}`;
+    return `value=${this.value} noteHash=${this.noteHash} counter=${this.counter}`;
   }
 
   scope(contractAddress: AztecAddress) {
@@ -43,7 +47,10 @@ export class Nullifier implements Ordered {
 }
 
 export class ScopedNullifier implements Ordered {
-  constructor(public nullifier: Nullifier, public contractAddress: AztecAddress) {}
+  constructor(
+    public nullifier: Nullifier,
+    public contractAddress: AztecAddress,
+  ) {}
 
   get counter() {
     return this.nullifier.counter;