@aztec/stdlib 0.0.1-commit.cf93bcc56 → 0.0.1-commit.d0fcfb7f

package/src/abi/utils.ts

@@ -81,6 +81,31 @@ export function isBoundedVecStruct(abiType: AbiType) {
   );
 }
 
+/**
+ * Returns whether the ABI type is Noir's std::option::Option lowered to a struct.
+ * @param abiType - Type to check.
+ * @returns A boolean indicating whether the ABI type is an Option struct.
+ */
+export function isOptionStruct(abiType: AbiType) {
+  return (
+    abiType.kind === 'struct' &&
+    abiType.path === 'std::option::Option' &&
+    abiType.fields.length === 2 &&
+    abiType.fields[0].name === '_is_some' &&
+    abiType.fields[1].name === '_value'
+  );
+}
+
+/**
+ * Returns whether `null` or `undefined` can be mapped to a valid ABI value for this type.
+ *
+ * @param abiType - Type to check.
+ * @returns A boolean indicating whether nullish values are valid shorthand for this ABI type.
+ */
+export function canBeMappedFromNullOrUndefined(abiType: AbiType) {
+  return isOptionStruct(abiType);
+}
+
 /**
  * Returns a bigint by parsing a serialized 2's complement signed int.
  * @param b - The signed int as a buffer

package/src/avm/revert_code.ts

@@ -5,10 +5,25 @@ import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 import { z } from 'zod';
 
+/**
+ * Tracks which revertible phases of a transaction's public execution reverted.
+ *
+ * A transaction executes in three sequential phases:
+ *   1. SETUP     – non-revertible; if this fails the entire transaction is rejected.
+ *   2. APP_LOGIC – revertible; its state changes are rolled back on failure.
+ *   3. TEARDOWN  – revertible; always runs (even after app-logic revert) so the fee-payment contract can clean up.
+ *
+ * Only APP_LOGIC and TEARDOWN can produce a revert code. SETUP failures throw instead and discard the transaction
+ * entirely.
+ */
 export enum RevertCodeEnum {
+  /** All phases completed successfully; no state was rolled back. */
   OK = 0,
+  /** APP_LOGIC reverted; its state changes were discarded. If present, TEARDOWN still ran and succeeded. */
   APP_LOGIC_REVERTED = 1,
+  /** TEARDOWN reverted; its state changes were discarded. APP_LOGIC succeeded. */
   TEARDOWN_REVERTED = 2,
+  /** Both APP_LOGIC and TEARDOWN reverted; only SETUP effects are kept. */
   BOTH_REVERTED = 3,
 }
 

package/src/block/l2_block.ts

@@ -1,4 +1,5 @@
 import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import { DA_GAS_PER_FIELD } from '@aztec/constants';
 import {
   BlockNumber,
   CheckpointNumber,
@@ -175,7 +176,7 @@ export class L2Block {
     } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
   ): Promise<L2Block> {
     const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
-    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
+    const header = BlockHeader.random({ ...blockHeaderOverrides, blockNumber });
     const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
     return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
@@ -221,4 +222,15 @@ export class L2Block {
       timestamp: this.header.globalVariables.timestamp,
     };
   }
+
+  /**
+   * Compute how much DA gas this block uses.
+   *
+   * @remarks This assumes DA gas is computed solely based on the number of blob fields in transactions.
+   * This may change in the future, but we cannot access the actual DA gas used in a block since it's not exposed
+   * in the L2BlockHeader, so we have to rely on recomputing it.
+   */
+  computeDAGasUsed(): number {
+    return this.body.txEffects.reduce((total, txEffect) => total + txEffect.getNumBlobFields(), 0) * DA_GAS_PER_FIELD;
+  }
 }

package/src/block/l2_block_source.ts

@@ -49,6 +49,12 @@ export interface L2BlockSource {
    */
   getBlockNumber(): Promise<BlockNumber>;
 
+  /**
+   * Gets the number of the latest L2 checkpoint processed by the block source implementation.
+   * @returns The number of the latest L2 checkpoint processed by the block source implementation.
+   */
+  getCheckpointNumber(): Promise<CheckpointNumber>;
+
   /**
    * Gets the number of the latest L2 block proven seen by the block source implementation.
    * @returns The number of the latest L2 block proven seen by the block source implementation.
@@ -170,14 +176,16 @@ export interface L2BlockSource {
   getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
 
   /**
-   * Returns the current L2 slot number based on the currently synced L1 timestamp.
+   * Returns the last L2 slot number that has been fully synchronized from L1.
+   * An L2 slot is fully synced when all L1 blocks that fall within its time range have been processed.
    */
-  getL2SlotNumber(): Promise<SlotNumber | undefined>;
+  getSyncedL2SlotNumber(): Promise<SlotNumber | undefined>;
 
   /**
-   * Returns the current L2 epoch number based on the currently synced L1 timestamp.
+   * Returns the last L2 epoch number that has been fully synchronized from L1.
+   * An epoch is fully synced when all its L2 slots have been fully synced.
    */
-  getL2EpochNumber(): Promise<EpochNumber | undefined>;
+  getSyncedL2EpochNumber(): Promise<EpochNumber | undefined>;
 
   /**
    * Returns all checkpointed block headers for a given epoch.

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -109,6 +109,27 @@ export class L2BlockStream {
 
       let nextBlockNumber = latestBlockNumber + 1;
       let nextCheckpointToEmit = CheckpointNumber(localTips.checkpointed.checkpoint.number + 1);
+
+      // When startingBlock is set, also skip ahead for checkpoints.
+      if (
+        this.opts.startingBlock !== undefined &&
+        this.opts.startingBlock >= 1 &&
+        nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number
+      ) {
+        const startingBlockCheckpoints = await this.l2BlockSource.getCheckpointedBlocks(
+          BlockNumber(this.opts.startingBlock),
+          1,
+        );
+        if (startingBlockCheckpoints.length > 0) {
+          nextCheckpointToEmit = CheckpointNumber(
+            Math.max(nextCheckpointToEmit, startingBlockCheckpoints[0].checkpointNumber),
+          );
+        } else {
+          // startingBlock is past all checkpointed blocks; skip Loop 1 entirely.
+          nextCheckpointToEmit = CheckpointNumber(sourceTips.checkpointed.checkpoint.number + 1);
+        }
+      }
+
       if (this.opts.skipFinalized) {
         // When skipping finalized blocks we need to provide reliable reorg detection while fetching as few blocks as
         // possible. Finalized blocks cannot be reorged by definition, so we can skip most of them. We do need the very

package/src/checkpoint/checkpoint.ts

@@ -6,7 +6,7 @@ import {
   IndexWithinCheckpoint,
   SlotNumber,
 } from '@aztec/foundation/branded-types';
-import { sum } from '@aztec/foundation/collection';
+import { pick, sum } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeSignedBigInt, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -152,10 +152,12 @@ export class Checkpoint {
       startBlockNumber?: number;
       previousArchive?: AppendOnlyTreeSnapshot;
       feeAssetPriceModifier?: bigint;
+      archive?: AppendOnlyTreeSnapshot;
     } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
       Partial<Parameters<typeof L2Block.random>[1]> = {},
   ) {
-    const header = CheckpointHeader.random(options);
+    const headerOptions = previousArchive ? { lastArchiveRoot: previousArchive.root, ...options } : options;
+    const header = CheckpointHeader.random(headerOptions);
 
     // Create blocks sequentially to chain archive roots properly.
     // Each block's header.lastArchive must equal the previous block's archive.
@@ -166,11 +168,18 @@ export class Checkpoint {
         indexWithinCheckpoint: IndexWithinCheckpoint(i),
         ...options,
         ...(lastArchive ? { lastArchive } : {}),
+        ...pick(header, 'slotNumber', 'timestamp', 'coinbase', 'feeRecipient', 'gasFees'),
       });
       lastArchive = block.archive;
       blocks.push(block);
     }
 
-    return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber, feeAssetPriceModifier);
+    return new Checkpoint(
+      options.archive ?? AppendOnlyTreeSnapshot.random(),
+      header,
+      blocks,
+      checkpointNumber,
+      feeAssetPriceModifier,
+    );
   }
 }

package/src/checkpoint/index.ts

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

package/src/checkpoint/validate.ts

@@ -0,0 +1,230 @@
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec/constants';
+import type { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { sum } from '@aztec/foundation/collection';
+
+import { MAX_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
+import type { Checkpoint } from './checkpoint.js';
+
+export class CheckpointValidationError extends Error {
+  constructor(
+    message: string,
+    public readonly checkpointNumber: CheckpointNumber,
+    public readonly slot: SlotNumber,
+  ) {
+    super(message);
+    this.name = 'CheckpointValidationError';
+  }
+}
+
+/**
+ * Validates a checkpoint. Throws a CheckpointValidationError if any validation fails.
+ * - Validates structural integrity (non-empty, block count, sequential numbers, archive chaining, slot consistency)
+ * - Validates checkpoint blob field count against maxBlobFields limit
+ * - Validates total L2 gas used by checkpoint blocks against the Rollup contract mana limit
+ * - Validates total DA gas used by checkpoint blocks against MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT
+ * - Validates individual block L2 gas and DA gas against maxL2BlockGas and maxDABlockGas limits
+ */
+export function validateCheckpoint(
+  checkpoint: Checkpoint,
+  opts: {
+    rollupManaLimit?: number;
+    maxL2BlockGas?: number;
+    maxDABlockGas?: number;
+    maxTxsPerCheckpoint?: number;
+    maxTxsPerBlock?: number;
+  },
+): void {
+  validateCheckpointStructure(checkpoint);
+  validateCheckpointLimits(checkpoint, opts);
+  validateCheckpointBlocksGasLimits(checkpoint, opts);
+}
+
+/**
+ * Validates structural integrity of a checkpoint.
+ * - Non-empty block list
+ * - Block count within MAX_BLOCKS_PER_CHECKPOINT
+ * - Checkpoint slot matches the first block's slot
+ * - Checkpoint lastArchiveRoot matches the first block's lastArchive root
+ * - Sequential block numbers without gaps
+ * - Sequential indexWithinCheckpoint starting at 0
+ * - Archive root chaining between consecutive blocks
+ * - Consistent slot number across all blocks
+ * - Global variables (slot, timestamp, coinbase, feeRecipient, gasFees) match checkpoint header for each block
+ */
+export function validateCheckpointStructure(checkpoint: Checkpoint): void {
+  const { blocks, number, slot } = checkpoint;
+
+  if (blocks.length === 0) {
+    throw new CheckpointValidationError('Checkpoint has no blocks', number, slot);
+  }
+
+  if (blocks.length > MAX_BLOCKS_PER_CHECKPOINT) {
+    throw new CheckpointValidationError(
+      `Checkpoint has ${blocks.length} blocks, exceeding limit of ${MAX_BLOCKS_PER_CHECKPOINT}`,
+      number,
+      slot,
+    );
+  }
+
+  const firstBlock = blocks[0];
+
+  if (!checkpoint.header.lastArchiveRoot.equals(firstBlock.header.lastArchive.root)) {
+    throw new CheckpointValidationError(
+      `Checkpoint lastArchiveRoot does not match first block's lastArchive root`,
+      number,
+      slot,
+    );
+  }
+
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+
+    if (block.indexWithinCheckpoint !== i) {
+      throw new CheckpointValidationError(
+        `Block at index ${i} has indexWithinCheckpoint ${block.indexWithinCheckpoint}, expected ${i}`,
+        number,
+        slot,
+      );
+    }
+
+    if (block.slot !== slot) {
+      throw new CheckpointValidationError(
+        `Block ${block.number} has slot ${block.slot}, expected ${slot} (all blocks must share the same slot)`,
+        number,
+        slot,
+      );
+    }
+
+    if (!checkpoint.header.matchesGlobalVariables(block.header.globalVariables)) {
+      throw new CheckpointValidationError(
+        `Block ${block.number} global variables (slot, timestamp, coinbase, feeRecipient, gasFees) do not match checkpoint header`,
+        number,
+        slot,
+      );
+    }
+
+    if (i > 0) {
+      const prev = blocks[i - 1];
+      if (block.number !== prev.number + 1) {
+        throw new CheckpointValidationError(
+          `Block numbers are not sequential: block at index ${i - 1} has number ${prev.number}, block at index ${i} has number ${block.number}`,
+          number,
+          slot,
+        );
+      }
+
+      if (!block.header.lastArchive.root.equals(prev.archive.root)) {
+        throw new CheckpointValidationError(
+          `Block ${block.number} lastArchive root does not match archive root of block ${prev.number}`,
+          number,
+          slot,
+        );
+      }
+    }
+  }
+}
+
+/** Validates checkpoint blocks gas limits */
+function validateCheckpointBlocksGasLimits(
+  checkpoint: Checkpoint,
+  opts: {
+    maxL2BlockGas?: number;
+    maxDABlockGas?: number;
+    maxTxsPerBlock?: number;
+  },
+): void {
+  const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = opts;
+
+  if (maxL2BlockGas !== undefined) {
+    for (const block of checkpoint.blocks) {
+      const blockL2Gas = block.header.totalManaUsed.toNumber();
+      if (blockL2Gas > maxL2BlockGas) {
+        throw new CheckpointValidationError(
+          `Block ${block.number} in checkpoint has L2 gas used ${blockL2Gas} exceeding limit of ${maxL2BlockGas}`,
+          checkpoint.number,
+          checkpoint.slot,
+        );
+      }
+    }
+  }
+
+  if (maxDABlockGas !== undefined) {
+    for (const block of checkpoint.blocks) {
+      const blockDAGas = block.computeDAGasUsed();
+      if (blockDAGas > maxDABlockGas) {
+        throw new CheckpointValidationError(
+          `Block ${block.number} in checkpoint has DA gas used ${blockDAGas} exceeding limit of ${maxDABlockGas}`,
+          checkpoint.number,
+          checkpoint.slot,
+        );
+      }
+    }
+  }
+
+  if (maxTxsPerBlock !== undefined) {
+    for (const block of checkpoint.blocks) {
+      const blockTxCount = block.body.txEffects.length;
+      if (blockTxCount > maxTxsPerBlock) {
+        throw new CheckpointValidationError(
+          `Block ${block.number} in checkpoint has ${blockTxCount} txs exceeding limit of ${maxTxsPerBlock}`,
+          checkpoint.number,
+          checkpoint.slot,
+        );
+      }
+    }
+  }
+}
+
+/** Validates checkpoint max blob fields, gas limits, and tx limits */
+function validateCheckpointLimits(
+  checkpoint: Checkpoint,
+  opts: {
+    rollupManaLimit?: number;
+    maxTxsPerCheckpoint?: number;
+  },
+): void {
+  const { rollupManaLimit, maxTxsPerCheckpoint } = opts;
+
+  const maxBlobFields = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+  const maxDAGas = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+
+  if (rollupManaLimit !== undefined) {
+    const checkpointMana = sum(checkpoint.blocks.map(block => block.header.totalManaUsed.toNumber()));
+    if (checkpointMana > rollupManaLimit) {
+      throw new CheckpointValidationError(
+        `Checkpoint mana cost ${checkpointMana} exceeds rollup limit of ${rollupManaLimit}`,
+        checkpoint.number,
+        checkpoint.slot,
+      );
+    }
+  }
+
+  const checkpointDAGas = sum(checkpoint.blocks.map(block => block.computeDAGasUsed()));
+  if (checkpointDAGas > maxDAGas) {
+    throw new CheckpointValidationError(
+      `Checkpoint DA gas cost ${checkpointDAGas} exceeds limit of ${maxDAGas}`,
+      checkpoint.number,
+      checkpoint.slot,
+    );
+  }
+
+  const checkpointBlobFields = checkpoint.toBlobFields().length;
+  if (checkpointBlobFields > maxBlobFields) {
+    throw new CheckpointValidationError(
+      `Checkpoint blob field count ${checkpointBlobFields} exceeds limit of ${maxBlobFields}`,
+      checkpoint.number,
+      checkpoint.slot,
+    );
+  }
+
+  if (maxTxsPerCheckpoint !== undefined) {
+    const checkpointTxCount = sum(checkpoint.blocks.map(block => block.body.txEffects.length));
+    if (checkpointTxCount > maxTxsPerCheckpoint) {
+      throw new CheckpointValidationError(
+        `Checkpoint tx count ${checkpointTxCount} exceeds limit of ${maxTxsPerCheckpoint}`,
+        checkpoint.number,
+        checkpoint.slot,
+      );
+    }
+  }
+}

package/src/config/sequencer-config.ts

@@ -8,7 +8,9 @@ import type { SequencerConfig } from '../interfaces/configs.js';
  * (like blockDurationMs needed by both p2p and sequencer-client) are defined here
  * to avoid duplication.
  */
-export const sharedSequencerConfigMappings: ConfigMappingsType<Pick<SequencerConfig, 'blockDurationMs'>> = {
+export const sharedSequencerConfigMappings: ConfigMappingsType<
+  Pick<SequencerConfig, 'blockDurationMs' | 'expectedBlockProposalsPerSlot' | 'maxTxsPerBlock'>
+> = {
   blockDurationMs: {
     env: 'SEQ_BLOCK_DURATION_MS',
     description:
@@ -16,4 +18,17 @@ export const sharedSequencerConfigMappings: ConfigMappingsType<Pick<SequencerCon
       'If undefined (default), builds a single block per slot using the full slot duration.',
     parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
   },
+  expectedBlockProposalsPerSlot: {
+    env: 'SEQ_EXPECTED_BLOCK_PROPOSALS_PER_SLOT',
+    description:
+      'Expected number of block proposals per slot for P2P peer scoring. ' +
+      '0 (default) disables block proposal scoring. Set to a positive value to enable.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : 0),
+    defaultValue: 0,
+  },
+  maxTxsPerBlock: {
+    env: 'SEQ_MAX_TX_PER_BLOCK',
+    description: 'The maximum number of txs to include in a block.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
 };

package/src/contract/contract_class.ts

@@ -8,7 +8,7 @@ import { type ContractClassIdPreimage, computeContractClassIdWithPreimage } from
 import type { ContractClass, ContractClassWithId } from './interfaces/index.js';
 
 /** Contract artifact including its artifact hash */
-type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
+export type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
 
 const cmpFunctionArtifacts = <T extends { selector: FunctionSelector }>(a: T, b: T) =>
   a.selector.toField().cmp(b.selector.toField());
@@ -35,8 +35,8 @@ export async function getContractClassFromArtifact(
 
   privateArtifactFunctions.sort(cmpFunctionArtifacts);
 
-  const contractClass: ContractClass = {
-    version: 1,
+  const contractClass = {
+    version: 1 as const,
     artifactHash,
     packedBytecode,
     privateFunctions: privateArtifactFunctions,

package/src/epoch-helpers/index.ts

@@ -12,6 +12,7 @@ export type L1RollupConstants = {
   ethereumSlotDuration: number;
   proofSubmissionEpochs: number;
   targetCommitteeSize: number;
+  rollupManaLimit: number;
 };
 
 export const EmptyL1RollupConstants: L1RollupConstants = {
@@ -22,6 +23,7 @@ export const EmptyL1RollupConstants: L1RollupConstants = {
   ethereumSlotDuration: 1,
   proofSubmissionEpochs: 1,
   targetCommitteeSize: 48,
+  rollupManaLimit: Number.MAX_SAFE_INTEGER,
 };
 
 export const L1RollupConstantsSchema = zodFor<L1RollupConstants>()(
@@ -33,6 +35,7 @@ export const L1RollupConstantsSchema = zodFor<L1RollupConstants>()(
     ethereumSlotDuration: z.number(),
     proofSubmissionEpochs: z.number(),
     targetCommitteeSize: z.number(),
+    rollupManaLimit: z.number(),
   }),
 );
 

package/src/interfaces/allowed_element.ts

@@ -6,18 +6,38 @@ import type { FunctionSelector } from '../abi/function_selector.js';
 import type { AztecAddress } from '../aztec-address/index.js';
 import { schemas, zodFor } from '../schemas/index.js';
 
-type AllowedInstance = { address: AztecAddress };
-type AllowedInstanceFunction = { address: AztecAddress; selector: FunctionSelector };
-type AllowedClass = { classId: Fr };
-type AllowedClassFunction = { classId: Fr; selector: FunctionSelector };
+type AllowedInstanceFunction = {
+  address: AztecAddress;
+  selector: FunctionSelector;
+  onlySelf?: boolean;
+  rejectNullMsgSender?: boolean;
+  calldataLength?: number;
+};
+type AllowedClassFunction = {
+  classId: Fr;
+  selector: FunctionSelector;
+  onlySelf?: boolean;
+  rejectNullMsgSender?: boolean;
+  calldataLength?: number;
+};
 
-export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
+export type AllowedElement = AllowedInstanceFunction | AllowedClassFunction;
 
 export const AllowedElementSchema = zodFor<AllowedElement>()(
   z.union([
-    z.object({ address: schemas.AztecAddress, selector: schemas.FunctionSelector }),
-    z.object({ address: schemas.AztecAddress }),
-    z.object({ classId: schemas.Fr, selector: schemas.FunctionSelector }),
-    z.object({ classId: schemas.Fr }),
+    z.object({
+      address: schemas.AztecAddress,
+      selector: schemas.FunctionSelector,
+      onlySelf: z.boolean().optional(),
+      rejectNullMsgSender: z.boolean().optional(),
+      calldataLength: z.number().optional(),
+    }),
+    z.object({
+      classId: schemas.Fr,
+      selector: schemas.FunctionSelector,
+      onlySelf: z.boolean().optional(),
+      rejectNullMsgSender: z.boolean().optional(),
+      calldataLength: z.number().optional(),
+    }),
   ]),
 );

package/src/interfaces/archiver.ts

@@ -86,6 +86,7 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getBlockNumber: z.function().args().returns(BlockNumberSchema),
   getProvenBlockNumber: z.function().args().returns(BlockNumberSchema),
   getCheckpointedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
+  getCheckpointNumber: z.function().args().returns(CheckpointNumberSchema),
   getFinalizedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
   getBlock: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
   getBlockHeader: z
@@ -113,8 +114,8 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   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()),
+  getSyncedL2SlotNumber: z.function().args().returns(schemas.SlotNumber.optional()),
+  getSyncedL2EpochNumber: z.function().args().returns(EpochNumberSchema.optional()),
   getCheckpointsForEpoch: z.function().args(EpochNumberSchema).returns(z.array(Checkpoint.schema)),
   getCheckpointsDataForEpoch: z.function().args(EpochNumberSchema).returns(z.array(CheckpointDataSchema)),
   getCheckpointedBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(CheckpointedL2Block.schema)),

package/src/interfaces/aztec-node.ts

@@ -4,7 +4,9 @@ import {
   BlockNumber,
   BlockNumberPositiveSchema,
   BlockNumberSchema,
+  CheckpointNumber,
   CheckpointNumberPositiveSchema,
+  CheckpointNumberSchema,
   EpochNumber,
   EpochNumberSchema,
   type SlotNumber,
@@ -23,6 +25,7 @@ import { CheckpointedL2Block } from '../block/checkpointed_l2_block.js';
 import { type DataInBlock, dataInBlockSchemaFor } from '../block/in_block.js';
 import { L2Block } from '../block/l2_block.js';
 import { type L2BlockSource, type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
+import { CheckpointDataSchema } from '../checkpoint/checkpoint_data.js';
 import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import {
   type ContractClassPublic,
@@ -72,7 +75,12 @@ import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_s
 export interface AztecNode
   extends Pick<
     L2BlockSource,
-    'getBlocks' | 'getCheckpoints' | 'getBlockHeader' | 'getL2Tips' | 'getCheckpointedBlocks'
+    | 'getBlocks'
+    | 'getCheckpoints'
+    | 'getBlockHeader'
+    | 'getL2Tips'
+    | 'getCheckpointedBlocks'
+    | 'getCheckpointsDataForEpoch'
   > {
   /**
    * Returns the tips of the L2 chain.
@@ -172,14 +180,14 @@ export interface AztecNode
     l1ToL2Message: Fr,
   ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>] | undefined>;
 
-  /** Returns the L2 block number in which this L1 to L2 message becomes available, or undefined if not found. */
-  getL1ToL2MessageBlock(l1ToL2Message: Fr): Promise<BlockNumber | undefined>;
+  /** Returns the L2 checkpoint number in which this L1 to L2 message becomes available, or undefined if not found. */
+  getL1ToL2MessageCheckpoint(l1ToL2Message: Fr): Promise<CheckpointNumber | undefined>;
 
   /**
    * Returns whether an L1 to L2 message is synced by archiver.
    * @param l1ToL2Message - The L1 to L2 message to check.
    * @returns Whether the message is synced.
-   * @deprecated Use `getL1ToL2MessageBlock` instead. This method may return true even if the message is not ready to use.
+   * @deprecated Use `getL1ToL2MessageCheckpoint` instead. This method may return true even if the message is not ready to use.
    */
   isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean>;
 
@@ -230,6 +238,12 @@ export interface AztecNode
    */
   getCheckpointedBlockNumber(): Promise<BlockNumber>;
 
+  /**
+   * Method to fetch the latest checkpoint number synchronized by the node.
+   * @returns The checkpoint number.
+   */
+  getCheckpointNumber(): Promise<CheckpointNumber>;
+
   /**
    * Method to determine if the node is ready to accept transactions.
    * @returns - Flag indicating the readiness for tx submission.
@@ -517,7 +531,7 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
     .args(BlockParameterSchema, schemas.Fr)
     .returns(z.tuple([schemas.BigInt, SiblingPath.schemaFor(L1_TO_L2_MSG_TREE_HEIGHT)]).optional()),
 
-  getL1ToL2MessageBlock: z.function().args(schemas.Fr).returns(BlockNumberSchema.optional()),
+  getL1ToL2MessageCheckpoint: z.function().args(schemas.Fr).returns(CheckpointNumberSchema.optional()),
 
   isL1ToL2MessageSynced: z.function().args(schemas.Fr).returns(z.boolean()),
 
@@ -534,6 +548,8 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   getBlockNumber: z.function().returns(BlockNumberSchema),
 
+  getCheckpointNumber: z.function().returns(CheckpointNumberSchema),
+
   getProvenBlockNumber: z.function().returns(BlockNumberSchema),
 
   getCheckpointedBlockNumber: z.function().returns(BlockNumberSchema),
@@ -557,6 +573,8 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
     .args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN))
     .returns(z.array(CheckpointedL2Block.schema)),
 
+  getCheckpointsDataForEpoch: z.function().args(EpochNumberSchema).returns(z.array(CheckpointDataSchema)),
+
   getCurrentMinFees: z.function().returns(GasFees.schema),
 
   getMaxPriorityFees: z.function().returns(GasFees.schema),