@aztec-labs/aztec-node 6.0.0-nightly.20260829

package/dest/bin/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --no-warnings
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iaW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":""}

package/dest/bin/index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env -S node --no-warnings
+import { createNamespacedSafeJsonRpcServer, startHttpRpcServer } from '@aztec-labs/foundation/json-rpc/server';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { getRpcCorsAllowedOrigins } from '@aztec-labs/stdlib/config';
+import { getOtelJsonRpcDiagnosticsMiddleware, getOtelJsonRpcPropagationMiddleware, getOtelJsonRpcServerMetricsMiddleware } from '@aztec-labs/telemetry-client';
+import { createAztecNodeService, getConfigEnvVars, registerAztecNodeRpcHandlers } from '../index.js';
+const { AZTEC_NODE_PORT = 8081, API_PREFIX = '' } = process.env;
+const logger = createLogger('node');
+/**
+ * Creates the node from provided config
+ */ async function createAndDeployAztecNode(aztecNodeConfig) {
+    return await createAztecNodeService(aztecNodeConfig);
+}
+/**
+ * Create and start a new Aztec Node HTTP Server
+ */ async function main() {
+    logger.info(`Setting up Aztec Node...`);
+    const aztecNodeConfig = {
+        ...getConfigEnvVars()
+    };
+    const aztecNode = await createAndDeployAztecNode(aztecNodeConfig);
+    const shutdown = async ()=>{
+        logger.info('Shutting down...');
+        await aztecNode.stop();
+        process.exit(0);
+    };
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    process.once('SIGINT', shutdown);
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    process.once('SIGTERM', shutdown);
+    const services = {};
+    registerAztecNodeRpcHandlers(aztecNode, services, undefined, {
+        p2pHealthMinPeers: aztecNodeConfig.p2pHealthMinPeers
+    });
+    const rpcServer = createNamespacedSafeJsonRpcServer(services, {
+        diagnostic: getOtelJsonRpcDiagnosticsMiddleware(),
+        middlewares: [
+            getOtelJsonRpcServerMetricsMiddleware(),
+            getOtelJsonRpcPropagationMiddleware()
+        ],
+        maxBatchSize: aztecNodeConfig.rpcMaxBatchSize,
+        maxBodySizeBytes: aztecNodeConfig.rpcMaxBodySize,
+        corsAllowedHeaders: aztecNodeConfig.rpcCorsAllowedHeaders,
+        corsAllowedOrigins: getRpcCorsAllowedOrigins(aztecNodeConfig)
+    });
+    await startHttpRpcServer(rpcServer, {
+        port: +AZTEC_NODE_PORT,
+        apiPrefix: API_PREFIX,
+        keepAliveTimeoutMs: aztecNodeConfig.rpcHttpKeepAliveTimeoutMs,
+        headersTimeoutMs: aztecNodeConfig.rpcHttpHeadersTimeoutMs
+    });
+    logger.info(`Aztec Node JSON-RPC Server listening on port ${AZTEC_NODE_PORT}`);
+}
+main().catch((err)=>{
+    logger.error(err);
+    process.exit(1);
+});

package/dest/factory.d.ts

@@ -0,0 +1,33 @@
+import { type Logger } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { type P2PClientDeps } from '@aztec-labs/p2p';
+import { type ProverNodeDeps } from '@aztec-labs/prover-node';
+import { type SequencerPublisher } from '@aztec-labs/sequencer-client';
+import type { GenesisData } from '@aztec-labs/stdlib/world-state';
+import { type TelemetryClient } from '@aztec-labs/telemetry-client';
+import type { SlashingProtectionDatabase } from '@aztec-labs/validator-ha-signer/types';
+import { type AztecNodeConfig } from './aztec-node/config.js';
+import { AztecNodeService } from './aztec-node/server.js';
+/** Dependencies that can be injected when creating a node, mostly to override defaults in tests. */
+export interface CreateAztecNodeDeps {
+    telemetry?: TelemetryClient;
+    logger?: Logger;
+    publisher?: SequencerPublisher;
+    dateProvider?: DateProvider;
+    p2pClientDeps?: P2PClientDeps;
+    proverNodeDeps?: Partial<ProverNodeDeps>;
+    slashingProtectionDb?: SlashingProtectionDatabase;
+}
+/** Options controlling which subsystems are started when creating a node. */
+export interface CreateAztecNodeOptions {
+    genesis?: GenesisData;
+    dontStartSequencer?: boolean;
+    dontStartProverNode?: boolean;
+}
+/**
+ * Initializes the Aztec Node, waiting for its components to sync.
+ * @param inputConfig - The configuration to be used by the aztec node.
+ * @returns A fully synced Aztec Node for use in development/testing.
+ */
+export declare function createAztecNodeService(inputConfig: AztecNodeConfig, deps?: CreateAztecNodeDeps, options?: CreateAztecNodeOptions): Promise<AztecNodeService>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBWUEsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFnQixNQUFNLDRCQUE0QixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUk1RCxPQUFPLEVBQUUsS0FBSyxhQUFhLEVBQW1CLE1BQU0saUJBQWlCLENBQUM7QUFDdEUsT0FBTyxFQUFtQixLQUFLLGNBQWMsRUFBb0IsTUFBTSx5QkFBeUIsQ0FBQztBQUVqRyxPQUFPLEVBSUwsS0FBSyxrQkFBa0IsRUFDeEIsTUFBTSw4QkFBOEIsQ0FBQztBQWlCdEMsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbEUsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUFzQixNQUFNLDhCQUE4QixDQUFDO0FBVXhGLE9BQU8sS0FBSyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFJeEYsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUE4QixNQUFNLHdCQUF3QixDQUFDO0FBQzFGLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRzFELG9HQUFvRztBQUNwRyxNQUFNLFdBQVcsbUJBQW1CO0lBQ2xDLFNBQVMsQ0FBQyxFQUFFLGVBQWUsQ0FBQztJQUM1QixNQUFNLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDaEIsU0FBUyxDQUFDLEVBQUUsa0JBQWtCLENBQUM7SUFDL0IsWUFBWSxDQUFDLEVBQUUsWUFBWSxDQUFDO0lBQzVCLGFBQWEsQ0FBQyxFQUFFLGFBQWEsQ0FBQztJQUM5QixjQUFjLENBQUMsRUFBRSxPQUFPLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDekMsb0JBQW9CLENBQUMsRUFBRSwwQkFBMEIsQ0FBQztDQUNuRDtBQUVELDZFQUE2RTtBQUM3RSxNQUFNLFdBQVcsc0JBQXNCO0lBQ3JDLE9BQU8sQ0FBQyxFQUFFLFdBQVcsQ0FBQztJQUN0QixrQkFBa0IsQ0FBQyxFQUFFLE9BQU8sQ0FBQztJQUM3QixtQkFBbUIsQ0FBQyxFQUFFLE9BQU8sQ0FBQztDQUMvQjtBQUVEOzs7O0dBSUc7QUFDSCx3QkFBc0Isc0JBQXNCLENBQzFDLFdBQVcsRUFBRSxlQUFlLEVBQzVCLElBQUksR0FBRSxtQkFBd0IsRUFDOUIsT0FBTyxHQUFFLHNCQUEyQixHQUNuQyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0E2a0IzQiJ9

package/dest/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAI5D,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAmB,KAAK,cAAc,EAAoB,MAAM,yBAAyB,CAAC;AAEjG,OAAO,EAIL,KAAK,kBAAkB,EACxB,MAAM,8BAA8B,CAAC;AAiBtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,8BAA8B,CAAC;AAUxF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AAIxF,OAAO,EAAE,KAAK,eAAe,EAA8B,MAAM,wBAAwB,CAAC;AAC1F,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,oGAAoG;AACpG,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,kBAAkB,CAAC;IAC/B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IACzC,oBAAoB,CAAC,EAAE,0BAA0B,CAAC;CACnD;AAED,6EAA6E;AAC7E,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,eAAe,EAC5B,IAAI,GAAE,mBAAwB,EAC9B,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,gBAAgB,CAAC,CA6kB3B"}

package/dest/factory.js

@@ -0,0 +1,539 @@
+import { createArchiver } from '@aztec-labs/archiver';
+import { BBCircuitVerifier, BatchChonkVerifier, QueuedIVCVerifier } from '@aztec-labs/bb-prover';
+import { TestCircuitVerifier } from '@aztec-labs/bb-prover/test';
+import { createBlobClientWithFileStores } from '@aztec-labs/blob-client/client';
+import { Blob, getKzg } from '@aztec-labs/blob-lib';
+import { EpochCache } from '@aztec-labs/epoch-cache';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { getPublicClient, makeL1HttpTransport } from '@aztec-labs/ethereum/client';
+import { RegistryContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import { pickL1ContractAddresses } from '@aztec-labs/ethereum/l1-contract-addresses';
+import { compactArray } from '@aztec-labs/foundation/collection';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { KeystoreManager, loadKeystores, mergeKeystores } from '@aztec-labs/node-keystore';
+import { trySnapshotSync } from '@aztec-labs/node-lib/actions';
+import { createForwarderL1TxUtilsFromSigners, createL1TxUtilsFromSigners } from '@aztec-labs/node-lib/factories';
+import { createP2PClient } from '@aztec-labs/p2p';
+import { createProverNode } from '@aztec-labs/prover-node';
+import { createKeyStoreForProver } from '@aztec-labs/prover-node/config';
+import { FeeProviderImpl, GlobalVariableBuilder, SequencerClient } from '@aztec-labs/sequencer-client';
+import { createAutomineSequencer } from '@aztec-labs/sequencer-client/automine';
+import { AvmSimulatorPool } from '@aztec-labs/simulator/server';
+import { AttestationsBlockWatcher, AttestedInvalidProposalWatcher, BroadcastedInvalidCheckpointProposalWatcher, CheckpointEquivocationWatcher, DataWithholdingWatcher, createSlasher } from '@aztec-labs/slasher';
+import { CheckpointReexecutionTracker } from '@aztec-labs/stdlib/checkpoint';
+import { tryStop } from '@aztec-labs/stdlib/interfaces/server';
+import { InMemoryDebugLogStore, NullDebugLogStore } from '@aztec-labs/stdlib/logs';
+import { getPackageVersion } from '@aztec-labs/stdlib/update-checker';
+import { getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { FullNodeCheckpointsBuilder as CheckpointsBuilder, FullNodeCheckpointsBuilder, NodeKeystoreAdapter, ValidatorClient, createProposalHandler, createValidatorClient } from '@aztec-labs/validator-client';
+import { createWorldState, createWorldStateSynchronizer } from '@aztec-labs/world-state';
+import { createPublicClient } from 'viem';
+import { createKeyStoreForValidator } from './aztec-node/config.js';
+import { AztecNodeService } from './aztec-node/server.js';
+import { createSentinel } from './sentinel/factory.js';
+/**
+ * Initializes the Aztec Node, waiting for its components to sync.
+ * @param inputConfig - The configuration to be used by the aztec node.
+ * @returns A fully synced Aztec Node for use in development/testing.
+ */ export async function createAztecNodeService(inputConfig, deps = {}, options = {}) {
+    const config = {
+        ...inputConfig
+    }; // Copy the config so we dont mutate the input object
+    const log = deps.logger ?? createLogger('node');
+    // Initialise the bb.js sync WASM singleton here, before any subsystem runs.
+    const { BarretenbergSync } = await import('@aztec/bb.js');
+    await BarretenbergSync.initSingleton();
+    // Warm the KZG trusted-setup singleton before any subsystem runs. getKzg() synchronously builds
+    // its precomputation tables on first use (~2s locally, blocking the event loop; 12-15s under
+    // production CPU limits). If that first use is instead the archiver reconstructing blobs or the
+    // proposal handler uploading them, the stalled loop overruns the gossipsub mcache window and
+    // attestation forwarding is skipped. Paying it here keeps it off the gossip path. Idempotent, so
+    // it is a no-op for sequencers (warmed in Sequencer.init) and for tests that pre-warm via
+    // warmBlobKzg.
+    getKzg(log);
+    const packageVersion = getPackageVersion();
+    const telemetry = deps.telemetry ?? getTelemetryClient();
+    const dateProvider = deps.dateProvider ?? new DateProvider();
+    const ethereumChain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
+    // Build a key store from file if given or from environment otherwise.
+    // We keep the raw KeyStore available so we can merge with prover keys if enableProverNode is set.
+    let keyStoreManager;
+    const keyStoreProvided = config.keyStoreDirectory !== undefined && config.keyStoreDirectory.length > 0;
+    if (keyStoreProvided) {
+        const keyStores = loadKeystores(config.keyStoreDirectory);
+        keyStoreManager = new KeystoreManager(mergeKeystores(keyStores));
+    } else {
+        const rawKeyStores = [];
+        const validatorKeyStore = createKeyStoreForValidator(config);
+        if (validatorKeyStore) {
+            rawKeyStores.push(validatorKeyStore);
+        }
+        if (config.enableProverNode) {
+            const proverKeyStore = createKeyStoreForProver(config);
+            if (proverKeyStore) {
+                rawKeyStores.push(proverKeyStore);
+            }
+        }
+        if (rawKeyStores.length > 0) {
+            keyStoreManager = new KeystoreManager(rawKeyStores.length === 1 ? rawKeyStores[0] : mergeKeystores(rawKeyStores));
+        }
+    }
+    await keyStoreManager?.validateSigners();
+    // If we are a validator, verify our configuration before doing too much more.
+    if (!config.disableValidator) {
+        if (keyStoreManager === undefined) {
+            throw new Error('Failed to create key store, a requirement for running a validator');
+        }
+        if (!keyStoreProvided && process.env.NODE_ENV !== 'test') {
+            log.warn("Keystore created from env: it's recommended to use a file-based key store for production");
+        }
+        ValidatorClient.validateKeyStoreConfiguration(keyStoreManager, log);
+    }
+    // validate that the actual chain id matches that specified in configuration
+    if (config.l1ChainId !== ethereumChain.chainInfo.id) {
+        throw new Error(`RPC URL configured for chain id ${ethereumChain.chainInfo.id} but expected id ${config.l1ChainId}`);
+    }
+    const publicClient = createPublicClient({
+        chain: ethereumChain.chainInfo,
+        transport: makeL1HttpTransport(config.l1RpcUrls, {
+            timeout: config.l1HttpTimeoutMS
+        }),
+        pollingInterval: config.viemPollingIntervalMS
+    });
+    const l1ContractsAddresses = await RegistryContract.collectAddresses(publicClient, config.registryAddress, config.rollupVersion ?? 'canonical');
+    Object.assign(config, l1ContractsAddresses);
+    const rollupContract = new RollupContract(publicClient, config.rollupAddress.toString());
+    const [l1GenesisTime, slotDuration, epochDuration, rollupVersionFromRollup, rollupManaLimit] = await Promise.all([
+        rollupContract.getL1GenesisTime(),
+        rollupContract.getSlotDuration(),
+        rollupContract.getEpochDuration(),
+        rollupContract.getVersion(),
+        rollupContract.getManaLimit().then(Number)
+    ]);
+    config.rollupVersion ??= Number(rollupVersionFromRollup);
+    if (config.rollupVersion !== Number(rollupVersionFromRollup)) {
+        log.warn(`Registry looked up and returned a rollup with version (${config.rollupVersion}), but this does not match with version detected from the rollup directly: (${rollupVersionFromRollup}).`);
+    }
+    const blobClient = await createBlobClientWithFileStores(config, log.createChild('blob-client'));
+    // attempt snapshot sync if possible
+    await trySnapshotSync(config, log);
+    const epochCache = await EpochCache.create(config.rollupAddress, config, {
+        dateProvider
+    });
+    // Track started resources so we can clean up on partial failure during node creation.
+    const started = [];
+    try {
+        config.skipOrphanProposedBlockPruning ||= !!config.useAutomineSequencer;
+        checkConfigMatchesRollup(config, {
+            slotDuration: Number(slotDuration),
+            epochDuration: Number(epochDuration)
+        });
+        // Create world-state first so we can retrieve the initial header before constructing the archiver.
+        const nativeWs = await createWorldState(config, options.genesis);
+        const initialHeader = nativeWs.getInitialHeader();
+        const initialBlockHash = await initialHeader.hash();
+        // AVM execution backend for public simulation: a pool of bb-avm-sim processes reaching the world state
+        // over its IPC socket. Owned here and threaded into the public-processor consumers (node, checkpoint
+        // builders, prover node); disposed on stop via the started-resources cleanup.
+        log.info('WSDB ready, creating AVM simulator pool');
+        const avmSimulator = await AvmSimulatorPool.spawn({
+            wsdbIpcPath: nativeWs.getIpcPath(),
+            logger: (msg)=>log.debug(msg)
+        });
+        started.push({
+            stop: ()=>avmSimulator[Symbol.asyncDispose]()
+        });
+        const archiver = await createArchiver(config, {
+            blobClient,
+            epochCache,
+            telemetry,
+            dateProvider
+        }, {
+            blockUntilSync: !config.skipArchiverInitialSync
+        }, initialHeader, initialBlockHash);
+        started.push(archiver);
+        // The synchronizer takes ownership of the native world-state from here
+        const worldStateSynchronizer = await createWorldStateSynchronizer(config, archiver, nativeWs, telemetry);
+        started.push(worldStateSynchronizer);
+        const useRealVerifiers = config.realProofs || config.debugForceTxProofVerification;
+        let peerProofVerifier;
+        let rpcProofVerifier;
+        if (useRealVerifiers) {
+            peerProofVerifier = await BatchChonkVerifier.new(config, config.bbChonkVerifyMaxBatch, 'peer');
+            const rpcVerifier = await BBCircuitVerifier.new(config);
+            rpcProofVerifier = new QueuedIVCVerifier(rpcVerifier, config.numConcurrentIVCVerifiers);
+        } else {
+            peerProofVerifier = new TestCircuitVerifier(config.proverTestVerificationDelayMs);
+            rpcProofVerifier = new TestCircuitVerifier(config.proverTestVerificationDelayMs);
+        }
+        started.push(peerProofVerifier, rpcProofVerifier);
+        let debugLogStore;
+        if (!config.realProofs) {
+            log.warn(`Aztec node is accepting fake proofs`);
+            debugLogStore = new InMemoryDebugLogStore();
+            log.info('Aztec node started in test mode (realProofs set to false) hence debug logs from public functions will be collected and served');
+        } else {
+            debugLogStore = new NullDebugLogStore();
+        }
+        const globalVariableBuilderConfig = {
+            rollupAddress: config.rollupAddress,
+            ethereumSlotDuration: config.ethereumSlotDuration,
+            rollupVersion: BigInt(config.rollupVersion),
+            l1GenesisTime,
+            slotDuration: Number(slotDuration)
+        };
+        const globalVariableBuilder = new GlobalVariableBuilder(publicClient, globalVariableBuilderConfig);
+        const feeProvider = new FeeProviderImpl(dateProvider, publicClient, globalVariableBuilderConfig);
+        await feeProvider.start();
+        started.push(feeProvider);
+        const collectOffenses = !config.disableValidator || config.enableOffenseCollection;
+        // A prover node may still be proving an epoch whose blocks have already finalized on L1. Its proof
+        // submission window spans (proofSubmissionEpochs + 1) epochs, so its tx pool must keep finalized txs
+        // for at least that long to re-fetch them for proving and failure upload. Operators may configure a
+        // larger margin but not a smaller one.
+        if (config.enableProverNode) {
+            const proofSubmissionEpochs = await rollupContract.getProofSubmissionEpochs();
+            const proverRetentionFloorSlots = (proofSubmissionEpochs + 1) * Number(epochDuration);
+            const configuredSlots = config.keepFinalizedTxsForSlots ?? 0;
+            if (proverRetentionFloorSlots > configuredSlots) {
+                log.warn(`Increasing keepFinalizedTxsForSlots from ${configuredSlots} to ${proverRetentionFloorSlots} ` + `(proof submission window of ${proofSubmissionEpochs + 1} epochs) to retain finalized txs for proving`);
+                config.keepFinalizedTxsForSlots = proverRetentionFloorSlots;
+            }
+        }
+        // create the tx pool and the p2p client, which will need the l2 block source
+        const p2pClient = await createP2PClient(config, archiver, peerProofVerifier, worldStateSynchronizer, epochCache, feeProvider, packageVersion, dateProvider, telemetry, deps.p2pClientDeps, initialBlockHash);
+        started.push(p2pClient);
+        archiver.setCheckpointProposalPresence(p2pClient);
+        // We'll accumulate sentinel watchers here
+        const watchers = [];
+        // Create FullNodeCheckpointsBuilder for block proposal handling and tx validation.
+        // Override maxTxsPerCheckpoint with the validator-specific limit if set.
+        const validatorCheckpointsBuilder = new FullNodeCheckpointsBuilder({
+            ...config,
+            l1GenesisTime,
+            slotDuration: Number(slotDuration),
+            rollupManaLimit,
+            maxTxsPerCheckpoint: config.validateMaxTxsPerCheckpoint
+        }, worldStateSynchronizer, archiver, dateProvider, avmSimulator, telemetry);
+        let validatorClient;
+        // The proposal handler (validator-owned or standalone) tracks invalid-proposal/equivocation slots and
+        // feeds the attested-invalid-proposal watcher, so the watcher works on non-validator nodes too.
+        let proposalHandler;
+        // Tracks successful checkpoint re-execution by a checkpoint proposal handler.
+        const reexecutionTracker = new CheckpointReexecutionTracker();
+        if (!config.disableValidator) {
+            // Create validator client if required
+            validatorClient = await createValidatorClient(config, {
+                checkpointsBuilder: validatorCheckpointsBuilder,
+                worldState: worldStateSynchronizer,
+                p2pClient,
+                telemetry,
+                dateProvider,
+                epochCache,
+                blockSource: archiver,
+                l1ToL2MessageSource: archiver,
+                keyStoreManager,
+                blobClient,
+                reexecutionTracker,
+                slashingProtectionDb: deps.slashingProtectionDb
+            });
+            // If we have a validator client, register it as a source of offenses for the slasher,
+            // and have it register callbacks on the p2p client *before* we start it, otherwise messages
+            // like attestations or auths will fail.
+            if (validatorClient) {
+                watchers.push(validatorClient);
+                const vc = validatorClient;
+                const getValidatorAddresses = ()=>vc.getValidatorAddresses().map((a)=>a.toString());
+                proposalHandler = validatorClient.getProposalHandler();
+                proposalHandler.register(p2pClient, true, archiver, getValidatorAddresses);
+                if (!options.dontStartSequencer) {
+                    await validatorClient.registerHandlers();
+                }
+            }
+        }
+        // If there's no validator client, create a ProposalHandler to handle block and checkpoint proposals
+        // for monitoring or reexecution. Reexecution (default) allows us to follow the pending chain,
+        // while non-reexecution is used for validating the proposals and collecting their txs.
+        // Checkpoint proposals rebuild blobs if the blob client can upload blobs.
+        if (!validatorClient) {
+            const reexecute = !!config.alwaysReexecuteBlockProposals;
+            log.info(`Setting up proposal handler` + (reexecute ? ' with reexecution of proposals' : ''));
+            proposalHandler = createProposalHandler(config, {
+                checkpointsBuilder: validatorCheckpointsBuilder,
+                worldState: worldStateSynchronizer,
+                epochCache,
+                blockSource: archiver,
+                l1ToL2MessageSource: archiver,
+                p2pClient,
+                blobClient,
+                dateProvider,
+                telemetry,
+                reexecutionTracker
+            });
+            proposalHandler.register(p2pClient, reexecute, archiver);
+        }
+        // Start world state and wait for it to sync to the archiver.
+        await worldStateSynchronizer.start();
+        // Start p2p. Note that it depends on world state to be running.
+        await p2pClient.start();
+        let dataWithholdingWatcher;
+        let attestationsBlockWatcher;
+        let attestedInvalidProposalWatcher;
+        let broadcastedInvalidCheckpointProposalWatcher;
+        let checkpointEquivocationWatcher;
+        const validatorsSentinel = await createSentinel(epochCache, archiver, p2pClient, reexecutionTracker, config);
+        if (validatorsSentinel) {
+            watchers.push(validatorsSentinel);
+        }
+        if (collectOffenses) {
+            // The watcher's only evidence is the absence of gossiped txs in the local pool, so it cannot make a
+            // valid claim on a node that runs no p2p stack at all. Skipped entirely rather than gated at runtime.
+            if (config.p2pEnabled) {
+                dataWithholdingWatcher = new DataWithholdingWatcher(epochCache, archiver, p2pClient.getTxProvider(), p2pClient, reexecutionTracker, {
+                    chainId: config.l1ChainId,
+                    rollupAddress: config.rollupAddress
+                }, config);
+                watchers.push(dataWithholdingWatcher);
+            } else {
+                log.verbose('Skipping data-withholding watcher since p2p is disabled');
+            }
+            broadcastedInvalidCheckpointProposalWatcher = new BroadcastedInvalidCheckpointProposalWatcher(p2pClient, archiver, epochCache, config);
+            watchers.push(broadcastedInvalidCheckpointProposalWatcher);
+            // The proposal handler (validator-owned or standalone) is the source of invalid-proposal/equivocation
+            // slots, so the watcher runs on non-validator offense collectors too.
+            if (proposalHandler) {
+                attestedInvalidProposalWatcher = new AttestedInvalidProposalWatcher(p2pClient, proposalHandler, archiver, epochCache, config, {
+                    log: log.createChild('attested-invalid-proposal-watcher')
+                });
+                watchers.push(attestedInvalidProposalWatcher);
+            }
+            checkpointEquivocationWatcher = new CheckpointEquivocationWatcher(archiver, epochCache, config);
+            watchers.push(checkpointEquivocationWatcher);
+            attestationsBlockWatcher = new AttestationsBlockWatcher(archiver, epochCache, config, log.getBindings());
+            watchers.push(attestationsBlockWatcher);
+        }
+        const watchersToStart = compactArray([
+            validatorsSentinel,
+            dataWithholdingWatcher,
+            attestationsBlockWatcher,
+            broadcastedInvalidCheckpointProposalWatcher,
+            attestedInvalidProposalWatcher,
+            checkpointEquivocationWatcher
+        ]);
+        const startedWatchers = [];
+        const stopStartedWatchers = async ()=>{
+            for (const watcher of startedWatchers){
+                await tryStop(watcher);
+            }
+        };
+        // Start p2p-related services once the archiver has completed sync
+        void archiver.waitForInitialSync().then(async ()=>{
+            for (const watcher of watchersToStart){
+                await watcher.start();
+                startedWatchers.push(watcher);
+            }
+            log.info(`All p2p services started`);
+        }).catch((err)=>log.error('Failed to start p2p services after archiver sync', err));
+        started.push({
+            stop: stopStartedWatchers
+        });
+        // Validator enabled, create/start relevant service
+        let sequencer;
+        let automineSequencer;
+        let slasherClient;
+        // The slasher can run standalone to collect offenses for non-validators; it only writes to L1 when a
+        // proposer is elected (which requires a sequencer), so running it read-only on a non-validator is safe.
+        if (collectOffenses) {
+            const validatorAddresses = keyStoreManager ? NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager).getAddresses() : [];
+            slasherClient = await createSlasher(config, pickL1ContractAddresses(config), getPublicClient(config), watchers, dateProvider, epochCache, validatorAddresses, undefined);
+            await slasherClient.start();
+            started.push(slasherClient);
+        }
+        if (!config.disableValidator && validatorClient) {
+            const l1TxUtils = config.sequencerPublisherForwarderAddress ? await createForwarderL1TxUtilsFromSigners(publicClient, keyStoreManager.createAllValidatorPublisherSigners(), config.sequencerPublisherForwarderAddress, {
+                ...config,
+                scope: 'sequencer'
+            }, {
+                telemetry,
+                logger: log.createChild('l1-tx-utils'),
+                dateProvider,
+                kzg: Blob.getViemKzgInstance()
+            }) : await createL1TxUtilsFromSigners(publicClient, keyStoreManager.createAllValidatorPublisherSigners(), {
+                ...config,
+                scope: 'sequencer'
+            }, {
+                telemetry,
+                logger: log.createChild('l1-tx-utils'),
+                dateProvider,
+                kzg: Blob.getViemKzgInstance()
+            });
+            // Create a funder L1TxUtils from the keystore funding account (if configured)
+            const fundingSigner = keyStoreManager?.createFundingSigner();
+            let funderL1TxUtils;
+            if (fundingSigner) {
+                const [funder] = await createL1TxUtilsFromSigners(publicClient, [
+                    fundingSigner
+                ], {
+                    ...config,
+                    scope: 'sequencer'
+                }, {
+                    telemetry,
+                    logger: log.createChild('l1-tx-utils:funder'),
+                    dateProvider
+                });
+                funderL1TxUtils = funder;
+            }
+            // Create and start the sequencer client
+            const checkpointsBuilder = new CheckpointsBuilder({
+                ...config,
+                l1GenesisTime,
+                slotDuration: Number(slotDuration),
+                rollupManaLimit
+            }, worldStateSynchronizer, archiver, dateProvider, avmSimulator, telemetry, debugLogStore);
+            if (config.useAutomineSequencer) {
+                // Test-only path: deterministic, queue-driven sequencer for non-block-building e2e tests.
+                // See `AUTOMINE_E2E_OPTS` in `end-to-end/src/fixtures/fixtures.ts`.
+                automineSequencer = await createAutomineSequencer({
+                    config,
+                    l1TxUtils,
+                    funderL1TxUtils,
+                    publicClient,
+                    rollupContract,
+                    epochCache,
+                    blobClient,
+                    telemetry,
+                    dateProvider,
+                    keyStoreManager: keyStoreManager,
+                    validatorClient,
+                    checkpointsBuilder,
+                    globalVariableBuilder,
+                    worldStateSynchronizer,
+                    archiver,
+                    p2pClient,
+                    l1Constants: {
+                        l1GenesisTime,
+                        slotDuration: Number(slotDuration),
+                        ethereumSlotDuration: config.ethereumSlotDuration,
+                        rollupManaLimit
+                    },
+                    autoSettle: config.automineEnableProveEpoch,
+                    log
+                });
+            } else {
+                sequencer = await SequencerClient.new(config, {
+                    ...deps,
+                    epochCache,
+                    l1TxUtils,
+                    funderL1TxUtils,
+                    validatorClient,
+                    p2pClient,
+                    worldStateSynchronizer,
+                    slasherClient,
+                    checkpointsBuilder,
+                    l2BlockSource: archiver,
+                    l1ToL2MessageSource: archiver,
+                    telemetry,
+                    dateProvider,
+                    blobClient,
+                    nodeKeyStore: keyStoreManager,
+                    globalVariableBuilder
+                });
+            }
+        }
+        if (!options.dontStartSequencer && sequencer) {
+            await sequencer.start();
+            started.push(sequencer);
+            log.verbose(`Sequencer started`);
+        } else if (sequencer) {
+            log.warn(`Sequencer created but not started`);
+        }
+        if (!options.dontStartSequencer && automineSequencer) {
+            await automineSequencer.start();
+            started.push({
+                stop: ()=>automineSequencer.stop()
+            });
+            log.verbose(`AutomineSequencer started`);
+        } else if (automineSequencer) {
+            log.warn(`AutomineSequencer created but not started`);
+        }
+        // Create prover node subsystem if enabled
+        let proverNode;
+        if (config.enableProverNode) {
+            proverNode = await createProverNode(config, {
+                ...deps.proverNodeDeps,
+                telemetry,
+                dateProvider,
+                archiver,
+                worldStateSynchronizer,
+                p2pClient,
+                epochCache,
+                blobClient,
+                keyStoreManager,
+                avmSimulator
+            });
+            if (!options.dontStartProverNode) {
+                await proverNode.start();
+                started.push(proverNode);
+                log.info(`Prover node subsystem started`);
+            } else {
+                log.info(`Prover node subsystem created but not started`);
+            }
+        }
+        const node = new AztecNodeService({
+            config,
+            p2pClient,
+            blockSource: archiver,
+            logsSource: archiver,
+            contractDataSource: archiver,
+            l1ToL2MessageSource: archiver,
+            worldStateSynchronizer,
+            sequencer,
+            proverNode,
+            slasherClient,
+            validatorsSentinel,
+            stopStartedWatchers,
+            l1ChainId: ethereumChain.chainInfo.id,
+            version: config.rollupVersion,
+            globalVariableBuilder,
+            rollupContract,
+            feeProvider,
+            epochCache,
+            packageVersion,
+            peerProofVerifier,
+            rpcProofVerifier,
+            telemetry,
+            log,
+            blobClient,
+            validatorClient,
+            keyStoreManager,
+            debugLogStore,
+            automineSequencer,
+            avmSimulator
+        });
+        return node;
+    } catch (err) {
+        log.error('Failed during node creation, stopping started resources', err);
+        for (const resource of started.reverse()){
+            await tryStop(resource);
+        }
+        throw err;
+    }
+}
+/**
+ * Verifies the node's configured L1 timing matches the rollup contract it is pointed at, for the fields the
+ * node's own config carries. Each comparison is guarded against an undefined config value, so a config that
+ * does not carry a field is not checked. Throws a single error listing every mismatch. Runs in the shared
+ * startup path for every node role.
+ */ function checkConfigMatchesRollup(config, rollup) {
+    const mismatches = [];
+    if (config.aztecSlotDuration !== undefined && config.aztecSlotDuration !== rollup.slotDuration) {
+        mismatches.push(`aztecSlotDuration is ${config.aztecSlotDuration} but the rollup reports ${rollup.slotDuration}`);
+    }
+    if (config.aztecEpochDuration !== undefined && config.aztecEpochDuration !== rollup.epochDuration) {
+        mismatches.push(`aztecEpochDuration is ${config.aztecEpochDuration} but the rollup reports ${rollup.epochDuration}`);
+    }
+    if (mismatches.length > 0) {
+        throw new Error(`The node's configured L1 timing does not match the rollup contract it is pointed at: ${mismatches.join('; ')}`);
+    }
+}

package/dest/index.d.ts

@@ -0,0 +1,5 @@
+export * from './aztec-node/config.js';
+export * from './aztec-node/register_node_rpc_handlers.js';
+export * from './aztec-node/server.js';
+export * from './factory.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsNENBQTRDLENBQUM7QUFDM0QsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGNBQWMsQ0FBQyJ9

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC"}

package/dest/index.js

@@ -0,0 +1,4 @@
+export * from './aztec-node/config.js';
+export * from './aztec-node/register_node_rpc_handlers.js';
+export * from './aztec-node/server.js';
+export * from './factory.js';