@aztec/stdlib 0.0.1-commit.fcb71a6 → 0.0.1-commit.fffb133c

package/src/block/validate_block_result.ts

@@ -5,57 +5,62 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
-import { BlockInfoSchema, type L2BlockInfo, deserializeBlockInfo, serializeBlockInfo } from './l2_block_info.js';
+import {
+  type CheckpointInfo,
+  CheckpointInfoSchema,
+  deserializeCheckpointInfo,
+  serializeCheckpointInfo,
+} from '../checkpoint/checkpoint_info.js';
+import { MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
-/** Subtype for invalid block validation results */
-export type ValidateBlockNegativeResult =
+/** Subtype for invalid checkpoint validation results */
+export type ValidateCheckpointNegativeResult =
   | {
       valid: false;
-      /** Identifiers from the invalid block */
-      block: L2BlockInfo;
-      /** Committee members at the epoch this block was proposed */
+      /** Identifiers from the invalid checkpoint */
+      checkpoint: CheckpointInfo;
+      /** Committee members at the epoch this checkpoint was proposed */
       committee: EthAddress[];
-      /** Epoch in which this block was proposed */
+      /** Epoch in which this checkpoint was proposed */
       epoch: EpochNumber;
       /** Proposer selection seed for the epoch */
       seed: bigint;
-      /** List of committee members who signed this block proposal */
+      /** List of committee members who signed this checkpoint proposal */
       attestors: EthAddress[];
-      /** Committee attestations for this block as they were posted to L1 */
+      /** Committee attestations for this checkpoint as they were posted to L1 */
       attestations: CommitteeAttestation[];
-      /** Reason for the block being invalid: not enough attestations were posted */
+      /** Reason for the checkpoint being invalid: not enough attestations were posted */
       reason: 'insufficient-attestations';
     }
   | {
       valid: false;
-      /** Identifiers from the invalid block */
-      block: L2BlockInfo;
-      /** Committee members at the epoch this block was proposed */
+      /** Identifiers from the invalid checkpoint */
+      checkpoint: CheckpointInfo;
+      /** Committee members at the epoch this checkpoint was proposed */
       committee: EthAddress[];
-      /** Epoch in which this block was proposed */
+      /** Epoch in which this checkpoint was proposed */
       epoch: EpochNumber;
       /** Proposer selection seed for the epoch */
       seed: bigint;
-      /** List of committee members who signed this block proposal */
+      /** List of committee members who signed this checkpoint proposal */
       attestors: EthAddress[];
-      /** Committee attestations for this block as they were posted to L1 */
+      /** Committee attestations for this checkpoint as they were posted to L1 */
       attestations: CommitteeAttestation[];
-      /** Reason for the block being invalid: an invalid attestation was posted */
+      /** Reason for the checkpoint being invalid: an invalid attestation was posted */
       reason: 'invalid-attestation';
       /** Index in the attestations array of the invalid attestation posted */
       invalidIndex: number;
     };
 
-// TODO: Rename to ValidateAttestationsResult
-/** Result type for validating a block attestations */
-export type ValidateBlockResult = { valid: true } | ValidateBlockNegativeResult;
+/** Result type for validating checkpoint attestations */
+export type ValidateCheckpointResult = { valid: true } | ValidateCheckpointNegativeResult;
 
-export const ValidateBlockResultSchema: ZodFor<ValidateBlockResult> = z.union([
+export const ValidateCheckpointResultSchema: ZodFor<ValidateCheckpointResult> = z.union([
   z.object({ valid: z.literal(true) }),
   z.object({
     valid: z.literal(false),
-    block: BlockInfoSchema,
+    checkpoint: CheckpointInfoSchema,
     committee: z.array(schemas.EthAddress),
     epoch: EpochNumberSchema,
     seed: schemas.BigInt,
@@ -65,7 +70,7 @@ export const ValidateBlockResultSchema: ZodFor<ValidateBlockResult> = z.union([
   }),
   z.object({
     valid: z.literal(false),
-    block: BlockInfoSchema,
+    checkpoint: CheckpointInfoSchema,
     committee: z.array(schemas.EthAddress),
     epoch: EpochNumberSchema,
     seed: schemas.BigInt,
@@ -76,17 +81,17 @@ export const ValidateBlockResultSchema: ZodFor<ValidateBlockResult> = z.union([
   }),
 ]);
 
-export function serializeValidateBlockResult(result: ValidateBlockResult): Buffer {
+export function serializeValidateCheckpointResult(result: ValidateCheckpointResult): Buffer {
   if (result.valid) {
     return serializeToBuffer(true);
   }
 
-  const l2Block = serializeBlockInfo(result.block);
+  const checkpointBuffer = serializeCheckpointInfo(result.checkpoint);
   return serializeToBuffer(
     result.valid,
     result.reason,
-    l2Block.length,
-    l2Block,
+    checkpointBuffer.length,
+    checkpointBuffer,
     result.committee.length,
     result.committee,
     result.epoch,
@@ -99,24 +104,24 @@ export function serializeValidateBlockResult(result: ValidateBlockResult): Buffe
   );
 }
 
-export function deserializeValidateBlockResult(bufferOrReader: Buffer | BufferReader): ValidateBlockResult {
+export function deserializeValidateCheckpointResult(bufferOrReader: Buffer | BufferReader): ValidateCheckpointResult {
   const reader = BufferReader.asReader(bufferOrReader);
   const valid = reader.readBoolean();
   if (valid) {
     return { valid };
   }
-  const reason = reader.readString() as 'insufficient-attestations' | 'invalid-attestation';
-  const block = deserializeBlockInfo(reader.readBuffer());
-  const committee = reader.readVector(EthAddress);
+  const reason = reader.readString(64) as 'insufficient-attestations' | 'invalid-attestation';
+  const checkpoint = deserializeCheckpointInfo(reader.readBuffer());
+  const committee = reader.readVector(EthAddress, MAX_COMMITTEE_SIZE);
   const epoch = EpochNumber(reader.readNumber());
   const seed = reader.readBigInt();
-  const attestors = reader.readVector(EthAddress);
-  const attestations = reader.readVector(CommitteeAttestation);
+  const attestors = reader.readVector(EthAddress, MAX_COMMITTEE_SIZE);
+  const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
   const invalidIndex = reader.readNumber();
   if (reason === 'insufficient-attestations') {
-    return { valid, reason, block, committee, epoch, seed, attestors, attestations: attestations };
+    return { valid, reason, checkpoint, committee, epoch, seed, attestors, attestations };
   } else if (reason === 'invalid-attestation') {
-    return { valid, reason, block, committee, epoch, seed, attestors, invalidIndex, attestations: attestations };
+    return { valid, reason, checkpoint, committee, epoch, seed, attestors, invalidIndex, attestations };
   } else {
     const _: never = reason;
     throw new Error(`Unknown reason: ${reason}`);

package/src/checkpoint/checkpoint.ts

@@ -1,5 +1,11 @@
 import { encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
-import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import {
+  BlockNumber,
+  CheckpointNumber,
+  CheckpointNumberSchema,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
 import { sum } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -7,11 +13,15 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { L2BlockNew } from '../block/l2_block_new.js';
+import { L2Block } from '../block/l2_block.js';
+import { MAX_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
+import { computeCheckpointOutHash } from '../messaging/out_hash.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import type { CheckpointInfo } from './checkpoint_info.js';
 
+type FieldsOfCheckpoint = Omit<FieldsOf<Checkpoint>, 'slot'>;
+
 export class Checkpoint {
   constructor(
     /** Snapshot of archive tree after the checkpoint is added. */
@@ -19,27 +29,31 @@ export class Checkpoint {
     /** Header of the checkpoint. */
     public header: CheckpointHeader,
     /** L2 blocks in the checkpoint. */
-    public blocks: L2BlockNew[],
+    public blocks: L2Block[],
     /** Number of the checkpoint. */
     public number: CheckpointNumber,
   ) {}
 
+  get slot(): SlotNumber {
+    return this.header.slotNumber;
+  }
+
   static get schema() {
     return z
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
         header: CheckpointHeader.schema,
-        blocks: z.array(L2BlockNew.schema),
+        blocks: z.array(L2Block.schema),
         number: CheckpointNumberSchema,
       })
       .transform(({ archive, header, blocks, number }) => new Checkpoint(archive, header, blocks, number));
   }
 
-  static from(fields: FieldsOf<Checkpoint>) {
+  static from(fields: FieldsOfCheckpoint) {
     return new Checkpoint(...Checkpoint.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<Checkpoint>) {
+  static getFields(fields: FieldsOfCheckpoint) {
     return [fields.archive, fields.header, fields.blocks, fields.number] as const;
   }
 
@@ -48,7 +62,7 @@ export class Checkpoint {
     return new Checkpoint(
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(CheckpointHeader),
-      reader.readVector(L2BlockNew),
+      reader.readVector(L2Block, MAX_BLOCKS_PER_CHECKPOINT),
       CheckpointNumber(reader.readNumber()),
     );
   }
@@ -66,6 +80,14 @@ export class Checkpoint {
     return this.header.hash();
   }
 
+  // Returns the out hash computed from all l2-to-l1 messages in this checkpoint.
+  // Note: This value is different from the out hash in the header, which is the **accumulated** out hash over all
+  // checkpoints up to and including this one in the epoch.
+  public getCheckpointOutHash(): Fr {
+    const msgs = this.blocks.map(block => block.body.txEffects.map(txEffect => txEffect.l2ToL1Msgs));
+    return computeCheckpointOutHash(msgs);
+  }
+
   public getState() {
     return this.blocks.at(-1)!.header.state;
   }
@@ -73,6 +95,7 @@ export class Checkpoint {
   public toCheckpointInfo(): CheckpointInfo {
     return {
       archive: this.archive.root,
+      lastArchive: this.header.lastArchiveRoot,
       slotNumber: this.header.slotNumber,
       checkpointNumber: this.number,
       timestamp: this.header.timestamp,
@@ -112,17 +135,17 @@ export class Checkpoint {
       startBlockNumber?: number;
       previousArchive?: AppendOnlyTreeSnapshot;
     } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
-      Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+      Partial<Parameters<typeof L2Block.random>[1]> = {},
   ) {
     const header = CheckpointHeader.random(options);
 
     // Create blocks sequentially to chain archive roots properly.
     // Each block's header.lastArchive must equal the previous block's archive.
-    const blocks: L2BlockNew[] = [];
+    const blocks: L2Block[] = [];
     let lastArchive = previousArchive;
     for (let i = 0; i < numBlocks; i++) {
-      const block = await L2BlockNew.random(BlockNumber(startBlockNumber + i), {
-        indexWithinCheckpoint: i,
+      const block = await L2Block.random(BlockNumber(startBlockNumber + i), {
+        indexWithinCheckpoint: IndexWithinCheckpoint(i),
         ...options,
         ...(lastArchive ? { lastArchive } : {}),
       });

package/src/checkpoint/checkpoint_info.ts

@@ -1,9 +1,52 @@
-import type { CheckpointNumber } from '@aztec/foundation/branded-types';
-import type { Fr, SlotNumber } from '@aztec/foundation/schemas';
+import {
+  CheckpointNumber,
+  CheckpointNumberSchema,
+  SlotNumber,
+  SlotNumberSchema,
+} from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
 
 export type CheckpointInfo = {
   archive: Fr;
+  lastArchive: Fr;
   slotNumber: SlotNumber;
   checkpointNumber: CheckpointNumber;
   timestamp: bigint;
 };
+
+export function randomCheckpointInfo(checkpointNumber?: CheckpointNumber | number): CheckpointInfo {
+  return {
+    archive: Fr.random(),
+    lastArchive: Fr.random(),
+    slotNumber: SlotNumber(Math.floor(Math.random() * 100000) + 1),
+    checkpointNumber: CheckpointNumber(checkpointNumber ?? Math.floor(Math.random() * 100000) + 1),
+    timestamp: BigInt(Math.floor(Date.now() / 1000)),
+  };
+}
+
+export const CheckpointInfoSchema = z.object({
+  archive: schemas.Fr,
+  lastArchive: schemas.Fr,
+  slotNumber: SlotNumberSchema,
+  checkpointNumber: CheckpointNumberSchema,
+  timestamp: schemas.BigInt,
+});
+
+export function serializeCheckpointInfo(info: CheckpointInfo): Buffer {
+  return serializeToBuffer(info.archive, info.lastArchive, info.slotNumber, info.checkpointNumber, info.timestamp);
+}
+
+export function deserializeCheckpointInfo(buffer: Buffer | BufferReader): CheckpointInfo {
+  const reader = BufferReader.asReader(buffer);
+  return {
+    archive: reader.readObject(Fr),
+    lastArchive: reader.readObject(Fr),
+    slotNumber: SlotNumber(reader.readNumber()),
+    checkpointNumber: CheckpointNumber(reader.readNumber()),
+    timestamp: reader.readBigInt(),
+  };
+}

package/src/checkpoint/index.ts

@@ -1,2 +1,3 @@
 export * from './checkpoint.js';
+export * from './checkpoint_info.js';
 export * from './published_checkpoint.js';

package/src/checkpoint/published_checkpoint.ts

@@ -8,6 +8,7 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
 
 import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
 import { Checkpoint } from './checkpoint.js';
 
 export class L1PublishedData {
@@ -42,7 +43,7 @@ export class L1PublishedData {
   static fromBuffer(bufferOrReader: Buffer | BufferReader): L1PublishedData {
     const reader = BufferReader.asReader(bufferOrReader);
     const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
     const l1Timestamp = reader.readBigInt();
     return new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash);
   }
@@ -82,9 +83,9 @@ export class PublishedCheckpoint {
     const reader = BufferReader.asReader(bufferOrReader);
     const checkpoint = reader.readObject(Checkpoint);
     const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
     const l1Timestamp = reader.readBigInt();
-    const attestations = reader.readVector(CommitteeAttestation);
+    const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
     return new PublishedCheckpoint(
       checkpoint,
       new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),

package/src/config/node-rpc-config.ts

@@ -21,7 +21,7 @@ export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
   rpcMaxBodySize: {
     env: 'RPC_MAX_BODY_SIZE',
     description: 'Maximum allowed batch size for JSON RPC batch requests.',
-    defaultValue: '50mb',
+    defaultValue: '1mb',
   },
 };
 

package/src/contract/index.ts

@@ -1,11 +1,9 @@
 export * from './artifact_hash.js';
 export * from './contract_address.js';
 export * from './contract_class.js';
-export * from './contract_class_metadata.js';
 export * from './contract_class_id.js';
 export * from './contract_deployment_data.js';
 export * from './contract_instance.js';
-export * from './contract_metadata.js';
 export * from './contract_instance_update.js';
 export * from './private_function.js';
 export * from './private_function_membership_proof.js';

package/src/contract/private_function.ts

@@ -1,5 +1,4 @@
 import { FUNCTION_TREE_HEIGHT, GeneratorIndex } from '@aztec/constants';
-import { pedersenHash } from '@aztec/foundation/crypto/pedersen';
 import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';
@@ -38,7 +37,7 @@ export async function computePrivateFunctionLeaf(fn: PrivateFunction): Promise<B
 async function getPrivateFunctionTreeCalculator(): Promise<MerkleTreeCalculator> {
   if (!privateFunctionTreeCalculator) {
     const functionTreeZeroLeaf = (
-      await pedersenHash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))
+      await poseidon2Hash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))
     ).toBuffer() as Buffer<ArrayBuffer>;
     privateFunctionTreeCalculator = await MerkleTreeCalculator.create(
       FUNCTION_TREE_HEIGHT,

package/src/delayed_public_mutable/delayed_public_mutable_values.ts

@@ -68,23 +68,22 @@ export class DelayedPublicMutableValues {
   }
 
   static async readFromTree(delayedPublicMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
-    const fields = [];
-    for (let i = 0; i < DELAYED_PUBLIC_MUTABLE_VALUES_LEN; i++) {
-      fields.push(await readStorage(delayedPublicMutableSlot.add(new Fr(i))));
-    }
-    return DelayedPublicMutableValues.fromFields(fields);
+    const fieldPromises = Array.from({ length: DELAYED_PUBLIC_MUTABLE_VALUES_LEN }).map((_, i) =>
+      readStorage(delayedPublicMutableSlot.add(new Fr(i))),
+    );
+    return DelayedPublicMutableValues.fromFields(await Promise.all(fieldPromises));
   }
 
   isEmpty(): boolean {
     return this.svc.isEmpty() && this.sdc.isEmpty();
   }
 
-  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
-    const fields = this.toFields();
+  writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fieldPromises = this.toFields().map((field, i) =>
+      storageWrite(delayedPublicMutableSlot.add(new Fr(i)), field),
+    );
 
-    for (let i = 0; i < fields.length; i++) {
-      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
-    }
+    return Promise.all(fieldPromises);
   }
 
   async hash(): Promise<Fr> {

package/src/deserialization/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Constants for deserialization bounds checking.
+ * These constants define maximum allowed sizes during deserialization
+ * to prevent DoS attacks via maliciously crafted messages.
+ */
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
+
+/** Max transactions per block for deserialization validation */
+export const MAX_TXS_PER_BLOCK = 2 ** 16;
+
+/** Max committee size - theoretical max from bitmap design (256 bytes × 8 bits) */
+export const MAX_COMMITTEE_SIZE = 2048;
+
+/** Max blocks per checkpoint */
+export const MAX_BLOCKS_PER_CHECKPOINT = 72;
+
+/** Max tx effects per body (based on blob capacity per checkpoint) */
+export const MAX_TX_EFFECTS_PER_BODY = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+
+/** Max block hash string length (hex: 0x + 64 chars, with generous headroom) */
+export const MAX_BLOCK_HASH_STRING_LENGTH = 128;

package/src/epoch-helpers/index.ts

@@ -69,7 +69,7 @@ export function getSlotRangeForEpoch(
   epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
 ): [SlotNumber, SlotNumber] {
-  const startSlot = SlotNumber(epochNumber * constants.epochDuration);
+  const startSlot = SlotNumber(Number(epochNumber) * constants.epochDuration);
   return [startSlot, SlotNumber(startSlot + constants.epochDuration - 1)];
 }
 

package/src/interfaces/api_limit.ts

@@ -1,3 +1,5 @@
 export const MAX_RPC_LEN = 100;
 export const MAX_RPC_TXS_LEN = 50;
 export const MAX_RPC_BLOCKS_LEN = 50;
+export const MAX_RPC_CHECKPOINTS_LEN = 50;
+export const MAX_LOGS_PER_TAG = 10;

package/src/interfaces/archiver.ts

@@ -4,11 +4,10 @@ import type { ApiSchemaFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
-import { CheckpointedL2Block, PublishedL2Block } from '../block/checkpointed_l2_block.js';
+import { CheckpointedL2Block } from '../block/checkpointed_l2_block.js';
 import { L2Block } from '../block/l2_block.js';
-import { L2BlockNew } from '../block/l2_block_new.js';
 import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
-import { ValidateBlockResultSchema } from '../block/validate_block_result.js';
+import { ValidateCheckpointResultSchema } from '../block/validate_block_result.js';
 import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import {
@@ -52,14 +51,14 @@ export type ArchiverSpecificConfig = {
   /** The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb. */
   archiverStoreMapSizeKb?: number;
 
-  /** Whether to skip validating block attestations (use only for testing). */
-  skipValidateBlockAttestations?: boolean;
-
   /** Maximum allowed drift in seconds between the Ethereum client and current time. */
   maxAllowedEthClientDriftSeconds?: number;
 
   /** Whether to allow starting the archiver without debug/trace method support on Ethereum hosts */
   ethereumAllowNoDebugHosts?: boolean;
+
+  /** Skip validating checkpoint attestations (for testing purposes only) */
+  skipValidateCheckpointAttestations?: boolean;
 };
 
 export const ArchiverSpecificConfigSchema = z.object({
@@ -68,9 +67,9 @@ export const ArchiverSpecificConfigSchema = z.object({
   viemPollingIntervalMS: schemas.Integer.optional(),
   maxLogs: schemas.Integer.optional(),
   archiverStoreMapSizeKb: schemas.Integer.optional(),
-  skipValidateBlockAttestations: z.boolean().optional(),
   maxAllowedEthClientDriftSeconds: schemas.Integer.optional(),
   ethereumAllowNoDebugHosts: z.boolean().optional(),
+  skipValidateCheckpointAttestations: z.boolean().optional(),
 });
 
 export type ArchiverApi = Omit<
@@ -83,45 +82,47 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getRegistryAddress: z.function().args().returns(schemas.EthAddress),
   getBlockNumber: z.function().args().returns(BlockNumberSchema),
   getProvenBlockNumber: z.function().args().returns(BlockNumberSchema),
+  getCheckpointedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
+  getFinalizedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
   getBlock: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
   getBlockHeader: z
     .function()
     .args(z.union([BlockNumberSchema, z.literal('latest')]))
     .returns(BlockHeader.schema.optional()),
   getCheckpointedBlock: z.function().args(BlockNumberSchema).returns(CheckpointedL2Block.schema.optional()),
-  getBlocks: z
+  getCheckpointedBlocks: z
     .function()
-    .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
-    .returns(z.array(L2Block.schema)),
-  getPublishedCheckpoints: z
+    .args(BlockNumberSchema, schemas.Integer)
+    .returns(z.array(CheckpointedL2Block.schema)),
+  getBlocks: z.function().args(BlockNumberSchema, schemas.Integer).returns(z.array(L2Block.schema)),
+  getCheckpoints: z
     .function()
     .args(CheckpointNumberSchema, schemas.Integer)
     .returns(z.array(PublishedCheckpoint.schema)),
-  getPublishedBlocks: z
-    .function()
-    .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
-    .returns(z.array(PublishedL2Block.schema)),
-  getPublishedBlockByHash: z.function().args(schemas.Fr).returns(PublishedL2Block.schema.optional()),
-  getPublishedBlockByArchive: z.function().args(schemas.Fr).returns(PublishedL2Block.schema.optional()),
+  getCheckpointedBlockByHash: z.function().args(schemas.Fr).returns(CheckpointedL2Block.schema.optional()),
+  getCheckpointedBlockByArchive: z.function().args(schemas.Fr).returns(CheckpointedL2Block.schema.optional()),
   getBlockHeaderByHash: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
   getBlockHeaderByArchive: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
-  getL2BlockNew: z.function().args(BlockNumberSchema).returns(L2BlockNew.schema.optional()),
+  getL2Block: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
+  getL2BlockByHash: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
+  getL2BlockByArchive: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
   getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
   getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
   getL2SlotNumber: z.function().args().returns(schemas.SlotNumber.optional()),
   getL2EpochNumber: z.function().args().returns(EpochNumberSchema.optional()),
   getCheckpointsForEpoch: z.function().args(EpochNumberSchema).returns(z.array(Checkpoint.schema)),
-  getBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(L2Block.schema)),
-  getBlockHeadersForEpoch: z.function().args(EpochNumberSchema).returns(z.array(BlockHeader.schema)),
+  getCheckpointedBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(CheckpointedL2Block.schema)),
+  getBlocksForSlot: z.function().args(schemas.SlotNumber).returns(z.array(L2Block.schema)),
+  getCheckpointedBlockHeadersForEpoch: z.function().args(EpochNumberSchema).returns(z.array(BlockHeader.schema)),
   isEpochComplete: z.function().args(EpochNumberSchema).returns(z.boolean()),
   getL2Tips: z.function().args().returns(L2TipsSchema),
   getPrivateLogsByTags: z
     .function()
-    .args(z.array(SiloedTag.schema))
+    .args(z.array(SiloedTag.schema), optional(z.number().gte(0)))
     .returns(z.array(z.array(TxScopedL2Log.schema))),
   getPublicLogsByTagsFromContract: z
     .function()
-    .args(schemas.AztecAddress, z.array(Tag.schema))
+    .args(schemas.AztecAddress, z.array(Tag.schema), optional(z.number().gte(0)))
     .returns(z.array(z.array(TxScopedL2Log.schema))),
   getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
   getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
@@ -144,5 +145,5 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getL1Timestamp: z.function().args().returns(schemas.BigInt.optional()),
   syncImmediate: z.function().args().returns(z.void()),
   isPendingChainInvalid: z.function().args().returns(z.boolean()),
-  getPendingChainValidationStatus: z.function().args().returns(ValidateBlockResultSchema),
+  getPendingChainValidationStatus: z.function().args().returns(ValidateCheckpointResultSchema),
 };

package/src/interfaces/aztec-node-admin.ts

@@ -56,7 +56,10 @@ export type AztecNodeAdminConfig = ValidatorClientFullConfig &
   SequencerConfig &
   ProverConfig &
   SlasherConfig &
-  Pick<ArchiverSpecificConfig, 'archiverPollingIntervalMS' | 'skipValidateBlockAttestations' | 'archiverBatchSize'> & {
+  Pick<
+    ArchiverSpecificConfig,
+    'archiverPollingIntervalMS' | 'archiverBatchSize' | 'skipValidateCheckpointAttestations'
+  > & {
     maxPendingTxCount: number;
   };
 
@@ -66,8 +69,8 @@ export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConf
   .merge(
     ArchiverSpecificConfigSchema.pick({
       archiverPollingIntervalMS: true,
-      skipValidateBlockAttestations: true,
       archiverBatchSize: true,
+      skipValidateCheckpointAttestations: true,
     }),
   )
   .merge(z.object({ maxPendingTxCount: z.number() }));