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

package/dest/aztec-node/node_public_calls_simulator.js

@@ -0,0 +1,380 @@
+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 { MAX_L1_TO_L2_MSGS_PER_BLOCK, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT } from '@aztec-labs/constants';
+import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec-labs/epoch-cache';
+import { SimulationOverridesBuilder } from '@aztec-labs/ethereum/contracts';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { compactArray } from '@aztec-labs/foundation/collection';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { BadRequestError } from '@aztec-labs/foundation/json-rpc';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { selectInboxBucketForBlock } from '@aztec-labs/sequencer-client';
+import { PublicContractsDB, PublicProcessorFactory } from '@aztec-labs/simulator/server';
+import { CollectionLimitsConfig, PublicSimulatorConfig } from '@aztec-labs/stdlib/avm';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { buildCheckpointSimulationOverridesPlan } from '@aztec-labs/stdlib/checkpoint';
+import { appendL1ToL2MessagesToTree, getInboxCutoffTimestamp } from '@aztec-labs/stdlib/messaging';
+import { MerkleTreeId } from '@aztec-labs/stdlib/trees';
+import { GlobalVariables, PublicSimulationOutput } from '@aztec-labs/stdlib/tx';
+import { getTelemetryClient } from '@aztec-labs/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.
+ * - **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.
+ *
+ * Either way it also predicts the L1-to-L2 message bundle the next block would consume and appends it
+ * to the fork, so a transaction consuming a message that is in the Inbox but not yet in a block
+ * simulates against the state it will actually run in.
+ */ export class NodePublicCallsSimulator {
+    blockSource;
+    worldStateSynchronizer;
+    l1ToL2MessageSource;
+    contractDataSource;
+    globalVariableBuilder;
+    rollupContract;
+    epochCache;
+    signatureContext;
+    config;
+    avmSimulator;
+    telemetry;
+    log;
+    dateProvider = new DateProvider();
+    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;
+            const { globalVariables: newGlobalVariables } = 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, this.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 merkleTreeFork = _ts_add_disposable_resource(env, await this.worldStateSynchronizer.fork(latestBlockNumber), true);
+            await this.appendPredictedL1ToL2Messages(merkleTreeFork, {
+                slotNumber: newGlobalVariables.slotNumber,
+                checkpointStartBlock: atCheckpointBoundary ? undefined : proposedCheckpointLastBlock
+            });
+            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;
+        }
+    }
+    /**
+   * Appends the L1-to-L2 message bundle the next block would consume to the simulation fork, so a transaction
+   * consuming a message that has reached the Inbox but no block yet simulates against the state it will run in.
+   * Runs the same bucket selection the sequencer runs (lag eligibility plus the per-block and per-checkpoint caps),
+   * treating the next block as non-final: the censorship cutoff only widens consumption on a checkpoint's last
+   * block, and the node cannot know whether the next block is it.
+   *
+   * Best-effort. Any failure — Inbox buckets not synced yet, a torn archiver snapshot — leaves the fork at the tip
+   * state, which is what the transaction sees if the next block consumes nothing.
+   */ async appendPredictedL1ToL2Messages(fork, opts) {
+        try {
+            const parentTotalMsgCount = (await fork.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE)).size;
+            const parentBucket = await this.l1ToL2MessageSource.getInboxBucketByTotalMsgCount(parentTotalMsgCount);
+            if (parentBucket === undefined) {
+                this.log.debug(`Inbox bucket at message total ${parentTotalMsgCount} not synced; simulating against the tip`, {
+                    parentTotalMsgCount
+                });
+                return;
+            }
+            // Origin of the per-checkpoint cap: the total consumed as of the checkpoint's parent. A block extending an
+            // in-progress checkpoint reads it off that checkpoint's parent block; a block opening one starts from the tip.
+            const checkpointStartTotalMsgCount = opts.checkpointStartBlock === undefined ? parentTotalMsgCount : await this.getConsumedMessageTotal(opts.checkpointStartBlock);
+            if (checkpointStartTotalMsgCount === undefined) {
+                this.log.debug(`Block ${opts.checkpointStartBlock} has no header on this node; simulating against the tip`);
+                return;
+            }
+            const l1Constants = this.epochCache.getL1Constants();
+            const selection = await selectInboxBucketForBlock({
+                messageSource: this.l1ToL2MessageSource,
+                now: BigInt(Math.floor(this.dateProvider.now() / 1000)),
+                minBucketAgeSeconds: BigInt(l1Constants.ethereumSlotDuration),
+                parent: {
+                    seq: parentBucket.seq,
+                    totalMsgCount: parentBucket.totalMsgCount
+                },
+                checkpointStartTotalMsgCount,
+                perBlockCap: MAX_L1_TO_L2_MSGS_PER_BLOCK,
+                perCheckpointCap: MAX_L1_TO_L2_MSGS_PER_CHECKPOINT,
+                isLastBlock: false,
+                cutoffTimestamp: getInboxCutoffTimestamp(opts.slotNumber, l1Constants)
+            });
+            if (!selection.consume || selection.bundle.length === 0) {
+                return;
+            }
+            await appendL1ToL2MessagesToTree(fork, selection.bundle);
+            this.log.debug(`Appended ${selection.bundle.length} predicted L1-to-L2 messages to the simulation fork`, {
+                bucketSeq: selection.bucket.seq,
+                messageCount: selection.bundle.length
+            });
+        } catch (err) {
+            this.log.verbose(`Could not predict the next block's L1-to-L2 messages, simulating against the tip: ${err}`);
+        }
+    }
+    /** Cumulative Inbox message total consumed as of `blockNumber`, i.e. its L1-to-L2 message tree leaf count. */ async getConsumedMessageTotal(blockNumber) {
+        if (blockNumber === BlockNumber.ZERO) {
+            return 0n;
+        }
+        const block = await this.blockSource.getBlockData({
+            number: blockNumber
+        });
+        return block === undefined ? undefined : BigInt(block.header.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+    }
+    /**
+   * 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 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, whose globals would be built for the wrong slot.
+   */ 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.
+   */ async buildGlobalVariablesForNewCheckpoint(l2Tips, proposedCheckpointData, blockNumber) {
+        const checkpointedCheckpointNumber = l2Tips.checkpointed.checkpoint.number;
+        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
+            })
+        };
+    }
+    /**
+   * 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-labs/stdlib/interfaces/client';
+import type { MerkleTreeWriteOperations } from '@aztec-labs/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2RhdGFfb3ZlcnJpZGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp0ZWMtbm9kZS9wdWJsaWNfZGF0YV9vdmVycmlkZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNsRixPQUFPLEtBQUssRUFBRSx5QkFBeUIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBR3RGOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxJQUFJLEVBQUUseUJBQXlCLEVBQy9CLGFBQWEsRUFBRSxxQkFBcUIsRUFBRSxHQUFHLFNBQVMsR0FDakQsT0FBTyxDQUFDLElBQUksQ0FBQyxDQWdCZiJ9

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,sCAAsC,CAAC;AAClF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAGtF;;;;;;;;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-labs/stdlib/avm';
+import { computePublicDataTreeLeafSlot } from '@aztec-labs/stdlib/hash';
+import { MerkleTreeId } from '@aztec-labs/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,11 @@
+import type { NamespacedApiHandlers } from '@aztec-labs/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;
+    p2pHealthMinPeers?: number;
+}): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXJfbm9kZV9ycGNfaGFuZGxlcnMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9henRlYy1ub2RlL3JlZ2lzdGVyX25vZGVfcnBjX2hhbmRsZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLHFCQUFxQixFQUFpQixNQUFNLHdDQUF3QyxDQUFDO0FBUW5HLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBYXBEOzs7R0FHRztBQUVILHdCQUFnQiw0QkFBNEIsQ0FDMUMsSUFBSSxFQUFFLGdCQUFnQixFQUN0QixRQUFRLEVBQUUscUJBQXFCLEVBQy9CLGFBQWEsQ0FBQyxFQUFFLHFCQUFxQixFQUNyQyxPQUFPLEdBQUU7SUFBRSxLQUFLLENBQUMsRUFBRSxPQUFPLENBQUM7SUFBQyxpQkFBaUIsQ0FBQyxFQUFFLE1BQU0sQ0FBQTtDQUFPLEdBQzVELElBQUksQ0FhTiJ9

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,EAAiB,MAAM,wCAAwC,CAAC;AAQnG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAapD;;;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,CAAC;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5D,IAAI,CAaN"}

package/dest/aztec-node/register_node_rpc_handlers.js

@@ -0,0 +1,48 @@
+import { AztecNodeAdminApiSchema, AztecNodeApiSchema, AztecNodeDebugApiSchema } from '@aztec-labs/stdlib/interfaces/client';
+import { P2PApiSchema } from '@aztec-labs/stdlib/interfaces/server';
+/**
+ * Health check for the p2p component: reports whether p2p is enabled and how many peers are connected, and fails
+ * when p2p is enabled but connected to fewer peers than the given minimum. A minimum of zero never fails.
+ */ function makeP2PHealthCheck(p2p, minPeers) {
+    return async ()=>{
+        const { enabled, connectedPeers } = await p2p.getP2PConnectivity();
+        return {
+            healthy: !enabled || connectedPeers >= minPeers,
+            details: {
+                enabled,
+                connectedPeers
+            }
+        };
+    };
+}
+/**
+ * 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 = {}) {
+    const p2p = node.getP2P();
+    services.aztec = [
+        node,
+        AztecNodeApiSchema
+    ];
+    services.node = services.aztec;
+    services.p2p = [
+        p2p,
+        P2PApiSchema,
+        makeP2PHealthCheck(p2p, options.p2pHealthMinPeers ?? 0)
+    ];
+    if (adminServices) {
+        adminServices.aztecAdmin = [
+            node,
+            AztecNodeAdminApiSchema
+        ];
+        adminServices.nodeAdmin = adminServices.aztecAdmin;
+    }
+    if (options.debug) {
+        services.aztecDebug = [
+            node,
+            AztecNodeDebugApiSchema
+        ];
+        services.nodeDebug = services.aztecDebug;
+    }
+}