@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/interfaces/server_circuit_prover.ts

@@ -3,24 +3,36 @@ import type {
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 
 import type { AvmCircuitInputs } from '../avm/avm.js';
-import type { BaseParityInputs } from '../parity/base_parity_inputs.js';
+import type { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import type { ParityPublicInputs } from '../parity/parity_public_inputs.js';
-import type { RootParityInputs } from '../parity/root_parity_inputs.js';
-import type { BaseOrMergeRollupPublicInputs } from '../rollup/base_or_merge_rollup_public_inputs.js';
-import type { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
-import type { BlockRootOrBlockMergePublicInputs } from '../rollup/block_root_or_block_merge_public_inputs.js';
-import type { BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
-import type { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
-import type { PaddingBlockRootRollupInputs } from '../rollup/index.js';
-import type { MergeRollupInputs } from '../rollup/merge_rollup.js';
-import type { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
-import type { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
-import type { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
-import type { TubeInputs } from '../rollup/tube_inputs.js';
+import type { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
+import type { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
+import type { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
+import type {
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+} from '../rollup/block_root_rollup_private_inputs.js';
+import type { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup_private_inputs.js';
+import type { CheckpointRollupPublicInputs } from '../rollup/checkpoint_rollup_public_inputs.js';
+import type {
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRootRollupPrivateInputs,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+} from '../rollup/checkpoint_root_rollup_private_inputs.js';
+import type { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import type { PublicChonkVerifierPrivateInputs } from '../rollup/public_chonk_verifier_private_inputs.js';
+import type { PublicChonkVerifierPublicInputs } from '../rollup/public_chonk_verifier_public_inputs.js';
+import type { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
+import type { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
+import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
+import type { TxMergeRollupPrivateInputs } from '../rollup/tx_merge_rollup_private_inputs.js';
+import type { TxRollupPublicInputs } from '../rollup/tx_rollup_public_inputs.js';
 import type { Tx } from '../tx/tx.js';
 import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from './proving-job.js';
 
@@ -33,7 +45,7 @@ export interface ServerCircuitProver {
    * @param input - Input to the circuit.
    */
   getBaseParityProof(
-    inputs: BaseParityInputs,
+    inputs: ParityBasePrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>>;
@@ -43,103 +55,119 @@ export interface ServerCircuitProver {
    * @param input - Input to the circuit.
    */
   getRootParityProof(
-    inputs: RootParityInputs,
+    inputs: ParityRootPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
 
+  getPublicChonkVerifierProof(
+    inputs: PublicChonkVerifierPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  >;
+
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getPrivateBaseRollupProof(
-    baseRollupInput: PrivateBaseRollupInputs,
+  getPrivateTxBaseRollupProof(
+    baseRollupInput: PrivateTxBaseRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
-  getPublicBaseRollupProof(
-    inputs: PublicBaseRollupInputs,
+  getPublicTxBaseRollupProof(
+    inputs: PublicTxBaseRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
-   * Get a recursively verified client IVC proof (making it a compatible honk proof for the rest of the rollup).
+   * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getTubeProof(
-    tubeInput: TubeInputs,
+  getTxMergeRollupProof(
+    input: TxMergeRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>;
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getMergeRollupProof(
-    input: MergeRollupInputs,
+  getBlockRootFirstRollupProof(
+    input: BlockRootFirstRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
+  getBlockRootSingleTxFirstRollupProof(
+    input: BlockRootSingleTxFirstRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
+  getBlockRootEmptyTxFirstRollupProof(
+    input: BlockRootEmptyTxFirstRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
+  getBlockRootRollupProof(
+    input: BlockRootRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
+  getBlockRootSingleTxRollupProof(
+    input: BlockRootSingleTxRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getBlockRootRollupProof(
-    input: BlockRootRollupInputs,
+  getBlockMergeRollupProof(
+    input: BlockMergeRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
-  getSingleTxBlockRootRollupProof(
-    input: SingleTxBlockRootRollupInputs,
+  getCheckpointRootRollupProof(
+    input: CheckpointRootRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */
-  getEmptyBlockRootRollupProof(
-    input: EmptyBlockRootRollupInputs,
+  getCheckpointRootSingleBlockRollupProof(
+    input: CheckpointRootSingleBlockRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
-  getPaddingBlockRootRollupProof(
-    input: PaddingBlockRootRollupInputs,
+  getCheckpointPaddingRollupProof(
+    input: CheckpointPaddingRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */
-  getBlockMergeRollupProof(
-    input: BlockMergeRollupInputs,
+  getCheckpointMergeRollupProof(
+    input: CheckpointMergeRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
   /**
@@ -147,7 +175,7 @@ export interface ServerCircuitProver {
    * @param input - Input to the circuit.
    */
   getRootRollupProof(
-    input: RootRollupInputs,
+    input: RootRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;

package/src/interfaces/slasher.ts

@@ -24,6 +24,7 @@ export interface SlasherConfig {
   slashOffenseExpirationRounds: number; // Number of rounds after which pending offenses expire
   slashMaxPayloadSize: number; // Maximum number of offenses to include in a single slash payload
   slashGracePeriodL2Slots: number; // Number of L2 slots to wait after genesis before slashing for most offenses
+  slashExecuteRoundsLookBack: number; // How many rounds to look back when searching for a round to execute
 }
 
 export const SlasherConfigSchema = z.object({
@@ -44,5 +45,6 @@ export const SlasherConfigSchema = z.object({
   slashMaxPayloadSize: z.number(),
   slashGracePeriodL2Slots: z.number(),
   slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+  slashExecuteRoundsLookBack: z.number(),
   slashSelfAllowed: z.boolean().optional(),
 }) satisfies ZodFor<SlasherConfig>;

package/src/interfaces/tx_provider.ts

@@ -9,6 +9,7 @@ export interface ITxProvider {
 
   getTxsForBlockProposal(
     blockProposal: BlockProposal,
+    blockNumber: number,
     opts: { pinnedPeer: PeerId | undefined; deadline: Date },
   ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
 

package/src/interfaces/validator.ts

@@ -0,0 +1,95 @@
+import type { SecretValue } from '@aztec/foundation/config';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import type { SequencerConfig, SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { BlockAttestation, BlockProposal, BlockProposalOptions } from '@aztec/stdlib/p2p';
+import type { StateReference, Tx } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+import { z } from 'zod';
+
+import type { CommitteeAttestationsAndSigners } from '../block/index.js';
+import type { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AllowedElementSchema } from './allowed_element.js';
+
+/**
+ * Validator client configuration
+ */
+export interface ValidatorClientConfig {
+  /** 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[];
+
+  /** Do not run the validator */
+  disableValidator: boolean;
+
+  /** Temporarily disable these specific validator addresses */
+  disabledValidators: EthAddress[];
+
+  /** Interval between polling for new attestations from peers */
+  attestationPollingIntervalMs: number;
+
+  /** Whether to re-execute transactions in a block proposal before attesting */
+  validatorReexecute: boolean;
+
+  /** Will re-execute until this many milliseconds are left in the slot */
+  validatorReexecuteDeadlineMs: number;
+
+  /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the currnet committee */
+  alwaysReexecuteBlockProposals?: boolean;
+}
+
+export type ValidatorClientFullConfig = ValidatorClientConfig &
+  Pick<SequencerConfig, 'txPublicSetupAllowList' | 'broadcastInvalidBlockProposal'> &
+  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'> & {
+    /**
+     * 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.
+     */
+    disableTransactions?: boolean;
+  };
+
+export const ValidatorClientConfigSchema = z.object({
+  validatorAddresses: z.array(schemas.EthAddress).optional(),
+  disableValidator: z.boolean(),
+  disabledValidators: z.array(schemas.EthAddress),
+  attestationPollingIntervalMs: z.number().min(0),
+  validatorReexecute: z.boolean(),
+  validatorReexecuteDeadlineMs: z.number().min(0),
+  alwaysReexecuteBlockProposals: z.boolean().optional(),
+}) satisfies ZodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>;
+
+export const ValidatorClientFullConfigSchema = ValidatorClientConfigSchema.extend({
+  txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
+  broadcastInvalidBlockProposal: z.boolean().optional(),
+  slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+  disableTransactions: z.boolean().optional(),
+}) satisfies ZodFor<Omit<ValidatorClientFullConfig, 'validatorPrivateKeys'>>;
+
+export interface Validator {
+  start(): Promise<void>;
+  updateConfig(config: Partial<ValidatorClientFullConfig>): void;
+
+  // Block validation responsibilities
+  createBlockProposal(
+    blockNumber: number,
+    header: CheckpointHeader,
+    archive: Fr,
+    stateReference: StateReference,
+    txs: Tx[],
+    proposerAddress: EthAddress | undefined,
+    options: BlockProposalOptions,
+  ): Promise<BlockProposal | undefined>;
+  attestToProposal(proposal: BlockProposal, sender: PeerId): Promise<BlockAttestation[] | undefined>;
+
+  broadcastBlockProposal(proposal: BlockProposal): Promise<void>;
+  collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]>;
+  signAttestationsAndSigners(
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    proposer: EthAddress,
+  ): Promise<Signature>;
+}

package/src/kernel/hints/build_nullifier_read_request_hints.ts

@@ -4,9 +4,10 @@ import {
   type NULLIFIER_TREE_HEIGHT,
 } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/fields';
-import { type IndexedTreeLeafPreimage, MembershipWitness } from '@aztec/foundation/trees';
+import { MembershipWitness } from '@aztec/foundation/trees';
 
 import { siloNullifier } from '../../hash/hash.js';
+import type { NullifierLeafPreimage } from '../../trees/nullifier_leaf.js';
 import type { ClaimedLengthArray } from '../claimed_length_array.js';
 import type { ScopedNullifier } from '../nullifier.js';
 import { NullifierReadRequestHintsBuilder } from './nullifier_read_request_hints.js';
@@ -24,7 +25,7 @@ export function isValidNullifierReadRequest(readRequest: ScopedReadRequest, null
 
 interface NullifierMembershipWitnessWithPreimage {
   membershipWitness: MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>;
-  leafPreimage: IndexedTreeLeafPreimage;
+  leafPreimage: NullifierLeafPreimage;
 }
 
 export function getNullifierReadRequestResetActions(

package/src/kernel/hints/nullifier_read_request_hints.ts

@@ -1,7 +1,7 @@
 import { MAX_NULLIFIER_READ_REQUESTS_PER_TX, NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import type { BufferReader } from '@aztec/foundation/serialize';
-import type { MembershipWitness, TreeLeafPreimage } from '@aztec/foundation/trees';
+import type { MembershipWitness } from '@aztec/foundation/trees';
 
 import { NullifierLeafPreimage } from '../../trees/index.js';
 import { PendingReadHint, ReadRequestAction, ReadRequestResetHints, SettledReadHint } from './read_request_hints.js';
@@ -11,7 +11,7 @@ export type NullifierReadRequestHints<PENDING extends number, SETTLED extends nu
   PENDING,
   SETTLED,
   typeof NULLIFIER_TREE_HEIGHT,
-  TreeLeafPreimage
+  NullifierLeafPreimage
 >;
 
 export function nullifierReadRequestHintsFromBuffer<PENDING extends number, SETTLED extends number>(
@@ -64,7 +64,7 @@ export class NullifierReadRequestHintsBuilder<PENDING extends number, SETTLED ex
   addSettledReadRequest(
     readRequestIndex: number,
     membershipWitness: MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>,
-    leafPreimage: TreeLeafPreimage,
+    leafPreimage: NullifierLeafPreimage,
   ) {
     if (this.numSettledReadHints === this.maxSettled) {
       throw new Error('Cannot add more settled read request.');

package/src/kernel/nullifier.ts

@@ -7,38 +7,38 @@ import type { Ordered } from './utils/interfaces.js';
 export class Nullifier implements Ordered {
   constructor(
     public value: Fr,
-    public counter: number,
     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) {

package/src/kernel/private_call_data.ts

@@ -1,9 +1,4 @@
-import {
-  FUNCTION_TREE_HEIGHT,
-  PROTOCOL_CONTRACT_TREE_HEIGHT,
-  PUBLIC_DATA_TREE_HEIGHT,
-  UPDATES_VALUE_SIZE,
-} from '@aztec/constants';
+import { FUNCTION_TREE_HEIGHT, PUBLIC_DATA_TREE_HEIGHT, UPDATES_VALUE_SIZE } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
@@ -11,7 +6,7 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { DelayedPublicMutableValues } from '../delayed_public_mutable/delayed_public_mutable_values.js';
 import { PublicKeys } from '../keys/public_keys.js';
-import { ProtocolContractLeafPreimage, PublicDataTreeLeafPreimage } from '../trees/index.js';
+import { PublicDataTreeLeafPreimage } from '../trees/index.js';
 import { VerificationKeyAsFields } from '../vks/verification_key.js';
 import { PrivateCircuitPublicInputs } from './private_circuit_public_inputs.js';
 
@@ -94,16 +89,6 @@ export class PrivateVerificationKeyHints {
      * The membership witness for the function leaf corresponding to the function being invoked.
      */
     public functionLeafMembershipWitness: MembershipWitness<typeof FUNCTION_TREE_HEIGHT>,
-    /**
-     * The membership witness for the protocolContractLeaf.
-     */
-    public protocolContractMembershipWitness: MembershipWitness<typeof PROTOCOL_CONTRACT_TREE_HEIGHT>,
-    /**
-     * The leaf of the protocol contract tree, of either:
-     *  The protocol contract being called.
-     *  The low leaf showing that the address of the contract being called is not in the tree.
-     */
-    public protocolContractLeaf: ProtocolContractLeafPreimage,
 
     public updatedClassIdHints: UpdatedClassIdHints,
   ) {}
@@ -120,8 +105,6 @@ export class PrivateVerificationKeyHints {
       fields.publicKeys,
       fields.saltedInitializationHash,
       fields.functionLeafMembershipWitness,
-      fields.protocolContractMembershipWitness,
-      fields.protocolContractLeaf,
       fields.updatedClassIdHints,
     ] as const;
   }
@@ -151,8 +134,6 @@ export class PrivateVerificationKeyHints {
       reader.readObject(PublicKeys),
       reader.readObject(Fr),
       reader.readObject(MembershipWitness.deserializer(FUNCTION_TREE_HEIGHT)),
-      reader.readObject(MembershipWitness.deserializer(PROTOCOL_CONTRACT_TREE_HEIGHT)),
-      reader.readObject(ProtocolContractLeafPreimage),
       reader.readObject(UpdatedClassIdHints),
     );
   }

package/src/kernel/private_circuit_public_inputs.ts

@@ -127,11 +127,11 @@ export class PrivateCircuitPublicInputs {
     /**
      * Header of a block whose state is used during private execution (not the block the transaction is included in).
      */
-    public historicalHeader: BlockHeader,
+    public anchorBlockHeader: BlockHeader,
     /**
      * Transaction context.
      *
-     * Note: The chainId and version in the txContext are not redundant to the values in self.historical_header.global_variables because
+     * Note: The chainId and version in the txContext are not redundant to the values in self.anchor_block_header.global_variables because
      * they can be different in case of a protocol upgrade. In such a situation we could be using header from a block
      * before the upgrade took place but be using the updated protocol to execute and prove the transaction.
      */
@@ -261,7 +261,7 @@ export class PrivateCircuitPublicInputs {
       this.contractClassLogsHashes.isEmpty() &&
       this.startSideEffectCounter.isZero() &&
       this.endSideEffectCounter.isZero() &&
-      this.historicalHeader.isEmpty() &&
+      this.anchorBlockHeader.isEmpty() &&
       this.txContext.isEmpty()
     );
   }
@@ -292,7 +292,7 @@ export class PrivateCircuitPublicInputs {
       fields.contractClassLogsHashes,
       fields.startSideEffectCounter,
       fields.endSideEffectCounter,
-      fields.historicalHeader,
+      fields.anchorBlockHeader,
       fields.txContext,
     ] as const;
   }
@@ -324,7 +324,7 @@ export class PrivateCircuitPublicInputs {
       this.contractClassLogsHashes,
       this.startSideEffectCounter,
       this.endSideEffectCounter,
-      this.historicalHeader,
+      this.anchorBlockHeader,
       this.txContext,
     ]);
   }

package/src/kernel/private_context_inputs.ts

@@ -8,7 +8,7 @@ import { TxContext } from '../tx/tx_context.js';
 export class PrivateContextInputs {
   constructor(
     public callContext: CallContext,
-    public historicalHeader: BlockHeader,
+    public anchorBlockHeader: BlockHeader,
     public txContext: TxContext,
     public startSideEffectCounter: number,
   ) {}
@@ -18,6 +18,6 @@ export class PrivateContextInputs {
   }
 
   public toFields(): Fr[] {
-    return serializeToFields([this.callContext, this.historicalHeader, this.txContext, this.startSideEffectCounter]);
+    return serializeToFields([this.callContext, this.anchorBlockHeader, this.txContext, this.startSideEffectCounter]);
   }
 }

package/src/kernel/private_kernel_circuit_public_inputs.ts

@@ -3,7 +3,7 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import { TxConstantData } from '../tx/tx_constant_data.js';
+import { PrivateTxConstantData } from '../tx/private_tx_constant_data.js';
 import type { UInt64 } from '../types/shared.js';
 import { PrivateAccumulatedData } from './private_accumulated_data.js';
 import { PrivateValidationRequests } from './private_validation_requests.js';
@@ -17,7 +17,7 @@ export class PrivateKernelCircuitPublicInputs {
     /**
      * Data which is not modified by the circuits.
      */
-    public constants: TxConstantData,
+    public constants: PrivateTxConstantData,
     /**
      * The side effect counter that non-revertible side effects are all beneath.
      */
@@ -82,7 +82,7 @@ export class PrivateKernelCircuitPublicInputs {
   static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelCircuitPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new PrivateKernelCircuitPublicInputs(
-      reader.readObject(TxConstantData),
+      reader.readObject(PrivateTxConstantData),
       reader.readObject(Fr),
       reader.readObject(PrivateValidationRequests),
       reader.readObject(PrivateAccumulatedData),
@@ -96,7 +96,7 @@ export class PrivateKernelCircuitPublicInputs {
 
   static empty() {
     return new PrivateKernelCircuitPublicInputs(
-      TxConstantData.empty(),
+      PrivateTxConstantData.empty(),
       Fr.zero(),
       PrivateValidationRequests.empty(),
       PrivateAccumulatedData.empty(),

package/src/kernel/private_kernel_data.ts

@@ -7,8 +7,8 @@ import { PrivateKernelCircuitPublicInputs } from './private_kernel_circuit_publi
  * Data of the previous kernel iteration in the chain of kernels.
  */
 export class PrivateKernelData {
-  // NOTE: as of move to honk and client IVC, previous private kernels no longer come with their proof
-  // as we do client IVC not recursive verification. We need to ensure the public inputs here is properly constrained, TODO(https://github.com/AztecProtocol/barretenberg/issues/1048)
+  // NOTE: as of move to honk and chonk, previous private kernels no longer come with their proof
+  // as we do chonk not recursive verification. We need to ensure the public inputs here is properly constrained, TODO(https://github.com/AztecProtocol/barretenberg/issues/1048)
   constructor(
     /**
      * Public inputs of the previous kernel.

package/src/kernel/private_kernel_init_circuit_private_inputs.ts

@@ -1,6 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
 import { TxRequest } from '../tx/tx_request.js';
 import { PrivateCallData } from './private_call_data.js';
 
@@ -18,9 +19,9 @@ export class PrivateKernelInitCircuitPrivateInputs {
      */
     public vkTreeRoot: Fr,
     /**
-     * The root of the protocol contract tree.
+     * The protocol contracts.
      */
-    public protocolContractTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
     /**
      * Private calldata corresponding to this iteration of the kernel.
      */
@@ -43,7 +44,7 @@ export class PrivateKernelInitCircuitPrivateInputs {
     return serializeToBuffer(
       this.txRequest,
       this.vkTreeRoot,
-      this.protocolContractTreeRoot,
+      this.protocolContracts,
       this.privateCall,
       this.firstNullifierHint,
     );
@@ -59,7 +60,7 @@ export class PrivateKernelInitCircuitPrivateInputs {
     return new PrivateKernelInitCircuitPrivateInputs(
       reader.readObject(TxRequest),
       Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
       reader.readObject(PrivateCallData),
       reader.readBoolean(),
       Fr.fromBuffer(reader),