@aztec/stdlib 0.0.1-commit.9ef841308 → 0.0.1-commit.a89ec08

package/src/contract/utility_function_membership_proof.ts

@@ -0,0 +1,118 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
+
+import { type ContractArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
+import {
+  computeArtifactFunctionTree,
+  computeArtifactHash,
+  computeArtifactHashPreimage,
+  computeFunctionArtifactHash,
+  computeFunctionMetadataHash,
+  getArtifactMerkleTreeHasher,
+} from './artifact_hash.js';
+import type {
+  ContractClassPublic,
+  UtilityFunctionMembershipProof,
+  UtilityFunctionWithMembershipProof,
+} from './interfaces/index.js';
+
+/**
+ * Creates a membership proof for a utility  function in a contract class, to be verified via `isValidUtilityFunctionMembershipProof`.
+ * @param selector - Selector of the function to create the proof for.
+ * @param artifact - Artifact of the contract class where the function is defined.
+ */
+export async function createUtilityFunctionMembershipProof(
+  selector: FunctionSelector,
+  artifact: ContractArtifact,
+): Promise<UtilityFunctionMembershipProof> {
+  const log = createLogger('circuits:function_membership_proof');
+
+  // Locate function artifact
+  const utilityFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UTILITY);
+  const utilityFunctionsAndSelectors = await Promise.all(
+    utilityFunctions.map(async fn => ({ fn, selector: await FunctionSelector.fromNameAndParameters(fn) })),
+  );
+  const fn = utilityFunctionsAndSelectors.find(fnAndSelector => selector.equals(fnAndSelector.selector))?.fn;
+  if (!fn) {
+    throw new Error(`Utility function with selector ${selector.toString()} not found`);
+  }
+  // Compute preimage for the artifact hash
+  const { privateFunctionRoot: privateFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } =
+    await computeArtifactHashPreimage(artifact);
+
+  // Compute the sibling path for the "artifact tree"
+  const functionMetadataHash = computeFunctionMetadataHash(fn);
+  const functionArtifactHash = await computeFunctionArtifactHash({ ...fn, functionMetadataHash });
+  const artifactTree = (await computeArtifactFunctionTree(artifact, FunctionType.UTILITY))!;
+  const artifactTreeLeafIndex = artifactTree.getIndex(functionArtifactHash.toBuffer());
+  const artifactTreeSiblingPath = artifactTree.getSiblingPath(artifactTreeLeafIndex).map(Fr.fromBuffer);
+
+  log.debug(`Computed proof for utility function with selector ${selector.toString()}`, {
+    functionArtifactHash,
+    functionMetadataHash,
+    artifactMetadataHash,
+    artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
+    privateFunctionsArtifactTreeRoot,
+  });
+
+  return {
+    artifactTreeSiblingPath,
+    artifactTreeLeafIndex,
+    artifactMetadataHash,
+    functionMetadataHash,
+    privateFunctionsArtifactTreeRoot,
+  };
+}
+
+/**
+ * Verifies that a utility  function with a membership proof as emitted by the ClassRegistry contract is valid,
+ * as defined in the protocol specs at contract-deployment/classes:
+ *
+ * ```
+ * // Load contract class from local db
+ * contract_class = db.get_contract_class(contract_class_id)
+ *
+ * // Compute artifact leaf and assert it belongs to the artifact
+ * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
+ * computed_artifact_utility_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path, artifact_function_tree_leaf_index)
+ * computed_artifact_hash = sha256(private_functions_artifact_tree_root, computed_artifact_utility_function_tree_root, artifact_metadata_hash)
+ * assert computed_artifact_hash == contract_class.artifact_hash
+ * ```
+ * @param fn - Function to check membership proof for.
+ * @param contractClass - In which contract class the function is expected to be.
+ */
+export async function isValidUtilityFunctionMembershipProof(
+  fn: UtilityFunctionWithMembershipProof,
+  contractClass: Pick<ContractClassPublic, 'artifactHash'>,
+) {
+  const log = createLogger('circuits:function_membership_proof');
+
+  const functionArtifactHash = await computeFunctionArtifactHash(fn);
+  const computedArtifactFunctionTreeRootBuffer = await computeRootFromSiblingPath(
+    functionArtifactHash.toBuffer(),
+    fn.artifactTreeSiblingPath.map(fr => fr.toBuffer()),
+    fn.artifactTreeLeafIndex,
+    getArtifactMerkleTreeHasher(),
+  );
+  const computedArtifactFunctionTreeRoot = Fr.fromBuffer(computedArtifactFunctionTreeRootBuffer);
+  const computedArtifactHash = await computeArtifactHash({
+    privateFunctionRoot: fn.privateFunctionsArtifactTreeRoot,
+    utilityFunctionRoot: computedArtifactFunctionTreeRoot,
+    metadataHash: fn.artifactMetadataHash,
+  });
+  if (!contractClass.artifactHash.equals(computedArtifactHash)) {
+    log.debug(`Artifact hash mismatch`, {
+      expected: contractClass.artifactHash,
+      computedArtifactHash,
+      computedFunctionArtifactHash: functionArtifactHash,
+      computedArtifactFunctionTreeRoot,
+      privateFunctionsArtifactTreeRoot: fn.privateFunctionsArtifactTreeRoot,
+      metadataHash: fn.artifactMetadataHash,
+      artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
+    });
+    return false;
+  }
+
+  return true;
+}

package/src/file-store/factory.ts

@@ -1,7 +1,7 @@
 import { type Logger, createLogger } from '@aztec/foundation/log';
 
 import { GoogleCloudFileStore } from './gcs.js';
-import { HttpFileStore, type HttpFileStoreOptions } from './http.js';
+import { HttpFileStore } from './http.js';
 import type { FileStore, ReadOnlyFileStore } from './interface.js';
 import { LocalFileStore } from './local.js';
 import { S3FileStore } from './s3.js';
@@ -59,26 +59,17 @@ export async function createFileStore(
   }
 }
 
-export async function createReadOnlyFileStore(
-  config: string,
-  logger?: Logger,
-  options?: HttpFileStoreOptions,
-): Promise<ReadOnlyFileStore>;
-export async function createReadOnlyFileStore(
-  config: undefined,
-  logger?: Logger,
-  options?: HttpFileStoreOptions,
-): Promise<undefined>;
+export async function createReadOnlyFileStore(config: string, logger?: Logger): Promise<ReadOnlyFileStore>;
+export async function createReadOnlyFileStore(config: undefined, logger?: Logger): Promise<undefined>;
 export async function createReadOnlyFileStore(
   config: string | undefined,
   logger = createLogger('stdlib:file-store'),
-  options?: HttpFileStoreOptions,
 ): Promise<ReadOnlyFileStore | undefined> {
   if (config === undefined) {
     return undefined;
   } else if (config.startsWith('http://') || config.startsWith('https://')) {
     logger.info(`Creating read-only HTTP file store at ${config}`);
-    return new HttpFileStore(config, logger, options);
+    return new HttpFileStore(config, logger);
   } else {
     return await createFileStore(config, logger);
   }

package/src/file-store/http.ts

@@ -10,14 +10,6 @@ import { pipeline } from 'stream/promises';
 
 import type { ReadOnlyFileStore } from './interface.js';
 
-/** Options for configuring HttpFileStore behavior. */
-export interface HttpFileStoreOptions {
-  /** Retry backoff intervals in seconds. Empty array disables retries. Default: [1, 1, 3]. */
-  retryBackoff?: number[];
-  /** Request timeout in milliseconds. Default: no timeout (axios default). */
-  timeoutMs?: number;
-}
-
 export class HttpFileStore implements ReadOnlyFileStore {
   private readonly axiosInstance: AxiosInstance;
   private readonly fetch: <T>(config: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
@@ -25,28 +17,17 @@ export class HttpFileStore implements ReadOnlyFileStore {
   constructor(
     private readonly baseUrl: string,
     private readonly log: Logger = createLogger('stdlib:http-file-store'),
-    options?: HttpFileStoreOptions,
   ) {
-    this.axiosInstance = axios.create({
-      ...(options?.timeoutMs !== undefined && { timeout: options.timeoutMs }),
-    });
-
-    const retryBackoff = options?.retryBackoff ?? [1, 1, 3];
-    if (retryBackoff.length > 0) {
-      this.fetch = async <T>(config: AxiosRequestConfig) => {
-        return await retry(
-          () => this.axiosInstance.request<T>(config),
-          `Fetching ${config.url}`,
-          makeBackoff(retryBackoff),
-          this.log,
-          /*failSilently=*/ true,
-        );
-      };
-    } else {
-      this.fetch = async <T>(config: AxiosRequestConfig) => {
-        return await this.axiosInstance.request<T>(config);
-      };
-    }
+    this.axiosInstance = axios.create();
+    this.fetch = async <T>(config: AxiosRequestConfig) => {
+      return await retry(
+        () => this.axiosInstance.request<T>(config),
+        `Fetching ${config.url}`,
+        makeBackoff([1, 1, 3]),
+        this.log,
+        /*failSilently=*/ true,
+      );
+    };
   }
 
   public async read(pathOrUrl: string): Promise<Buffer> {

package/src/file-store/index.ts

@@ -1,3 +1,2 @@
 export * from './interface.js';
 export * from './factory.js';
-export { type HttpFileStoreOptions } from './http.js';

package/src/gas/gas_settings.ts

@@ -1,10 +1,4 @@
-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 { GAS_SETTINGS_LENGTH, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS } 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';
@@ -14,6 +8,21 @@ import { z } from 'zod';
 import { Gas, GasDimensions } from './gas.js';
 import { GasFees } from './gas_fees.js';
 
+/** Approximate max DA gas limit. Arbitrary, assuming 4 blocks per checkpoint — users should use gas estimation. */
+export const APPROXIMATE_MAX_DA_GAS_PER_BLOCK = Math.floor(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT / 4);
+/** Fallback teardown L2 gas limit. Arbitrary — users should use gas estimation. */
+export const FALLBACK_TEARDOWN_L2_GAS_LIMIT = Math.floor(MAX_PROCESSABLE_L2_GAS / 8);
+/** Fallback teardown DA gas limit. Arbitrary — users should use gas estimation. */
+export const FALLBACK_TEARDOWN_DA_GAS_LIMIT = Math.floor(APPROXIMATE_MAX_DA_GAS_PER_BLOCK / 2);
+
+// For gas estimation, we use intentionally high limits above what the network can process,
+// so the simulation runs without hitting gas caps. Since teardown gas is counted towards total,
+// the total estimation limit is teardown + max processable.
+export const GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT = MAX_PROCESSABLE_L2_GAS;
+export const GAS_ESTIMATION_L2_GAS_LIMIT = GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT + MAX_PROCESSABLE_L2_GAS;
+export const GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+export const GAS_ESTIMATION_DA_GAS_LIMIT = GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT + MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+
 // docs:start:gas_settings_vars
 /** Gas usage and fees limits set by the transaction sender for different dimensions and phases. */
 export class GasSettings {
@@ -95,18 +104,62 @@ export class GasSettings {
     return new GasSettings(Gas.empty(), Gas.empty(), GasFees.empty(), GasFees.empty());
   }
 
-  /** Default gas settings to use when user has not provided them. Requires explicit max fees per gas. */
-  static default(overrides: {
+  /**
+   * Fills in gas limits high enough for transactions to be included in most cases.
+   * gasLimits is set to the maximum the protocol allows; since teardown gas is reserved
+   * from gasLimits during private execution (see gas_meter.nr), the effective gas available
+   * for app logic will be gasLimits - teardownGasLimits - privateOverhead.
+   * The DA gas limit is set to an approximate max per block assuming 4 blocks per checkpoint,
+   * since using the maximum per checkpoint would cause nodes to reject transactions.
+   * These values won't work if:
+   *  - Teardown consumes more than the arbitrarily assigned fallback limits
+   *  - The rest of the transaction consumes more than the remaining gas after teardown
+   *  - The DA gas limit is too low for the transaction, while still within the checkpoint limit
+   */
+  static fallback(overrides: {
+    gasLimits?: Gas;
+    teardownGasLimits?: Gas;
+    maxFeesPerGas: GasFees;
+    maxPriorityFeesPerGas?: GasFees;
+  }) {
+    return GasSettings.from({
+      gasLimits: overrides.gasLimits ?? {
+        l2Gas: MAX_PROCESSABLE_L2_GAS,
+        daGas: APPROXIMATE_MAX_DA_GAS_PER_BLOCK,
+      },
+      teardownGasLimits: overrides.teardownGasLimits ?? {
+        l2Gas: FALLBACK_TEARDOWN_L2_GAS_LIMIT,
+        daGas: FALLBACK_TEARDOWN_DA_GAS_LIMIT,
+      },
+      maxFeesPerGas: overrides.maxFeesPerGas,
+      maxPriorityFeesPerGas: overrides.maxPriorityFeesPerGas ?? GasFees.empty(),
+    });
+  }
+
+  /**
+   * Gas settings for simulation/estimation only.
+   * Since teardown gas is reserved upfront from gasLimits during private execution (see gas_meter.nr),
+   * the effective gas available for app logic is gasLimits - teardownGasLimits - privateOverhead.
+   * To ensure estimation never hits gas caps, we set both limits above what the protocol allows:
+   * teardown gets MAX_PROCESSABLE and gasLimits gets teardown + MAX_PROCESSABLE, so the full
+   * processable amount remains available for each phase independently. To be used in conjunction
+   * with skipTxValidation: true during public simulation, or the node would reject the transaction
+   * outright due to gas limits being above protocol max.
+   */
+  static forEstimation(overrides: {
     gasLimits?: Gas;
     teardownGasLimits?: Gas;
     maxFeesPerGas: GasFees;
     maxPriorityFeesPerGas?: GasFees;
   }) {
     return GasSettings.from({
-      gasLimits: overrides.gasLimits ?? { l2Gas: DEFAULT_L2_GAS_LIMIT, daGas: DEFAULT_DA_GAS_LIMIT },
+      gasLimits: overrides.gasLimits ?? {
+        l2Gas: GAS_ESTIMATION_L2_GAS_LIMIT,
+        daGas: GAS_ESTIMATION_DA_GAS_LIMIT,
+      },
       teardownGasLimits: overrides.teardownGasLimits ?? {
-        l2Gas: DEFAULT_TEARDOWN_L2_GAS_LIMIT,
-        daGas: DEFAULT_TEARDOWN_DA_GAS_LIMIT,
+        l2Gas: GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT,
+        daGas: GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT,
       },
       maxFeesPerGas: overrides.maxFeesPerGas,
       maxPriorityFeesPerGas: overrides.maxPriorityFeesPerGas ?? GasFees.empty(),

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

@@ -0,0 +1,40 @@
+import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
+
+import { z } from 'zod';
+
+import type { ApiSchemaFor } from '../schemas/schemas.js';
+import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
+
+/**
+ * Debug interface for Aztec node available in sandbox/local-network mode.
+ */
+export interface AztecNodeDebug {
+  /**
+   * Triggers the sequencer to produce an L2 block and waits for it to appear.
+   *
+   * **Precondition**: The current L2 slot must not already contain a block. Callers must ensure L1 time has been
+   * advanced to a slot with no existing block before calling this method (e.g. via `EthCheatCodes.warp()`).
+   * If the slot is already taken, the sequencer will fail to propose and this call will time out.
+   *
+   * @throws If no sequencer is running.
+   */
+  mineBlock(): Promise<void>;
+}
+
+export const AztecNodeDebugApiSchema: ApiSchemaFor<AztecNodeDebug> = {
+  mineBlock: z.function().returns(z.void()),
+};
+
+export function createAztecNodeDebugClient(
+  url: string,
+  versions: Partial<ComponentsVersions> = {},
+  fetch = defaultFetch,
+  apiKey?: string,
+): AztecNodeDebug {
+  return createSafeJsonRpcClient<AztecNodeDebug>(url, AztecNodeDebugApiSchema, {
+    namespaceMethods: 'nodeDebug',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+    ...(apiKey ? { extraHeaders: { 'x-api-key': apiKey } } : {}),
+  });
+}

package/src/interfaces/client.ts

@@ -1,5 +1,6 @@
 export * from './aztec-node.js';
 export * from './aztec-node-admin.js';
+export * from './aztec-node-debug.js';
 export * from './private_kernel_prover.js';
 export * from './get_logs_response.js';
 export * from './api_limit.js';

package/src/interfaces/l2_logs_source.ts

@@ -16,11 +16,10 @@ export interface L2LogsSource {
    * array implies no logs match that tag.
    * @param tags - The tags to search for.
    * @param page - The page number (0-indexed) for pagination.
-   * @param upToBlockNumber - If set, only return logs from blocks up to and including this block number.
    * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
    * for a tag, the caller should fetch the next page to check for more logs.
    */
-  getPrivateLogsByTags(tags: SiloedTag[], page?: number, upToBlockNumber?: BlockNumber): Promise<TxScopedL2Log[][]>;
+  getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]>;
 
   /**
    * Gets public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
@@ -28,7 +27,6 @@ export interface L2LogsSource {
    * @param contractAddress - The contract address to search logs for.
    * @param tags - The tags to search for.
    * @param page - The page number (0-indexed) for pagination.
-   * @param upToBlockNumber - If set, only return logs from blocks up to and including this block number.
    * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
    * for a tag, the caller should fetch the next page to check for more logs.
    */
@@ -36,7 +34,6 @@ export interface L2LogsSource {
     contractAddress: AztecAddress,
     tags: Tag[],
     page?: number,
-    upToBlockNumber?: BlockNumber,
   ): Promise<TxScopedL2Log[][]>;
 
   /**

package/src/interfaces/validator.ts

@@ -15,66 +15,63 @@ import type {
 } from '@aztec/stdlib/p2p';
 import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
+import { type ValidatorHASignerConfig, ValidatorHASignerConfigSchema } from '@aztec/validator-ha-signer/config';
 
 import type { PeerId } from '@libp2p/interface';
 import { z } from 'zod';
 
 import type { CommitteeAttestationsAndSigners } from '../block/index.js';
-import {
-  type LocalSignerConfig,
-  LocalSignerConfigSchema,
-  type ValidatorHASignerConfig,
-  ValidatorHASignerConfigSchema,
-} from '../ha-signing/index.js';
 import { AllowedElementSchema } from './allowed_element.js';
 
 /**
  * Validator client configuration
  */
-export type ValidatorClientConfig = ValidatorHASignerConfig &
-  LocalSignerConfig & {
-    /** The private keys of the validators participating in attestation duties */
-    validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
+export type ValidatorClientConfig = ValidatorHASignerConfig & {
+  /** The private keys of the validators participating in attestation duties */
+  validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
 
-    /** The addresses of the validators to use with remote signers */
-    validatorAddresses?: EthAddress[];
+  /** The addresses of the validators to use with remote signers */
+  validatorAddresses?: EthAddress[];
 
-    /** Do not run the validator */
-    disableValidator: boolean;
+  /** Do not run the validator */
+  disableValidator: boolean;
 
-    /** Temporarily disable these specific validator addresses */
-    disabledValidators: EthAddress[];
+  /** Temporarily disable these specific validator addresses */
+  disabledValidators: EthAddress[];
 
-    /** Interval between polling for new attestations from peers */
-    attestationPollingIntervalMs: number;
+  /** Interval between polling for new attestations from peers */
+  attestationPollingIntervalMs: number;
 
-    /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the current committee */
-    alwaysReexecuteBlockProposals?: boolean;
+  /** Whether to re-execute transactions in a block proposal before attesting */
+  validatorReexecute: boolean;
 
-    /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
-    fishermanMode?: boolean;
+  /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the currnet committee */
+  alwaysReexecuteBlockProposals?: boolean;
 
-    /** Skip checkpoint proposal validation and always attest (default: false) */
-    skipCheckpointProposalValidation?: boolean;
+  /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
+  fishermanMode?: boolean;
 
-    /** Skip pushing re-executed blocks to archiver (default: false) */
-    skipPushProposedBlocksToArchiver?: boolean;
+  /** Skip checkpoint proposal validation and always attest (default: false) */
+  skipCheckpointProposalValidation?: boolean;
 
-    /** Agree to attest to equivocated checkpoint proposals (for testing purposes only) */
-    attestToEquivocatedProposals?: boolean;
+  /** Skip pushing re-executed blocks to archiver (default: false) */
+  skipPushProposedBlocksToArchiver?: boolean;
 
-    /** Maximum L2 gas per block for validation. Proposals exceeding this limit are rejected. */
-    validateMaxL2BlockGas?: number;
+  /** Agree to attest to equivocated checkpoint proposals (for testing purposes only) */
+  attestToEquivocatedProposals?: boolean;
 
-    /** Maximum DA gas per block for validation. Proposals exceeding this limit are rejected. */
-    validateMaxDABlockGas?: number;
+  /** Maximum L2 gas per block for validation. Proposals exceeding this limit are rejected. */
+  validateMaxL2BlockGas?: number;
 
-    /** Maximum transactions per block for validation. Proposals exceeding this limit are rejected. */
-    validateMaxTxsPerBlock?: number;
+  /** Maximum DA gas per block for validation. Proposals exceeding this limit are rejected. */
+  validateMaxDABlockGas?: number;
 
-    /** Maximum transactions per checkpoint for validation. Proposals exceeding this limit are rejected. */
-    validateMaxTxsPerCheckpoint?: number;
-  };
+  /** Maximum transactions per block for validation. Proposals exceeding this limit are rejected. */
+  validateMaxTxsPerBlock?: number;
+
+  /** Maximum transactions per checkpoint for validation. Proposals exceeding this limit are rejected. */
+  validateMaxTxsPerCheckpoint?: number;
+};
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
   Pick<SequencerConfig, 'txPublicSetupAllowListExtend' | 'broadcastInvalidBlockProposal'> &
@@ -90,11 +87,12 @@ export type ValidatorClientFullConfig = ValidatorClientConfig &
   };
 
 export const ValidatorClientConfigSchema = zodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>()(
-  ValidatorHASignerConfigSchema.merge(LocalSignerConfigSchema).extend({
+  ValidatorHASignerConfigSchema.extend({
     validatorAddresses: z.array(schemas.EthAddress).optional(),
     disableValidator: z.boolean(),
     disabledValidators: z.array(schemas.EthAddress),
     attestationPollingIntervalMs: z.number().min(0),
+    validatorReexecute: z.boolean(),
     alwaysReexecuteBlockProposals: z.boolean().optional(),
     fishermanMode: z.boolean().optional(),
     skipCheckpointProposalValidation: z.boolean().optional(),

package/src/kernel/claimed_length_array.ts

@@ -25,7 +25,7 @@ export class ClaimedLengthArray<T extends Serializable, N extends number> {
     arrayLength: N,
   ): ClaimedLengthArray<T, N> {
     const reader = BufferReader.asReader(buffer);
-    const array = reader.readArray(arrayLength, deserializer);
+    const array = reader.readArray(arrayLength, deserializer) as Tuple<T, N>;
     const claimedLength = reader.readNumber();
     return new ClaimedLengthArray(array, claimedLength);
   }
@@ -42,7 +42,7 @@ export class ClaimedLengthArray<T extends Serializable, N extends number> {
     arrayLength: N,
   ): ClaimedLengthArray<T, N> {
     const reader = FieldReader.asReader(fields);
-    const array = reader.readArray(arrayLength, deserializer);
+    const array = reader.readTuple(arrayLength, deserializer);
     const claimedLength = reader.readU32();
     return new ClaimedLengthArray(array, claimedLength);
   }

package/src/kernel/hints/private_kernel_reset_hints.ts

@@ -105,8 +105,11 @@ export class PrivateKernelResetHints<
         fromBuffer: buf =>
           nullifierReadRequestHintsFromBuffer(buf, numNullifierReadRequestPending, numNullifierReadRequestSettled),
       }),
-      reader.readArray(numKeyValidationHints, KeyValidationHint),
-      reader.readArray(numTransientDataSquashingHints, TransientDataSquashingHint),
+      reader.readArray(numKeyValidationHints, KeyValidationHint) as Tuple<KeyValidationHint, KEY_VALIDATION_HINTS_LEN>,
+      reader.readArray(numTransientDataSquashingHints, TransientDataSquashingHint) as Tuple<
+        TransientDataSquashingHint,
+        TRANSIENT_DATA_HINTS_LEN
+      >,
     );
   }
 }

package/src/kernel/hints/read_request_hints.ts

@@ -158,11 +158,11 @@ export class ReadRequestResetHints<
   > {
     const reader = BufferReader.asReader(buffer);
     return new ReadRequestResetHints(
-      reader.readArray(readRequestLen, ReadRequestAction),
-      reader.readArray(numPendingReads, PendingReadHint),
+      reader.readArray(readRequestLen, ReadRequestAction) as Tuple<ReadRequestAction, READ_REQUEST_LEN>,
+      reader.readArray(numPendingReads, PendingReadHint) as Tuple<PendingReadHint, PENDING_READ_HINTS_LEN>,
       reader.readArray(numSettledReads, {
         fromBuffer: r => SettledReadHint.fromBuffer(r, treeHeight, leafPreimageFromBuffer),
-      }),
+      }) as Tuple<SettledReadHint<TREE_HEIGHT, LEAF_PREIMAGE>, SETTLED_READ_HINTS_LEN>,
     );
   }
 

package/src/kernel/padded_side_effects.ts

@@ -19,9 +19,9 @@ export class PaddedSideEffects {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PaddedSideEffects(
-      reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
-      reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
-      reader.readArray(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
+      reader.readTuple(MAX_NOTE_HASHES_PER_TX, Fr),
+      reader.readTuple(MAX_NULLIFIERS_PER_TX, Fr),
+      reader.readTuple(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
     );
   }
 

package/src/kernel/private_to_avm_accumulated_data.ts

@@ -73,7 +73,7 @@ export class PrivateToAvmAccumulatedData {
     return new this(
       reader.readFieldArray(MAX_NOTE_HASHES_PER_TX),
       reader.readFieldArray(MAX_NULLIFIERS_PER_TX),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
+      reader.readTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
     );
   }
 
@@ -94,9 +94,9 @@ export class PrivateToAvmAccumulatedData {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PrivateToAvmAccumulatedData(
-      reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
-      reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
+      reader.readTuple(MAX_NOTE_HASHES_PER_TX, Fr),
+      reader.readTuple(MAX_NULLIFIERS_PER_TX, Fr),
+      reader.readTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
     );
   }
 

package/src/kernel/private_to_public_accumulated_data.ts

@@ -62,10 +62,10 @@ export class PrivateToPublicAccumulatedData {
     return new this(
       reader.readFieldArray(MAX_NOTE_HASHES_PER_TX),
       reader.readFieldArray(MAX_NULLIFIERS_PER_TX),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
-      reader.readArray(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedLogHash),
-      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
+      reader.readTuple(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
+      reader.readTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedLogHash),
+      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
     );
   }
 
@@ -76,12 +76,12 @@ export class PrivateToPublicAccumulatedData {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PrivateToPublicAccumulatedData(
-      reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
-      reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
-      reader.readArray(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedLogHash),
-      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readTuple(MAX_NOTE_HASHES_PER_TX, Fr),
+      reader.readTuple(MAX_NULLIFIERS_PER_TX, Fr),
+      reader.readTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
+      reader.readTuple(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
+      reader.readTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedLogHash),
+      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
     );
   }
 

package/src/kernel/private_to_rollup_accumulated_data.ts

@@ -95,11 +95,11 @@ export class PrivateToRollupAccumulatedData {
   static fromBuffer(buffer: Buffer | BufferReader): PrivateToRollupAccumulatedData {
     const reader = BufferReader.asReader(buffer);
     return new PrivateToRollupAccumulatedData(
-      reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
-      reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
-      reader.readArray(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedLogHash),
+      reader.readTuple(MAX_NOTE_HASHES_PER_TX, Fr),
+      reader.readTuple(MAX_NULLIFIERS_PER_TX, Fr),
+      reader.readTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
+      reader.readTuple(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
+      reader.readTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedLogHash),
     );
   }