@aztec/stdlib 5.0.0-rc.2 → 5.0.1

package/src/ha-signing/local_config.ts

@@ -1,4 +1,9 @@
-import { type ConfigMappingsType, getConfigFromMappings, optionalNumberConfigHelper } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  optionalNumberConfigHelper,
+} from '@aztec/foundation/config';
 import { zodFor } from '@aztec/foundation/schemas';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
 
@@ -17,6 +22,12 @@ export type LocalSignerConfig = BaseSignerConfig &
   DataStoreConfig & {
     /** Maximum size of the local signing-protection LMDB store in KB. Overwrites the general dataStoreMapSizeKb. */
     signingProtectionMapSizeKb?: number;
+    /**
+     * Allow local signing protection to run against an ephemeral store when no data directory is set.
+     * Without this, a missing data directory fails startup, since ephemeral protection does not survive
+     * restarts. Intended for dev/test networks only; production validators must persist to disk.
+     */
+    allowEphemeralSigningProtection?: boolean;
   };
 
 export const localSignerConfigMappings: ConfigMappingsType<LocalSignerConfig> = {
@@ -28,6 +39,13 @@ export const localSignerConfigMappings: ConfigMappingsType<LocalSignerConfig> =
       'Maximum size of the local signing-protection LMDB store in KB. Overwrites the general dataStoreMapSizeKb.',
     ...optionalNumberConfigHelper(),
   },
+  allowEphemeralSigningProtection: {
+    env: 'VALIDATOR_ALLOW_EPHEMERAL_SIGNING_PROTECTION',
+    description:
+      'Allow local signing protection to run against an ephemeral store when no data directory is set (dev/test only). ' +
+      'Ephemeral protection does not survive restarts, so this is unsafe for production validators.',
+    ...booleanConfigHelper(false),
+  },
 };
 
 export const LocalSignerConfigSchema = zodFor<LocalSignerConfig>()(
@@ -35,6 +53,7 @@ export const LocalSignerConfigSchema = zodFor<LocalSignerConfig>()(
     dataDirectory: z.string().optional(),
     dataStoreMapSizeKb: z.number(),
     signingProtectionMapSizeKb: z.number().optional(),
+    allowEphemeralSigningProtection: z.boolean().optional(),
   }),
 );
 

package/src/hash/hash.ts

@@ -188,14 +188,6 @@ export function computeSecretHash(secret: Fr): Promise<Fr> {
   return poseidon2HashWithSeparator([secret], DomainSeparator.SECRET_HASH);
 }
 
-export async function computeL1ToL2MessageNullifier(contract: AztecAddress, messageHash: Fr, secret: Fr) {
-  const innerMessageNullifier = await poseidon2HashWithSeparator(
-    [messageHash, secret],
-    DomainSeparator.MESSAGE_NULLIFIER,
-  );
-  return siloNullifier(contract, innerMessageNullifier);
-}
-
 /**
  * Calculates a siloed hash of a scoped l2 to l1 message.
  * @returns Fr containing 248 bits of information of sha256 hash.

package/src/interfaces/archiver.ts

@@ -68,6 +68,13 @@ export type ArchiverSpecificConfig = {
 
   /** Skip pruning orphan proposed blocks that have no matching proposed checkpoint. */
   skipOrphanProposedBlockPruning?: boolean;
+
+  /**
+   * Preload the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) into the contract store at block 0.
+   * For test environments only: it must only be set when genesis also seeds the matching registration/deployment
+   * nullifiers, otherwise a later on-chain publish of a preloaded class would collide with the block-0 preload.
+   */
+  testPreloadStandardContracts?: boolean;
 };
 
 export const ArchiverSpecificConfigSchema = z.object({
@@ -82,6 +89,7 @@ export const ArchiverSpecificConfigSchema = z.object({
   skipPromoteProposedCheckpointDuringL1Sync: z.boolean().optional(),
   orphanPruneNoProposalTolerance: schemas.Integer.optional(),
   skipOrphanProposedBlockPruning: z.boolean().optional(),
+  testPreloadStandardContracts: z.boolean().optional(),
 });
 
 export type ArchiverApi = Omit<

package/src/interfaces/configs.ts

@@ -96,6 +96,8 @@ export interface SequencerConfig {
   injectHighSValueAttestation?: boolean;
   /** Inject an attestation with an unrecoverable signature (for testing only) */
   injectUnrecoverableSignatureAttestation?: boolean;
+  /** Inject a non-proposer attestation slot in yParity (v ∈ {0, 1}) form in the packed L1 tuple (for testing only) */
+  injectYParityAttestation?: 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) */
@@ -165,6 +167,7 @@ export const SequencerConfigSchema = zodFor<SequencerConfig>()(
     injectFakeAttestation: z.boolean().optional(),
     injectHighSValueAttestation: z.boolean().optional(),
     injectUnrecoverableSignatureAttestation: z.boolean().optional(),
+    injectYParityAttestation: z.boolean().optional(),
     fishermanMode: z.boolean().optional(),
     shuffleAttestationOrdering: z.boolean().optional(),
     blockDurationMs: z.number().positive().optional(),

package/src/interfaces/private_kernel_prover.ts

@@ -10,8 +10,8 @@ import type {
   PrivateKernelInner3CircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
   PrivateKernelResetCircuitPrivateInputs,
+  PrivateKernelResetTailCircuitPrivateInputs,
   PrivateKernelSimulateOutput,
-  PrivateKernelTailCircuitPrivateInputs,
   PrivateKernelTailCircuitPublicInputs,
 } from '../kernel/index.js';
 import type { ChonkProofWithPublicInputs } from '../proofs/chonk_proof.js';
@@ -166,23 +166,21 @@ export interface PrivateKernelProver {
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
 
   /**
-   * Creates a proof output based on the last inner kernel iteration kernel data for the final ordering iteration.
+   * Creates a proof output for the terminal reset+tail step. Dispatches to the rollup-bound or
+   * public-bound family based on `inputs.isForPublic()`.
    *
-   * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
-   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   * @param privateKernelInputs - Reset hints, dimensions, and tail params.
+   * @returns A Promise resolving to a ProofOutput containing the tail-shaped public inputs.
    */
-  generateTailOutput(
-    privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
+  generateResetTailOutput(
+    privateKernelInputs: PrivateKernelResetTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
 
   /**
-   * Executes the final ordering iteration circuit.
-   *
-   * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
-   * @returns A Promise resolving to a ProofOutput object containing public inputs an empty kernel proof.
+   * Simulates the terminal reset+tail step without generating a proof.
    */
-  simulateTail(
-    privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
+  simulateResetTail(
+    privateKernelInputs: PrivateKernelResetTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
 
   generateHidingToRollupOutput(

package/src/interfaces/proving-job.ts

@@ -1,5 +1,5 @@
 import {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -204,7 +204,7 @@ export type ProvingJobInputsMap = {
 export const ProvingJobResult = z.discriminatedUnion('type', [
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_VM),
-    result: RecursiveProof.schemaFor(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
+    result: RecursiveProof.schemaFor(AVM_V2_PROOF_LENGTH_IN_FIELDS),
   }),
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_CHONK_VERIFIER),
@@ -319,7 +319,7 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
 ]);
 export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
 export type ProvingJobResultsMap = {
-  [ProvingRequestType.PUBLIC_VM]: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
+  [ProvingRequestType.PUBLIC_VM]: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>;
   [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: PublicInputsAndRecursiveProof<
     PublicChonkVerifierPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
@@ -441,9 +441,20 @@ export const ProvingJobRejectedResult = z.object({
 });
 export type ProvingJobRejectedResult = z.infer<typeof ProvingJobRejectedResult>;
 
+/**
+ * The result of a job that was cancelled by its producer. Unlike a fulfilled or rejected result it
+ * is not truly terminal: re-enqueuing the same job id revives it, so an abort never permanently
+ * blocks a proof from being produced.
+ */
+export const ProvingJobAbortedResult = z.object({
+  status: z.literal('aborted'),
+});
+export type ProvingJobAbortedResult = z.infer<typeof ProvingJobAbortedResult>;
+
 export const ProvingJobSettledResult = z.discriminatedUnion('status', [
   ProvingJobFulfilledResult,
   ProvingJobRejectedResult,
+  ProvingJobAbortedResult,
 ]);
 export type ProvingJobSettledResult = z.infer<typeof ProvingJobSettledResult>;
 
@@ -453,5 +464,6 @@ export const ProvingJobStatus = z.discriminatedUnion('status', [
   z.object({ status: z.literal('not-found') }),
   ProvingJobFulfilledResult,
   ProvingJobRejectedResult,
+  ProvingJobAbortedResult,
 ]);
 export type ProvingJobStatus = z.infer<typeof ProvingJobStatus>;

package/src/interfaces/server_circuit_prover.ts

@@ -1,5 +1,5 @@
 import type {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -189,7 +189,7 @@ export interface ServerCircuitProver {
     inputs: AvmCircuitInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>>;
+  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>>;
 }
 
 export type IVCProofVerificationResult = {

package/src/interfaces/world_state.ts

@@ -65,6 +65,20 @@ export interface ReadonlyWorldStateAccess {
 
 /** Defines the interface for a world state synchronizer. */
 export interface WorldStateSynchronizer extends ReadonlyWorldStateAccess, ForkMerkleTreeOperations {
+  /**
+   * Returns a read handle to the world state at `blockNumber`, but only after verifying that the block at that
+   * height is on the fork identified by `blockHash`. This pins the returned view to a specific fork so a reorg
+   * that replaced the block at `blockNumber` cannot be served silently, closing the gap between resolving a query
+   * and reading its snapshot.
+   *
+   * Rejects if the block at `blockNumber` does not match `blockHash` (a reorg), or if the block's hash cannot be
+   * read from the requested view. Both are transient from a caller's perspective: re-resolving the query against
+   * the current chain and retrying may succeed or produce a more precise error. However, if the block's history
+   * has been pruned away (it predates the oldest historical block kept by world state), the rejection is terminal:
+   * retrying cannot bring the data back.
+   */
+  getVerifiedSnapshot(blockNumber: BlockNumber, blockHash: BlockHash): Promise<MerkleTreeReadOperations>;
+
   /** Starts the synchronizer. */
   start(): Promise<void | PromiseWithResolvers<void>>;
 

package/src/kernel/hints/find_private_kernel_reset_dimensions.ts

@@ -1,8 +1,7 @@
-import { isDefined } from '@aztec/foundation/types';
-
 import {
   PrivateKernelResetDimensions,
   type PrivateKernelResetDimensionsConfig,
+  type ResetCatalogEntry,
   privateKernelResetDimensionNames,
 } from '../private_kernel_reset_dimensions.js';
 
@@ -12,13 +11,6 @@ interface DimensionOption {
   remainder?: PrivateKernelResetDimensions;
 }
 
-function computeCost(dimensions: PrivateKernelResetDimensions, config: PrivateKernelResetDimensionsConfig) {
-  return privateKernelResetDimensionNames.reduce(
-    (accum, name) => accum + dimensions[name] * config.dimensions[name].cost,
-    0,
-  );
-}
-
 function getSize(dimensions: PrivateKernelResetDimensions) {
   return privateKernelResetDimensionNames.reduce((accum, name) => accum + dimensions[name], 0);
 }
@@ -38,124 +30,42 @@ function getRemainder(
   return remainingDimensions ? remainder : undefined;
 }
 
-function pickFromValues(targetValue: number, values: number[]) {
-  // Find the min value in `values` that's greater than or equal to `targetValue`.
-  const minGte = values.reduce(
-    (prev: number | undefined, curr) => (curr >= targetValue && (prev === undefined || curr < prev) ? curr : prev),
-    undefined,
-  );
-
-  // If no such value is found, returns the max value.
-  return minGte ?? Math.max(...values);
-}
-
-function pickCheapest(options: DimensionOption[]) {
-  return options.reduce((prev, curr) => (curr.cost < prev.cost ? curr : prev), options[0]);
-}
-
-function pickSmallestRemainder(options: DimensionOption[]) {
-  const optionsWithSize = options
-    .filter(o => o.remainder)
-    .map(option => ({ option, size: getSize(option.remainder!) }));
-  return optionsWithSize.reduce((prev, curr) => (curr.size < prev.size ? curr : prev), optionsWithSize[0])?.option;
-}
-
-function pickBestOption(options: DimensionOption[]) {
-  const optionsResetAll = options.filter(opt => !opt.remainder);
-  const optionsResetPartial = options.filter(opt => opt.remainder);
-  // The best option is the cheapest one that can reset all dimensions.
-  // If no such option exists, find one that can reset the most data.
-  return pickCheapest(optionsResetAll) || pickSmallestRemainder(optionsResetPartial);
-}
-
-function findVariant(
-  requestedDimensions: PrivateKernelResetDimensions,
-  config: PrivateKernelResetDimensionsConfig,
-  isQualified: (dimensions: PrivateKernelResetDimensions) => boolean,
-): DimensionOption | undefined {
-  const variant = PrivateKernelResetDimensions.empty();
-  privateKernelResetDimensionNames.forEach(name => {
-    variant[name] = pickFromValues(requestedDimensions[name], config.dimensions[name].variants);
-  });
-  if (!isQualified(variant)) {
-    return;
+// Returns the cheapest option that fully covers the request, or the option with the smallest
+// remainder if none do. Caller must pass a non-empty list.
+function pickBestOption(options: DimensionOption[]): DimensionOption {
+  const fullCoverage = options.filter(opt => !opt.remainder);
+  if (fullCoverage.length) {
+    return fullCoverage.reduce((prev, curr) => (curr.cost < prev.cost ? curr : prev));
   }
-
-  return {
-    dimensions: variant,
-    cost: computeCost(variant, config),
-    remainder: getRemainder(requestedDimensions, variant),
-  };
+  return options.reduce((prev, curr) => (getSize(curr.remainder!) < getSize(prev.remainder!) ? curr : prev));
 }
 
-function findStandalone(
-  requestedDimensions: PrivateKernelResetDimensions,
-  config: PrivateKernelResetDimensionsConfig,
-  isQualified: (dimensions: PrivateKernelResetDimensions) => boolean,
-): DimensionOption | undefined {
-  const needsReset = privateKernelResetDimensionNames.filter(name => requestedDimensions[name] > 0);
-  if (needsReset.length !== 1) {
-    // At the moment, we only use standalone to reset one dimension when it's about to overflow.
-    return;
-  }
-
-  const name = needsReset[0];
-  const value = pickFromValues(requestedDimensions[name], config.dimensions[name].standalone);
-  if (!value) {
-    return;
-  }
-
-  const dimensions = PrivateKernelResetDimensions.from({ [name]: value });
-  if (!isQualified(dimensions)) {
-    return;
-  }
-
+function buildOption(entry: ResetCatalogEntry, requestedDimensions: PrivateKernelResetDimensions): DimensionOption {
+  const dimensions = PrivateKernelResetDimensions.fromValues(entry.dimensions);
   return {
     dimensions,
-    cost: computeCost(dimensions, config),
+    cost: entry.cost,
     remainder: getRemainder(requestedDimensions, dimensions),
   };
 }
 
-function findSpecialCase(
-  requestedDimensions: PrivateKernelResetDimensions,
-  config: PrivateKernelResetDimensionsConfig,
-  isQualified: (dimensions: PrivateKernelResetDimensions) => boolean,
-): DimensionOption | undefined {
-  const specialCases = config.specialCases.map(PrivateKernelResetDimensions.fromValues);
-  const options = specialCases.filter(isQualified).map(dimensions => ({
-    dimensions,
-    cost: computeCost(dimensions, config),
-    remainder: getRemainder(requestedDimensions, dimensions),
-  }));
-  return pickBestOption(options);
-}
+/**
+ * Picks which catalog group the selector should search. Mid-tx resets go to `inner` (no
+ * siloing); terminal kernels go to `finalTail` or `finalTailToPublic`, depending on whether
+ * the tx has public function calls.
+ */
+export type ResetDimensionsMode = 'inner' | 'finalTail' | 'finalTailToPublic';
 
 export function findPrivateKernelResetDimensions(
   requestedDimensions: PrivateKernelResetDimensions,
   config: PrivateKernelResetDimensionsConfig,
-  isInner = false,
+  mode: ResetDimensionsMode,
   allowRemainder = false,
 ) {
-  const requestedValues = requestedDimensions.toValues();
-  const isEnough = allowRemainder
-    ? () => true
-    : (dimensions: PrivateKernelResetDimensions) => dimensions.toValues().every((v, i) => v >= requestedValues[i]);
-
-  const isQualified = !isInner
-    ? isEnough
-    : // If isInner is true, it's a reset to prevent overflow. The following must be zero because siloing can't be done at the moment.
-      (dimensions: PrivateKernelResetDimensions) =>
-        dimensions.NOTE_HASH_SILOING === 0 &&
-        dimensions.NULLIFIER_SILOING === 0 &&
-        dimensions.PRIVATE_LOG_SILOING === 0 &&
-        isEnough(dimensions);
-
-  const options = [
-    findVariant(requestedDimensions, config, isQualified),
-    findStandalone(requestedDimensions, config, isQualified),
-    findSpecialCase(requestedDimensions, config, isQualified),
-  ].filter(isDefined);
+  const catalog = config[mode];
+  const options = catalog
+    .map(entry => buildOption(entry, requestedDimensions))
+    .filter(option => allowRemainder || !option.remainder);
 
   if (!options.length) {
     throw new Error(`Cannot find an option for dimension: ${requestedDimensions.toValues()}`);

package/src/kernel/index.ts

@@ -14,7 +14,7 @@ export * from './private_kernel_inner_2_circuit_private_inputs.js';
 export * from './private_kernel_inner_3_circuit_private_inputs.js';
 export * from './private_kernel_reset_circuit_private_inputs.js';
 export * from './private_kernel_reset_dimensions.js';
-export * from './private_kernel_tail_circuit_private_inputs.js';
+export * from './private_kernel_reset_tail_circuit_private_inputs.js';
 export * from './private_kernel_tail_circuit_public_inputs.js';
 export * from './private_to_avm_accumulated_data.js';
 export * from './private_to_public_accumulated_data.js';

package/src/kernel/private_circuit_public_inputs.ts

@@ -144,6 +144,11 @@ export class PrivateCircuitPublicInputs {
      * Hash of the contract class logs emitted in this function call.
      */
     public contractClassLogsHashes: ClaimedLengthArray<CountedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_CALL>,
+    /**
+     * The tx request's salt. Keeps `tx_request.hash()` (the protocol nullifier) unpredictable, and lets the init
+     * kernel bind this proof to a specific tx request (it asserts this equals `tx_request.salt`).
+     */
+    public txRequestSalt: Fr,
   ) {}
 
   /**
@@ -188,6 +193,7 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(ClaimedLengthArrayFromBuffer(CountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromBuffer(CountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL)),
+      reader.readObject(Fr),
     );
   }
 
@@ -219,6 +225,7 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(ClaimedLengthArrayFromFields(CountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL)),
       reader.readObject(ClaimedLengthArrayFromFields(CountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL)),
+      reader.readField(),
     );
   }
 
@@ -251,6 +258,7 @@ export class PrivateCircuitPublicInputs {
       ClaimedLengthArray.empty(CountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL),
       ClaimedLengthArray.empty(PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL),
       ClaimedLengthArray.empty(CountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL),
+      Fr.ZERO,
     );
   }
 
@@ -278,7 +286,8 @@ export class PrivateCircuitPublicInputs {
       this.nullifiers.isEmpty() &&
       this.l2ToL1Msgs.isEmpty() &&
       this.privateLogs.isEmpty() &&
-      this.contractClassLogsHashes.isEmpty()
+      this.contractClassLogsHashes.isEmpty() &&
+      this.txRequestSalt.isZero()
     );
   }
 
@@ -312,6 +321,7 @@ export class PrivateCircuitPublicInputs {
       fields.l2ToL1Msgs,
       fields.privateLogs,
       fields.contractClassLogsHashes,
+      fields.txRequestSalt,
     ] as const;
   }
 
@@ -346,6 +356,7 @@ export class PrivateCircuitPublicInputs {
       this.l2ToL1Msgs,
       this.privateLogs,
       this.contractClassLogsHashes,
+      this.txRequestSalt,
     ]);
   }
 

package/src/kernel/private_context_inputs.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { serializeToFields } from '@aztec/foundation/serialize';
 
 import { BlockHeader } from '../tx/block_header.js';
@@ -11,13 +11,20 @@ export class PrivateContextInputs {
     public anchorBlockHeader: BlockHeader,
     public txContext: TxContext,
     public startSideEffectCounter: number,
+    public txRequestSalt: Fr,
   ) {}
 
   public static empty(): PrivateContextInputs {
-    return new PrivateContextInputs(CallContext.empty(), BlockHeader.empty(), TxContext.empty(), 0);
+    return new PrivateContextInputs(CallContext.empty(), BlockHeader.empty(), TxContext.empty(), 0, Fr.ZERO);
   }
 
   public toFields(): Fr[] {
-    return serializeToFields([this.callContext, this.anchorBlockHeader, this.txContext, this.startSideEffectCounter]);
+    return serializeToFields([
+      this.callContext,
+      this.anchorBlockHeader,
+      this.txContext,
+      this.startSideEffectCounter,
+      this.txRequestSalt,
+    ]);
   }
 }

package/src/kernel/private_kernel_circuit_public_inputs.ts

@@ -115,3 +115,12 @@ export class PrivateKernelCircuitPublicInputs {
     );
   }
 }
+
+/**
+ * Returns true iff the tx requires the public-bound terminal path: it has either un-processed
+ * public-call requests in the side-effect stream or a pending public-teardown call request. Every
+ * site picking between the rollup-bound and public-bound terminal artifact must route through this.
+ */
+export function kernelStateIsForPublic(publicInputs: PrivateKernelCircuitPublicInputs): boolean {
+  return publicInputs.end.publicCallRequests.claimedLength > 0 || !publicInputs.publicTeardownCallRequest.isEmpty();
+}

package/src/kernel/private_kernel_init_2_circuit_private_inputs.ts

@@ -17,7 +17,6 @@ export class PrivateKernelInit2CircuitPrivateInputs {
     public privateCall0: PrivateCallData,
     public privateCall1: PrivateCallData,
     public isPrivateOnly: boolean,
-    public firstNullifierHint: Fr,
     public revertibleCounterHint: number,
   ) {}
 
@@ -28,7 +27,6 @@ export class PrivateKernelInit2CircuitPrivateInputs {
       this.protocolContracts,
       this.privateCall0,
       this.privateCall1,
-      this.firstNullifierHint,
       this.revertibleCounterHint,
     );
   }
@@ -42,7 +40,6 @@ export class PrivateKernelInit2CircuitPrivateInputs {
       reader.readObject(PrivateCallData),
       reader.readObject(PrivateCallData),
       reader.readBoolean(),
-      Fr.fromBuffer(reader),
       reader.readNumber(),
     );
   }

package/src/kernel/private_kernel_init_3_circuit_private_inputs.ts

@@ -18,7 +18,6 @@ export class PrivateKernelInit3CircuitPrivateInputs {
     public privateCall1: PrivateCallData,
     public privateCall2: PrivateCallData,
     public isPrivateOnly: boolean,
-    public firstNullifierHint: Fr,
     public revertibleCounterHint: number,
   ) {}
 
@@ -30,7 +29,6 @@ export class PrivateKernelInit3CircuitPrivateInputs {
       this.privateCall0,
       this.privateCall1,
       this.privateCall2,
-      this.firstNullifierHint,
       this.revertibleCounterHint,
     );
   }
@@ -45,7 +43,6 @@ export class PrivateKernelInit3CircuitPrivateInputs {
       reader.readObject(PrivateCallData),
       reader.readObject(PrivateCallData),
       reader.readBoolean(),
-      Fr.fromBuffer(reader),
       reader.readNumber(),
     );
   }

package/src/kernel/private_kernel_init_circuit_private_inputs.ts

@@ -30,10 +30,6 @@ export class PrivateKernelInitCircuitPrivateInputs {
      * Wether this tx will make public calls or not.
      */
     public isPrivateOnly: boolean,
-    /**
-     * A hint to what will be the first nullifier of the transaction, used for nonce generation.
-     */
-    public firstNullifierHint: Fr,
     /**
      * A claim to the final min revertible side effect counter of a tx.
      */
@@ -50,7 +46,6 @@ export class PrivateKernelInitCircuitPrivateInputs {
       this.vkTreeRoot,
       this.protocolContracts,
       this.privateCall,
-      this.firstNullifierHint,
       this.revertibleCounterHint,
     );
   }
@@ -68,7 +63,6 @@ export class PrivateKernelInitCircuitPrivateInputs {
       reader.readObject(ProtocolContracts),
       reader.readObject(PrivateCallData),
       reader.readBoolean(),
-      Fr.fromBuffer(reader),
       reader.readNumber(),
     );
   }

package/src/kernel/private_kernel_reset_dimensions.ts

@@ -68,14 +68,24 @@ export const privateKernelResetDimensionNames: DimensionName[] = [
   'PRIVATE_LOG_SILOING',
 ];
 
-export interface DimensionConfig {
-  variants: number[];
-  standalone: number[];
+export interface ResetCatalogEntry {
+  name: string;
+  dimensions: number[];
+  // Measured gate count (circuit_size) of the compiled variant. Used by the selector to pick the
+  // cheapest variant that covers the requested dimensions, e.g. if the required dimensions are
+  // `6 - 2 - 2` then a variant with capacity `8 - 2 - 2` might be cheaper than one with capacity
+  // `6 - 4 - 4`.
   cost: number;
 }
 
 // Must match the config in noir-projects/noir-protocol-circuits/private_kernel_reset_config.json
 export interface PrivateKernelResetDimensionsConfig {
-  dimensions: { [K in DimensionName]: DimensionConfig };
-  specialCases: number[][];
+  // Variants used for mid-tx resets that prevent overflow. Never the last kernel in the chain.
+  inner: ResetCatalogEntry[];
+  // Variants used as the terminal kernel for the rollup-bound private-only path. Each runs
+  // final-reset siloing and tail finalisation in one proof.
+  finalTail: ResetCatalogEntry[];
+  // Terminal variants for the public-bound path (transactions with public function calls). Runs
+  // final-reset siloing and tail-to-public partitioning by revertibility in one proof.
+  finalTailToPublic: ResetCatalogEntry[];
 }