@aztec/stdlib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/file-store/s3.ts

@@ -0,0 +1,250 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import {
+  GetObjectCommand,
+  type GetObjectCommandOutput,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { createReadStream, createWriteStream } from 'fs';
+import { mkdir, mkdtemp, stat, unlink } from 'fs/promises';
+import { tmpdir } from 'os';
+import { basename, dirname, join } from 'path';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { createGzip } from 'zlib';
+
+import type { FileStore, FileStoreSaveOptions } from './interface.js';
+
+function normalizeBasePath(path: string): string {
+  return path?.replace(/^\/+|\/+$/g, '') ?? '';
+}
+
+export class S3FileStore implements FileStore {
+  private readonly s3: S3Client;
+  private readonly region: string;
+  private readonly endpoint?: string;
+  private readonly publicBaseUrl?: string;
+
+  constructor(
+    private readonly bucketName: string,
+    private readonly basePath: string,
+    opts: { endpoint?: string; publicBaseUrl?: string },
+    private readonly log: Logger = createLogger('stdlib:s3-file-store'),
+  ) {
+    this.endpoint = opts.endpoint;
+    this.region = this.endpoint ? 'auto' : (process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1');
+    this.publicBaseUrl = opts.publicBaseUrl;
+
+    const clientOptions: any = {};
+    if (this.endpoint) {
+      clientOptions.region = 'auto';
+      clientOptions.endpoint = this.endpoint;
+      clientOptions.forcePathStyle = true;
+    } else {
+      clientOptions.region = this.region;
+    }
+    this.s3 = new S3Client(clientOptions);
+  }
+
+  public async save(path: string, data: Buffer, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(path);
+    const shouldCompress = !!opts.compress;
+
+    const body = shouldCompress ? (await import('zlib')).gzipSync(data) : data;
+    const contentLength = body.length;
+    const contentType = this.detectContentType(key, shouldCompress);
+    const put = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: body,
+      ContentType: contentType,
+      CacheControl: opts.metadata?.['Cache-control'],
+      Metadata: this.extractUserMetadata(opts.metadata),
+      ContentLength: contentLength,
+    });
+    await this.s3.send(put);
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async upload(destPath: string, srcPath: string, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(destPath);
+    const shouldCompress = opts.compress !== false; // default true like GCS impl
+
+    await mkdir(dirname(srcPath), { recursive: true }).catch(() => undefined);
+    let contentLength: number | undefined;
+    let bodyPath = srcPath;
+
+    // We don't set Content-Encoding and we avoid SigV4 streaming (aws-chunked).
+    // With AWS SigV4 streaming uploads (Content-Encoding: aws-chunked[,gzip]), servers require
+    // x-amz-decoded-content-length (the size of the decoded payload) and an exact Content-Length
+    // that includes chunk metadata. For on-the-fly compression, providing
+    // those values without buffering or a pre-pass is impractical. Instead, we pre-gzip to a temp file
+    // to know ContentLength up-front and upload the gzipped bytes as-is, omitting Content-Encoding.
+    // Reference: AWS SigV4 streaming (chunked upload) requirements —
+    // https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming.html
+    if (shouldCompress) {
+      // Pre-gzip to a temp file so we know the exact length for R2/S3 headers
+      const tmpDir = await mkdtemp(join(tmpdir(), 's3-upload-'));
+      const gzPath = join(tmpDir, `${basename(srcPath)}.gz`);
+      try {
+        await pipeline(createReadStream(srcPath), createGzip(), createWriteStream(gzPath));
+        const st = await stat(gzPath);
+        contentLength = st.size;
+        bodyPath = gzPath;
+      } catch (err) {
+        // Ensure temp file is removed on failure
+        await unlink(gzPath).catch(() => undefined);
+        throw err;
+      }
+    } else {
+      const st = await stat(srcPath);
+      contentLength = st.size;
+      bodyPath = srcPath;
+    }
+
+    const bodyStream = createReadStream(bodyPath);
+    const contentType = this.detectContentType(key, shouldCompress);
+    try {
+      const put = new PutObjectCommand({
+        Bucket: this.bucketName,
+        Key: key,
+        Body: bodyStream as any,
+        ContentType: contentType,
+        CacheControl: opts.metadata?.['Cache-control'],
+        Metadata: this.extractUserMetadata(opts.metadata),
+        // Explicitly set ContentLength so R2 can compute x-amz-decoded-content-length correctly
+        ContentLength: contentLength,
+      } as any);
+      await this.s3.send(put);
+    } finally {
+      if (shouldCompress && bodyPath !== srcPath) {
+        await unlink(bodyPath).catch(() => undefined);
+      }
+    }
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async read(pathOrUrlStr: string): Promise<Buffer> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    const stream = out.Body as Readable;
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+
+  public async download(pathOrUrlStr: string, destPath: string): Promise<void> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    await mkdir(dirname(destPath), { recursive: true });
+    await pipeline(out.Body as Readable, createWriteStream(destPath));
+  }
+
+  public async exists(pathOrUrlStr: string): Promise<boolean> {
+    try {
+      const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+      await this.s3.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+      return true;
+    } catch (err: any) {
+      const code = err?.$metadata?.httpStatusCode ?? err?.name ?? err?.Code;
+      if (code === 404 || code === 'NotFound' || code === 'NoSuchKey') {
+        return false;
+      }
+      this.log.warn(`Error checking existence for ${pathOrUrlStr}: ${err?.message ?? String(err)}`);
+      return false;
+    }
+  }
+
+  private extractUserMetadata(meta?: Record<string, string>): Record<string, string> | undefined {
+    if (!meta) {
+      return undefined;
+    }
+    const { ['Cache-control']: _ignored, ...rest } = meta;
+    return Object.keys(rest).length ? rest : undefined;
+  }
+
+  private detectContentType(key: string, isCompressed: boolean | undefined): string | undefined {
+    // Basic content type inference
+    const lower = key.toLowerCase();
+    if (lower.endsWith('.json') || lower.endsWith('.json.gz')) {
+      return 'application/json';
+    }
+    if (lower.endsWith('.txt') || lower.endsWith('.log') || lower.endsWith('.csv') || lower.endsWith('.md')) {
+      return 'text/plain; charset=utf-8';
+    }
+    if (lower.endsWith('.db') || lower.endsWith('.sqlite') || lower.endsWith('.bin')) {
+      return 'application/octet-stream';
+    }
+    if (lower.endsWith('.wasm') || lower.endsWith('.wasm.gz')) {
+      return 'application/wasm';
+    }
+    // If compressed, prefer octet-stream unless known
+    if (isCompressed) {
+      return 'application/octet-stream';
+    }
+    return undefined;
+  }
+
+  private buildReturnedUrl(key: string, makePublic: boolean): string {
+    if (!makePublic) {
+      return `s3://${this.bucketName}/${key}`;
+    }
+
+    if (this.publicBaseUrl) {
+      const base = this.publicBaseUrl.replace(/\/$/, '');
+      // key already includes basePath via getFullPath, so do not prefix basePath again
+      const full = key.replace(/^\/+/, '');
+      return `${base}/${full}`;
+    }
+
+    // Try to synthesize a URL from endpoint if available (works for public R2 buckets)
+    if (this.endpoint) {
+      try {
+        const url = new URL(this.endpoint);
+        return `https://${this.bucketName}.${url.host}/${key}`;
+      } catch {
+        // fallthrough
+      }
+    }
+
+    // Fallback to AWS style URL if region looks valid
+    return `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}`;
+  }
+
+  private getBucketAndKey(pathOrUrlStr: string): { bucket: string; key: string } {
+    if (URL.canParse(pathOrUrlStr)) {
+      const url = new URL(pathOrUrlStr);
+      if (url.protocol === 's3:') {
+        return { bucket: url.host, key: url.pathname.replace(/^\/+/, '') };
+      }
+      // For https URLs, try to infer virtual-hosted or path-style
+      if (url.protocol === 'https:' || url.protocol === 'http:') {
+        // If the URL matches the configured publicBaseUrl host, map back to our bucket and key
+        if (this.publicBaseUrl && url.host === new URL(this.publicBaseUrl).host) {
+          return { bucket: this.bucketName, key: url.pathname.replace(/^\/+/, '') };
+        }
+        const hostParts = url.host.split('.');
+        if (hostParts.length > 3 && (hostParts[1] === 's3' || hostParts[hostParts.length - 2] === 'r2')) {
+          // virtual hosted
+          return { bucket: hostParts[0], key: url.pathname.replace(/^\/+/, '') };
+        } else if (this.endpoint && url.host === new URL(this.endpoint).host) {
+          // path-style at custom endpoint
+          const [bucket, ...rest] = url.pathname.replace(/^\/+/, '').split('/');
+          return { bucket, key: rest.join('/') };
+        }
+      }
+    }
+    // Treat as path
+    return { bucket: this.bucketName, key: this.getFullPath(pathOrUrlStr) };
+  }
+
+  private getFullPath(path: string): string {
+    const base = normalizeBasePath(this.basePath);
+    const rel = path.replace(/^\/+/, '');
+    return base ? join(base, rel) : rel;
+  }
+}

package/src/gas/gas.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -48,6 +48,20 @@ export class Gas {
     return new Gas(fields.daGas ?? 0, fields.l2Gas ?? 0);
   }
 
+  /**
+   * Creates a Gas instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing Gas fields
+   * @returns A Gas instance
+   */
+  static fromPlainObject(obj: any): Gas {
+    if (obj instanceof Gas) {
+      return obj;
+    }
+    return Gas.from(obj);
+  }
+
   static empty() {
     return new Gas(0, 0);
   }

package/src/gas/gas_fees.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import {
   BufferReader,
@@ -65,6 +65,20 @@ export class GasFees {
     return new GasFees(fields.feePerDaGas, fields.feePerL2Gas);
   }
 
+  /**
+   * Creates a GasFees instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing GasFees fields
+   * @returns A GasFees instance
+   */
+  static fromPlainObject(obj: any): GasFees {
+    if (obj instanceof GasFees) {
+      return obj;
+    }
+    return GasFees.from(obj);
+  }
+
   static random() {
     return new GasFees(Math.floor(Math.random() * 1e9), Math.floor(Math.random() * 1e9));
   }

package/src/gas/gas_settings.ts

@@ -5,7 +5,7 @@ import {
   DEFAULT_TEARDOWN_L2_GAS_LIMIT,
   GAS_SETTINGS_LENGTH,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -54,6 +54,25 @@ export class GasSettings {
     );
   }
 
+  /**
+   * Creates a GasSettings instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing GasSettings fields
+   * @returns A GasSettings instance
+   */
+  static fromPlainObject(obj: any): GasSettings {
+    if (obj instanceof GasSettings) {
+      return obj;
+    }
+    return new GasSettings(
+      Gas.fromPlainObject(obj.gasLimits),
+      Gas.fromPlainObject(obj.teardownGasLimits),
+      GasFees.fromPlainObject(obj.maxFeesPerGas),
+      GasFees.fromPlainObject(obj.maxPriorityFeesPerGas),
+    );
+  }
+
   clone() {
     return new GasSettings(
       this.gasLimits.clone(),

package/src/gas/gas_used.ts

@@ -1,4 +1,4 @@
-import type { Gas } from './gas.js';
+import { Gas } from './gas.js';
 
 export interface GasUsed {
   /**
@@ -21,3 +21,24 @@ export interface GasUsed {
    */
   billedGas: Gas;
 }
+
+/**
+ * Creates a GasUsed from a plain object without Zod validation.
+ * This method is optimized for performance and skips validation, making it suitable
+ * for deserializing trusted data (e.g., from C++ via MessagePack).
+ * @param obj - Plain object containing GasUsed fields
+ * @returns A GasUsed object
+ */
+export function gasUsedFromPlainObject(obj: any): GasUsed {
+  return {
+    totalGas: Gas.fromPlainObject(obj.totalGas),
+    publicGas: Gas.fromPlainObject(obj.publicGas),
+    teardownGas: Gas.fromPlainObject(obj.teardownGas),
+    billedGas: Gas.fromPlainObject(obj.billedGas),
+  };
+}
+
+// Export as a namespace to match the pattern
+export const GasUsed = {
+  fromPlainObject: gasUsedFromPlainObject,
+};

package/src/hash/hash.ts

@@ -1,9 +1,10 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2Hash, poseidon2HashWithSeparator, sha256ToField } from '@aztec/foundation/crypto';
+import { GeneratorIndex, NULL_MSG_SENDER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 
-import type { AztecAddress } from '../aztec-address/index.js';
+import { AztecAddress } from '../aztec-address/index.js';
 
 /**
  * Computes a hash of a given verification key.
@@ -58,14 +59,14 @@ export function siloNullifier(contract: AztecAddress, innerNullifier: Fr): Promi
 }
 
 /**
- * Computes a siloed private log tag, given the contract address and the unsiloed tag.
- * A siloed private log tag effectively namespaces a log to a specific contract.
- * @param contract - The contract address.
- * @param unsiloedTag - The unsiloed tag.
- * @returns A siloed private log tag.
+ * Computes the protocol nullifier, which is the hash of the initial tx request siloed with the null msg sender address.
+ * @param txRequestHash - The hash of the initial tx request.
+ * @returns The siloed value of the protocol nullifier.
+ *
+ * @dev Must match the implementation in noir-protocol-circuits/crates/types/src/hash.nr > compute_protocol_nullifier
  */
-export function siloPrivateLog(contract: AztecAddress, unsiloedTag: Fr): Promise<Fr> {
-  return poseidon2Hash([contract, unsiloedTag]);
+export function computeProtocolNullifier(txRequestHash: Fr): Promise<Fr> {
+  return siloNullifier(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS), txRequestHash);
 }
 
 /**
@@ -109,10 +110,6 @@ export function computeVarArgsHash(args: Fr[]): Promise<Fr> {
  * @returns Hash of the calldata.
  */
 export function computeCalldataHash(calldata: Fr[]): Promise<Fr> {
-  if (calldata.length === 0) {
-    return Promise.resolve(Fr.ZERO);
-  }
-
   return poseidon2HashWithSeparator(calldata, GeneratorIndex.PUBLIC_CALLDATA);
 }
 

package/src/hash/map_slot.ts

@@ -1,5 +1,5 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import type { Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 /**
  * Computes the resulting storage slot for an entry in a map.

package/src/interfaces/allowed_element.ts

@@ -1,10 +1,10 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import { z } from 'zod';
 
 import type { FunctionSelector } from '../abi/function_selector.js';
 import type { AztecAddress } from '../aztec-address/index.js';
-import { type ZodFor, schemas } from '../schemas/index.js';
+import { schemas, zodFor } from '../schemas/index.js';
 
 type AllowedInstance = { address: AztecAddress };
 type AllowedInstanceFunction = { address: AztecAddress; selector: FunctionSelector };
@@ -13,9 +13,11 @@ type AllowedClassFunction = { classId: Fr; selector: FunctionSelector };
 
 export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
 
-export const AllowedElementSchema = 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 }),
-]) satisfies ZodFor<AllowedElement>;
+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 }),
+  ]),
+);

package/src/interfaces/archiver.ts

@@ -1,10 +1,16 @@
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { BlockNumberSchema, CheckpointNumberSchema, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import type { ApiSchemaFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
+import { CheckpointedL2Block, PublishedL2Block } from '../block/checkpointed_l2_block.js';
 import { L2Block } from '../block/l2_block.js';
-import { type L2BlockSource, L2TipsSchema, ValidateBlockResultSchema } from '../block/l2_block_source.js';
-import { PublishedL2Block } from '../block/published_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 { Checkpoint } from '../checkpoint/checkpoint.js';
+import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import {
   ContractClassPublicSchema,
   type ContractDataSource,
@@ -12,7 +18,8 @@ import {
 } from '../contract/index.js';
 import { L1RollupConstantsSchema } from '../epoch-helpers/index.js';
 import { LogFilterSchema } from '../logs/log_filter.js';
-import { PrivateLog } from '../logs/private_log.js';
+import { SiloedTag } from '../logs/siloed_tag.js';
+import { Tag } from '../logs/tag.js';
 import { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
 import type { L1ToL2MessageSource } from '../messaging/l1_to_l2_message_source.js';
 import { optional, schemas } from '../schemas/schemas.js';
@@ -23,6 +30,49 @@ import { TxReceipt } from '../tx/tx_receipt.js';
 import { GetContractClassLogsResponseSchema, GetPublicLogsResponseSchema } from './get_logs_response.js';
 import type { L2LogsSource } from './l2_logs_source.js';
 
+/**
+ * The archiver configuration.
+ */
+export type ArchiverSpecificConfig = {
+  /** The polling interval in ms for retrieving new L2 blocks and encrypted logs. */
+  archiverPollingIntervalMS?: number;
+
+  /** The number of L2 blocks the archiver will attempt to download at a time. */
+  archiverBatchSize?: number;
+
+  /** The polling interval viem uses in ms */
+  viemPollingIntervalMS?: number;
+
+  /** The deployed L1 contract addresses */
+  l1Contracts: L1ContractAddresses;
+
+  /** The max number of logs that can be obtained in 1 "getPublicLogs" call. */
+  maxLogs?: number;
+
+  /** 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;
+};
+
+export const ArchiverSpecificConfigSchema = z.object({
+  archiverPollingIntervalMS: schemas.Integer.optional(),
+  archiverBatchSize: schemas.Integer.optional(),
+  viemPollingIntervalMS: schemas.Integer.optional(),
+  maxLogs: schemas.Integer.optional(),
+  archiverStoreMapSizeKb: schemas.Integer.optional(),
+  skipValidateBlockAttestations: z.boolean().optional(),
+  maxAllowedEthClientDriftSeconds: schemas.Integer.optional(),
+  ethereumAllowNoDebugHosts: z.boolean().optional(),
+});
+
 export type ArchiverApi = Omit<
   L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource,
   'start' | 'stop'
@@ -31,33 +81,47 @@ export type ArchiverApi = Omit<
 export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getRollupAddress: z.function().args().returns(schemas.EthAddress),
   getRegistryAddress: z.function().args().returns(schemas.EthAddress),
-  getBlockNumber: z.function().args().returns(schemas.Integer),
-  getProvenBlockNumber: z.function().args().returns(schemas.Integer),
-  getBlock: z.function().args(schemas.Integer).returns(L2Block.schema.optional()),
+  getBlockNumber: z.function().args().returns(BlockNumberSchema),
+  getProvenBlockNumber: z.function().args().returns(BlockNumberSchema),
+  getBlock: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
   getBlockHeader: z
     .function()
-    .args(z.union([schemas.Integer, z.literal('latest')]))
+    .args(z.union([BlockNumberSchema, z.literal('latest')]))
     .returns(BlockHeader.schema.optional()),
+  getCheckpointedBlock: z.function().args(BlockNumberSchema).returns(CheckpointedL2Block.schema.optional()),
   getBlocks: z
     .function()
-    .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
+    .args(BlockNumberSchema, schemas.Integer, optional(z.boolean()))
     .returns(z.array(L2Block.schema)),
+  getPublishedCheckpoints: z
+    .function()
+    .args(CheckpointNumberSchema, schemas.Integer)
+    .returns(z.array(PublishedCheckpoint.schema)),
   getPublishedBlocks: z
     .function()
-    .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
+    .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()),
+  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()),
   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.BigInt),
-  getL2EpochNumber: z.function().args().returns(schemas.BigInt),
-  getBlocksForEpoch: z.function().args(schemas.BigInt).returns(z.array(L2Block.schema)),
-  getBlockHeadersForEpoch: z.function().args(schemas.BigInt).returns(z.array(BlockHeader.schema)),
-  isEpochComplete: z.function().args(schemas.BigInt).returns(z.boolean()),
+  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)),
+  isEpochComplete: z.function().args(EpochNumberSchema).returns(z.boolean()),
   getL2Tips: z.function().args().returns(L2TipsSchema),
-  getPrivateLogs: z.function().args(z.number(), z.number()).returns(z.array(PrivateLog.schema)),
-  getLogsByTags: z
+  getPrivateLogsByTags: z
     .function()
-    .args(z.array(schemas.Fr))
+    .args(z.array(SiloedTag.schema))
+    .returns(z.array(z.array(TxScopedL2Log.schema))),
+  getPublicLogsByTagsFromContract: z
+    .function()
+    .args(schemas.AztecAddress, z.array(Tag.schema))
     .returns(z.array(z.array(TxScopedL2Log.schema))),
   getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
   getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
@@ -69,11 +133,15 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
     .returns(ContractInstanceWithAddressSchema.optional()),
   getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
   registerContractFunctionSignatures: z.function().args(z.array(z.string())).returns(z.void()),
-  getL1ToL2Messages: z.function().args(schemas.Integer).returns(z.array(schemas.Fr)),
+  getL1ToL2Messages: z.function().args(CheckpointNumberSchema).returns(z.array(schemas.Fr)),
   getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
   getDebugFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
   getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
-  getL1Timestamp: z.function().args().returns(schemas.BigInt),
+  getGenesisValues: z
+    .function()
+    .args()
+    .returns(z.object({ genesisArchiveRoot: schemas.Fr })),
+  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),

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

@@ -5,10 +5,11 @@ import { z } from 'zod';
 import type { ApiSchemaFor } from '../schemas/schemas.js';
 import { type Offense, OffenseSchema, type SlashPayloadRound, SlashPayloadRoundSchema } from '../slashing/index.js';
 import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
+import { type ArchiverSpecificConfig, ArchiverSpecificConfigSchema } from './archiver.js';
 import { type SequencerConfig, SequencerConfigSchema } from './configs.js';
 import { type ProverConfig, ProverConfigSchema } from './prover-client.js';
 import { type SlasherConfig, SlasherConfigSchema } from './slasher.js';
-import { ValidatorClientConfigSchema, type ValidatorClientFullConfig } from './validator.js';
+import { type ValidatorClientFullConfig, ValidatorClientFullConfigSchema } from './validator.js';
 
 /**
  * Aztec node admin API.
@@ -54,12 +55,22 @@ export interface AztecNodeAdmin {
 export type AztecNodeAdminConfig = ValidatorClientFullConfig &
   SequencerConfig &
   ProverConfig &
-  SlasherConfig & { maxTxPoolSize: number };
+  SlasherConfig &
+  Pick<ArchiverSpecificConfig, 'archiverPollingIntervalMS' | 'skipValidateBlockAttestations' | 'archiverBatchSize'> & {
+    maxPendingTxCount: number;
+  };
 
 export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConfigSchema)
   .merge(SlasherConfigSchema)
-  .merge(ValidatorClientConfigSchema)
-  .merge(z.object({ maxTxPoolSize: z.number() }));
+  .merge(ValidatorClientFullConfigSchema)
+  .merge(
+    ArchiverSpecificConfigSchema.pick({
+      archiverPollingIntervalMS: true,
+      skipValidateBlockAttestations: true,
+      archiverBatchSize: true,
+    }),
+  )
+  .merge(z.object({ maxPendingTxCount: z.number() }));
 
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
   getConfig: z.function().returns(AztecNodeAdminConfigSchema),