@aztec/aztec-node 6.0.0-nightly.20260605 → 6.0.0-nightly.20260722

package/dest/aztec-node/config.d.ts

@@ -26,12 +26,21 @@ export type AztecNodeConfig = ArchiverConfig & SequencerClientConfig & Validator
     debugForceTxProofVerification: boolean;
     /** Whether to enable the prover node as a subsystem. */
     enableProverNode: boolean;
+    /** Whether to run the slashing watchers to collect offenses even if not a validator. */
+    enableOffenseCollection: boolean;
     /**
      * Test-only: use the deterministic AutomineSequencer instead of the production Sequencer.
      * Requires `aztecTargetCommitteeSize === 0` on the deployed rollup and anvil-backed L1.
      * See `AUTOMINE_E2E_OPTS` in `end-to-end/src/fixtures/fixtures.ts`.
      */
     useAutomineSequencer?: boolean;
+    /**
+     * Test-only: have the AutomineSequencer automatically prove epochs (write epoch out hashes into
+     * the L1 Outbox and advance the proven tip) as checkpoints land, replacing the standalone
+     * `EpochTestSettler`. Set by the local network/sandbox; the e2e `AUTOMINE_E2E_OPTS` fixture leaves
+     * it off so tests drive proving manually via `prove` / `cheatCodes.rollup.markAsProven`.
+     */
+    automineEnableProveEpoch?: boolean;
 };
 export declare const aztecNodeConfigMappings: ConfigMappingsType<AztecNodeConfig>;
 /**
@@ -40,4 +49,4 @@ export declare const aztecNodeConfigMappings: ConfigMappingsType<AztecNodeConfig
  */
 export declare function getConfigEnvVars(): AztecNodeConfig;
 export declare function createKeyStoreForValidator(config: SequencerTxSenderConfig & SequencerClientConfig & SharedNodeConfig): KeyStore | undefined;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp0ZWMtbm9kZS9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssY0FBYyxFQUEwQixNQUFNLHdCQUF3QixDQUFDO0FBQ3JGLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUE4QixNQUFNLHdCQUF3QixDQUFDO0FBQzdGLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUE4QyxNQUFNLDBCQUEwQixDQUFDO0FBRS9HLE9BQU8sRUFDTCxLQUFLLFFBQVEsRUFJZCxNQUFNLHNCQUFzQixDQUFDO0FBQzlCLE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUE0QixNQUFNLHdCQUF3QixDQUFDO0FBQ3pGLE9BQU8sRUFBRSxLQUFLLFNBQVMsRUFBcUIsTUFBTSxtQkFBbUIsQ0FBQztBQUN0RSxPQUFPLEVBQUUsS0FBSyxzQkFBc0IsRUFBOEIsTUFBTSw2QkFBNkIsQ0FBQztBQUN0RyxPQUFPLEVBQ0wsS0FBSyxnQkFBZ0IsRUFHdEIsTUFBTSwyQkFBMkIsQ0FBQztBQUNuQyxPQUFPLEVBQ0wsS0FBSyxxQkFBcUIsRUFDMUIsS0FBSyx1QkFBdUIsRUFDNUIsNkJBQTZCLEVBQzlCLE1BQU0sZ0NBQWdDLENBQUM7QUFHeEMsT0FBTyxFQUFFLEtBQUssYUFBYSxFQUF5QixNQUFNLHNCQUFzQixDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0IsTUFBTSx3QkFBd0IsQ0FBQztBQUNsRixPQUFPLEVBQUUsS0FBSyxxQkFBcUIsRUFBaUMsTUFBTSxnQ0FBZ0MsQ0FBQztBQUMzRyxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBNEIsTUFBTSwyQkFBMkIsQ0FBQztBQUk1RixPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQTBCLE1BQU0sdUJBQXVCLENBQUM7QUFFcEYsT0FBTyxFQUFFLDZCQUE2QixFQUFFLEtBQUsscUJBQXFCLEVBQUUsQ0FBQztBQUVyRTs7R0FFRztBQUNILE1BQU0sTUFBTSxlQUFlLEdBQUcsY0FBYyxHQUMxQyxxQkFBcUIsR0FDckIscUJBQXFCLEdBQ3JCLHNCQUFzQixHQUN0QixnQkFBZ0IsR0FDaEIsSUFBSSxDQUFDLHNCQUFzQixFQUFFLGNBQWMsR0FBRyxvQkFBb0IsR0FBRyxZQUFZLENBQUMsR0FDbEYsU0FBUyxHQUNULGVBQWUsR0FDZixjQUFjLEdBQ2QsZ0JBQWdCLEdBQ2hCLGtCQUFrQixHQUNsQixhQUFhLEdBQ2IsYUFBYSxHQUNiLGdCQUFnQixHQUFHO0lBQ2pCLHNEQUFzRDtJQUN0RCxnQkFBZ0IsRUFBRSxPQUFPLENBQUM7SUFDMUIsaUdBQWlHO0lBQ2pHLHVCQUF1QixFQUFFLE9BQU8sQ0FBQztJQUNqQyw2RUFBNkU7SUFDN0UsNkJBQTZCLEVBQUUsT0FBTyxDQUFDO0lBQ3ZDLHdEQUF3RDtJQUN4RCxnQkFBZ0IsRUFBRSxPQUFPLENBQUM7SUFDMUIsd0ZBQXdGO0lBQ3hGLHVCQUF1QixFQUFFLE9BQU8sQ0FBQztJQUNqQzs7OztPQUlHO0lBQ0gsb0JBQW9CLENBQUMsRUFBRSxPQUFPLENBQUM7SUFDL0I7Ozs7O09BS0c7SUFDSCx3QkFBd0IsQ0FBQyxFQUFFLE9BQU8sQ0FBQztDQUNwQyxDQUFDO0FBRUosZUFBTyxNQUFNLHVCQUF1QixFQUFFLGtCQUFrQixDQUFDLGVBQWUsQ0FtRHZFLENBQUM7QUFFRjs7O0dBR0c7QUFDSCx3QkFBZ0IsZ0JBQWdCLElBQUksZUFBZSxDQUVsRDtBQXNFRCx3QkFBZ0IsMEJBQTBCLENBQ3hDLE1BQU0sRUFBRSx1QkFBdUIsR0FBRyxxQkFBcUIsR0FBRyxnQkFBZ0IsR0FDekUsUUFBUSxHQUFHLFNBQVMsQ0FNdEIifQ==

package/dest/aztec-node/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/aztec-node/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,wBAAwB,CAAC;AACrF,OAAO,EAAE,KAAK,kBAAkB,EAA8B,MAAM,wBAAwB,CAAC;AAC7F,OAAO,EAAE,KAAK,kBAAkB,EAA8C,MAAM,0BAA0B,CAAC;AAE/G,OAAO,EACL,KAAK,QAAQ,EAId,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,gBAAgB,EAA4B,MAAM,wBAAwB,CAAC;AACzF,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,KAAK,sBAAsB,EAA8B,MAAM,6BAA6B,CAAC;AACtG,OAAO,EACL,KAAK,gBAAgB,EAGtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,6BAA6B,EAC9B,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EAAE,KAAK,aAAa,EAAyB,MAAM,sBAAsB,CAAC;AACjF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,KAAK,qBAAqB,EAAiC,MAAM,gCAAgC,CAAC;AAC3G,OAAO,EAAE,KAAK,gBAAgB,EAA4B,MAAM,2BAA2B,CAAC;AAI5F,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,uBAAuB,CAAC;AAEpF,OAAO,EAAE,6BAA6B,EAAE,KAAK,qBAAqB,EAAE,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,cAAc,GAC1C,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,gBAAgB,GAChB,IAAI,CAAC,sBAAsB,EAAE,cAAc,GAAG,oBAAoB,GAAG,YAAY,CAAC,GAClF,SAAS,GACT,eAAe,GACf,cAAc,GACd,gBAAgB,GAChB,kBAAkB,GAClB,aAAa,GACb,aAAa,GACb,gBAAgB,GAAG;IACjB,sDAAsD;IACtD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,iGAAiG;IACjG,uBAAuB,EAAE,OAAO,CAAC;IACjC,6EAA6E;IAC7E,6BAA6B,EAAE,OAAO,CAAC;IACvC,wDAAwD;IACxD,gBAAgB,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEJ,eAAO,MAAM,uBAAuB,EAAE,kBAAkB,CAAC,eAAe,CAyCvE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CAElD;AAsED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,uBAAuB,GAAG,qBAAqB,GAAG,gBAAgB,GACzE,QAAQ,GAAG,SAAS,CAMtB"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/aztec-node/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,wBAAwB,CAAC;AACrF,OAAO,EAAE,KAAK,kBAAkB,EAA8B,MAAM,wBAAwB,CAAC;AAC7F,OAAO,EAAE,KAAK,kBAAkB,EAA8C,MAAM,0BAA0B,CAAC;AAE/G,OAAO,EACL,KAAK,QAAQ,EAId,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,gBAAgB,EAA4B,MAAM,wBAAwB,CAAC;AACzF,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,KAAK,sBAAsB,EAA8B,MAAM,6BAA6B,CAAC;AACtG,OAAO,EACL,KAAK,gBAAgB,EAGtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,6BAA6B,EAC9B,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EAAE,KAAK,aAAa,EAAyB,MAAM,sBAAsB,CAAC;AACjF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,KAAK,qBAAqB,EAAiC,MAAM,gCAAgC,CAAC;AAC3G,OAAO,EAAE,KAAK,gBAAgB,EAA4B,MAAM,2BAA2B,CAAC;AAI5F,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,uBAAuB,CAAC;AAEpF,OAAO,EAAE,6BAA6B,EAAE,KAAK,qBAAqB,EAAE,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,cAAc,GAC1C,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,gBAAgB,GAChB,IAAI,CAAC,sBAAsB,EAAE,cAAc,GAAG,oBAAoB,GAAG,YAAY,CAAC,GAClF,SAAS,GACT,eAAe,GACf,cAAc,GACd,gBAAgB,GAChB,kBAAkB,GAClB,aAAa,GACb,aAAa,GACb,gBAAgB,GAAG;IACjB,sDAAsD;IACtD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,iGAAiG;IACjG,uBAAuB,EAAE,OAAO,CAAC;IACjC,6EAA6E;IAC7E,6BAA6B,EAAE,OAAO,CAAC;IACvC,wDAAwD;IACxD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,wFAAwF;IACxF,uBAAuB,EAAE,OAAO,CAAC;IACjC;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;OAKG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,CAAC;AAEJ,eAAO,MAAM,uBAAuB,EAAE,kBAAkB,CAAC,eAAe,CAmDvE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CAElD;AAsED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,uBAAuB,GAAG,qBAAqB,GAAG,gBAAgB,GACzE,QAAQ,GAAG,SAAS,CAMtB"}

package/dest/aztec-node/config.js

@@ -53,10 +53,20 @@ export const aztecNodeConfigMappings = {
         description: 'Whether to enable the prover node as a subsystem.',
         ...booleanConfigHelper(false)
     },
+    enableOffenseCollection: {
+        env: 'OFFENSE_COLLECTION_ENABLED',
+        description: 'Whether to run the slashing watchers to collect offenses even if not a validator.',
+        ...booleanConfigHelper(false)
+    },
     useAutomineSequencer: {
         env: 'USE_AUTOMINE_SEQUENCER',
         description: 'Test-only: use AutomineSequencer instead of the production Sequencer.',
         ...booleanConfigHelper(false)
+    },
+    automineEnableProveEpoch: {
+        env: 'AUTOMINE_ENABLE_PROVE_EPOCH',
+        description: 'Test-only: have the AutomineSequencer automatically prove epochs as checkpoints land.',
+        ...booleanConfigHelper(false)
     }
 };
 /**

package/dest/aztec-node/node_public_calls_simulator.d.ts

@@ -0,0 +1,97 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type RollupContract } from '@aztec/ethereum/contracts';
+import { type Logger } from '@aztec/foundation/log';
+import { type AvmSimulator } from '@aztec/simulator/server';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { type L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { CoordinationSignatureContext } from '@aztec/stdlib/p2p';
+import { type GlobalVariableBuilder, PublicSimulationOutput, type SimulationOverrides, type Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+/** Config fields the simulator needs — a narrow subset of `AztecNodeConfig`. */
+export interface NodePublicCallsSimulatorConfig {
+    /** Maximum total gas limit accepted for an incoming simulation. */
+    rpcSimulatePublicMaxGasLimit: number;
+    /** Maximum number of debug-log memory reads collected during simulation. */
+    rpcSimulatePublicMaxDebugLogMemoryReads: number;
+}
+/** Dependencies required to build a {@link NodePublicCallsSimulator}. */
+export interface NodePublicCallsSimulatorDeps {
+    blockSource: L2BlockSource;
+    worldStateSynchronizer: WorldStateSynchronizer;
+    l1ToL2MessageSource: L1ToL2MessageSource;
+    contractDataSource: ContractDataSource;
+    globalVariableBuilder: GlobalVariableBuilder;
+    /**
+     * Rollup contract used to build the fee-relevant L1 state overrides when opening a new checkpoint.
+     * Only needed when a proposed parent checkpoint exists (pipelining) or the pending chain is invalid;
+     * may be omitted in environments that never reach those states (e.g. TXE). When omitted, those paths
+     * degrade to a pinned-tips plan (non-pipelined fees) instead.
+     */
+    rollupContract?: RollupContract;
+    epochCache: EpochCacheInterface;
+    signatureContext: CoordinationSignatureContext;
+    config: NodePublicCallsSimulatorConfig;
+    /**
+     * AVM execution backend the public processor drives to run public calls. Optional because unit/TXE nodes
+     * that never call {@link simulate} are constructed without one; asserted at the simulation call site.
+     */
+    avmSimulator?: AvmSimulator;
+    telemetry?: TelemetryClient;
+    log?: Logger;
+}
+/**
+ * Simulates the public part of a transaction against a fresh world-state fork.
+ *
+ * Extracted from `AztecNodeService` so the slot/globals selection can be unit-tested without
+ * standing up the whole node, and to keep `server.ts` smaller.
+ *
+ * The simulator picks globals in one of two ways, mirroring how the sequencer builds the next block:
+ * - **When the next block continues an in-progress checkpoint** (the latest proposed block is ahead of
+ *   the proposed-checkpoint frontier): every block in a checkpoint shares the same
+ *   `CheckpointGlobalVariables`, so we copy the latest proposed block's globals verbatim and only
+ *   bump the block number. No L1 calls, no L1-to-L2 message insertion.
+ * - **When the next block opens a new checkpoint** (the latest proposed block coincides with the
+ *   proposed-checkpoint frontier): we compute fresh globals for the slot the next block will land in,
+ *   applying the same `SimulationOverridesPlan` the sequencer applies so the simulated mana min fee
+ *   matches what the sequencer will write into the block header.
+ */
+export declare class NodePublicCallsSimulator {
+    private readonly blockSource;
+    private readonly worldStateSynchronizer;
+    private readonly l1ToL2MessageSource;
+    private readonly contractDataSource;
+    private readonly globalVariableBuilder;
+    private readonly rollupContract;
+    private readonly epochCache;
+    private readonly signatureContext;
+    private readonly config;
+    private readonly avmSimulator?;
+    private readonly telemetry;
+    private readonly log;
+    constructor(deps: NodePublicCallsSimulatorDeps);
+    /**
+     * Simulates the public part of a transaction with the current state.
+     * @param tx - The transaction to simulate.
+     * @param skipFeeEnforcement - If true, fee enforcement is skipped.
+     * @param overrides - Optional pre-simulation overrides applied to the ephemeral fork and contract DB.
+     */
+    simulate(tx: Tx, skipFeeEnforcement?: boolean, overrides?: SimulationOverrides): Promise<PublicSimulationOutput>;
+    private getNextCheckpointMessages;
+    private copyGlobalVariablesFromLatestProposedBlock;
+    private buildGlobalVariablesForNewCheckpoint;
+    /**
+     * Slot the next block will land in. The first term is the sequencer's exact formula
+     * (`getEpochAndSlotInNextL1Slot().slot + PROPOSER_PIPELINING_SLOT_OFFSET`). The `max` with
+     * `proposedCheckpointSlot + 1` is an RPC-side approximation of the next build: when a proposed
+     * checkpoint is gossiped before its L1 slot starts, the next build (once its wall clock arrives)
+     * will target `parentSlot + 1`. The sequencer never advances its own target past wall clock — it
+     * just declines to build — so this is a prediction of inclusion globals, not literal sequencer
+     * behavior. The parent slot comes from the proposed checkpoint header so the slot and the
+     * overrides plan cannot derive from different snapshots.
+     */
+    private computeTargetSlot;
+    private buildSimulationOverridesPlan;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/aztec-node/node_public_calls_simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node_public_calls_simulator.d.ts","sourceRoot":"","sources":["../../src/aztec-node/node_public_calls_simulator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,2BAA2B,CAAC;AAMnC,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAGlE,OAAO,EAAE,KAAK,YAAY,EAA6C,MAAM,yBAAyB,CAAC;AAGvG,OAAO,KAAK,EAAE,aAAa,EAAU,MAAM,qBAAqB,CAAC;AAEjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,KAAK,mBAAmB,EAA8B,MAAM,yBAAyB,CAAC;AAC/F,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EACL,KAAK,qBAAqB,EAE1B,sBAAsB,EACtB,KAAK,mBAAmB,EACxB,KAAK,EAAE,EACR,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAInF,kFAAgF;AAChF,MAAM,WAAW,8BAA8B;IAC7C,mEAAmE;IACnE,4BAA4B,EAAE,MAAM,CAAC;IACrC,4EAA4E;IAC5E,uCAAuC,EAAE,MAAM,CAAC;CACjD;AAED,yEAAyE;AACzE,MAAM,WAAW,4BAA4B;IAC3C,WAAW,EAAE,aAAa,CAAC;IAC3B,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C;;;;;OAKG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,UAAU,EAAE,mBAAmB,CAAC;IAChC,gBAAgB,EAAE,4BAA4B,CAAC;IAC/C,MAAM,EAAE,8BAA8B,CAAC;IACvC;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgB;IAC5C,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAyB;IAChE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;IACxD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAwB;IAC9D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;IAC5D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA+B;IAChE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAe;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YAAY,IAAI,EAAE,4BAA4B,EAa7C;IAED;;;;;OAKG;IACU,QAAQ,CACnB,EAAE,EAAE,EAAE,EACN,kBAAkB,UAAQ,EAC1B,SAAS,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,sBAAsB,CAAC,CA8GjC;YAUa,yBAAyB;YAmCzB,0CAA0C;YAuB1C,oCAAoC;IA2BlD;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;YAmBX,4BAA4B;CAkC3C"}

package/dest/aztec-node/node_public_calls_simulator.js

@@ -0,0 +1,351 @@
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+import { L1ToL2MessagesNotReadyError } from '@aztec/archiver';
+import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
+import { SimulationOverridesBuilder } from '@aztec/ethereum/contracts';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { compactArray } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { BadRequestError } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { isErrorClass } from '@aztec/foundation/types';
+import { PublicContractsDB, PublicProcessorFactory } from '@aztec/simulator/server';
+import { CollectionLimitsConfig, PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { buildCheckpointSimulationOverridesPlan } from '@aztec/stdlib/checkpoint';
+import { appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging';
+import { GlobalVariables, PublicSimulationOutput } from '@aztec/stdlib/tx';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { applyPublicDataOverrides } from './public_data_overrides.js';
+/**
+ * Simulates the public part of a transaction against a fresh world-state fork.
+ *
+ * Extracted from `AztecNodeService` so the slot/globals selection can be unit-tested without
+ * standing up the whole node, and to keep `server.ts` smaller.
+ *
+ * The simulator picks globals in one of two ways, mirroring how the sequencer builds the next block:
+ * - **When the next block continues an in-progress checkpoint** (the latest proposed block is ahead of
+ *   the proposed-checkpoint frontier): every block in a checkpoint shares the same
+ *   `CheckpointGlobalVariables`, so we copy the latest proposed block's globals verbatim and only
+ *   bump the block number. No L1 calls, no L1-to-L2 message insertion.
+ * - **When the next block opens a new checkpoint** (the latest proposed block coincides with the
+ *   proposed-checkpoint frontier): we compute fresh globals for the slot the next block will land in,
+ *   applying the same `SimulationOverridesPlan` the sequencer applies so the simulated mana min fee
+ *   matches what the sequencer will write into the block header.
+ */ export class NodePublicCallsSimulator {
+    blockSource;
+    worldStateSynchronizer;
+    l1ToL2MessageSource;
+    contractDataSource;
+    globalVariableBuilder;
+    rollupContract;
+    epochCache;
+    signatureContext;
+    config;
+    avmSimulator;
+    telemetry;
+    log;
+    constructor(deps){
+        this.blockSource = deps.blockSource;
+        this.worldStateSynchronizer = deps.worldStateSynchronizer;
+        this.l1ToL2MessageSource = deps.l1ToL2MessageSource;
+        this.contractDataSource = deps.contractDataSource;
+        this.globalVariableBuilder = deps.globalVariableBuilder;
+        this.rollupContract = deps.rollupContract;
+        this.epochCache = deps.epochCache;
+        this.signatureContext = deps.signatureContext;
+        this.config = deps.config;
+        this.avmSimulator = deps.avmSimulator;
+        this.telemetry = deps.telemetry ?? getTelemetryClient();
+        this.log = deps.log ?? createLogger('node:public-calls-simulator');
+    }
+    /**
+   * Simulates the public part of a transaction with the current state.
+   * @param tx - The transaction to simulate.
+   * @param skipFeeEnforcement - If true, fee enforcement is skipped.
+   * @param overrides - Optional pre-simulation overrides applied to the ephemeral fork and contract DB.
+   */ async simulate(tx, skipFeeEnforcement = false, overrides) {
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+        };
+        try {
+            // Check total gas limit for simulation
+            const gasSettings = tx.data.constants.txContext.gasSettings;
+            const txGasLimit = gasSettings.gasLimits.l2Gas;
+            const teardownGasLimit = gasSettings.teardownGasLimits.l2Gas;
+            if (txGasLimit + teardownGasLimit > this.config.rpcSimulatePublicMaxGasLimit) {
+                throw new BadRequestError(`Transaction total gas limit ${txGasLimit + teardownGasLimit} (${txGasLimit} + ${teardownGasLimit}) exceeds maximum gas limit ${this.config.rpcSimulatePublicMaxGasLimit} for simulation`);
+            }
+            const txHash = tx.getTxHash();
+            const [l2Tips, proposedCheckpointData] = await Promise.all([
+                this.blockSource.getL2Tips(),
+                this.blockSource.getProposedCheckpointData()
+            ]);
+            const latestBlockNumber = l2Tips.proposed.number;
+            const blockNumber = BlockNumber.add(latestBlockNumber, 1);
+            // Terminating block of the proposed-checkpoint frontier. `getProposedCheckpointData()` returns the
+            // leading proposed (not-yet-L1-confirmed) checkpoint, whose last block is `startBlock + blockCount
+            // - 1`; with no proposed checkpoint the frontier coincides with the checkpointed tip.
+            const proposedCheckpointLastBlock = proposedCheckpointData ? BlockNumber.add(proposedCheckpointData.startBlock, proposedCheckpointData.blockCount - 1) : l2Tips.checkpointed.block.number;
+            // The next block continues the in-progress checkpoint when the latest proposed block is ahead of
+            // the proposed-checkpoint terminating block; it opens a new checkpoint when they coincide.
+            const atCheckpointBoundary = proposedCheckpointLastBlock === l2Tips.proposed.number;
+            // `targetCheckpoint` is the checkpoint whose L1-to-L2 messages must be inserted into the fork
+            // before simulation. Only set when opening a new checkpoint, where the next block is its first block.
+            const { globalVariables: newGlobalVariables, targetCheckpoint } = atCheckpointBoundary ? await this.buildGlobalVariablesForNewCheckpoint(l2Tips, proposedCheckpointData, blockNumber) : {
+                globalVariables: await this.copyGlobalVariablesFromLatestProposedBlock(latestBlockNumber, blockNumber)
+            };
+            if (!this.avmSimulator) {
+                throw new Error('NodePublicCallsSimulator.simulate requires an AVM simulator, but none was configured');
+            }
+            const publicProcessorFactory = new PublicProcessorFactory(this.contractDataSource, this.avmSimulator, new DateProvider(), this.telemetry, this.log.getBindings());
+            this.log.verbose(`Simulating public calls for tx ${txHash}`, {
+                globalVariables: newGlobalVariables.toInspect(),
+                txHash,
+                blockNumber,
+                atCheckpointBoundary
+            });
+            // Ensure world-state has caught up with the latest block we loaded from the archiver
+            await this.worldStateSynchronizer.syncImmediate(latestBlockNumber);
+            const nextCheckpointMessages = await this.getNextCheckpointMessages(targetCheckpoint);
+            const merkleTreeFork = _ts_add_disposable_resource(env, await this.worldStateSynchronizer.fork(latestBlockNumber), true);
+            if (nextCheckpointMessages !== undefined) {
+                this.log.debug(`Appending ${nextCheckpointMessages.length} L1-to-L2 messages to the world state tree for the next checkpoint`, {
+                    checkpointNumber: targetCheckpoint
+                });
+                await appendL1ToL2MessagesToTree(merkleTreeFork, nextCheckpointMessages);
+            }
+            await applyPublicDataOverrides(merkleTreeFork, overrides?.publicStorage);
+            const config = PublicSimulatorConfig.from({
+                skipFeeEnforcement,
+                collectDebugLogs: true,
+                collectHints: false,
+                collectCallMetadata: true,
+                collectStatistics: false,
+                collectionLimits: CollectionLimitsConfig.from({
+                    maxDebugLogMemoryReads: this.config.rpcSimulatePublicMaxDebugLogMemoryReads
+                })
+            });
+            const contractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings());
+            if (overrides?.contracts) {
+                contractsDB.addContracts(Object.values(overrides.contracts).map(({ instance })=>instance));
+            }
+            const processor = publicProcessorFactory.create(merkleTreeFork, newGlobalVariables, config, contractsDB);
+            // REFACTOR: Consider merging ProcessReturnValues into ProcessedTx
+            const [processedTxs, failedTxs, _usedTxs, returns, debugLogs] = await processor.process([
+                tx
+            ]);
+            // REFACTOR: Consider returning the error rather than throwing
+            if (failedTxs.length) {
+                this.log.warn(`Simulated tx ${txHash} fails: ${failedTxs[0].error}`, {
+                    txHash
+                });
+                throw failedTxs[0].error;
+            }
+            const [processedTx] = processedTxs;
+            return new PublicSimulationOutput(processedTx.revertReason, processedTx.globalVariables, processedTx.txEffect, returns, processedTx.gasUsed, debugLogs);
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
+        }
+    }
+    /**
+   * Fetches the next checkpoint's L1-to-L2 messages to insert into the fork before simulation. Only set
+   * when opening a new checkpoint; when continuing an in-progress checkpoint the ongoing checkpoint's
+   * messages were already applied when its first block synced, so inserting here would double-count them
+   * — which is why a missing header for the latest proposed block throws rather than falling through to
+   * this path. A not-ready or failed fetch degrades to simulating without the messages rather than
+   * failing the request.
+   */ async getNextCheckpointMessages(targetCheckpoint) {
+        if (targetCheckpoint === undefined) {
+            return undefined;
+        }
+        try {
+            return await this.l1ToL2MessageSource.getL1ToL2Messages(targetCheckpoint);
+        } catch (err) {
+            if (isErrorClass(err, L1ToL2MessagesNotReadyError)) {
+                this.log.warn(`L1-to-L2 messages for checkpoint ${targetCheckpoint} are not ready yet (simulating without them)`, {
+                    checkpointNumber: targetCheckpoint
+                });
+            } else {
+                this.log.error(`Failed to get L1-to-L2 messages for checkpoint ${targetCheckpoint} (simulating without them)`, err, {
+                    checkpointNumber: targetCheckpoint
+                });
+            }
+            return undefined;
+        }
+    }
+    /**
+   * Continues an in-progress checkpoint: the next block extends the checkpoint the latest proposed
+   * block belongs to. Every block in a checkpoint shares the same `CheckpointGlobalVariables`, so the
+   * next block's globals are the latest proposed block's globals with only the block number bumped —
+   * including the proposer's real coinbase/feeRecipient. No L1 reads and no L1-to-L2 message insertion
+   * happen here.
+   *
+   * A missing header means the archiver reported a proposed tip via `getL2Tips` but no longer has its
+   * data (a torn snapshot). We throw a transient/retryable error rather than treating the next block as
+   * opening a new checkpoint: the fork at `latestBlockNumber` already contains the ongoing checkpoint's
+   * L1-to-L2 messages, so inserting the next checkpoint's messages would append them a second time.
+   */ async copyGlobalVariablesFromLatestProposedBlock(latestBlockNumber, blockNumber) {
+        const latestBlockData = await this.blockSource.getBlockData({
+            number: latestBlockNumber
+        });
+        if (!latestBlockData) {
+            throw new Error(`Cannot simulate public calls: latest proposed block ${latestBlockNumber} has no header on this node ` + `(torn archiver snapshot); retry`);
+        }
+        return GlobalVariables.from({
+            ...latestBlockData.header.globalVariables,
+            blockNumber
+        });
+    }
+    /**
+   * Opens a new checkpoint: the next block is the first of a fresh checkpoint. Picks the slot the next
+   * block will land in, mirroring the sequencer, and builds the same `SimulationOverridesPlan` the
+   * sequencer applies so the simulated mana min fee matches what the sequencer will write into the
+   * block header. Coinbase and fee recipient stay zero (we cannot know the future proposer's payout
+   * addresses), unlike continuing an in-progress checkpoint which inherits the real ones from the
+   * proposed header. Returns the target checkpoint so the caller inserts that checkpoint's L1-to-L2
+   * messages into the fork.
+   */ async buildGlobalVariablesForNewCheckpoint(l2Tips, proposedCheckpointData, blockNumber) {
+        const checkpointedCheckpointNumber = l2Tips.checkpointed.checkpoint.number;
+        // The new checkpoint sits on top of the proposed one when pipelining, otherwise on the
+        // checkpointed tip. The target slot and the overrides plan both derive from the single
+        // `proposedCheckpointData` read, so they cannot disagree about the proposed parent.
+        const proposedCheckpointNumber = proposedCheckpointData?.checkpointNumber ?? checkpointedCheckpointNumber;
+        const targetSlot = this.computeTargetSlot(proposedCheckpointData);
+        const plan = await this.buildSimulationOverridesPlan(proposedCheckpointData, checkpointedCheckpointNumber);
+        const checkpointGlobalVariables = await this.globalVariableBuilder.buildCheckpointGlobalVariables(EthAddress.ZERO, AztecAddress.ZERO, targetSlot, plan);
+        return {
+            globalVariables: GlobalVariables.from({
+                blockNumber,
+                ...checkpointGlobalVariables
+            }),
+            targetCheckpoint: CheckpointNumber(proposedCheckpointNumber + 1)
+        };
+    }
+    /**
+   * Slot the next block will land in. The first term is the sequencer's exact formula
+   * (`getEpochAndSlotInNextL1Slot().slot + PROPOSER_PIPELINING_SLOT_OFFSET`). The `max` with
+   * `proposedCheckpointSlot + 1` is an RPC-side approximation of the next build: when a proposed
+   * checkpoint is gossiped before its L1 slot starts, the next build (once its wall clock arrives)
+   * will target `parentSlot + 1`. The sequencer never advances its own target past wall clock — it
+   * just declines to build — so this is a prediction of inclusion globals, not literal sequencer
+   * behavior. The parent slot comes from the proposed checkpoint header so the slot and the
+   * overrides plan cannot derive from different snapshots.
+   */ computeTargetSlot(proposedCheckpointData) {
+        const slotFromNextL1Timestamp = this.epochCache.getEpochAndSlotInNextL1Slot().slot + PROPOSER_PIPELINING_SLOT_OFFSET;
+        const slotAfterProposedCheckpoint = proposedCheckpointData ? proposedCheckpointData.header.slotNumber + 1 : undefined;
+        return SlotNumber(Math.max(...compactArray([
+            slotFromNextL1Timestamp,
+            slotAfterProposedCheckpoint
+        ])));
+    }
+    /**
+   * Builds the chain-state overrides plan the simulator passes to `buildCheckpointGlobalVariables`,
+   * mirroring the sequencer (which always pins tips to neutralize prunes). When pipelining, the plan
+   * carries the proposed parent's archive, temp-checkpoint-log cell, and locally-derived fee header.
+   *
+   * Both the pipelining and invalid-pending-chain paths need a rollup contract for the L1 fee reads.
+   * Environments that omit it (e.g. TXE, which never has a proposed checkpoint and whose pending chain
+   * is always valid) fall back to pinning both pending and proven tips to the checkpointed tip, which
+   * neutralizes prunes in fee computation at the cost of non-pipelined fees.
+   */ async buildSimulationOverridesPlan(proposedCheckpointData, checkpointedCheckpointNumber) {
+        const rollup = this.rollupContract;
+        if (rollup) {
+            if (proposedCheckpointData) {
+                return buildCheckpointSimulationOverridesPlan({
+                    checkpointNumber: CheckpointNumber(proposedCheckpointData.checkpointNumber + 1),
+                    proposedCheckpointData,
+                    checkpointedCheckpointNumber,
+                    rollup,
+                    signatureContext: this.signatureContext,
+                    log: this.log
+                });
+            }
+            const validationStatus = await this.blockSource.getPendingChainValidationStatus();
+            if (!validationStatus.valid) {
+                return buildCheckpointSimulationOverridesPlan({
+                    checkpointNumber: CheckpointNumber(checkpointedCheckpointNumber + 1),
+                    invalidateToPendingCheckpointNumber: CheckpointNumber(validationStatus.checkpoint.checkpointNumber - 1),
+                    checkpointedCheckpointNumber,
+                    rollup,
+                    signatureContext: this.signatureContext,
+                    log: this.log
+                });
+            }
+        }
+        return new SimulationOverridesBuilder().withChainTips({
+            pending: checkpointedCheckpointNumber,
+            proven: checkpointedCheckpointNumber
+        }).build();
+    }
+}

package/dest/aztec-node/register_node_rpc_handlers.d.ts

@@ -0,0 +1,10 @@
+import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import type { AztecNodeService } from './server.js';
+/**
+ * Registers the Aztec node RPC handlers (`aztec_*`, `aztecAdmin_*`, and optionally `aztecDebug_*`), along with the
+ * legacy pre-v5 namespaces (`node_*`, `nodeAdmin_*`, `nodeDebug_*`, `p2p_*`) for backwards compatibility.
+ */
+export declare function registerAztecNodeRpcHandlers(node: AztecNodeService, services: NamespacedApiHandlers, adminServices?: NamespacedApiHandlers, options?: {
+    debug?: boolean;
+}): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXJfbm9kZV9ycGNfaGFuZGxlcnMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9henRlYy1ub2RlL3JlZ2lzdGVyX25vZGVfcnBjX2hhbmRsZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFJL0UsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFcEQ7OztHQUdHO0FBRUgsd0JBQWdCLDRCQUE0QixDQUMxQyxJQUFJLEVBQUUsZ0JBQWdCLEVBQ3RCLFFBQVEsRUFBRSxxQkFBcUIsRUFDL0IsYUFBYSxDQUFDLEVBQUUscUJBQXFCLEVBQ3JDLE9BQU8sR0FBRTtJQUFFLEtBQUssQ0FBQyxFQUFFLE9BQU8sQ0FBQTtDQUFPLEdBQ2hDLElBQUksQ0FZTiJ9

package/dest/aztec-node/register_node_rpc_handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register_node_rpc_handlers.d.ts","sourceRoot":"","sources":["../../src/aztec-node/register_node_rpc_handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAI/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;GAGG;AAEH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,gBAAgB,EACtB,QAAQ,EAAE,qBAAqB,EAC/B,aAAa,CAAC,EAAE,qBAAqB,EACrC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAChC,IAAI,CAYN"}

package/dest/aztec-node/register_node_rpc_handlers.js

@@ -0,0 +1,31 @@
+import { AztecNodeAdminApiSchema, AztecNodeApiSchema, AztecNodeDebugApiSchema } from '@aztec/stdlib/interfaces/client';
+import { P2PApiSchema } from '@aztec/stdlib/interfaces/server';
+/**
+ * Registers the Aztec node RPC handlers (`aztec_*`, `aztecAdmin_*`, and optionally `aztecDebug_*`), along with the
+ * legacy pre-v5 namespaces (`node_*`, `nodeAdmin_*`, `nodeDebug_*`, `p2p_*`) for backwards compatibility.
+ */ // TODO: Legacy support for node, nodeAdmin, nodeDebug, p2p namespaces. New namespaces introduced in v5. Remove on future release. A-1169
+export function registerAztecNodeRpcHandlers(node, services, adminServices, options = {}) {
+    services.aztec = [
+        node,
+        AztecNodeApiSchema
+    ];
+    services.node = services.aztec;
+    services.p2p = [
+        node.getP2P(),
+        P2PApiSchema
+    ];
+    if (adminServices) {
+        adminServices.aztecAdmin = [
+            node,
+            AztecNodeAdminApiSchema
+        ];
+        adminServices.nodeAdmin = adminServices.aztecAdmin;
+    }
+    if (options.debug) {
+        services.aztecDebug = [
+            node,
+            AztecNodeDebugApiSchema
+        ];
+        services.nodeDebug = services.aztecDebug;
+    }
+}