@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/config/chain-config.ts

@@ -0,0 +1,40 @@
+import { type L1ContractAddresses, pickL1ContractAddressMappings } from '@aztec-labs/ethereum/l1-contract-addresses';
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec-labs/foundation/config';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+
+export { type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
+export { type AllowedElement } from '../interfaces/allowed_element.js';
+
+export const emptyChainConfig: ChainConfig = {
+  l1ChainId: 0,
+  rollupVersion: 0,
+  rollupAddress: EthAddress.ZERO,
+};
+
+export const chainConfigMappings: ConfigMappingsType<ChainConfig> = {
+  l1ChainId: {
+    env: 'L1_CHAIN_ID',
+    ...numberConfigHelper(31337),
+    description: 'The chain ID of the ethereum host.',
+  },
+  rollupVersion: {
+    env: 'ROLLUP_VERSION',
+    description: 'The version of the rollup.',
+    parseEnv: (val: string) => {
+      const parsed = parseInt(val, 10);
+      if (!Number.isSafeInteger(parsed)) {
+        throw new Error(`Invalid rollup version: ${val}`);
+      }
+      return parsed;
+    },
+  },
+  ...pickL1ContractAddressMappings('rollupAddress'),
+};
+
+/** Chain configuration. */
+export type ChainConfig = {
+  /** The chain id of the ethereum host. */
+  l1ChainId: number;
+  /** The version of the rollup. */
+  rollupVersion: number;
+} & Pick<L1ContractAddresses, 'rollupAddress'>;

package/src/config/index.ts

@@ -0,0 +1,4 @@
+export * from './chain-config.js';
+export * from './network-consensus-config.js';
+export * from './node-rpc-config.js';
+export * from './sequencer-config.js';

package/src/config/network-consensus-config.ts

@@ -0,0 +1,304 @@
+import { type L1ContractsConfig, l1ContractsConfigMappings, validateSlotDurations } from '@aztec-labs/ethereum/config';
+import { type EnvVar, pickConfigMappings } from '@aztec-labs/foundation/config';
+
+import { MAX_ATTESTABLE_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
+import type { SequencerConfig } from '../interfaces/configs.js';
+import { MIN_BLOCKS_FOR_INBOX_CATCHUP } from '../messaging/inbox_consumption.js';
+import {
+  DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+  DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+  DEFAULT_MIN_BLOCK_DURATION,
+  DEFAULT_P2P_PROPAGATION_TIME,
+} from '../timetable/budgets.js';
+import { ProposerTimetable } from '../timetable/proposer_timetable.js';
+import { sharedSequencerConfigMappings } from './sequencer-config.js';
+
+/**
+ * Environment variables whose values must be identical across every node of a network. They fall into three
+ * categories, all consensus-critical:
+ *
+ * - Timing/protocol consensus: slot and epoch durations, block sub-slot duration, max blocks per checkpoint, and
+ *   the checkpoint-proposal materialization grace. Proposers and validators must agree on these to land on the
+ *   same proposed chain and the same checkpoint-proposal receive/handoff deadlines.
+ * - Network identity and L1-posted deployment params: the L1 chain id and the staking/governance/slashing
+ *   parameters baked into the deployed rollup contract (committee size, lags, thresholds, mana target, fee
+ *   pricing, governance/slashing round sizes, quorums, slash amounts, etc.). A node disagreeing with the rollup
+ *   it points at would compute the wrong epoch geometry, fees, or slashing rounds.
+ * - Node-side slashing offense consensus: the offense detection/penalty parameters validators apply locally to
+ *   decide which payloads to sign. Validators must agree on these to reach the on-chain slashing quorum.
+ *
+ * Deliberately excluded: bootnodes, P2P/store/OTEL/sentinel settings, SEQ_MIN_TX_PER_BLOCK, SEQ_MAX_TX_PER_*,
+ * AZTEC_SLASHER_ENABLED, PROVER_REAL_PROOFS, TRANSACTIONS_DISABLED, and AZTEC_ENTRY_QUEUE_* (mainnet-only genesis
+ * params enforced by L1).
+ */
+export const NETWORK_CONSENSUS_ENV_VARS = [
+  // Timing/protocol consensus.
+  'ETHEREUM_SLOT_DURATION',
+  'AZTEC_SLOT_DURATION',
+  'AZTEC_EPOCH_DURATION',
+  'SEQ_BLOCK_DURATION_MS',
+  'MAX_BLOCKS_PER_CHECKPOINT',
+  'CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS',
+
+  // Network identity / L1-posted deployment params.
+  'L1_CHAIN_ID',
+  'AZTEC_TARGET_COMMITTEE_SIZE',
+  'AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET',
+  'AZTEC_LAG_IN_EPOCHS_FOR_RANDAO',
+  'AZTEC_ACTIVATION_THRESHOLD',
+  'AZTEC_EJECTION_THRESHOLD',
+  'AZTEC_LOCAL_EJECTION_THRESHOLD',
+  'AZTEC_EXIT_DELAY_SECONDS',
+  'AZTEC_PROOF_SUBMISSION_EPOCHS',
+  'AZTEC_MANA_TARGET',
+  'AZTEC_PROVING_COST_PER_MANA',
+  'AZTEC_INITIAL_ETH_PER_FEE_ASSET',
+  'AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE',
+  'AZTEC_GOVERNANCE_PROPOSER_QUORUM',
+  'AZTEC_SLASHING_QUORUM',
+  'AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS',
+  'AZTEC_SLASHING_LIFETIME_IN_ROUNDS',
+  'AZTEC_SLASHING_OFFSET_IN_ROUNDS',
+  'AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS',
+  'AZTEC_SLASHING_VETOER',
+  'AZTEC_SLASHING_DISABLE_DURATION',
+  'AZTEC_SLASH_AMOUNT_SMALL',
+  'AZTEC_SLASH_AMOUNT_MEDIUM',
+  'AZTEC_SLASH_AMOUNT_LARGE',
+
+  // Node-side slashing offense consensus.
+  'SLASH_OFFENSE_EXPIRATION_ROUNDS',
+  'SLASH_MAX_PAYLOAD_SIZE',
+  'SLASH_EXECUTE_ROUNDS_LOOK_BACK',
+  'SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS',
+  'SLASH_DATA_WITHHOLDING_PENALTY',
+  'SLASH_INACTIVITY_TARGET_PERCENTAGE',
+  'SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD',
+  'SLASH_INACTIVITY_PENALTY',
+  'SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY',
+  'SLASH_DUPLICATE_PROPOSAL_PENALTY',
+  'SLASH_DUPLICATE_ATTESTATION_PENALTY',
+  'SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY',
+  'SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY',
+  'SLASH_UNKNOWN_PENALTY',
+  'SLASH_INVALID_BLOCK_PENALTY',
+  'SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY',
+  'SLASH_GRACE_PERIOD_L2_SLOTS',
+] as const satisfies readonly EnvVar[];
+
+/** A consensus-critical environment variable name; see {@link NETWORK_CONSENSUS_ENV_VARS}. */
+export type ConsensusEnvVar = (typeof NETWORK_CONSENSUS_ENV_VARS)[number];
+
+/**
+ * The subset of consensus-critical timing config whose geometry can be validated in isolation. Composed by
+ * picking the canonical fields from their owning config types so the field set never drifts from the config
+ * layer: slot durations from {@link L1ContractsConfig}, block sub-slot/checkpoint timings from
+ * {@link SequencerConfig} (whose fields are optional there, hence `Required`).
+ */
+export type NetworkConsensusConfig = Pick<L1ContractsConfig, 'aztecSlotDuration' | 'ethereumSlotDuration'> &
+  Required<Pick<SequencerConfig, 'blockDurationMs' | 'maxBlocksPerCheckpoint' | 'checkpointProposalSyncGraceSeconds'>>;
+
+/** Config mappings for the slot-timing fields of {@link NetworkConsensusConfig}, picked from their owners. */
+const networkConsensusConfigMappings = {
+  ...pickConfigMappings(l1ContractsConfigMappings, ['aztecSlotDuration', 'ethereumSlotDuration']),
+  ...pickConfigMappings(sharedSequencerConfigMappings, [
+    'blockDurationMs',
+    'maxBlocksPerCheckpoint',
+    'checkpointProposalSyncGraceSeconds',
+  ]),
+};
+
+/**
+ * Extracts the timing {@link NetworkConsensusConfig} from a generated network config object. The env-var names
+ * and the per-field parsing both come from the canonical config mappings (`l1ContractsConfigMappings` and
+ * `sharedSequencerConfigMappings`), so each field is parsed exactly as the node's config layer would parse it.
+ * A field whose env var is absent becomes `NaN`, which {@link validateNetworkConsensusConfig} reports as an
+ * error. Never throws: parse helpers that would throw or yield `undefined` are coerced to `NaN`.
+ */
+export function getConsensusConfigFromNetworkEnv(
+  values: Record<string, string | number | boolean>,
+): NetworkConsensusConfig {
+  const result = {} as Record<keyof NetworkConsensusConfig, number>;
+  for (const [field, mapping] of Object.entries(networkConsensusConfigMappings)) {
+    const raw = mapping.env !== undefined ? values[mapping.env] : undefined;
+    if (raw === undefined) {
+      result[field as keyof NetworkConsensusConfig] = NaN;
+      continue;
+    }
+    let parsed: number | undefined;
+    try {
+      parsed = mapping.parseEnv ? mapping.parseEnv(String(raw)) : Number(raw);
+    } catch {
+      parsed = NaN;
+    }
+    result[field as keyof NetworkConsensusConfig] = parsed ?? NaN;
+  }
+  return result;
+}
+
+/**
+ * Validates a {@link NetworkConsensusConfig} for self-consistency, returning a list of error messages (empty
+ * when valid). Used by the cli unit test that gates the generated network configs.
+ *
+ * The check requires `maxBlocksPerCheckpoint` to be *exactly* what a {@link ProposerTimetable} built from the
+ * same slot timings and the production default budgets derives. This exact-equality requirement ensures the
+ * published network value is precisely what the production default budgets produce, so every node running those
+ * defaults agrees on the per-checkpoint block count without clamping. It must also be at least
+ * {@link MIN_BLOCKS_FOR_INBOX_CATCHUP}, without which the network is permanently haltable.
+ */
+export function validateNetworkConsensusConfig(config: NetworkConsensusConfig): string[] {
+  const errors: string[] = [];
+
+  for (const [field, value] of Object.entries(config)) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+      errors.push(`${field} must be a finite number (got ${value})`);
+    }
+  }
+  if (errors.length > 0) {
+    return errors;
+  }
+
+  errors.push(...validateSlotDurations(config));
+  if (config.blockDurationMs <= 0) {
+    errors.push(`blockDurationMs must be positive (got ${config.blockDurationMs})`);
+  }
+  if (config.blockDurationMs / 1000 > config.aztecSlotDuration) {
+    errors.push(
+      `blockDurationMs (${config.blockDurationMs}ms) exceeds aztecSlotDuration (${config.aztecSlotDuration}s)`,
+    );
+  }
+  if (config.maxBlocksPerCheckpoint < MIN_BLOCKS_FOR_INBOX_CATCHUP) {
+    errors.push(
+      `maxBlocksPerCheckpoint must be at least ${MIN_BLOCKS_FOR_INBOX_CATCHUP} so a checkpoint can always clear a ` +
+        `mandatory streaming-Inbox backlog (got ${config.maxBlocksPerCheckpoint}); lower the block duration or raise ` +
+        `the slot duration so the proposer budgets derive at least that many blocks`,
+    );
+  }
+  if (config.maxBlocksPerCheckpoint > MAX_ATTESTABLE_BLOCKS_PER_CHECKPOINT) {
+    errors.push(
+      `maxBlocksPerCheckpoint (${config.maxBlocksPerCheckpoint}) exceeds the ` +
+        `${MAX_ATTESTABLE_BLOCKS_PER_CHECKPOINT} blocks nodes will build or attest to, so the network would ` +
+        `reject block indices its own configuration admits`,
+    );
+  }
+  if (config.checkpointProposalSyncGraceSeconds < 0) {
+    errors.push(
+      `checkpointProposalSyncGraceSeconds must be non-negative (got ${config.checkpointProposalSyncGraceSeconds})`,
+    );
+  }
+  if (errors.length > 0) {
+    return errors;
+  }
+
+  let computed: number;
+  try {
+    computed = new ProposerTimetable({
+      l1Constants: {
+        l1GenesisTime: 0n,
+        slotDuration: config.aztecSlotDuration,
+        ethereumSlotDuration: config.ethereumSlotDuration,
+      },
+      blockDuration: config.blockDurationMs / 1000,
+      minBlockDuration: DEFAULT_MIN_BLOCK_DURATION,
+      p2pPropagationTime: DEFAULT_P2P_PROPAGATION_TIME,
+      checkpointProposalPrepareTime: DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+      checkpointProposalInitTime: DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+      checkpointProposalSyncGrace: config.checkpointProposalSyncGraceSeconds,
+    }).getMaxBlocksPerCheckpoint();
+  } catch (err) {
+    // The timetable constructor throws when not even one block fits the default budgets; report instead.
+    errors.push(
+      `maxBlocksPerCheckpoint (${config.maxBlocksPerCheckpoint}) cannot be achieved: the default operational ` +
+        `budgets fit fewer than one block for slot duration ${config.aztecSlotDuration}s and block duration ` +
+        `${config.blockDurationMs / 1000}s (${err instanceof Error ? err.message : String(err)})`,
+    );
+    return errors;
+  }
+
+  if (computed !== config.maxBlocksPerCheckpoint) {
+    errors.push(
+      `maxBlocksPerCheckpoint (${config.maxBlocksPerCheckpoint}) does not match the ${computed} blocks the ` +
+        `production default budgets derive for slot duration ${config.aztecSlotDuration}s and block duration ` +
+        `${config.blockDurationMs / 1000}s`,
+    );
+  }
+
+  return errors;
+}
+
+/**
+ * Enforces that operators do not silently override consensus-critical values diverging from the network config.
+ *
+ * For each var in {@link NETWORK_CONSENSUS_ENV_VARS} present in `networkConfig`: if the operator set it in `env`
+ * to a conflicting value, this throws unless `ALLOW_OVERRIDING_NETWORK_CONFIG` is truthy (in which case it logs
+ * and keeps the operator value).
+ *
+ * This function is pure: it never writes to `env`. Instead it returns the canonical env writes the caller
+ * should apply — a map of env-var name to canonical string value for every numeric var whose env value matched
+ * the network value numerically. Applying these closes a bypass where the config layer parses some vars with
+ * `parseInt` (which reads '6e3' as 6); rewriting them to the network value's string form keeps the operator's
+ * numerically-equal value but in canonical form. Vars kept under `ALLOW_OVERRIDING_NETWORK_CONFIG` (genuine
+ * conflicts) are not included, so the operator value is preserved untouched.
+ *
+ * @returns Canonical env writes (env-var name -> canonical string value) for the caller to apply.
+ */
+export function checkConsensusEnvOverrides(
+  networkConfig: Record<string, string | number | boolean>,
+  env: { [key: string]: string | undefined } = process.env,
+  log?: (msg: string) => void,
+): Record<string, string> {
+  const allowOverride = allowsNetworkConfigOverride(env);
+  const canonical: Record<string, string> = {};
+  const conflicts: string[] = [];
+
+  for (const envVar of NETWORK_CONSENSUS_ENV_VARS) {
+    const networkValue = networkConfig[envVar];
+    if (networkValue === undefined) {
+      continue;
+    }
+
+    const current = env[envVar];
+    if (current === undefined || current === '') {
+      continue;
+    }
+
+    const networkIsNumeric = typeof networkValue === 'number';
+    const matches = networkIsNumeric ? Number(current) === networkValue : current === String(networkValue);
+    if (matches) {
+      if (networkIsNumeric) {
+        canonical[envVar] = String(networkValue);
+      }
+      continue;
+    }
+
+    const conflict = `${envVar}=${current} conflicts with the network value ${networkValue}`;
+    if (allowOverride) {
+      log?.(
+        `Environment variable ${conflict}. Consensus-critical values must match across the network, but ` +
+          `ALLOW_OVERRIDING_NETWORK_CONFIG is set so the operator value is kept (only do this if you know what ` +
+          `you are doing).`,
+      );
+      continue;
+    }
+    conflicts.push(conflict);
+  }
+
+  // Accumulate every conflict so the operator sees all the env vars they need to reconcile at once, rather than
+  // fixing them one failed startup at a time.
+  if (conflicts.length > 0) {
+    throw new Error(
+      `Environment variables conflict with consensus-critical network values:\n` +
+        conflicts.map(c => `  - ${c}`).join('\n') +
+        `\nConsensus-critical values must match across the network. Set ALLOW_OVERRIDING_NETWORK_CONFIG=1 to ` +
+        `override (only do this if you know what you are doing).`,
+    );
+  }
+
+  return canonical;
+}
+
+/** Whether the env opts into overriding network-wide consensus values (`ALLOW_OVERRIDING_NETWORK_CONFIG`). */
+export function allowsNetworkConfigOverride(env: { [key: string]: string | undefined } = process.env): boolean {
+  const value = env.ALLOW_OVERRIDING_NETWORK_CONFIG;
+  return value === '1' || value?.toLowerCase() === 'true';
+}

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

@@ -0,0 +1,88 @@
+import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from '@aztec-labs/foundation/config';
+
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '../avm/avm.js';
+
+const parseCommaSeparatedList = (value: string) =>
+  value
+    .split(',')
+    .map(item => item.trim())
+    .filter(Boolean);
+
+export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
+  rpcSimulatePublicMaxGasLimit: {
+    env: 'RPC_SIMULATE_PUBLIC_MAX_GAS_LIMIT',
+    description: 'Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`.',
+    ...numberConfigHelper(10e9),
+  },
+  rpcSimulatePublicMaxDebugLogMemoryReads: {
+    env: 'RPC_SIMULATE_PUBLIC_MAX_DEBUG_LOG_MEMORY_READS',
+    description:
+      'Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. ',
+    ...numberConfigHelper(DEFAULT_MAX_DEBUG_LOG_MEMORY_READS),
+  },
+  rpcMaxBatchSize: {
+    env: 'RPC_MAX_BATCH_SIZE',
+    description: 'Maximum allowed batch size for JSON RPC batch requests.',
+    ...numberConfigHelper(100),
+  },
+  rpcMaxBodySize: {
+    env: 'RPC_MAX_BODY_SIZE',
+    description: 'Maximum allowed batch size for JSON RPC batch requests.',
+    defaultValue: '1mb',
+  },
+  rpcHttpKeepAliveTimeoutMs: {
+    env: 'RPC_HTTP_KEEP_ALIVE_TIMEOUT_MS',
+    description: 'HTTP keep-alive timeout for JSON RPC connections in milliseconds.',
+    ...numberConfigHelper(5_000),
+  },
+  rpcHttpHeadersTimeoutMs: {
+    env: 'RPC_HTTP_HEADERS_TIMEOUT_MS',
+    description: 'Timeout for receiving complete HTTP headers on JSON RPC connections in milliseconds.',
+    ...numberConfigHelper(60_000),
+  },
+  rpcCorsAllowedOrigins: {
+    env: 'RPC_CORS_ALLOWED_ORIGINS',
+    description: 'Origins allowed to make credentialed cross-origin JSON RPC requests, separated by commas.',
+    parseEnv: parseCommaSeparatedList,
+    defaultValue: [],
+  },
+  rpcCorsAllowedHeaders: {
+    env: 'RPC_CORS_ALLOWED_HEADERS',
+    description: 'Headers allowed in cross-origin JSON RPC requests, separated by commas.',
+    parseEnv: parseCommaSeparatedList,
+    defaultValue: [],
+  },
+  rpcCorsAllowAnyOrigin: {
+    env: 'RPC_CORS_ALLOW_ANY_ORIGIN',
+    description: 'Allow credentialed cross-origin JSON RPC requests from any origin.',
+    ...booleanConfigHelper(false),
+  },
+};
+
+export type NodeRPCConfig = {
+  /** Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`. */
+  rpcSimulatePublicMaxGasLimit: number;
+  /** Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. */
+  rpcSimulatePublicMaxDebugLogMemoryReads: number;
+  /** Maximum allowed batch size for JSON RPC batch requests. */
+  rpcMaxBatchSize: number;
+  /** The maximum body size the RPC server will accept */
+  rpcMaxBodySize: string;
+  /** HTTP keep-alive timeout for JSON RPC connections in milliseconds. */
+  rpcHttpKeepAliveTimeoutMs: number;
+  /** Timeout for receiving complete HTTP headers on JSON RPC connections in milliseconds. */
+  rpcHttpHeadersTimeoutMs: number;
+  /** Origins allowed to make credentialed cross-origin requests to the RPC server. */
+  rpcCorsAllowedOrigins: string[];
+  /** Headers allowed in cross-origin requests to the RPC server. */
+  rpcCorsAllowedHeaders: string[];
+  /** Whether to allow credentialed cross-origin requests from any origin. */
+  rpcCorsAllowAnyOrigin: boolean;
+};
+
+/** Resolves the CORS origin policy for an RPC server. */
+export function getRpcCorsAllowedOrigins(
+  config: Pick<NodeRPCConfig, 'rpcCorsAllowedOrigins' | 'rpcCorsAllowAnyOrigin'>,
+): string[] {
+  return config.rpcCorsAllowAnyOrigin ? ['*'] : config.rpcCorsAllowedOrigins;
+}

package/src/config/sequencer-config.ts

@@ -0,0 +1,96 @@
+import {
+  type ConfigMappingsType,
+  floatConfigHelper,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+} from '@aztec-labs/foundation/config';
+
+import type { SequencerConfig } from '../interfaces/configs.js';
+import {
+  DEFAULT_BLOCK_DURATION,
+  DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+  DEFAULT_MIN_BLOCK_DURATION,
+  DEFAULT_P2P_PROPAGATION_TIME,
+  getDefaultCheckpointProposalSyncGrace,
+} from '../timetable/index.js';
+
+/** Default duration per block in milliseconds, used to derive how many blocks fit in a slot. */
+export const DEFAULT_BLOCK_DURATION_MS = DEFAULT_BLOCK_DURATION * 1000;
+
+/** Default maximum number of transactions per block. */
+export const DEFAULT_MAX_TXS_PER_BLOCK = 32;
+
+/** Default maximum number of blocks the sequencer packs into a single checkpoint. */
+export const DEFAULT_MAX_BLOCKS_PER_CHECKPOINT = 24;
+
+/**
+ * Partial sequencer config mappings for fields that need to be shared across packages.
+ * The full sequencer config mappings remain in sequencer-client, but shared fields
+ * (like blockDurationMs needed by both p2p and sequencer-client) are defined here
+ * to avoid duplication.
+ */
+export const sharedSequencerConfigMappings: ConfigMappingsType<
+  Pick<
+    SequencerConfig,
+    | 'blockDurationMs'
+    | 'checkpointProposalSyncGraceSeconds'
+    | 'expectedBlockProposalsPerSlot'
+    | 'maxTxsPerBlock'
+    | 'attestationPropagationTime'
+    | 'checkpointProposalPrepareTime'
+    | 'minBlockDuration'
+    | 'maxBlocksPerCheckpoint'
+  >
+> = {
+  blockDurationMs: {
+    env: 'SEQ_BLOCK_DURATION_MS',
+    description: 'Duration per block in milliseconds, used to derive how many blocks fit in a slot.',
+    ...numberConfigHelper(DEFAULT_BLOCK_DURATION_MS),
+  },
+  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.',
+    ...numberConfigHelper(0),
+  },
+  checkpointProposalSyncGraceSeconds: {
+    env: 'CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS',
+    description:
+      'Consensus grace in seconds for a received checkpoint proposal to materialize into local proposed state. ' +
+      'Defaults to twice the block duration.',
+    defaultValue: getDefaultCheckpointProposalSyncGrace(DEFAULT_BLOCK_DURATION_MS / 1000),
+    ...optionalNumberConfigHelper(),
+  },
+  maxTxsPerBlock: {
+    env: 'SEQ_MAX_TX_PER_BLOCK',
+    description: 'The maximum number of txs to include in a block.',
+    ...optionalNumberConfigHelper(),
+  },
+  attestationPropagationTime: {
+    env: 'SEQ_ATTESTATION_PROPAGATION_TIME',
+    description: 'How many seconds it takes for proposals and attestations to travel across the p2p layer (one-way).',
+    defaultValue: DEFAULT_P2P_PROPAGATION_TIME,
+    ...floatConfigHelper(DEFAULT_P2P_PROPAGATION_TIME),
+  },
+  checkpointProposalPrepareTime: {
+    env: 'SEQ_CHECKPOINT_PROPOSAL_PREPARE_TIME',
+    description:
+      'Local time in seconds between the last block build finishing and the checkpoint proposal being ready for p2p send.',
+    defaultValue: DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+    ...floatConfigHelper(DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME),
+  },
+  minBlockDuration: {
+    env: 'SEQ_MIN_BLOCK_DURATION',
+    description: 'Minimum block-building time in seconds still worth allocating if the proposer starts late.',
+    defaultValue: DEFAULT_MIN_BLOCK_DURATION,
+    ...floatConfigHelper(DEFAULT_MIN_BLOCK_DURATION),
+  },
+  maxBlocksPerCheckpoint: {
+    env: 'MAX_BLOCKS_PER_CHECKPOINT',
+    description:
+      'Maximum number of blocks the sequencer packs into a single checkpoint, and the maximum indexWithinCheckpoint accepted on inbound block proposals.',
+    parseEnv: (val: string) => parseInt(val, 10),
+    defaultValue: DEFAULT_MAX_BLOCKS_PER_CHECKPOINT,
+  },
+};

package/src/contract/artifact_hash.ts

@@ -0,0 +1,128 @@
+import { sha256 } from '@aztec-labs/foundation/crypto/sha256';
+import { Fr, reduceFn } from '@aztec-labs/foundation/curves/bn254';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { numToUInt8 } from '@aztec-labs/foundation/serialize';
+import { MerkleTree, MerkleTreeCalculator } from '@aztec-labs/foundation/trees';
+import deterministicStringify from 'json-stringify-deterministic';
+
+import {
+  type ContractArtifact,
+  type FunctionArtifact,
+  FunctionSelector,
+  FunctionType,
+  getFunctionReturnType,
+} from '../abi/index.js';
+
+const VERSION = 1;
+
+// TODO(miranda): Artifact and artifact metadata hashes are currently the only SHAs not truncated by a byte.
+// They are never recalculated in the circuit or L1 contract, but they are input to circuits, so perhaps modding here is preferable?
+// TODO(@spalladino) Reducing sha256 to a field may have security implications. Validate this with crypto team.
+const sha256Fr = reduceFn(sha256, Fr);
+
+/**
+ * Returns the artifact hash of a given compiled contract artifact.
+ *
+ * ```
+ * private_functions_artifact_leaves = artifact.private_functions.map fn =>
+ *   sha256(fn.selector, fn.metadata_hash, sha256(fn.bytecode))
+ * private_functions_artifact_tree_root = merkleize(private_functions_artifact_leaves)
+ *
+ * utility_functions_artifact_leaves = artifact.utility_functions.map fn =>
+ *   sha256(fn.selector, fn.metadata_hash, sha256(fn.bytecode))
+ * utility_functions_artifact_tree_root = merkleize(utility_functions_artifact_leaves)
+ *
+ * version = 1
+ * artifact_hash = sha256(
+ *   version,
+ *   private_functions_artifact_tree_root,
+ *   utility_functions_artifact_tree_root,
+ *   artifact_metadata,
+ * )
+ * ```
+ * @param artifact - Artifact to calculate the hash for.
+ */
+export async function computeArtifactHash(
+  artifact: ContractArtifact | { privateFunctionRoot: Fr; utilityFunctionRoot: Fr; metadataHash: Fr },
+): Promise<Fr> {
+  if ('privateFunctionRoot' in artifact && 'utilityFunctionRoot' in artifact && 'metadataHash' in artifact) {
+    const { privateFunctionRoot, utilityFunctionRoot, metadataHash } = artifact;
+    const preimage = [privateFunctionRoot, utilityFunctionRoot, metadataHash].map(x => x.toBuffer());
+    return sha256Fr(Buffer.concat([numToUInt8(VERSION), ...preimage]));
+  }
+
+  const preimage = await computeArtifactHashPreimage(artifact);
+  const artifactHash = computeArtifactHash(preimage);
+  getLogger().trace('Computed artifact hash', { artifactHash, ...preimage });
+  return artifactHash;
+}
+
+export async function computeArtifactHashPreimage(artifact: ContractArtifact) {
+  const privateFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.PRIVATE);
+  const utilityFunctionRoot = await computeArtifactFunctionTreeRoot(artifact, FunctionType.UTILITY);
+  const metadataHash = computeArtifactMetadataHash(artifact);
+  return { privateFunctionRoot, utilityFunctionRoot, metadataHash };
+}
+
+export function computeArtifactMetadataHash(artifact: ContractArtifact) {
+  return sha256Fr(Buffer.from(deterministicStringify({ name: artifact.name, outputs: artifact.outputs }), 'utf-8'));
+}
+
+export async function computeArtifactFunctionTreeRoot(artifact: ContractArtifact, fnType: FunctionType) {
+  const tree = await computeArtifactFunctionTree(artifact, fnType);
+  return tree?.root ? Fr.fromBuffer(tree.root) : Fr.ZERO;
+}
+
+export async function computeArtifactFunctionTree(
+  artifact: ContractArtifact,
+  fnType: FunctionType,
+): Promise<MerkleTree | undefined> {
+  const leaves = await computeFunctionLeaves(artifact, fnType);
+  // TODO(@spalladino) Consider implementing a null-object for empty trees
+  if (leaves.length === 0) {
+    return undefined;
+  }
+  const height = Math.ceil(Math.log2(leaves.length));
+  const calculator = await MerkleTreeCalculator.create(height, Buffer.alloc(32), getArtifactMerkleTreeHasher());
+  return calculator.computeTree(leaves.map(x => x.toBuffer()));
+}
+
+async function computeFunctionLeaves(artifact: ContractArtifact, fnType: FunctionType) {
+  const selectors = await Promise.all(
+    artifact.functions
+      .filter(f => f.functionType === fnType)
+      .map(async f => ({ ...f, selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters) })),
+  );
+  selectors.sort((a, b) => a.selector.value - b.selector.value);
+  return await Promise.all(selectors.map(computeFunctionArtifactHash));
+}
+
+export async function computeFunctionArtifactHash(
+  fn:
+    | FunctionArtifact
+    | (Pick<FunctionArtifact, 'bytecode'> & { functionMetadataHash: Fr; selector: FunctionSelector }),
+) {
+  const selector = 'selector' in fn ? fn.selector : await FunctionSelector.fromNameAndParameters(fn);
+
+  const bytecodeHash = sha256Fr(fn.bytecode).toBuffer();
+  const metadataHash = 'functionMetadataHash' in fn ? fn.functionMetadataHash : computeFunctionMetadataHash(fn);
+  return sha256Fr(Buffer.concat([numToUInt8(VERSION), selector.toBuffer(), metadataHash.toBuffer(), bytecodeHash]));
+}
+
+export function computeFunctionMetadataHash(fn: Pick<FunctionArtifact, 'returnType' | 'returnTypes'>) {
+  // Wrap the type in a list (empty when the function returns nothing) so the hash preimage is identical to
+  // what it was when this hash consumed the deprecated `returnTypes` list. This hash is part of the
+  // artifact hash preimage, which contract class ids commit to - changing it would move the computed
+  // class id and address of every contract, and break artifact validation against already-registered
+  // classes.
+  const returnType = getFunctionReturnType(fn);
+  return sha256Fr(Buffer.from(deterministicStringify(returnType ? [returnType] : []), 'utf8'));
+}
+
+function getLogger() {
+  return createLogger('circuits:artifact_hash');
+}
+
+export function getArtifactMerkleTreeHasher() {
+  return (l: Buffer, r: Buffer) => Promise.resolve(sha256Fr(Buffer.concat([l, r])).toBuffer() as Buffer<ArrayBuffer>);
+}