@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/gas/gas_fees.ts

@@ -1,28 +1,35 @@
-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 {
+  BufferReader,
+  FieldReader,
+  bigintToUInt128BE,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import type { UInt128 } from '../types/shared.js';
 import type { GasDimensions } from './gas.js';
 
 /** Gas prices for each dimension. */
 export class GasFees {
-  public readonly feePerDaGas: Fr;
-  public readonly feePerL2Gas: Fr;
+  public readonly feePerDaGas: UInt128;
+  public readonly feePerL2Gas: UInt128;
 
-  constructor(feePerDaGas: Fr | number | bigint, feePerL2Gas: Fr | number | bigint) {
-    this.feePerDaGas = new Fr(feePerDaGas);
-    this.feePerL2Gas = new Fr(feePerL2Gas);
+  constructor(feePerDaGas: number | bigint, feePerL2Gas: number | bigint) {
+    this.feePerDaGas = BigInt(feePerDaGas);
+    this.feePerL2Gas = BigInt(feePerL2Gas);
   }
 
   static get schema() {
     return z
       .object({
-        feePerDaGas: schemas.Fr,
-        feePerL2Gas: schemas.Fr,
+        feePerDaGas: schemas.BigInt,
+        feePerL2Gas: schemas.BigInt,
       })
       .transform(GasFees.from);
   }
@@ -32,7 +39,7 @@ export class GasFees {
   }
 
   equals(other: GasFees) {
-    return this.feePerDaGas.equals(other.feePerDaGas) && this.feePerL2Gas.equals(other.feePerL2Gas);
+    return this.feePerDaGas === other.feePerDaGas && this.feePerL2Gas === other.feePerL2Gas;
   }
 
   get(dimension: GasDimensions) {
@@ -48,12 +55,9 @@ export class GasFees {
     if (scalar === 1 || scalar === 1n) {
       return this.clone();
     } else if (typeof scalar === 'bigint') {
-      return new GasFees(new Fr(this.feePerDaGas.toBigInt() * scalar), new Fr(this.feePerL2Gas.toBigInt() * scalar));
+      return new GasFees(this.feePerDaGas * scalar, this.feePerL2Gas * scalar);
     } else {
-      return new GasFees(
-        new Fr(this.feePerDaGas.toNumberUnsafe() * scalar),
-        new Fr(this.feePerL2Gas.toNumberUnsafe() * scalar),
-      );
+      return new GasFees(Number(this.feePerDaGas) * scalar, Number(this.feePerL2Gas) * scalar);
     }
   }
 
@@ -61,30 +65,44 @@ 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(Fr.random(), Fr.random());
+    return new GasFees(Math.floor(Math.random() * 1e9), Math.floor(Math.random() * 1e9));
   }
 
   static empty() {
-    return new GasFees(Fr.ZERO, Fr.ZERO);
+    return new GasFees(0, 0);
   }
 
   isEmpty() {
-    return this.feePerDaGas.isZero() && this.feePerL2Gas.isZero();
+    return this.feePerDaGas === 0n && this.feePerL2Gas === 0n;
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): GasFees {
     const reader = BufferReader.asReader(buffer);
-    return new GasFees(reader.readObject(Fr), reader.readObject(Fr));
+    return new GasFees(reader.readUInt128(), reader.readUInt128());
   }
 
   toBuffer() {
-    return serializeToBuffer(this.feePerDaGas, this.feePerL2Gas);
+    return serializeToBuffer(bigintToUInt128BE(this.feePerDaGas), bigintToUInt128BE(this.feePerL2Gas));
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new GasFees(reader.readField(), reader.readField());
+    return new GasFees(reader.readField().toBigInt(), reader.readField().toBigInt());
   }
 
   toFields() {
@@ -93,12 +111,12 @@ export class GasFees {
 
   toInspect() {
     return {
-      feePerDaGas: this.feePerDaGas.toNumberUnsafe(),
-      feePerL2Gas: this.feePerL2Gas.toNumberUnsafe(),
+      feePerDaGas: this.feePerDaGas,
+      feePerL2Gas: this.feePerL2Gas,
     };
   }
 
   [inspect.custom]() {
-    return `GasFees { feePerDaGas=${this.feePerDaGas.toBigInt()} feePerL2Gas=${this.feePerL2Gas.toBigInt()} }`;
+    return `GasFees { feePerDaGas=${this.feePerDaGas} feePerL2Gas=${this.feePerL2Gas} }`;
   }
 }

package/src/gas/gas_settings.ts

@@ -1,5 +1,11 @@
-import { DEFAULT_GAS_LIMIT, DEFAULT_TEARDOWN_GAS_LIMIT, GAS_SETTINGS_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import {
+  DEFAULT_DA_GAS_LIMIT,
+  DEFAULT_L2_GAS_LIMIT,
+  DEFAULT_TEARDOWN_DA_GAS_LIMIT,
+  DEFAULT_TEARDOWN_L2_GAS_LIMIT,
+  GAS_SETTINGS_LENGTH,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -48,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(),
@@ -60,11 +85,7 @@ export class GasSettings {
   /** Returns the maximum fee to be paid according to gas limits and max fees set. */
   getFeeLimit() {
     return GasDimensions.reduce(
-      (acc, dimension) =>
-        this.maxFeesPerGas
-          .get(dimension)
-          .mul(new Fr(this.gasLimits.get(dimension)))
-          .add(acc),
+      (acc, dimension) => new Fr(this.maxFeesPerGas.get(dimension)).mul(new Fr(this.gasLimits.get(dimension))).add(acc),
       Fr.ZERO,
     );
   }
@@ -82,10 +103,10 @@ export class GasSettings {
     maxPriorityFeesPerGas?: GasFees;
   }) {
     return GasSettings.from({
-      gasLimits: overrides.gasLimits ?? { l2Gas: DEFAULT_GAS_LIMIT, daGas: DEFAULT_GAS_LIMIT },
+      gasLimits: overrides.gasLimits ?? { l2Gas: DEFAULT_L2_GAS_LIMIT, daGas: DEFAULT_DA_GAS_LIMIT },
       teardownGasLimits: overrides.teardownGasLimits ?? {
-        l2Gas: DEFAULT_TEARDOWN_GAS_LIMIT,
-        daGas: DEFAULT_TEARDOWN_GAS_LIMIT,
+        l2Gas: DEFAULT_TEARDOWN_L2_GAS_LIMIT,
+        daGas: DEFAULT_TEARDOWN_DA_GAS_LIMIT,
       },
       maxFeesPerGas: overrides.maxFeesPerGas,
       maxPriorityFeesPerGas: overrides.maxPriorityFeesPerGas ?? GasFees.empty(),

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,17 +1,19 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2Hash, poseidon2HashWithSeparator, sha256Trunc } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+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 type { AztecAddress } from '../aztec-address/index.js';
-import type { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
+import { AztecAddress } from '../aztec-address/index.js';
 
 /**
  * Computes a hash of a given verification key.
- * @param vkBuf - The verification key as fields.
+ * @param keyAsFields - The verification key as fields.
  * @returns The hash of the verification key.
  */
-export function hashVK(keyAsFields: Fr[]): Promise<Fr> {
-  return poseidon2Hash(keyAsFields);
+export async function hashVK(keyAsFields: Fr[]): Promise<Fr> {
+  // Should match the implementation in barretenberg/cpp/src/barretenberg/flavor/flavor.hpp > hash()
+  return await poseidon2Hash(keyAsFields);
 }
 
 /**
@@ -37,13 +39,12 @@ export function siloNoteHash(contract: AztecAddress, noteHash: Fr): Promise<Fr>
 
 /**
  * Computes a unique note hash.
- * @dev Includes a nonce which contains data that guarantees the resulting note hash will be unique.
- * @param nonce - A nonce (typically derived from tx hash and note hash index in the tx).
+ * @param noteNonce - The nonce that was injected into the note hash preimage in order to guarantee uniqueness.
  * @param siloedNoteHash - A siloed note hash.
  * @returns A unique note hash.
  */
-export function computeUniqueNoteHash(nonce: Fr, siloedNoteHash: Fr): Promise<Fr> {
-  return poseidon2HashWithSeparator([nonce, siloedNoteHash], GeneratorIndex.UNIQUE_NOTE_HASH);
+export function computeUniqueNoteHash(noteNonce: Fr, siloedNoteHash: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([noteNonce, siloedNoteHash], GeneratorIndex.UNIQUE_NOTE_HASH);
 }
 
 /**
@@ -57,6 +58,17 @@ export function siloNullifier(contract: AztecAddress, innerNullifier: Fr): Promi
   return poseidon2HashWithSeparator([contract, innerNullifier], GeneratorIndex.OUTER_NULLIFIER);
 }
 
+/**
+ * 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 computeProtocolNullifier(txRequestHash: Fr): Promise<Fr> {
+  return siloNullifier(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS), txRequestHash);
+}
+
 /**
  * Computes a public data tree value ready for insertion.
  * @param value - Raw public data tree value to hash into a tree-insertion-ready value.
@@ -80,8 +92,9 @@ export function computePublicDataTreeLeafSlot(contractAddress: AztecAddress, sto
 
 /**
  * Computes the hash of a list of arguments.
+ * Used for input arguments or return values for private functions, or for authwit creation.
  * @param args - Arguments to hash.
- * @returns Pedersen hash of the arguments.
+ * @returns Hash of the arguments.
  */
 export function computeVarArgsHash(args: Fr[]): Promise<Fr> {
   if (args.length === 0) {
@@ -91,6 +104,15 @@ export function computeVarArgsHash(args: Fr[]): Promise<Fr> {
   return poseidon2HashWithSeparator(args, GeneratorIndex.FUNCTION_ARGS);
 }
 
+/**
+ * Computes the hash of a public function's calldata.
+ * @param calldata - Calldata to hash.
+ * @returns Hash of the calldata.
+ */
+export function computeCalldataHash(calldata: Fr[]): Promise<Fr> {
+  return poseidon2HashWithSeparator(calldata, GeneratorIndex.PUBLIC_CALLDATA);
+}
+
 /**
  * Computes a hash of a secret.
  * @dev This function is used to generate secrets for the L1 to L2 message flow and for the TransparentNote.
@@ -113,21 +135,18 @@ export async function computeL1ToL2MessageNullifier(contract: AztecAddress, mess
  * Calculates a siloed hash of a scoped l2 to l1 message.
  * @returns Fr containing 248 bits of information of sha256 hash.
  */
-export function siloL2ToL1Message(l2ToL1Message: ScopedL2ToL1Message, version: Fr, chainId: Fr): Fr {
-  if (l2ToL1Message.contractAddress.isZero()) {
-    return Fr.ZERO;
-  }
-  // Left-pad recipient to 32 bytes to match what the circuit is doing
-  // TODO: Only hash 20 bytes for l2l1 recipient everywhere.
-  const paddedRecipient = Buffer.alloc(32);
-  l2ToL1Message.message.recipient.toBuffer().copy(paddedRecipient, 12);
-
-  const preimage = Buffer.concat([
-    l2ToL1Message.contractAddress.toBuffer(),
-    version.toBuffer(),
-    paddedRecipient,
-    chainId.toBuffer(),
-    l2ToL1Message.message.content.toBuffer(),
-  ]);
-  return Fr.fromBuffer(sha256Trunc(preimage));
+export function computeL2ToL1MessageHash({
+  l2Sender,
+  l1Recipient,
+  content,
+  rollupVersion,
+  chainId,
+}: {
+  l2Sender: AztecAddress;
+  l1Recipient: EthAddress;
+  content: Fr;
+  rollupVersion: Fr;
+  chainId: Fr;
+}) {
+  return sha256ToField([l2Sender, rollupVersion, l1Recipient, chainId, content]);
 }

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

@@ -0,0 +1,23 @@
+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 { 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 };
+
+export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | 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 }),
+  ]),
+);

package/src/interfaces/api_limit.ts

@@ -0,0 +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

@@ -1,83 +1,149 @@
+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 { inBlockSchemaFor } from '../block/in_block.js';
+import { CheckpointedL2Block } from '../block/checkpointed_l2_block.js';
 import { L2Block } from '../block/l2_block.js';
 import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
-import type { NullifierWithBlockSource } from '../block/nullifier_with_block_source.js';
+import { ValidateCheckpointResultSchema } from '../block/validate_block_result.js';
+import { Checkpoint } from '../checkpoint/checkpoint.js';
+import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import {
   ContractClassPublicSchema,
   type ContractDataSource,
   ContractInstanceWithAddressSchema,
-  PublicFunctionSchema,
 } 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';
 import { BlockHeader } from '../tx/block_header.js';
-import { TxEffect } from '../tx/tx_effect.js';
+import { indexedTxSchema } from '../tx/indexed_tx_effect.js';
 import { TxHash } from '../tx/tx_hash.js';
 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;
+
+  /** 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({
+  archiverPollingIntervalMS: schemas.Integer.optional(),
+  archiverBatchSize: schemas.Integer.optional(),
+  viemPollingIntervalMS: schemas.Integer.optional(),
+  maxLogs: schemas.Integer.optional(),
+  archiverStoreMapSizeKb: schemas.Integer.optional(),
+  maxAllowedEthClientDriftSeconds: schemas.Integer.optional(),
+  ethereumAllowNoDebugHosts: z.boolean().optional(),
+  skipValidateCheckpointAttestations: z.boolean().optional(),
+});
+
 export type ArchiverApi = Omit<
-  L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource & NullifierWithBlockSource,
+  L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource,
   'start' | 'stop'
 >;
 
 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),
+  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([schemas.Integer, z.literal('latest')]))
+    .args(z.union([BlockNumberSchema, z.literal('latest')]))
     .returns(BlockHeader.schema.optional()),
-  getBlocks: z
+  getCheckpointedBlock: z.function().args(BlockNumberSchema).returns(CheckpointedL2Block.schema.optional()),
+  getCheckpointedBlocks: z
     .function()
-    .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
-    .returns(z.array(L2Block.schema)),
-  getTxEffect: z.function().args(TxHash.schema).returns(inBlockSchemaFor(TxEffect.schema).optional()),
+    .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)),
+  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()),
+  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.BigInt),
-  getL2EpochNumber: z.function().args().returns(schemas.BigInt),
-  getBlocksForEpoch: z.function().args(schemas.BigInt).returns(z.array(L2Block.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)),
+  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),
-  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), optional(z.number().gte(0)))
     .returns(z.array(z.array(TxScopedL2Log.schema))),
-  findNullifiersIndexesWithBlock: z
+  getPublicLogsByTagsFromContract: z
     .function()
-    .args(z.number(), z.array(schemas.Fr))
-    .returns(z.array(optional(inBlockSchemaFor(schemas.BigInt)))),
+    .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),
-  getPublicFunction: z
-    .function()
-    .args(schemas.AztecAddress, schemas.FunctionSelector)
-    .returns(PublicFunctionSchema.optional()),
   getContractClass: z.function().args(schemas.Fr).returns(ContractClassPublicSchema.optional()),
   getBytecodeCommitment: z.function().args(schemas.Fr).returns(schemas.Fr),
-  getContract: z.function().args(schemas.AztecAddress).returns(ContractInstanceWithAddressSchema.optional()),
+  getContract: z
+    .function()
+    .args(schemas.AztecAddress, optional(schemas.BigInt))
+    .returns(ContractInstanceWithAddressSchema.optional()),
   getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
-  registerContractFunctionSignatures: z.function().args(schemas.AztecAddress, z.array(z.string())).returns(z.void()),
-  getL1ToL2Messages: z.function().args(schemas.BigInt).returns(z.array(schemas.Fr)),
+  registerContractFunctionSignatures: z.function().args(z.array(z.string())).returns(z.void()),
+  getL1ToL2Messages: z.function().args(CheckpointNumberSchema).returns(z.array(schemas.Fr)),
   getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
-  // TODO(#10007): Remove this method
-  addContractClass: z.function().args(ContractClassPublicSchema).returns(z.void()),
-  getContractFunctionName: z
-    .function()
-    .args(schemas.AztecAddress, schemas.FunctionSelector)
-    .returns(optional(z.string())),
+  getDebugFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
   getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
+  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(ValidateCheckpointResultSchema),
 };