@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/checkpoint/simulation_overrides.d.ts

@@ -0,0 +1,61 @@
+import { type FeeHeader, RollupContract, type SimulationOverridesPlan } from '@aztec-labs/ethereum/contracts';
+import { CheckpointNumber } from '@aztec-labs/foundation/branded-types';
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { CoordinationSignatureContext } from '../p2p/signature_utils.js';
+import type { ProposedCheckpointData } from './checkpoint_data.js';
+type CheckpointSimulationOverridesPlanInput = {
+    /** Target rollup contract. */
+    rollup: RollupContract;
+    /** Checkpoint number to be proposed. */
+    checkpointNumber: CheckpointNumber;
+    /** Logger instance. */
+    log: Logger;
+    /**
+     * The proposed parent checkpoint when pipelining. Its `checkpointNumber` must equal
+     * `checkpointNumber - 1`; the helper enforces this. Mutually exclusive with
+     * `invalidateToPendingCheckpointNumber`.
+     */
+    proposedCheckpointData?: ProposedCheckpointData;
+    /**
+     * The pending checkpoint number we'll end up at after invalidation lands. Mutually exclusive
+     * with `proposedCheckpointData`.
+     */
+    invalidateToPendingCheckpointNumber?: CheckpointNumber;
+    /**
+     * The real on-chain pending checkpoint number (typically `syncedTo.checkpointedCheckpointNumber`).
+     * Used as the snapshot we pin both `pending` and `proven` to avoid prunes in simulation.
+     */
+    checkpointedCheckpointNumber: CheckpointNumber;
+    /**
+     * Chain-level consensus signature context. Used to recompute the parent's `payloadDigest` for the
+     * pipelined simulation override so it matches what `propose` will write into `tempCheckpointLogs[parent]`
+     * once the parent lands.
+     */
+    signatureContext: CoordinationSignatureContext;
+};
+/**
+ * Builds the SimulationOverridesPlan describing the simulated L1 rollup state for a checkpoint's
+ * enqueue-time simulations: `canProposeAt` (in Sequencer.doWork) and the propose-related sims
+ * (validateCheckpointHeader, simulateProposeTx). The plan reflects "as if our pipelined parent
+ * checkpoint has landed and any required invalidation has executed" — the gap that needs to be
+ * bridged at enqueue time.
+ *
+ * Pipelining (`proposedCheckpointData`) and invalidation (`invalidateToPendingCheckpointNumber`)
+ * are mutually exclusive; passing both throws.
+ */
+export declare function buildCheckpointSimulationOverridesPlan(input: CheckpointSimulationOverridesPlanInput): Promise<SimulationOverridesPlan | undefined>;
+type PipelinedParentFeeHeaderInput = {
+    checkpointNumber: CheckpointNumber;
+    proposedCheckpointData: ProposedCheckpointData;
+    rollup: RollupContract;
+    log: Logger;
+};
+/**
+ * Derives the pending parent fee header used during pipelined proposal simulation. Returns
+ * `undefined` only when no grandparent exists (i.e. the proposed parent is the genesis
+ * checkpoint); all other failure modes (missing grandparent state, missing fee header, RPC
+ * errors) throw so callers don't silently desync the fee-header override.
+ */
+export declare function computePipelinedParentFeeHeader(input: PipelinedParentFeeHeaderInput): Promise<FeeHeader | undefined>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltdWxhdGlvbl9vdmVycmlkZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jaGVja3BvaW50L3NpbXVsYXRpb25fb3ZlcnJpZGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLFNBQVMsRUFDZCxjQUFjLEVBRWQsS0FBSyx1QkFBdUIsRUFDN0IsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN4QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUV6RCxPQUFPLEtBQUssRUFBRSw0QkFBNEIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQzlFLE9BQU8sS0FBSyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFHbkUsS0FBSyxzQ0FBc0MsR0FBRztJQUM1Qyw4QkFBOEI7SUFDOUIsTUFBTSxFQUFFLGNBQWMsQ0FBQztJQUN2Qix3Q0FBd0M7SUFDeEMsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUM7SUFDbkMsdUJBQXVCO0lBQ3ZCLEdBQUcsRUFBRSxNQUFNLENBQUM7SUFDWjs7OztPQUlHO0lBQ0gsc0JBQXNCLENBQUMsRUFBRSxzQkFBc0IsQ0FBQztJQUNoRDs7O09BR0c7SUFDSCxtQ0FBbUMsQ0FBQyxFQUFFLGdCQUFnQixDQUFDO0lBQ3ZEOzs7T0FHRztJQUNILDRCQUE0QixFQUFFLGdCQUFnQixDQUFDO0lBQy9DOzs7O09BSUc7SUFDSCxnQkFBZ0IsRUFBRSw0QkFBNEIsQ0FBQztDQUNoRCxDQUFDO0FBRUY7Ozs7Ozs7OztHQVNHO0FBQ0gsd0JBQXNCLHNDQUFzQyxDQUMxRCxLQUFLLEVBQUUsc0NBQXNDLEdBQzVDLE9BQU8sQ0FBQyx1QkFBdUIsR0FBRyxTQUFTLENBQUMsQ0F5RDlDO0FBcUJELEtBQUssNkJBQTZCLEdBQUc7SUFDbkMsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUM7SUFDbkMsc0JBQXNCLEVBQUUsc0JBQXNCLENBQUM7SUFDL0MsTUFBTSxFQUFFLGNBQWMsQ0FBQztJQUN2QixHQUFHLEVBQUUsTUFBTSxDQUFDO0NBQ2IsQ0FBQztBQUVGOzs7OztHQUtHO0FBQ0gsd0JBQXNCLCtCQUErQixDQUNuRCxLQUFLLEVBQUUsNkJBQTZCLEdBQ25DLE9BQU8sQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDLENBd0JoQyJ9

package/dest/checkpoint/simulation_overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation_overrides.d.ts","sourceRoot":"","sources":["../../src/checkpoint/simulation_overrides.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,cAAc,EAEd,KAAK,uBAAuB,EAC7B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAGnE,KAAK,sCAAsC,GAAG;IAC5C,8BAA8B;IAC9B,MAAM,EAAE,cAAc,CAAC;IACvB,wCAAwC;IACxC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD;;;OAGG;IACH,mCAAmC,CAAC,EAAE,gBAAgB,CAAC;IACvD;;;OAGG;IACH,4BAA4B,EAAE,gBAAgB,CAAC;IAC/C;;;;OAIG;IACH,gBAAgB,EAAE,4BAA4B,CAAC;CAChD,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAsB,sCAAsC,CAC1D,KAAK,EAAE,sCAAsC,GAC5C,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAyD9C;AAqBD,KAAK,6BAA6B,GAAG;IACnC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,MAAM,EAAE,cAAc,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,+BAA+B,CACnD,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAwBhC"}

package/dest/checkpoint/simulation_overrides.js

@@ -0,0 +1,101 @@
+import { RollupContract, SimulationOverridesBuilder } from '@aztec-labs/ethereum/contracts';
+import { CheckpointNumber } from '@aztec-labs/foundation/branded-types';
+import { computeCheckpointPayloadDigest } from './digest.js';
+/**
+ * Builds the SimulationOverridesPlan describing the simulated L1 rollup state for a checkpoint's
+ * enqueue-time simulations: `canProposeAt` (in Sequencer.doWork) and the propose-related sims
+ * (validateCheckpointHeader, simulateProposeTx). The plan reflects "as if our pipelined parent
+ * checkpoint has landed and any required invalidation has executed" — the gap that needs to be
+ * bridged at enqueue time.
+ *
+ * Pipelining (`proposedCheckpointData`) and invalidation (`invalidateToPendingCheckpointNumber`)
+ * are mutually exclusive; passing both throws.
+ */ export async function buildCheckpointSimulationOverridesPlan(input) {
+    if (input.proposedCheckpointData && input.invalidateToPendingCheckpointNumber !== undefined) {
+        throw new Error('Error in buildCheckpointSimulationOverridesPlan: proposedCheckpointData and invalidateToPendingCheckpointNumber are mutually exclusive');
+    }
+    const builder = new SimulationOverridesBuilder();
+    const pendingCheckpointNumber = derivePendingCheckpointNumber(input);
+    // Override the latest checkpoint number when invalidating or pipelining, so our checkpoint
+    // follows from it. We also override the proven chain tip so we dont need to worry about
+    // prunes kicking in that would break out simulation if there's a prune pending. We always
+    // assume that a proof will land in time. If we don't have a pending checkpoint number to force,
+    // we still set both tips to the current checkpoint number to avoid the prune trigger.
+    const overridenChainTip = pendingCheckpointNumber ?? input.checkpointedCheckpointNumber;
+    builder.withChainTips({
+        pending: overridenChainTip,
+        proven: overridenChainTip
+    });
+    if (input.proposedCheckpointData) {
+        const { header, archive, checkpointOutHash, feeAssetPriceModifier, inboxMsgTotal } = input.proposedCheckpointData;
+        builder.withPendingArchive(archive.root);
+        // Override every locally-derivable `tempCheckpointLogs[parent]` field that L1 will eventually
+        // write. `slotNumber` is required by `STFLib.canPruneAtTime`: without it the cell reads
+        // slotNumber 0, the contract treats the pending tip as belonging to an expired epoch, and
+        // `getEffectivePendingCheckpointNumber` silently collapses pending back to proven — producing
+        // a spurious `Rollup__InvalidArchive` against the on-chain genesis archive. `inboxMsgTotal` is
+        // read by `ProposeLib.validateInboxConsumption` as the parent's consumed total: left at zero it
+        // makes our consumption look like the Inbox's entire history and trips
+        // `Rollup__TooManyInboxMessagesConsumed`. The remaining fields (headerHash, outHash,
+        // payloadDigest) are not read by `canProposeAt` / `validateCheckpointHeader`, but mirroring the full
+        // cell keeps the simulation byte-faithful with what the actual `propose()` send will observe,
+        // which is a defense against future reads taking dependencies on them.
+        builder.withPendingTempCheckpointLogFields({
+            headerHash: header.hash(),
+            outHash: checkpointOutHash,
+            slotNumber: header.slotNumber,
+            inboxMsgTotal,
+            payloadDigest: computeCheckpointPayloadDigest({
+                header,
+                archiveRoot: archive.root,
+                feeAssetPriceModifier,
+                signatureContext: input.signatureContext
+            })
+        });
+        const feeHeader = await computePipelinedParentFeeHeader({
+            checkpointNumber: input.checkpointNumber,
+            proposedCheckpointData: input.proposedCheckpointData,
+            rollup: input.rollup,
+            log: input.log
+        });
+        if (feeHeader) {
+            builder.withPendingFeeHeader(feeHeader);
+        }
+    }
+    return builder.build();
+}
+function derivePendingCheckpointNumber(input) {
+    if (input.invalidateToPendingCheckpointNumber !== undefined) {
+        return input.invalidateToPendingCheckpointNumber;
+    }
+    if (!input.proposedCheckpointData) {
+        return undefined;
+    }
+    if (input.checkpointNumber < 1) {
+        throw new Error(`Cannot build simulation override for checkpoint ${input.checkpointNumber}: no parent exists`);
+    }
+    const expectedParent = CheckpointNumber(input.checkpointNumber - 1);
+    if (input.proposedCheckpointData.checkpointNumber !== expectedParent) {
+        throw new Error(`Cannot build simulation override for checkpoint ${input.checkpointNumber}: proposedCheckpointData.checkpointNumber (${input.proposedCheckpointData.checkpointNumber}) does not match expected parent ${expectedParent}`);
+    }
+    return expectedParent;
+}
+/**
+ * Derives the pending parent fee header used during pipelined proposal simulation. Returns
+ * `undefined` only when no grandparent exists (i.e. the proposed parent is the genesis
+ * checkpoint); all other failure modes (missing grandparent state, missing fee header, RPC
+ * errors) throw so callers don't silently desync the fee-header override.
+ */ export async function computePipelinedParentFeeHeader(input) {
+    if (input.checkpointNumber < 2) {
+        return undefined;
+    }
+    const grandparentCheckpointNumber = CheckpointNumber(input.checkpointNumber - 2);
+    const [grandparentCheckpoint, manaTarget] = await Promise.all([
+        input.rollup.getCheckpoint(grandparentCheckpointNumber),
+        input.rollup.getManaTarget()
+    ]);
+    if (!grandparentCheckpoint?.feeHeader) {
+        throw new Error(`Grandparent checkpoint or feeHeader missing for checkpoint ${grandparentCheckpointNumber.toString()}`);
+    }
+    return RollupContract.computeChildFeeHeader(grandparentCheckpoint.feeHeader, input.proposedCheckpointData.totalManaUsed, input.proposedCheckpointData.feeAssetPriceModifier, manaTarget);
+}

package/dest/checkpoint/validate.d.ts

@@ -0,0 +1,44 @@
+import type { CheckpointNumber, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { Checkpoint } from './checkpoint.js';
+export declare class CheckpointValidationError extends Error {
+    readonly checkpointNumber: CheckpointNumber;
+    readonly slot: SlotNumber;
+    constructor(message: string, checkpointNumber: CheckpointNumber, slot: SlotNumber);
+}
+/**
+ * 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 declare function validateCheckpoint(checkpoint: Checkpoint, opts: {
+    rollupManaLimit?: number;
+    maxL2BlockGas?: number;
+    maxDABlockGas?: number;
+    maxTxsPerCheckpoint?: number;
+    maxTxsPerBlock?: number;
+    /**
+     * Max blocks per checkpoint. Defaults to {@link MAX_ATTESTABLE_BLOCKS_PER_CHECKPOINT}; the L1-sync
+     * ingest path passes `MAX_CAPACITY_BLOCKS_PER_CHECKPOINT` to tolerate larger checkpoints already
+     * accepted by L1.
+     */
+    maxBlocksPerCheckpoint?: number;
+}): void;
+/**
+ * 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 declare function validateCheckpointStructure(checkpoint: Checkpoint, opts?: {
+    maxBlocksPerCheckpoint?: number;
+}): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jaGVja3BvaW50L3ZhbGlkYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLFVBQVUsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBSXpGLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRWxELHFCQUFhLHlCQUEwQixTQUFRLEtBQUs7YUFHaEMsZ0JBQWdCLEVBQUUsZ0JBQWdCO2FBQ2xDLElBQUksRUFBRSxVQUFVO0lBSGxDLFlBQ0UsT0FBTyxFQUFFLE1BQU0sRUFDQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFDbEMsSUFBSSxFQUFFLFVBQVUsRUFJakM7Q0FDRjtBQUVEOzs7Ozs7O0dBT0c7QUFDSCx3QkFBZ0Isa0JBQWtCLENBQ2hDLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLElBQUksRUFBRTtJQUNKLGVBQWUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN6QixhQUFhLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdkIsYUFBYSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3ZCLG1CQUFtQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzdCLGNBQWMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN4Qjs7OztPQUlHO0lBQ0gsc0JBQXNCLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDakMsR0FDQSxJQUFJLENBSU47QUFFRDs7Ozs7Ozs7Ozs7R0FXRztBQUNILHdCQUFnQiwyQkFBMkIsQ0FDekMsVUFBVSxFQUFFLFVBQVUsRUFDdEIsSUFBSSxHQUFFO0lBQUUsc0JBQXNCLENBQUMsRUFBRSxNQUFNLENBQUE7Q0FBTyxHQUM3QyxJQUFJLENBd0VOIn0=

package/dest/checkpoint/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/checkpoint/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAIzF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,qBAAa,yBAA0B,SAAQ,KAAK;aAGhC,gBAAgB,EAAE,gBAAgB;aAClC,IAAI,EAAE,UAAU;IAHlC,YACE,OAAO,EAAE,MAAM,EACC,gBAAgB,EAAE,gBAAgB,EAClC,IAAI,EAAE,UAAU,EAIjC;CACF;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE;IACJ,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC,GACA,IAAI,CAIN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,UAAU,EACtB,IAAI,GAAE;IAAE,sBAAsB,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7C,IAAI,CAwEN"}

package/dest/checkpoint/validate.js

@@ -0,0 +1,123 @@
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec-labs/constants';
+import { sum } from '@aztec-labs/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

@@ -0,0 +1,14 @@
+import { type L1ContractAddresses } from '@aztec-labs/ethereum/l1-contract-addresses';
+import { type ConfigMappingsType } from '@aztec-labs/foundation/config';
+export { type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
+export { type AllowedElement } from '../interfaces/allowed_element.js';
+export declare const emptyChainConfig: ChainConfig;
+export declare const chainConfigMappings: ConfigMappingsType<ChainConfig>;
+/** Chain configuration. */
+export type ChainConfig = {
+    /** The chain id of the ethereum host. */
+    l1ChainId: number;
+    /** The version of the rollup. */
+    rollupVersion: number;
+} & Pick<L1ContractAddresses, 'rollupAddress'>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW4tY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NoYWluLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxtQkFBbUIsRUFBaUMsTUFBTSw0Q0FBNEMsQ0FBQztBQUNySCxPQUFPLEVBQUUsS0FBSyxrQkFBa0IsRUFBc0IsTUFBTSwrQkFBK0IsQ0FBQztBQUc1RixPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN2RixPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUV2RSxlQUFPLE1BQU0sZ0JBQWdCLEVBQUUsV0FJOUIsQ0FBQztBQUVGLGVBQU8sTUFBTSxtQkFBbUIsRUFBRSxrQkFBa0IsQ0FBQyxXQUFXLENBa0IvRCxDQUFDO0FBRUYsMkJBQTJCO0FBQzNCLE1BQU0sTUFBTSxXQUFXLEdBQUc7SUFDeEIseUNBQXlDO0lBQ3pDLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsaUNBQWlDO0lBQ2pDLGFBQWEsRUFBRSxNQUFNLENBQUM7Q0FDdkIsR0FBRyxJQUFJLENBQUMsbUJBQW1CLEVBQUUsZUFBZSxDQUFDLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"chain-config.d.ts","sourceRoot":"","sources":["../../src/config/chain-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAiC,MAAM,4CAA4C,CAAC;AACrH,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,+BAA+B,CAAC;AAG5F,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

@@ -0,0 +1,28 @@
+import { pickL1ContractAddressMappings } from '@aztec-labs/ethereum/l1-contract-addresses';
+import { numberConfigHelper } from '@aztec-labs/foundation/config';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+export { SequencerConfigSchema } from '../interfaces/configs.js';
+export const emptyChainConfig = {
+    l1ChainId: 0,
+    rollupVersion: 0,
+    rollupAddress: EthAddress.ZERO
+};
+export const chainConfigMappings = {
+    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)=>{
+            const parsed = parseInt(val, 10);
+            if (!Number.isSafeInteger(parsed)) {
+                throw new Error(`Invalid rollup version: ${val}`);
+            }
+            return parsed;
+        }
+    },
+    ...pickL1ContractAddressMappings('rollupAddress')
+};

package/dest/config/index.d.ts

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

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

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

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

@@ -0,0 +1,73 @@
+import { type L1ContractsConfig } from '@aztec-labs/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_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. It must also be at least
+ * {@link MIN_BLOCKS_FOR_INBOX_CATCHUP}, without which the network is permanently haltable.
+ */
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29yay1jb25zZW5zdXMtY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL25ldHdvcmstY29uc2Vuc3VzLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxpQkFBaUIsRUFBb0QsTUFBTSw2QkFBNkIsQ0FBQztBQUl2SCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQVdoRTs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxlQUFPLE1BQU0sMEJBQTBCLHdrREFxREQsQ0FBQztBQUV2Qyw4RkFBOEY7QUFDOUYsTUFBTSxNQUFNLGVBQWUsR0FBRyxDQUFDLE9BQU8sMEJBQTBCLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUUxRTs7Ozs7R0FLRztBQUNILE1BQU0sTUFBTSxzQkFBc0IsR0FBRyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsbUJBQW1CLEdBQUcsc0JBQXNCLENBQUMsR0FDeEcsUUFBUSxDQUFDLElBQUksQ0FBQyxlQUFlLEVBQUUsaUJBQWlCLEdBQUcsd0JBQXdCLEdBQUcsb0NBQW9DLENBQUMsQ0FBQyxDQUFDO0FBWXZIOzs7Ozs7R0FNRztBQUNILHdCQUFnQixnQ0FBZ0MsQ0FDOUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxPQUFPLENBQUMsR0FDaEQsc0JBQXNCLENBaUJ4QjtBQUVEOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFnQiw4QkFBOEIsQ0FBQyxNQUFNLEVBQUUsc0JBQXNCLEdBQUcsTUFBTSxFQUFFLENBOEV2RjtBQUVEOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUNILHdCQUFnQiwwQkFBMEIsQ0FDeEMsYUFBYSxFQUFFLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxPQUFPLENBQUMsRUFDeEQsR0FBRyxHQUFFO0lBQUUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxTQUFTLENBQUE7Q0FBZ0IsRUFDeEQsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxLQUFLLElBQUksR0FDMUIsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FpRHhCO0FBRUQsOEdBQThHO0FBQzlHLHdCQUFnQiwyQkFBMkIsQ0FBQyxHQUFHLEdBQUU7SUFBRSxDQUFDLEdBQUcsRUFBRSxNQUFNLEdBQUcsTUFBTSxHQUFHLFNBQVMsQ0FBQTtDQUFnQixHQUFHLE9BQU8sQ0FHN0cifQ==

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,6BAA6B,CAAC;AAIvH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAWhE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,0BAA0B,wkDAqDD,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;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,EAAE,CA8EvF;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"}