@aztec/stdlib 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/dest/checkpoint/validate.js

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

package/dest/config/chain-config.d.ts

@@ -1,5 +1,5 @@
-import type { ConfigMappingsType } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
+import { type L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { type ConfigMappingsType } from '@aztec/foundation/config';
 export { type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
 export { type AllowedElement } from '../interfaces/allowed_element.js';
 export declare const emptyChainConfig: ChainConfig;
@@ -10,10 +10,5 @@ export type ChainConfig = {
     l1ChainId: number;
     /** The version of the rollup. */
     rollupVersion: number;
-    /** The address to the L1 contracts. */
-    l1Contracts: {
-        /** The address to rollup */
-        rollupAddress: EthAddress;
-    };
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW4tY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NoYWluLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ25FLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUUzRCxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN2RixPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUV2RSxlQUFPLE1BQU0sZ0JBQWdCLEVBQUUsV0FJOUIsQ0FBQztBQUVGLGVBQU8sTUFBTSxtQkFBbUIsRUFBRSxrQkFBa0IsQ0FBQyxXQUFXLENBZ0IvRCxDQUFDO0FBRUYsMkJBQTJCO0FBQzNCLE1BQU0sTUFBTSxXQUFXLEdBQUc7SUFDeEIseUNBQXlDO0lBQ3pDLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsaUNBQWlDO0lBQ2pDLGFBQWEsRUFBRSxNQUFNLENBQUM7SUFDdEIsdUNBQXVDO0lBQ3ZDLFdBQVcsRUFBRTtRQUNYLDRCQUE0QjtRQUM1QixhQUFhLEVBQUUsVUFBVSxDQUFDO0tBQzNCLENBQUM7Q0FDSCxDQUFDIn0=
+} & Pick<L1ContractAddresses, 'rollupAddress'>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW4tY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NoYWluLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxtQkFBbUIsRUFBaUMsTUFBTSx1Q0FBdUMsQ0FBQztBQUNoSCxPQUFPLEVBQUUsS0FBSyxrQkFBa0IsRUFBc0IsTUFBTSwwQkFBMEIsQ0FBQztBQUd2RixPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN2RixPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUV2RSxlQUFPLE1BQU0sZ0JBQWdCLEVBQUUsV0FJOUIsQ0FBQztBQUVGLGVBQU8sTUFBTSxtQkFBbUIsRUFBRSxrQkFBa0IsQ0FBQyxXQUFXLENBa0IvRCxDQUFDO0FBRUYsMkJBQTJCO0FBQzNCLE1BQU0sTUFBTSxXQUFXLEdBQUc7SUFDeEIseUNBQXlDO0lBQ3pDLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsaUNBQWlDO0lBQ2pDLGFBQWEsRUFBRSxNQUFNLENBQUM7Q0FDdkIsR0FBRyxJQUFJLENBQUMsbUJBQW1CLEVBQUUsZUFBZSxDQUFDLENBQUMifQ==

package/dest/config/chain-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain-config.d.ts","sourceRoot":"","sources":["../../src/config/chain-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,KAAK,eAAe,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE,eAAO,MAAM,gBAAgB,EAAE,WAI9B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,kBAAkB,CAAC,WAAW,CAgB/D,CAAC;AAEF,2BAA2B;AAC3B,MAAM,MAAM,WAAW,GAAG;IACxB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,WAAW,EAAE;QACX,4BAA4B;QAC5B,aAAa,EAAE,UAAU,CAAC;KAC3B,CAAC;CACH,CAAC"}
+{"version":3,"file":"chain-config.d.ts","sourceRoot":"","sources":["../../src/config/chain-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAiC,MAAM,uCAAuC,CAAC;AAChH,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,0BAA0B,CAAC;AAGvF,OAAO,EAAE,KAAK,eAAe,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE,eAAO,MAAM,gBAAgB,EAAE,WAI9B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,kBAAkB,CAAC,WAAW,CAkB/D,CAAC;AAEF,2BAA2B;AAC3B,MAAM,MAAM,WAAW,GAAG;IACxB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC"}

package/dest/config/chain-config.js

@@ -1,27 +1,28 @@
-import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
+import { pickL1ContractAddressMappings } from '@aztec/ethereum/l1-contract-addresses';
+import { numberConfigHelper } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 export { SequencerConfigSchema } from '../interfaces/configs.js';
 export const emptyChainConfig = {
     l1ChainId: 0,
-    l1Contracts: {
-        rollupAddress: EthAddress.ZERO
-    },
-    rollupVersion: 0
+    rollupVersion: 0,
+    rollupAddress: EthAddress.ZERO
 };
 export const chainConfigMappings = {
     l1ChainId: {
         env: 'L1_CHAIN_ID',
-        parseEnv: (val)=>+val,
-        defaultValue: 31337,
+        ...numberConfigHelper(31337),
         description: 'The chain ID of the ethereum host.'
     },
     rollupVersion: {
         env: 'ROLLUP_VERSION',
         description: 'The version of the rollup.',
-        parseEnv: (val)=>Number.isSafeInteger(parseInt(val, 10)) ? parseInt(val, 10) : undefined
+        parseEnv: (val)=>{
+            const parsed = parseInt(val, 10);
+            if (!Number.isSafeInteger(parsed)) {
+                throw new Error(`Invalid rollup version: ${val}`);
+            }
+            return parsed;
+        }
     },
-    l1Contracts: {
-        description: 'The deployed L1 contract addresses',
-        nested: l1ContractAddressesMapping
-    }
+    ...pickL1ContractAddressMappings('rollupAddress')
 };

package/dest/config/index.d.ts

@@ -1,3 +1,5 @@
 export * from './chain-config.js';
+export * from './network-consensus-config.js';
 export * from './node-rpc-config.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHNCQUFzQixDQUFDIn0=
+export * from './sequencer-config.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyx1QkFBdUIsQ0FBQyJ9

package/dest/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

package/dest/config/index.js

@@ -1,2 +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/dest/config/network-consensus-config.d.ts

@@ -0,0 +1,72 @@
+import { type L1ContractsConfig } from '@aztec/ethereum/config';
+import type { SequencerConfig } from '../interfaces/configs.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 declare const NETWORK_CONSENSUS_ENV_VARS: readonly ["ETHEREUM_SLOT_DURATION", "AZTEC_SLOT_DURATION", "AZTEC_EPOCH_DURATION", "SEQ_BLOCK_DURATION_MS", "MAX_BLOCKS_PER_CHECKPOINT", "CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS", "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_INBOX_LAG", "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", "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"];
+/** 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'>>;
+/**
+ * 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 declare function getConsensusConfigFromNetworkEnv(values: Record<string, string | number | boolean>): NetworkConsensusConfig;
+/**
+ * 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.
+ */
+export declare function validateNetworkConsensusConfig(config: NetworkConsensusConfig): string[];
+/**
+ * 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 declare function checkConsensusEnvOverrides(networkConfig: Record<string, string | number | boolean>, env?: {
+    [key: string]: string | undefined;
+}, log?: (msg: string) => void): Record<string, string>;
+/** Whether the env opts into overriding network-wide consensus values (`ALLOW_OVERRIDING_NETWORK_CONFIG`). */
+export declare function allowsNetworkConfigOverride(env?: {
+    [key: string]: string | undefined;
+}): boolean;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29yay1jb25zZW5zdXMtY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL25ldHdvcmstY29uc2Vuc3VzLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxpQkFBaUIsRUFBb0QsTUFBTSx3QkFBd0IsQ0FBQztBQUdsSCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQVVoRTs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxlQUFPLE1BQU0sMEJBQTBCLDJsREFzREQsQ0FBQztBQUV2Qyw4RkFBOEY7QUFDOUYsTUFBTSxNQUFNLGVBQWUsR0FBRyxDQUFDLE9BQU8sMEJBQTBCLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUUxRTs7Ozs7R0FLRztBQUNILE1BQU0sTUFBTSxzQkFBc0IsR0FBRyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsbUJBQW1CLEdBQUcsc0JBQXNCLENBQUMsR0FDeEcsUUFBUSxDQUFDLElBQUksQ0FBQyxlQUFlLEVBQUUsaUJBQWlCLEdBQUcsd0JBQXdCLEdBQUcsb0NBQW9DLENBQUMsQ0FBQyxDQUFDO0FBWXZIOzs7Ozs7R0FNRztBQUNILHdCQUFnQixnQ0FBZ0MsQ0FDOUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxPQUFPLENBQUMsR0FDaEQsc0JBQXNCLENBaUJ4QjtBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQWdCLDhCQUE4QixDQUFDLE1BQU0sRUFBRSxzQkFBc0IsR0FBRyxNQUFNLEVBQUUsQ0FtRXZGO0FBRUQ7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBQ0gsd0JBQWdCLDBCQUEwQixDQUN4QyxhQUFhLEVBQUUsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsTUFBTSxHQUFHLE9BQU8sQ0FBQyxFQUN4RCxHQUFHLEdBQUU7SUFBRSxDQUFDLEdBQUcsRUFBRSxNQUFNLEdBQUcsTUFBTSxHQUFHLFNBQVMsQ0FBQTtDQUFnQixFQUN4RCxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsRUFBRSxNQUFNLEtBQUssSUFBSSxHQUMxQixNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQWlEeEI7QUFFRCw4R0FBOEc7QUFDOUcsd0JBQWdCLDJCQUEyQixDQUFDLEdBQUcsR0FBRTtJQUFFLENBQUMsR0FBRyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsU0FBUyxDQUFBO0NBQWdCLEdBQUcsT0FBTyxDQUc3RyJ9

package/dest/config/network-consensus-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-consensus-config.d.ts","sourceRoot":"","sources":["../../src/config/network-consensus-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAoD,MAAM,wBAAwB,CAAC;AAGlH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAUhE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,0BAA0B,2lDAsDD,CAAC;AAEvC,8FAA8F;AAC9F,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,iBAAiB,EAAE,mBAAmB,GAAG,sBAAsB,CAAC,GACxG,QAAQ,CAAC,IAAI,CAAC,eAAe,EAAE,iBAAiB,GAAG,wBAAwB,GAAG,oCAAoC,CAAC,CAAC,CAAC;AAYvH;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAChD,sBAAsB,CAiBxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,EAAE,CAmEvF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EACxD,GAAG,GAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAgB,EACxD,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC1B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAiDxB;AAED,8GAA8G;AAC9G,wBAAgB,2BAA2B,CAAC,GAAG,GAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAgB,GAAG,OAAO,CAG7G"}

package/dest/config/network-consensus-config.js

@@ -0,0 +1,223 @@
+import { l1ContractsConfigMappings, validateSlotDurations } from '@aztec/ethereum/config';
+import { pickConfigMappings } from '@aztec/foundation/config';
+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_INBOX_LAG',
+    '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'
+];
+/** 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) {
+    const result = {};
+    for (const [field, mapping] of Object.entries(networkConsensusConfigMappings)){
+        const raw = mapping.env !== undefined ? values[mapping.env] : undefined;
+        if (raw === undefined) {
+            result[field] = NaN;
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = mapping.parseEnv ? mapping.parseEnv(String(raw)) : Number(raw);
+        } catch  {
+            parsed = NaN;
+        }
+        result[field] = 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.
+ */ export function validateNetworkConsensusConfig(config) {
+    const errors = [];
+    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 < 1) {
+        errors.push(`maxBlocksPerCheckpoint must be at least 1 (got ${config.maxBlocksPerCheckpoint})`);
+    }
+    if (config.checkpointProposalSyncGraceSeconds < 0) {
+        errors.push(`checkpointProposalSyncGraceSeconds must be non-negative (got ${config.checkpointProposalSyncGraceSeconds})`);
+    }
+    if (errors.length > 0) {
+        return errors;
+    }
+    let computed;
+    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, env = process.env, log) {
+    const allowOverride = allowsNetworkConfigOverride(env);
+    const canonical = {};
+    const conflicts = [];
+    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 = process.env) {
+    const value = env.ALLOW_OVERRIDING_NETWORK_CONFIG;
+    return value === '1' || value?.toLowerCase() === 'true';
+}

package/dest/config/node-rpc-config.js

@@ -19,6 +19,6 @@ export const nodeRpcConfigMappings = {
     rpcMaxBodySize: {
         env: 'RPC_MAX_BODY_SIZE',
         description: 'Maximum allowed batch size for JSON RPC batch requests.',
-        defaultValue: '50mb'
+        defaultValue: '1mb'
     }
 };

package/dest/config/sequencer-config.d.ts

@@ -0,0 +1,16 @@
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+import type { SequencerConfig } from '../interfaces/configs.js';
+/** Default duration per block in milliseconds, used to derive how many blocks fit in a slot. */
+export declare const DEFAULT_BLOCK_DURATION_MS: number;
+/** Default maximum number of transactions per block. */
+export declare const DEFAULT_MAX_TXS_PER_BLOCK = 32;
+/** Default maximum number of blocks the sequencer packs into a single checkpoint. */
+export declare 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 declare const sharedSequencerConfigMappings: ConfigMappingsType<Pick<SequencerConfig, 'blockDurationMs' | 'checkpointProposalSyncGraceSeconds' | 'expectedBlockProposalsPerSlot' | 'maxTxsPerBlock' | 'attestationPropagationTime' | 'checkpointProposalPrepareTime' | 'minBlockDuration' | 'maxBlocksPerCheckpoint'>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VxdWVuY2VyLWNvbmZpZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbmZpZy9zZXF1ZW5jZXItY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLGtCQUFrQixFQUl4QixNQUFNLDBCQUEwQixDQUFDO0FBRWxDLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBU2hFLGdHQUFnRztBQUNoRyxlQUFPLE1BQU0seUJBQXlCLFFBQWdDLENBQUM7QUFFdkUsd0RBQXdEO0FBQ3hELGVBQU8sTUFBTSx5QkFBeUIsS0FBSyxDQUFDO0FBRTVDLHFGQUFxRjtBQUNyRixlQUFPLE1BQU0saUNBQWlDLEtBQUssQ0FBQztBQUVwRDs7Ozs7R0FLRztBQUNILGVBQU8sTUFBTSw2QkFBNkIsRUFBRSxrQkFBa0IsQ0FDNUQsSUFBSSxDQUNGLGVBQWUsRUFDYixpQkFBaUIsR0FDakIsb0NBQW9DLEdBQ3BDLCtCQUErQixHQUMvQixnQkFBZ0IsR0FDaEIsNEJBQTRCLEdBQzVCLCtCQUErQixHQUMvQixrQkFBa0IsR0FDbEIsd0JBQXdCLENBQzNCLENBcURGLENBQUMifQ==

package/dest/config/sequencer-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencer-config.d.ts","sourceRoot":"","sources":["../../src/config/sequencer-config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAShE,gGAAgG;AAChG,eAAO,MAAM,yBAAyB,QAAgC,CAAC;AAEvE,wDAAwD;AACxD,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,qFAAqF;AACrF,eAAO,MAAM,iCAAiC,KAAK,CAAC;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAC5D,IAAI,CACF,eAAe,EACb,iBAAiB,GACjB,oCAAoC,GACpC,+BAA+B,GAC/B,gBAAgB,GAChB,4BAA4B,GAC5B,+BAA+B,GAC/B,kBAAkB,GAClB,wBAAwB,CAC3B,CAqDF,CAAC"}

package/dest/config/sequencer-config.js

@@ -0,0 +1,57 @@
+import { floatConfigHelper, numberConfigHelper, optionalNumberConfigHelper } from '@aztec/foundation/config';
+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 = {
+    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)=>parseInt(val, 10),
+        defaultValue: DEFAULT_MAX_BLOCKS_PER_CHECKPOINT
+    }
+};

package/dest/contract/artifact_hash.d.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { MerkleTree } from '@aztec/foundation/trees';
 import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
 /**
@@ -42,4 +42,4 @@ export declare function computeFunctionArtifactHash(fn: FunctionArtifact | (Pick
 })): Promise<Fr>;
 export declare function computeFunctionMetadataHash(fn: FunctionArtifact): Fr;
 export declare function getArtifactMerkleTreeHasher(): (l: Buffer<ArrayBufferLike>, r: Buffer<ArrayBufferLike>) => Promise<Buffer<ArrayBuffer>>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJ0aWZhY3RfaGFzaC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2FydGlmYWN0X2hhc2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBR3hELE9BQU8sRUFBRSxVQUFVLEVBQXdCLE1BQU0seUJBQXlCLENBQUM7QUFJM0UsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQVMvRzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUJHO0FBQ0gsd0JBQXNCLG1CQUFtQixDQUN2QyxRQUFRLEVBQUUsZ0JBQWdCLEdBQUc7SUFBRSxtQkFBbUIsRUFBRSxFQUFFLENBQUM7SUFBQyxtQkFBbUIsRUFBRSxFQUFFLENBQUM7SUFBQyxZQUFZLEVBQUUsRUFBRSxDQUFBO0NBQUUsR0FDbEcsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQVdiO0FBRUQsd0JBQXNCLDJCQUEyQixDQUFDLFFBQVEsRUFBRSxnQkFBZ0I7Ozs7R0FLM0U7QUFFRCx3QkFBZ0IsMkJBQTJCLENBQUMsUUFBUSxFQUFFLGdCQUFnQixNQUVyRTtBQUVELHdCQUFzQiwrQkFBK0IsQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxFQUFFLFlBQVksZUFHckc7QUFFRCx3QkFBc0IsMkJBQTJCLENBQy9DLFFBQVEsRUFBRSxnQkFBZ0IsRUFDMUIsTUFBTSxFQUFFLFlBQVksR0FDbkIsT0FBTyxDQUFDLFVBQVUsR0FBRyxTQUFTLENBQUMsQ0FTakM7QUFZRCx3QkFBc0IsMkJBQTJCLENBQy9DLEVBQUUsRUFDRSxnQkFBZ0IsR0FDaEIsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsVUFBVSxDQUFDLEdBQUc7SUFBRSxvQkFBb0IsRUFBRSxFQUFFLENBQUM7SUFBQyxRQUFRLEVBQUUsZ0JBQWdCLENBQUE7Q0FBRSxDQUFDLGVBT3BHO0FBRUQsd0JBQWdCLDJCQUEyQixDQUFDLEVBQUUsRUFBRSxnQkFBZ0IsTUFFL0Q7QUFNRCx3QkFBZ0IsMkJBQTJCLDZGQUUxQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJ0aWZhY3RfaGFzaC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2FydGlmYWN0X2hhc2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBWSxNQUFNLGdDQUFnQyxDQUFDO0FBRzlELE9BQU8sRUFBRSxVQUFVLEVBQXdCLE1BQU0seUJBQXlCLENBQUM7QUFJM0UsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQVMvRzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUJHO0FBQ0gsd0JBQXNCLG1CQUFtQixDQUN2QyxRQUFRLEVBQUUsZ0JBQWdCLEdBQUc7SUFBRSxtQkFBbUIsRUFBRSxFQUFFLENBQUM7SUFBQyxtQkFBbUIsRUFBRSxFQUFFLENBQUM7SUFBQyxZQUFZLEVBQUUsRUFBRSxDQUFBO0NBQUUsR0FDbEcsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQVdiO0FBRUQsd0JBQXNCLDJCQUEyQixDQUFDLFFBQVEsRUFBRSxnQkFBZ0I7Ozs7R0FLM0U7QUFFRCx3QkFBZ0IsMkJBQTJCLENBQUMsUUFBUSxFQUFFLGdCQUFnQixNQUVyRTtBQUVELHdCQUFzQiwrQkFBK0IsQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxFQUFFLFlBQVksZUFHckc7QUFFRCx3QkFBc0IsMkJBQTJCLENBQy9DLFFBQVEsRUFBRSxnQkFBZ0IsRUFDMUIsTUFBTSxFQUFFLFlBQVksR0FDbkIsT0FBTyxDQUFDLFVBQVUsR0FBRyxTQUFTLENBQUMsQ0FTakM7QUFZRCx3QkFBc0IsMkJBQTJCLENBQy9DLEVBQUUsRUFDRSxnQkFBZ0IsR0FDaEIsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsVUFBVSxDQUFDLEdBQUc7SUFBRSxvQkFBb0IsRUFBRSxFQUFFLENBQUM7SUFBQyxRQUFRLEVBQUUsZ0JBQWdCLENBQUE7Q0FBRSxDQUFDLGVBT3BHO0FBRUQsd0JBQWdCLDJCQUEyQixDQUFDLEVBQUUsRUFBRSxnQkFBZ0IsTUFFL0Q7QUFNRCx3QkFBZ0IsMkJBQTJCLDZGQUUxQyJ9