@aztec/stdlib 2.1.0-rc.9 → 3.0.0-devnet.2

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 { PublicTubePrivateInputs } from '../rollup/public_tube_private_inputs.js';
+import type { PublicTubePublicInputs } from '../rollup/public_tube_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,117 @@ 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>>;
 
+  getPublicTubeProof(
+    inputs: PublicTubePrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<PublicTubePublicInputs, 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 +173,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/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

@@ -5,12 +5,14 @@ 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 { ProposedBlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
+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
@@ -42,8 +44,14 @@ export interface ValidatorClientConfig {
 }
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
-  Pick<SequencerConfig, 'txPublicSetupAllowList'> &
-  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'>;
+  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(),
@@ -55,6 +63,13 @@ export const ValidatorClientConfigSchema = z.object({
   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;
@@ -62,7 +77,7 @@ export interface Validator {
   // Block validation responsibilities
   createBlockProposal(
     blockNumber: number,
-    header: ProposedBlockHeader,
+    header: CheckpointHeader,
     archive: Fr,
     stateReference: StateReference,
     txs: Tx[],

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_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),

package/src/kernel/private_kernel_prover_output.ts

@@ -45,7 +45,7 @@ export interface PrivateKernelExecutionProofOutput<
   /** The public inputs used by the proof generation process. */
   publicInputs: PublicInputsType;
   /** The private IVC proof optimized for user devices. It will be consumed by an Aztec prover,
-   * which recursively verifies it through the "tube" circuit.*/
+   * which recursively verifies it through the "private tx base" or the "public tube" circuit.*/
   clientIvcProof: ClientIvcProof;
   /**
    * The trace the clientIvcProof corresponds to.

package/src/kernel/private_kernel_tail_circuit_public_inputs.ts

@@ -170,10 +170,10 @@ export class PrivateKernelTailCircuitPublicInputs {
       throw new Error('Private tail public inputs is not for rollup circuit.');
     }
     const constants = new TxConstantData(
-      this.constants.historicalHeader,
+      this.constants.anchorBlockHeader,
       this.constants.txContext,
       this.constants.vkTreeRoot,
-      this.constants.protocolContractTreeRoot,
+      this.constants.protocolContractsHash,
     );
     return new PrivateToRollupKernelCircuitPublicInputs(
       constants,
@@ -184,6 +184,12 @@ export class PrivateKernelTailCircuitPublicInputs {
     );
   }
 
+  publicInputs(): PrivateToPublicKernelCircuitPublicInputs | PrivateToRollupKernelCircuitPublicInputs {
+    return this.forPublic
+      ? this.toPrivateToPublicKernelCircuitPublicInputs()
+      : this.toPrivateToRollupKernelCircuitPublicInputs();
+  }
+
   numberOfPublicCallRequests() {
     return (
       this.numberOfNonRevertiblePublicCallRequests() +

package/src/kernel/private_to_public_kernel_circuit_public_inputs.ts

@@ -1,6 +1,7 @@
 import { GeneratorIndex, PRIVATE_TO_PUBLIC_KERNEL_CIRCUIT_PUBLIC_INPUTS_LENGTH } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import type { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -93,4 +94,12 @@ export class PrivateToPublicKernelCircuitPublicInputs {
   hash() {
     return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.PUBLIC_TX_HASH);
   }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(PrivateToPublicKernelCircuitPublicInputs);
+  }
 }