@aztec/stdlib 0.0.1-commit.e2b2873ed → 0.0.1-commit.e304674f1

package/src/interfaces/configs.ts

@@ -13,6 +13,8 @@ export interface SequencerConfig {
   sequencerPollingIntervalMS?: number;
   /** The maximum number of txs to include in a block. */
   maxTxsPerBlock?: number;
+  /** The maximum number of txs across all blocks in a checkpoint. */
+  maxTxsPerCheckpoint?: number;
   /** The minimum number of txs to include in a block. */
   minTxsPerBlock?: number;
   /** The minimum number of valid txs (after execution) to include in a block. If not set, falls back to minTxsPerBlock. */
@@ -23,6 +25,10 @@ export interface SequencerConfig {
   maxL2BlockGas?: number;
   /** The maximum DA block gas. */
   maxDABlockGas?: number;
+  /** Per-block gas budget multiplier for both L2 and DA gas. Budget = (checkpointLimit / maxBlocks) * multiplier. */
+  perBlockAllocationMultiplier?: number;
+  /** Redistribute remaining checkpoint budget evenly across remaining blocks instead of allowing a single block to consume the entire remaining budget. */
+  redistributeCheckpointBudget?: boolean;
   /** Recipient of block reward. */
   coinbase?: EthAddress;
   /** Address to receive fees. */
@@ -31,10 +37,8 @@ export interface SequencerConfig {
   acvmWorkingDirectory?: string;
   /** The path to the ACVM binary */
   acvmBinaryPath?: string;
-  /** The list of functions calls allowed to run in setup */
-  txPublicSetupAllowList?: AllowedElement[];
-  /** Max block size */
-  maxBlockSizeInBytes?: number;
+  /** Additional entries to extend the default setup allow list. */
+  txPublicSetupAllowListExtend?: AllowedElement[];
   /** Payload address to vote for */
   governanceProposerPayload?: EthAddress;
   /** Whether to enforce the time table when building blocks */
@@ -59,33 +63,45 @@ export interface SequencerConfig {
   broadcastInvalidBlockProposal?: boolean;
   /** Inject a fake attestation (for testing only) */
   injectFakeAttestation?: boolean;
+  /** Inject a malleable attestation with a high-s value (for testing only) */
+  injectHighSValueAttestation?: boolean;
+  /** Inject an attestation with an unrecoverable signature (for testing only) */
+  injectUnrecoverableSignatureAttestation?: boolean;
   /** Whether to run in fisherman mode: builds blocks on every slot for validation without publishing */
   fishermanMode?: boolean;
   /** Shuffle attestation ordering to create invalid ordering (for testing only) */
   shuffleAttestationOrdering?: boolean;
   /** Duration per block in milliseconds when building multiple blocks per slot (default: undefined = single block per slot) */
   blockDurationMs?: number;
+  /** Expected number of block proposals per slot for P2P peer scoring. 0 disables scoring, undefined falls back to blocksPerSlot - 1. */
+  expectedBlockProposalsPerSlot?: number;
   /** Have sequencer build and publish an empty checkpoint if there are no txs */
   buildCheckpointIfEmpty?: boolean;
   /** Skip pushing proposed blocks to archiver (default: false) */
   skipPushProposedBlocksToArchiver?: boolean;
+  /** Minimum number of blocks required for a checkpoint proposal (test only, defaults to undefined = no minimum) */
+  minBlocksForCheckpoint?: number;
+  /** Skip publishing checkpoint proposals probability (for testing checkpoint prunes only) */
+  skipPublishingCheckpointsPercent?: number;
 }
 
 export const SequencerConfigSchema = zodFor<SequencerConfig>()(
   z.object({
     sequencerPollingIntervalMS: z.number().optional(),
     maxTxsPerBlock: z.number().optional(),
+    maxTxsPerCheckpoint: z.number().optional(),
     minValidTxsPerBlock: z.number().optional(),
     minTxsPerBlock: z.number().optional(),
     maxL2BlockGas: z.number().optional(),
     publishTxsWithProposals: z.boolean().optional(),
     maxDABlockGas: z.number().optional(),
+    perBlockAllocationMultiplier: z.number().optional(),
+    redistributeCheckpointBudget: z.boolean().optional(),
     coinbase: schemas.EthAddress.optional(),
     feeRecipient: schemas.AztecAddress.optional(),
     acvmWorkingDirectory: z.string().optional(),
     acvmBinaryPath: z.string().optional(),
-    txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
-    maxBlockSizeInBytes: z.number().optional(),
+    txPublicSetupAllowListExtend: z.array(AllowedElementSchema).optional(),
     governanceProposerPayload: schemas.EthAddress.optional(),
     l1PublishingTime: z.number().optional(),
     enforceTimeTable: z.boolean().optional(),
@@ -98,17 +114,23 @@ export const SequencerConfigSchema = zodFor<SequencerConfig>()(
     secondsBeforeInvalidatingBlockAsNonCommitteeMember: z.number(),
     broadcastInvalidBlockProposal: z.boolean().optional(),
     injectFakeAttestation: z.boolean().optional(),
+    injectHighSValueAttestation: z.boolean().optional(),
+    injectUnrecoverableSignatureAttestation: z.boolean().optional(),
     fishermanMode: z.boolean().optional(),
     shuffleAttestationOrdering: z.boolean().optional(),
     blockDurationMs: z.number().positive().optional(),
+    expectedBlockProposalsPerSlot: z.number().nonnegative().optional(),
     buildCheckpointIfEmpty: z.boolean().optional(),
     skipPushProposedBlocksToArchiver: z.boolean().optional(),
+    minBlocksForCheckpoint: z.number().positive().optional(),
+    skipPublishingCheckpointsPercent: z.number().gte(0).lte(100).optional(),
   }),
 );
 
 type SequencerConfigOptionalKeys =
   | 'governanceProposerPayload'
   | 'blockDurationMs'
+  | 'expectedBlockProposalsPerSlot'
   | 'coinbase'
   | 'feeRecipient'
   | 'acvmWorkingDirectory'
@@ -116,8 +138,14 @@ type SequencerConfigOptionalKeys =
   | 'fakeProcessingDelayPerTxMs'
   | 'fakeThrowAfterProcessingTxCount'
   | 'l1PublishingTime'
-  | 'txPublicSetupAllowList'
-  | 'minValidTxsPerBlock';
+  | 'txPublicSetupAllowListExtend'
+  | 'minValidTxsPerBlock'
+  | 'minBlocksForCheckpoint'
+  | 'maxTxsPerBlock'
+  | 'maxTxsPerCheckpoint'
+  | 'maxL2BlockGas'
+  | 'maxDABlockGas'
+  | 'redistributeCheckpointBudget';
 
 export type ResolvedSequencerConfig = Prettify<
   Required<Omit<SequencerConfig, SequencerConfigOptionalKeys>> & Pick<SequencerConfig, SequencerConfigOptionalKeys>

package/src/interfaces/l2_logs_source.ts

@@ -16,10 +16,11 @@ export interface L2LogsSource {
    * array implies no logs match that tag.
    * @param tags - The tags to search for.
    * @param page - The page number (0-indexed) for pagination.
+   * @param upToBlockNumber - If set, only return logs from blocks up to and including this block number.
    * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
    * for a tag, the caller should fetch the next page to check for more logs.
    */
-  getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]>;
+  getPrivateLogsByTags(tags: SiloedTag[], page?: number, upToBlockNumber?: BlockNumber): Promise<TxScopedL2Log[][]>;
 
   /**
    * Gets public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
@@ -27,6 +28,7 @@ export interface L2LogsSource {
    * @param contractAddress - The contract address to search logs for.
    * @param tags - The tags to search for.
    * @param page - The page number (0-indexed) for pagination.
+   * @param upToBlockNumber - If set, only return logs from blocks up to and including this block number.
    * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
    * for a tag, the caller should fetch the next page to check for more logs.
    */
@@ -34,6 +36,7 @@ export interface L2LogsSource {
     contractAddress: AztecAddress,
     tags: Tag[],
     page?: number,
+    upToBlockNumber?: BlockNumber,
   ): Promise<TxScopedL2Log[][]>;
 
   /**

package/src/interfaces/merkle_tree_operations.ts

@@ -225,36 +225,26 @@ export interface MerkleTreeReadOperations {
 }
 
 export interface MerkleTreeCheckpointOperations {
-  /**
-   * Checkpoints the current fork state
-   */
-  createCheckpoint(): Promise<void>;
+  /** Checkpoints the current fork state. Returns the depth of the new checkpoint. */
+  createCheckpoint(): Promise<number>;
 
-  /**
-   * Commits the current checkpoint
-   */
+  /** Commits the current checkpoint. */
   commitCheckpoint(): Promise<void>;
 
-  /**
-   * Reverts the current checkpoint
-   */
+  /** Reverts the current checkpoint. */
   revertCheckpoint(): Promise<void>;
 
-  /**
-   * Commits all checkpoints
-   */
-  commitAllCheckpoints(): Promise<void>;
+  /** Commits all checkpoints above the given depth, leaving checkpoint depth at the given value. */
+  commitAllCheckpointsTo(depth: number): Promise<void>;
 
-  /**
-   * Reverts all checkpoints
-   */
-  revertAllCheckpoints(): Promise<void>;
+  /** Reverts all checkpoints above the given depth, leaving checkpoint depth at the given value. */
+  revertAllCheckpointsTo(depth: number): Promise<void>;
 }
 
 export interface MerkleTreeWriteOperations
   extends MerkleTreeReadOperations,
     MerkleTreeCheckpointOperations,
-    Disposable {
+    AsyncDisposable {
   /**
    * Appends leaves to a given tree.
    * @param treeId - The tree to be updated.

package/src/interfaces/p2p.ts

@@ -3,7 +3,6 @@ import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { z } from 'zod';
 
 import { CheckpointAttestation } from '../p2p/checkpoint_attestation.js';
-import type { P2PClientType } from '../p2p/client_type.js';
 import { type ApiSchemaFor, optional, schemas } from '../schemas/index.js';
 import { Tx } from '../tx/tx.js';
 import { TxHash } from '../tx/tx_hash.js';
@@ -27,7 +26,7 @@ const PeerInfoSchema = z.discriminatedUnion('status', [
 ]);
 
 /** Exposed API to the P2P module. */
-export interface P2PApiWithoutAttestations {
+export interface P2PApi {
   /**
    * Returns all pending transactions in the transaction pool.
    * @param limit - The number of items to returns
@@ -48,9 +47,7 @@ export interface P2PApiWithoutAttestations {
    * Returns info for all connected, dialing, and cached peers.
    */
   getPeers(includePending?: boolean): Promise<PeerInfo[]>;
-}
 
-export interface P2PApiWithAttestations extends P2PApiWithoutAttestations {
   /**
    * Queries the Attestation pool for checkpoint attestations for the given slot
    *
@@ -61,19 +58,11 @@ export interface P2PApiWithAttestations extends P2PApiWithoutAttestations {
   getCheckpointAttestationsForSlot(slot: SlotNumber, proposalId?: string): Promise<CheckpointAttestation[]>;
 }
 
-export interface P2PClient extends P2PApiWithAttestations {
+export interface P2PClient extends P2PApi {
   /** Manually adds checkpoint attestations to the p2p client attestation pool. */
   addOwnCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void>;
 }
 
-export type P2PApi<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
-  ? P2PApiWithAttestations
-  : P2PApiWithoutAttestations;
-
-export type P2PApiFull<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
-  ? P2PApiWithAttestations & P2PClient
-  : P2PApiWithoutAttestations;
-
 export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
   getCheckpointAttestationsForSlot: z
     .function()

package/src/interfaces/prover-client.ts

@@ -23,6 +23,8 @@ export type ActualProverConfig = {
    * When true, jobs are explicitly cancelled with the broker, which prevents reuse.
    */
   cancelJobsOnStop: boolean;
+  /** Max concurrent jobs the orchestrator serializes and enqueues to the broker. */
+  enqueueConcurrency: number;
 };
 
 /**
@@ -53,6 +55,7 @@ export const ProverConfigSchema = zodFor<ProverConfig>()(
     proofStore: z.string().optional(),
     failedProofStore: z.string().optional(),
     cancelJobsOnStop: z.boolean(),
+    enqueueConcurrency: z.number(),
   }),
 );
 
@@ -107,6 +110,11 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
       'When true, jobs are explicitly cancelled with the broker, which prevents reuse.',
     ...booleanConfigHelper(false),
   },
+  enqueueConcurrency: {
+    env: 'PROVER_ENQUEUE_CONCURRENCY',
+    description: 'Max concurrent jobs the orchestrator serializes and enqueues to the broker.',
+    ...numberConfigHelper(50),
+  },
 };
 
 function parseProverId(str?: string) {

package/src/interfaces/slasher.ts

@@ -3,12 +3,8 @@ import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
-export type SlasherClientType = 'empire' | 'tally';
-
 export interface SlasherConfig {
   slashOverridePayload?: EthAddress;
-  slashMinPenaltyPercentage: number;
-  slashMaxPenaltyPercentage: number;
   slashSelfAllowed?: boolean; // Whether to allow slashes to own validators
   slashValidatorsAlways: EthAddress[]; // Array of validator addresses
   slashValidatorsNever: EthAddress[]; // Array of validator addresses
@@ -32,8 +28,6 @@ export interface SlasherConfig {
 export const SlasherConfigSchema = zodFor<SlasherConfig>()(
   z.object({
     slashOverridePayload: schemas.EthAddress.optional(),
-    slashMinPenaltyPercentage: z.number(),
-    slashMaxPenaltyPercentage: z.number(),
     slashValidatorsAlways: z.array(schemas.EthAddress),
     slashValidatorsNever: z.array(schemas.EthAddress),
     slashPrunePenalty: schemas.BigInt,

package/src/interfaces/validator.ts

@@ -9,60 +9,74 @@ import type {
   BlockProposal,
   BlockProposalOptions,
   CheckpointAttestation,
-  CheckpointLastBlockData,
   CheckpointProposal,
   CheckpointProposalOptions,
 } 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 LocalSignerConfig,
+  LocalSignerConfigSchema,
+  type ValidatorHASignerConfig,
+  ValidatorHASignerConfigSchema,
+} from '../ha-signing/index.js';
 import { AllowedElementSchema } from './allowed_element.js';
 
 /**
  * Validator client configuration
  */
-export type ValidatorClientConfig = ValidatorHASignerConfig & {
-  /** The private keys of the validators participating in attestation duties */
-  validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
+export type ValidatorClientConfig = ValidatorHASignerConfig &
+  LocalSignerConfig & {
+    /** The private keys of the validators participating in attestation duties */
+    validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
 
-  /** The addresses of the validators to use with remote signers */
-  validatorAddresses?: EthAddress[];
+    /** The addresses of the validators to use with remote signers */
+    validatorAddresses?: EthAddress[];
 
-  /** Do not run the validator */
-  disableValidator: boolean;
+    /** Do not run the validator */
+    disableValidator: boolean;
 
-  /** Temporarily disable these specific validator addresses */
-  disabledValidators: EthAddress[];
+    /** Temporarily disable these specific validator addresses */
+    disabledValidators: EthAddress[];
 
-  /** Interval between polling for new attestations from peers */
-  attestationPollingIntervalMs: number;
+    /** Interval between polling for new attestations from peers */
+    attestationPollingIntervalMs: number;
 
-  /** Whether to re-execute transactions in a block proposal before attesting */
-  validatorReexecute: boolean;
+    /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the current committee */
+    alwaysReexecuteBlockProposals?: boolean;
 
-  /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the currnet committee */
-  alwaysReexecuteBlockProposals?: boolean;
+    /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
+    fishermanMode?: boolean;
 
-  /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
-  fishermanMode?: boolean;
+    /** Skip checkpoint proposal validation and always attest (default: false) */
+    skipCheckpointProposalValidation?: boolean;
 
-  /** Skip checkpoint proposal validation and always attest (default: false) */
-  skipCheckpointProposalValidation?: boolean;
+    /** Skip pushing re-executed blocks to archiver (default: false) */
+    skipPushProposedBlocksToArchiver?: 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;
 
-  /** Agree to attest to equivocated checkpoint proposals (for testing purposes only) */
-  attestToEquivocatedProposals?: boolean;
-};
+    /** Maximum L2 gas per block for validation. Proposals exceeding this limit are rejected. */
+    validateMaxL2BlockGas?: number;
+
+    /** Maximum DA gas per block for validation. Proposals exceeding this limit are rejected. */
+    validateMaxDABlockGas?: number;
+
+    /** Maximum transactions per block for validation. Proposals exceeding this limit are rejected. */
+    validateMaxTxsPerBlock?: number;
+
+    /** Maximum transactions per checkpoint for validation. Proposals exceeding this limit are rejected. */
+    validateMaxTxsPerCheckpoint?: number;
+  };
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
-  Pick<SequencerConfig, 'txPublicSetupAllowList' | 'broadcastInvalidBlockProposal'> &
+  Pick<SequencerConfig, 'txPublicSetupAllowListExtend' | 'broadcastInvalidBlockProposal'> &
   Pick<
     SlasherConfig,
     'slashBroadcastedInvalidBlockPenalty' | 'slashDuplicateProposalPenalty' | 'slashDuplicateAttestationPenalty'
@@ -75,23 +89,26 @@ export type ValidatorClientFullConfig = ValidatorClientConfig &
   };
 
 export const ValidatorClientConfigSchema = zodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>()(
-  ValidatorHASignerConfigSchema.extend({
+  ValidatorHASignerConfigSchema.merge(LocalSignerConfigSchema).extend({
     validatorAddresses: z.array(schemas.EthAddress).optional(),
     disableValidator: z.boolean(),
     disabledValidators: z.array(schemas.EthAddress),
     attestationPollingIntervalMs: z.number().min(0),
-    validatorReexecute: z.boolean(),
     alwaysReexecuteBlockProposals: z.boolean().optional(),
     fishermanMode: z.boolean().optional(),
     skipCheckpointProposalValidation: z.boolean().optional(),
     skipPushProposedBlocksToArchiver: z.boolean().optional(),
     attestToEquivocatedProposals: z.boolean().optional(),
+    validateMaxL2BlockGas: z.number().optional(),
+    validateMaxDABlockGas: z.number().optional(),
+    validateMaxTxsPerBlock: z.number().optional(),
+    validateMaxTxsPerCheckpoint: z.number().optional(),
   }),
 );
 
 export const ValidatorClientFullConfigSchema = zodFor<Omit<ValidatorClientFullConfig, 'validatorPrivateKeys'>>()(
   ValidatorClientConfigSchema.extend({
-    txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
+    txPublicSetupAllowListExtend: z.array(AllowedElementSchema).optional(),
     broadcastInvalidBlockProposal: z.boolean().optional(),
     slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
     slashDuplicateProposalPenalty: schemas.BigInt,
@@ -100,8 +117,6 @@ export const ValidatorClientFullConfigSchema = zodFor<Omit<ValidatorClientFullCo
   }),
 );
 
-export type CreateCheckpointProposalLastBlockData = Omit<CheckpointLastBlockData, 'txHashes'> & { txs: Tx[] };
-
 export interface Validator {
   start(): Promise<void>;
   updateConfig(config: Partial<ValidatorClientFullConfig>): void;
@@ -121,7 +136,8 @@ export interface Validator {
   createCheckpointProposal(
     checkpointHeader: CheckpointHeader,
     archive: Fr,
-    lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
+    feeAssetPriceModifier: bigint,
+    lastBlockProposal: BlockProposal | undefined,
     proposerAddress: EthAddress | undefined,
     options: CheckpointProposalOptions,
   ): Promise<CheckpointProposal>;

package/src/interfaces/world_state.ts

@@ -3,6 +3,7 @@ import type { PromiseWithResolvers } from '@aztec/foundation/promise';
 
 import { z } from 'zod';
 
+import type { BlockHash } from '../block/block_hash.js';
 import type { SnapshotDataKeys } from '../snapshots/types.js';
 import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from './merkle_tree_operations.js';
 
@@ -80,12 +81,12 @@ export interface WorldStateSynchronizer extends ReadonlyWorldStateAccess, ForkMe
   resumeSync(): void;
 
   /**
-   * Forces an immediate sync to an optionally provided minimum block number
+   * Forces an immediate sync to an optionally provided minimum block number.
    * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
-   * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
+   * @param blockHash - If provided, verifies the block at targetBlockNumber matches this hash. On mismatch, triggers a resync (reorg detection).
    * @returns A promise that resolves with the block number the world state was synced to
    */
-  syncImmediate(minBlockNumber?: BlockNumber, skipThrowIfTargetNotReached?: boolean): Promise<BlockNumber>;
+  syncImmediate(minBlockNumber?: BlockNumber, blockHash?: BlockHash): Promise<BlockNumber>;
 
   /** Deletes the db */
   clear(): Promise<void>;

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;
+}