@aztec/aztec-node 5.0.0-private.20260319 → 5.0.0-rc.2

package/dest/aztec-node/node_public_calls_simulator.js

@@ -0,0 +1,346 @@
+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;
+    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.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)
+            };
+            const publicProcessorFactory = new PublicProcessorFactory(this.contractDataSource, 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/public_data_overrides.d.ts

@@ -0,0 +1,13 @@
+import type { PublicStorageOverride } from '@aztec/stdlib/interfaces/client';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+/**
+ * Injects public-state overrides into an (ephemeral) world-state fork before simulation.
+ *
+ * Each override is written via the same `sequentialInsert` path the public processor
+ * uses during real transaction execution, so low-leaf updates and root coherence are
+ * handled identically for both simulation and proof generation.
+ *
+ * Writes never reach committed world state — the fork is thrown away after simulation.
+ */
+export declare function applyPublicDataOverrides(fork: MerkleTreeWriteOperations, publicStorage: PublicStorageOverride[] | undefined): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2RhdGFfb3ZlcnJpZGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp0ZWMtbm9kZS9wdWJsaWNfZGF0YV9vdmVycmlkZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM3RSxPQUFPLEtBQUssRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBR2pGOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxJQUFJLEVBQUUseUJBQXlCLEVBQy9CLGFBQWEsRUFBRSxxQkFBcUIsRUFBRSxHQUFHLFNBQVMsR0FDakQsT0FBTyxDQUFDLElBQUksQ0FBQyxDQWdCZiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"public_data_overrides.d.ts","sourceRoot":"","sources":["../../src/aztec-node/public_data_overrides.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAGjF;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,yBAAyB,EAC/B,aAAa,EAAE,qBAAqB,EAAE,GAAG,SAAS,GACjD,OAAO,CAAC,IAAI,CAAC,CAgBf"}

package/dest/aztec-node/public_data_overrides.js

@@ -0,0 +1,21 @@
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+/**
+ * Injects public-state overrides into an (ephemeral) world-state fork before simulation.
+ *
+ * Each override is written via the same `sequentialInsert` path the public processor
+ * uses during real transaction execution, so low-leaf updates and root coherence are
+ * handled identically for both simulation and proof generation.
+ *
+ * Writes never reach committed world state — the fork is thrown away after simulation.
+ */ export async function applyPublicDataOverrides(fork, publicStorage) {
+    if (!publicStorage?.length) {
+        return;
+    }
+    const writes = await Promise.all(publicStorage.map(async (o)=>{
+        const leafSlot = await computePublicDataTreeLeafSlot(o.contract, o.slot);
+        return new PublicDataWrite(leafSlot, o.value);
+    }));
+    await fork.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, writes.map((w)=>w.toBuffer()));
+}

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;
+    }
+}