@aztec/stdlib 0.0.1-commit.bf2612ae → 0.0.1-commit.c0b82b2

package/src/interfaces/slasher.ts

@@ -18,6 +18,8 @@ export interface SlasherConfig {
   slashDataWithholdingPenalty: bigint;
   slashInactivityPenalty: bigint;
   slashBroadcastedInvalidBlockPenalty: bigint;
+  slashDuplicateProposalPenalty: bigint;
+  slashDuplicateAttestationPenalty: bigint;
   slashProposeInvalidAttestationsPenalty: bigint;
   slashAttestDescendantOfInvalidPenalty: bigint;
   slashUnknownPenalty: bigint;
@@ -40,6 +42,8 @@ export const SlasherConfigSchema = zodFor<SlasherConfig>()(
     slashInactivityConsecutiveEpochThreshold: z.number(),
     slashInactivityPenalty: schemas.BigInt,
     slashProposeInvalidAttestationsPenalty: schemas.BigInt,
+    slashDuplicateProposalPenalty: schemas.BigInt,
+    slashDuplicateAttestationPenalty: schemas.BigInt,
     slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
     slashUnknownPenalty: schemas.BigInt,
     slashOffenseExpirationRounds: z.number(),

package/src/interfaces/validator.ts

@@ -15,12 +15,12 @@ import type {
 } from '@aztec/stdlib/p2p';
 import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
-import { type ValidatorHASignerConfig, ValidatorHASignerConfigSchema } from '@aztec/validator-ha-signer/config';
 
 import type { PeerId } from '@libp2p/interface';
 import { z } from 'zod';
 
 import type { CommitteeAttestationsAndSigners } from '../block/index.js';
+import { type ValidatorHASignerConfig, ValidatorHASignerConfigSchema } from '../ha-signing/index.js';
 import { AllowedElementSchema } from './allowed_element.js';
 
 /**
@@ -51,17 +51,22 @@ export type ValidatorClientConfig = ValidatorHASignerConfig & {
   /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
   fishermanMode?: boolean;
 
-  // TODO(palla/mbps): Change default to false once checkpoint validation is stable
-  /** Skip checkpoint proposal validation and always attest (default: true) */
+  /** Skip checkpoint proposal validation and always attest (default: false) */
   skipCheckpointProposalValidation?: boolean;
 
   /** Skip pushing re-executed blocks to archiver (default: false) */
   skipPushProposedBlocksToArchiver?: boolean;
+
+  /** Agree to attest to equivocated checkpoint proposals (for testing purposes only) */
+  attestToEquivocatedProposals?: boolean;
 };
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
   Pick<SequencerConfig, 'txPublicSetupAllowList' | 'broadcastInvalidBlockProposal'> &
-  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'> & {
+  Pick<
+    SlasherConfig,
+    'slashBroadcastedInvalidBlockPenalty' | 'slashDuplicateProposalPenalty' | 'slashDuplicateAttestationPenalty'
+  > & {
     /**
      * Whether transactions are disabled for this node
      * @remarks This should match the property in P2PConfig. It's not picked from there to avoid circular dependencies.
@@ -80,6 +85,7 @@ export const ValidatorClientConfigSchema = zodFor<Omit<ValidatorClientConfig, 'v
     fishermanMode: z.boolean().optional(),
     skipCheckpointProposalValidation: z.boolean().optional(),
     skipPushProposedBlocksToArchiver: z.boolean().optional(),
+    attestToEquivocatedProposals: z.boolean().optional(),
   }),
 );
 
@@ -88,6 +94,8 @@ export const ValidatorClientFullConfigSchema = zodFor<Omit<ValidatorClientFullCo
     txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
     broadcastInvalidBlockProposal: z.boolean().optional(),
     slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+    slashDuplicateProposalPenalty: schemas.BigInt,
+    slashDuplicateAttestationPenalty: schemas.BigInt,
     disableTransactions: z.boolean().optional(),
   }),
 );
@@ -113,6 +121,7 @@ export interface Validator {
   createCheckpointProposal(
     checkpointHeader: CheckpointHeader,
     archive: Fr,
+    feeAssetPriceModifier: bigint,
     lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
     proposerAddress: EthAddress | undefined,
     options: CheckpointProposalOptions,

package/src/kernel/hints/build_note_hash_read_request_hints.ts

@@ -11,7 +11,6 @@ import type { ScopedNoteHash } from '../note_hash.js';
 import { NoteHashReadRequestHintsBuilder } from './note_hash_read_request_hints.js';
 import type { ScopedReadRequest } from './read_request.js';
 import { PendingReadHint, ReadRequestActionEnum, ReadRequestResetActions } from './read_request_hints.js';
-import { ScopedValueCache } from './scoped_value_cache.js';
 
 export function isValidNoteHashReadRequest(readRequest: ScopedReadRequest, noteHash: ScopedNoteHash) {
   return (
@@ -24,7 +23,6 @@ export function isValidNoteHashReadRequest(readRequest: ScopedReadRequest, noteH
 export function getNoteHashReadRequestResetActions(
   noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
   noteHashes: ClaimedLengthArray<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
-  futureNoteHashes: ScopedNoteHash[],
 ): ReadRequestResetActions<typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX> {
   const resetActions = ReadRequestResetActions.empty(MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
 
@@ -36,24 +34,23 @@ export function getNoteHashReadRequestResetActions(
     noteHashMap.set(value, arr);
   });
 
-  const futureNoteHashMap = new ScopedValueCache(futureNoteHashes);
-
   for (let i = 0; i < noteHashReadRequests.claimedLength; ++i) {
     const readRequest = noteHashReadRequests.array[i];
 
-    const pendingNoteHash = noteHashMap
-      .get(readRequest.value.toBigInt())
-      ?.find(n => isValidNoteHashReadRequest(readRequest, n.noteHash));
-
-    if (pendingNoteHash !== undefined) {
-      resetActions.actions[i] = ReadRequestActionEnum.READ_AS_PENDING;
-      resetActions.pendingReadHints.push(new PendingReadHint(i, pendingNoteHash.index));
-    } else if (
-      !futureNoteHashMap
-        .get(readRequest)
-        .find(futureNoteHash => isValidNoteHashReadRequest(readRequest, futureNoteHash))
-    ) {
+    if (readRequest.contractAddress.isZero()) {
+      // Settled read: empty contract address means resolve against the note hash tree.
       resetActions.actions[i] = ReadRequestActionEnum.READ_AS_SETTLED;
+    } else {
+      // Pending read: non-empty contract address means match against a pending note hash.
+      const pendingNoteHash = noteHashMap
+        .get(readRequest.value.toBigInt())
+        ?.find(n => isValidNoteHashReadRequest(readRequest, n.noteHash));
+
+      if (pendingNoteHash) {
+        resetActions.actions[i] = ReadRequestActionEnum.READ_AS_PENDING;
+        resetActions.pendingReadHints.push(new PendingReadHint(i, pendingNoteHash.index));
+      }
+      // Otherwise, the read request may be resolved by a future note hash. Leave as NOOP.
     }
   }
 
@@ -115,11 +112,10 @@ export async function buildNoteHashReadRequestHints<PENDING extends number, SETT
   },
   noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
   noteHashes: ClaimedLengthArray<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
-  futureNoteHashes: ScopedNoteHash[],
   maxPending: PENDING = MAX_NOTE_HASH_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NOTE_HASH_READ_REQUESTS_PER_TX as SETTLED,
 ) {
-  const resetActions = getNoteHashReadRequestResetActions(noteHashReadRequests, noteHashes, futureNoteHashes);
+  const resetActions = getNoteHashReadRequestResetActions(noteHashReadRequests, noteHashes);
   return await buildNoteHashReadRequestHintsFromResetActions(
     oracle,
     noteHashReadRequests,

package/src/kernel/hints/build_nullifier_read_request_hints.ts

@@ -12,7 +12,6 @@ import type { ScopedNullifier } from '../nullifier.js';
 import { NullifierReadRequestHintsBuilder } from './nullifier_read_request_hints.js';
 import { ScopedReadRequest } from './read_request.js';
 import { PendingReadHint, ReadRequestActionEnum, ReadRequestResetActions } from './read_request_hints.js';
-import { ScopedValueCache } from './scoped_value_cache.js';
 
 export function isValidNullifierReadRequest(readRequest: ScopedReadRequest, nullifier: ScopedNullifier) {
   return (
@@ -30,7 +29,6 @@ interface NullifierMembershipWitnessWithPreimage {
 export function getNullifierReadRequestResetActions(
   nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
   nullifiers: ClaimedLengthArray<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>,
-  futureNullifiers: ScopedNullifier[],
 ): ReadRequestResetActions<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX> {
   const resetActions = ReadRequestResetActions.empty(MAX_NULLIFIER_READ_REQUESTS_PER_TX);
 
@@ -42,23 +40,23 @@ export function getNullifierReadRequestResetActions(
     nullifierMap.set(value, arr);
   });
 
-  const futureNullifiersMap = new ScopedValueCache(futureNullifiers);
-
   for (let i = 0; i < nullifierReadRequests.claimedLength; ++i) {
     const readRequest = nullifierReadRequests.array[i];
-    const pendingNullifier = nullifierMap
-      .get(readRequest.value.toBigInt())
-      ?.find(({ nullifier }) => isValidNullifierReadRequest(readRequest, nullifier));
-
-    if (pendingNullifier !== undefined) {
-      resetActions.actions[i] = ReadRequestActionEnum.READ_AS_PENDING;
-      resetActions.pendingReadHints.push(new PendingReadHint(i, pendingNullifier.index));
-    } else if (
-      !futureNullifiersMap
-        .get(readRequest)
-        .some(futureNullifier => isValidNullifierReadRequest(readRequest, futureNullifier))
-    ) {
+
+    if (readRequest.contractAddress.isZero()) {
+      // Settled read: empty contract address means resolve against the nullifier tree.
       resetActions.actions[i] = ReadRequestActionEnum.READ_AS_SETTLED;
+    } else {
+      // Pending read: non-empty contract address means match against a pending nullifier.
+      const pendingNullifier = nullifierMap
+        .get(readRequest.value.toBigInt())
+        ?.find(({ nullifier }) => isValidNullifierReadRequest(readRequest, nullifier));
+
+      if (pendingNullifier) {
+        resetActions.actions[i] = ReadRequestActionEnum.READ_AS_PENDING;
+        resetActions.pendingReadHints.push(new PendingReadHint(i, pendingNullifier.index));
+      }
+      // Otherwise, the read request may be resolved by a future nullifier. Leave as NOOP.
     }
   }
 
@@ -111,11 +109,10 @@ export async function buildNullifierReadRequestHints<PENDING extends number, SET
   },
   nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
   nullifiers: ClaimedLengthArray<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>,
-  futureNullifiers: ScopedNullifier[],
   maxPending: PENDING = MAX_NULLIFIER_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NULLIFIER_READ_REQUESTS_PER_TX as SETTLED,
 ) {
-  const resetActions = getNullifierReadRequestResetActions(nullifierReadRequests, nullifiers, futureNullifiers);
+  const resetActions = getNullifierReadRequestResetActions(nullifierReadRequests, nullifiers);
   return await buildNullifierReadRequestHintsFromResetActions(
     oracle,
     nullifierReadRequests,

package/src/kernel/hints/build_transient_data_hints.ts

@@ -4,6 +4,7 @@ import type { Tuple } from '@aztec/foundation/serialize';
 import type { ClaimedLengthArray } from '../claimed_length_array.js';
 import type { ScopedNoteHash } from '../note_hash.js';
 import type { ScopedNullifier } from '../nullifier.js';
+import type { PrivateLogData, ScopedPrivateLogData } from '../private_log_data.js';
 import { isValidNoteHashReadRequest } from './build_note_hash_read_request_hints.js';
 import { isValidNullifierReadRequest } from './build_nullifier_read_request_hints.js';
 import type { ScopedReadRequest } from './read_request.js';
@@ -15,11 +16,13 @@ export function buildTransientDataHints<NOTE_HASHES_LEN extends number, NULLIFIE
   nullifiers: ClaimedLengthArray<ScopedNullifier, NULLIFIERS_LEN>,
   futureNoteHashReads: ScopedReadRequest[],
   futureNullifierReads: ScopedReadRequest[],
+  futureLogs: PrivateLogData[],
   noteHashNullifierCounterMap: Map<number, number>,
   splitCounter: number,
 ): { numTransientData: number; hints: Tuple<TransientDataSquashingHint, NULLIFIERS_LEN> } {
   const futureNoteHashReadsMap = new ScopedValueCache(futureNoteHashReads);
   const futureNullifierReadsMap = new ScopedValueCache(futureNullifierReads);
+  const futureLogNoteHashCounters = new Set(futureLogs.filter(l => l.noteHashCounter > 0).map(l => l.noteHashCounter));
 
   const nullifierIndexMap: Map<number, number> = new Map();
   nullifiers.getActiveItems().forEach((n, i) => nullifierIndexMap.set(n.counter, i));
@@ -28,10 +31,12 @@ export function buildTransientDataHints<NOTE_HASHES_LEN extends number, NULLIFIE
   for (let noteHashIndex = 0; noteHashIndex < noteHashes.claimedLength; noteHashIndex++) {
     const noteHash = noteHashes.array[noteHashIndex];
     const noteHashNullifierCounter = noteHashNullifierCounterMap.get(noteHash.counter);
-    // The note hash might not be linked to a nullifier or it might be read in the future
+    // The note hash might not be linked to a nullifier, or it might be read in the future, or a future log might be
+    // linked to it.
     if (
       !noteHashNullifierCounter ||
-      futureNoteHashReadsMap.get(noteHash).find(read => isValidNoteHashReadRequest(read, noteHash))
+      futureNoteHashReadsMap.get(noteHash).find(read => isValidNoteHashReadRequest(read, noteHash)) ||
+      futureLogNoteHashCounters.has(noteHash.counter)
     ) {
       continue;
     }
@@ -77,3 +82,13 @@ export function buildTransientDataHints<NOTE_HASHES_LEN extends number, NULLIFIE
     hints: padArrayEnd(hints, noActionHint, nullifiers.array.length as NULLIFIERS_LEN),
   };
 }
+
+/** Counts private logs that are linked to squashed note hashes and would be removed along with them. */
+export function countSquashedLogs<NOTE_HASHES_LEN extends number, LOGS_LEN extends number>(
+  noteHashes: ClaimedLengthArray<ScopedNoteHash, NOTE_HASHES_LEN>,
+  privateLogs: ClaimedLengthArray<ScopedPrivateLogData, LOGS_LEN>,
+  squashingHints: TransientDataSquashingHint[],
+): number {
+  const squashedNoteHashCounters = new Set(squashingHints.map(h => noteHashes.array[h.noteHashIndex].counter));
+  return privateLogs.getActiveItems().filter(l => squashedNoteHashCounters.has(l.inner.noteHashCounter)).length;
+}

package/src/kernel/hints/index.ts

@@ -6,10 +6,10 @@ export * from './note_hash_read_request_hints.js';
 export * from './nullifier_read_request_hints.js';
 export * from './read_request_hints.js';
 export * from './key_validation_hint.js';
-export * from './key_validation_request_and_generator.js';
+export * from './key_validation_request_and_separator.js';
 export * from './read_request.js';
 export * from './key_validation_request.js';
-export * from './scoped_key_validation_request_and_generator.js';
+export * from './scoped_key_validation_request_and_separator.js';
 export * from './transient_data_squashing_hint.js';
 export * from './private_kernel_reset_hints.js';
 export * from './tree_leaf_read_request.js';

package/src/kernel/hints/{key_validation_request_and_generator.ts → key_validation_request_and_separator.ts}

@@ -5,48 +5,45 @@ import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/
 import { KeyValidationRequest } from './key_validation_request.js';
 
 /**
- * Request for validating keys used in the app and a generator.
+ * Request for validating keys used in the app, along with a domain separator for the key type.
  */
-export class KeyValidationRequestAndGenerator {
+export class KeyValidationRequestAndSeparator {
   constructor(
     /** The key validation request. */
     public readonly request: KeyValidationRequest,
-    /**
-     * The generator index which can be used along with sk_m to derive the sk_app stored in the request.
-     * Note: This generator constrains that a correct key type gets validated in the kernel.
-     */
-    public readonly skAppGenerator: Fr,
+    /** Domain separator for the key type, used along with sk_m to derive the sk_app stored in the request. */
+    public readonly keyTypeDomainSeparator: Fr,
   ) {}
 
   toBuffer() {
-    return serializeToBuffer(this.request, this.skAppGenerator);
+    return serializeToBuffer(this.request, this.keyTypeDomainSeparator);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new KeyValidationRequestAndGenerator(reader.readObject(KeyValidationRequest), Fr.fromBuffer(reader));
+    return new KeyValidationRequestAndSeparator(reader.readObject(KeyValidationRequest), Fr.fromBuffer(reader));
   }
 
   toFields(): Fr[] {
-    const fields = [...this.request.toFields(), this.skAppGenerator];
+    const fields = [...this.request.toFields(), this.keyTypeDomainSeparator];
     if (fields.length !== KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH) {
       throw new Error(
-        `Invalid number of fields for KeyValidationRequestAndGenerator. Expected ${KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH}, got ${fields.length}`,
+        `Invalid number of fields for KeyValidationRequestAndSeparator. Expected ${KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH}, got ${fields.length}`,
       );
     }
     return fields;
   }
 
-  static fromFields(fields: Fr[] | FieldReader): KeyValidationRequestAndGenerator {
+  static fromFields(fields: Fr[] | FieldReader): KeyValidationRequestAndSeparator {
     const reader = FieldReader.asReader(fields);
-    return new KeyValidationRequestAndGenerator(KeyValidationRequest.fromFields(reader), reader.readField());
+    return new KeyValidationRequestAndSeparator(KeyValidationRequest.fromFields(reader), reader.readField());
   }
 
   isEmpty() {
-    return this.request.isEmpty() && this.skAppGenerator.isZero();
+    return this.request.isEmpty() && this.keyTypeDomainSeparator.isZero();
   }
 
   static empty() {
-    return new KeyValidationRequestAndGenerator(KeyValidationRequest.empty(), Fr.ZERO);
+    return new KeyValidationRequestAndSeparator(KeyValidationRequest.empty(), Fr.ZERO);
   }
 }

package/src/kernel/hints/{scoped_key_validation_request_and_generator.ts → scoped_key_validation_request_and_separator.ts}

@@ -3,14 +3,14 @@ import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { AztecAddress } from '../../aztec-address/index.js';
-import { KeyValidationRequestAndGenerator } from './key_validation_request_and_generator.js';
+import { KeyValidationRequestAndSeparator } from './key_validation_request_and_separator.js';
 
 /**
  * Request for validating keys used in the app.
  */
-export class ScopedKeyValidationRequestAndGenerator {
+export class ScopedKeyValidationRequestAndSeparator {
   constructor(
-    public readonly request: KeyValidationRequestAndGenerator,
+    public readonly request: KeyValidationRequestAndSeparator,
     public readonly contractAddress: AztecAddress,
   ) {}
 
@@ -20,8 +20,8 @@ export class ScopedKeyValidationRequestAndGenerator {
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new ScopedKeyValidationRequestAndGenerator(
-      KeyValidationRequestAndGenerator.fromBuffer(reader),
+    return new ScopedKeyValidationRequestAndSeparator(
+      KeyValidationRequestAndSeparator.fromBuffer(reader),
       AztecAddress.fromBuffer(reader),
     );
   }
@@ -30,16 +30,16 @@ export class ScopedKeyValidationRequestAndGenerator {
     const fields = [...this.request.toFields(), this.contractAddress.toField()];
     if (fields.length !== SCOPED_KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH) {
       throw new Error(
-        `Invalid number of fields for ScopedKeyValidationRequestAndGenerator. Expected ${SCOPED_KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH}, got ${fields.length}`,
+        `Invalid number of fields for ScopedKeyValidationRequestAndSeparator. Expected ${SCOPED_KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH}, got ${fields.length}`,
       );
     }
     return fields;
   }
 
-  static fromFields(fields: Fr[] | FieldReader): ScopedKeyValidationRequestAndGenerator {
+  static fromFields(fields: Fr[] | FieldReader): ScopedKeyValidationRequestAndSeparator {
     const reader = FieldReader.asReader(fields);
-    return new ScopedKeyValidationRequestAndGenerator(
-      KeyValidationRequestAndGenerator.fromFields(reader),
+    return new ScopedKeyValidationRequestAndSeparator(
+      KeyValidationRequestAndSeparator.fromFields(reader),
       AztecAddress.fromFields(reader),
     );
   }
@@ -49,6 +49,6 @@ export class ScopedKeyValidationRequestAndGenerator {
   }
 
   static empty() {
-    return new ScopedKeyValidationRequestAndGenerator(KeyValidationRequestAndGenerator.empty(), AztecAddress.ZERO);
+    return new ScopedKeyValidationRequestAndSeparator(KeyValidationRequestAndSeparator.empty(), AztecAddress.ZERO);
   }
 }

package/src/kernel/private_circuit_public_inputs.ts

@@ -21,7 +21,7 @@ import {
 } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { KeyValidationRequestAndGenerator } from '../kernel/hints/key_validation_request_and_generator.js';
+import { KeyValidationRequestAndSeparator } from '../kernel/hints/key_validation_request_and_separator.js';
 import { CountedLogHash } from '../kernel/log_hash.js';
 import { PrivateCallRequest } from '../kernel/private_call_request.js';
 import { PrivateLogData } from '../kernel/private_log_data.js';
@@ -80,7 +80,7 @@ export class PrivateCircuitPublicInputs {
     /**
      * The highest timestamp of a block in which the transaction can still be included.
      */
-    public includeByTimestamp: UInt64,
+    public expirationTimestamp: UInt64,
     /**
      * The side effect counter at the start of this call.
      */
@@ -106,10 +106,10 @@ export class PrivateCircuitPublicInputs {
      */
     public nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,
     /**
-     * Key validation requests and generators created by the corresponding function call.
+     * Key validation requests and separators created by the corresponding function call.
      */
-    public keyValidationRequestsAndGenerators: ClaimedLengthArray<
-      KeyValidationRequestAndGenerator,
+    public keyValidationRequestsAndSeparators: ClaimedLengthArray<
+      KeyValidationRequestAndSeparator,
       typeof MAX_KEY_VALIDATION_REQUESTS_PER_CALL
     >,
     /**
@@ -178,7 +178,7 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL)),
       reader.readObject(
-        ClaimedLengthArrayFromBuffer(KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
+        ClaimedLengthArrayFromBuffer(KeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
       ),
       reader.readObject(ClaimedLengthArrayFromBuffer(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL)),
@@ -209,7 +209,7 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(ClaimedLengthArrayFromFields(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL)),
       reader.readObject(
-        ClaimedLengthArrayFromFields(KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
+        ClaimedLengthArrayFromFields(KeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
       ),
       reader.readObject(ClaimedLengthArrayFromFields(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL)),
@@ -242,7 +242,7 @@ export class PrivateCircuitPublicInputs {
       Fr.ZERO,
       ClaimedLengthArray.empty(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL),
       ClaimedLengthArray.empty(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL),
-      ClaimedLengthArray.empty(KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
+      ClaimedLengthArray.empty(KeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
       ClaimedLengthArray.empty(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL),
       ClaimedLengthArray.empty(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL),
       PublicCallRequest.empty(),
@@ -263,14 +263,14 @@ export class PrivateCircuitPublicInputs {
       this.txContext.isEmpty() &&
       this.minRevertibleSideEffectCounter.isZero() &&
       !this.isFeePayer &&
-      !this.includeByTimestamp &&
+      !this.expirationTimestamp &&
       this.startSideEffectCounter.isZero() &&
       this.endSideEffectCounter.isZero() &&
       this.expectedNonRevertibleSideEffectCounter.isZero() &&
       this.expectedRevertibleSideEffectCounter.isZero() &&
       this.noteHashReadRequests.isEmpty() &&
       this.nullifierReadRequests.isEmpty() &&
-      this.keyValidationRequestsAndGenerators.isEmpty() &&
+      this.keyValidationRequestsAndSeparators.isEmpty() &&
       this.privateCallRequests.isEmpty() &&
       this.publicCallRequests.isEmpty() &&
       this.publicTeardownCallRequest.isEmpty() &&
@@ -296,14 +296,14 @@ export class PrivateCircuitPublicInputs {
       fields.txContext,
       fields.minRevertibleSideEffectCounter,
       fields.isFeePayer,
-      fields.includeByTimestamp,
+      fields.expirationTimestamp,
       fields.startSideEffectCounter,
       fields.endSideEffectCounter,
       fields.expectedNonRevertibleSideEffectCounter,
       fields.expectedRevertibleSideEffectCounter,
       fields.noteHashReadRequests,
       fields.nullifierReadRequests,
-      fields.keyValidationRequestsAndGenerators,
+      fields.keyValidationRequestsAndSeparators,
       fields.privateCallRequests,
       fields.publicCallRequests,
       fields.publicTeardownCallRequest,
@@ -330,14 +330,14 @@ export class PrivateCircuitPublicInputs {
       this.txContext,
       this.minRevertibleSideEffectCounter,
       this.isFeePayer,
-      bigintToUInt64BE(this.includeByTimestamp),
+      bigintToUInt64BE(this.expirationTimestamp),
       this.startSideEffectCounter,
       this.endSideEffectCounter,
       this.expectedNonRevertibleSideEffectCounter,
       this.expectedRevertibleSideEffectCounter,
       this.noteHashReadRequests,
       this.nullifierReadRequests,
-      this.keyValidationRequestsAndGenerators,
+      this.keyValidationRequestsAndSeparators,
       this.privateCallRequests,
       this.publicCallRequests,
       this.publicTeardownCallRequest,

package/src/kernel/private_kernel_circuit_public_inputs.ts

@@ -41,7 +41,7 @@ export class PrivateKernelCircuitPublicInputs {
     /**
      * The timestamp by which the transaction must be included in a block.
      */
-    public includeByTimestamp: UInt64,
+    public expirationTimestamp: UInt64,
     /**
      * Wether this is a private only tx or not
      */
@@ -72,7 +72,7 @@ export class PrivateKernelCircuitPublicInputs {
       this.end,
       this.publicTeardownCallRequest,
       this.feePayer,
-      bigintToUInt64BE(this.includeByTimestamp),
+      bigintToUInt64BE(this.expirationTimestamp),
       this.isPrivateOnly,
       this.claimedFirstNullifier,
       this.claimedRevertibleCounter,

package/src/kernel/private_kernel_tail_circuit_private_inputs.ts

@@ -20,7 +20,7 @@ export class PrivateKernelTailCircuitPrivateInputs {
     /**
      * The timestamp by which the transaction must be included in a block.
      */
-    public includeByTimestampUpperBound: UInt64,
+    public expirationTimestampUpperBound: UInt64,
   ) {}
 
   isForPublic() {
@@ -38,7 +38,7 @@ export class PrivateKernelTailCircuitPrivateInputs {
     return serializeToBuffer(
       this.previousKernel,
       this.paddedSideEffectAmounts,
-      bigintToUInt64BE(this.includeByTimestampUpperBound),
+      bigintToUInt64BE(this.expirationTimestampUpperBound),
     );
   }
 

package/src/kernel/private_kernel_tail_circuit_public_inputs.ts

@@ -116,7 +116,7 @@ export class PrivateKernelTailCircuitPublicInputs {
     /**
      * The timestamp by which the transaction must be included in a block.
      */
-    public includeByTimestamp: UInt64,
+    public expirationTimestamp: UInt64,
 
     public forPublic?: PartialPrivateTailPublicInputsForPublic,
     public forRollup?: PartialPrivateTailPublicInputsForRollup,
@@ -146,7 +146,7 @@ export class PrivateKernelTailCircuitPublicInputs {
       this.constants.getSize() +
       this.gasUsed.getSize() +
       this.feePayer.size +
-      8 // includeByTimestamp
+      8 // expirationTimestamp
     );
   }
 
@@ -161,7 +161,7 @@ export class PrivateKernelTailCircuitPublicInputs {
       this.forPublic.publicTeardownCallRequest,
       this.gasUsed,
       this.feePayer,
-      this.includeByTimestamp,
+      this.expirationTimestamp,
     );
   }
 
@@ -180,7 +180,7 @@ export class PrivateKernelTailCircuitPublicInputs {
       this.forRollup.end,
       this.gasUsed,
       this.feePayer,
-      this.includeByTimestamp,
+      this.expirationTimestamp,
     );
   }
 
@@ -298,7 +298,7 @@ export class PrivateKernelTailCircuitPublicInputs {
       this.constants,
       this.gasUsed,
       this.feePayer,
-      bigintToUInt64BE(this.includeByTimestamp),
+      bigintToUInt64BE(this.expirationTimestamp),
       isForPublic ? this.forPublic!.toBuffer() : this.forRollup!.toBuffer(),
     );
   }

package/src/kernel/private_to_public_kernel_circuit_public_inputs.ts

@@ -1,4 +1,4 @@
-import { GeneratorIndex, PRIVATE_TO_PUBLIC_KERNEL_CIRCUIT_PUBLIC_INPUTS_LENGTH } from '@aztec/constants';
+import { DomainSeparator, PRIVATE_TO_PUBLIC_KERNEL_CIRCUIT_PUBLIC_INPUTS_LENGTH } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
@@ -21,7 +21,7 @@ export class PrivateToPublicKernelCircuitPublicInputs {
     public publicTeardownCallRequest: PublicCallRequest,
     public gasUsed: Gas,
     public feePayer: AztecAddress,
-    public includeByTimestamp: UInt64,
+    public expirationTimestamp: UInt64,
   ) {}
 
   toBuffer() {
@@ -32,7 +32,7 @@ export class PrivateToPublicKernelCircuitPublicInputs {
       this.publicTeardownCallRequest,
       this.gasUsed,
       this.feePayer,
-      bigintToUInt64BE(this.includeByTimestamp),
+      bigintToUInt64BE(this.expirationTimestamp),
     );
   }
 
@@ -44,7 +44,7 @@ export class PrivateToPublicKernelCircuitPublicInputs {
       fields.publicTeardownCallRequest,
       fields.gasUsed,
       fields.feePayer,
-      fields.includeByTimestamp,
+      fields.expirationTimestamp,
     ] as const;
   }
 
@@ -92,7 +92,7 @@ export class PrivateToPublicKernelCircuitPublicInputs {
   }
 
   hash() {
-    return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.PUBLIC_TX_HASH);
+    return poseidon2HashWithSeparator(this.toFields(), DomainSeparator.PUBLIC_TX_HASH);
   }
 
   toJSON() {