@aztec-labs/cli 6.0.0-nightly.20260829

package/dest/cmds/l1/prover_stats.d.ts

@@ -0,0 +1,14 @@
+import { type LogFn } from '@aztec-labs/foundation/log';
+export declare function proverStats(opts: {
+    l1RpcUrls: string[];
+    chainId: number;
+    l1RollupAddress: string | undefined;
+    nodeUrl: string | undefined;
+    log: LogFn;
+    startBlock: bigint;
+    endBlock: bigint | undefined;
+    batchSize: bigint;
+    provingTimeout: bigint | undefined;
+    rawLogs: boolean;
+}): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmVyX3N0YXRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY21kcy9sMS9wcm92ZXJfc3RhdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0EsT0FBTyxFQUFFLEtBQUssS0FBSyxFQUE2QixNQUFNLDRCQUE0QixDQUFDO0FBTW5GLHdCQUFzQixXQUFXLENBQUMsSUFBSSxFQUFFO0lBQ3RDLFNBQVMsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUNwQixPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLGVBQWUsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQ3BDLE9BQU8sRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQzVCLEdBQUcsRUFBRSxLQUFLLENBQUM7SUFDWCxVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25CLFFBQVEsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQzdCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsY0FBYyxFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDbkMsT0FBTyxFQUFFLE9BQU8sQ0FBQztDQUNsQixpQkEwSUEifQ==

package/dest/cmds/l1/prover_stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover_stats.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/prover_stats.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,KAAK,EAA6B,MAAM,4BAA4B,CAAC;AAMnF,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACtC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,GAAG,EAAE,KAAK,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,OAAO,EAAE,OAAO,CAAC;CAClB,iBA0IA"}

package/dest/cmds/l1/prover_stats.js

@@ -0,0 +1,147 @@
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { retrieveL2ProofVerifiedEvents } from '@aztec-labs/archiver';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { compactArray, mapValues, unique } from '@aztec-labs/foundation/collection';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { createAztecNodeClient } from '@aztec-labs/stdlib/interfaces/client';
+import chunk from 'lodash.chunk';
+import groupBy from 'lodash.groupby';
+import { createPublicClient, fallback, getAbiItem, getAddress, http } from 'viem';
+export async function proverStats(opts) {
+    const debugLog = createLogger('cli:prover_stats');
+    const { startBlock, chainId, l1RpcUrls, l1RollupAddress, batchSize, nodeUrl, provingTimeout, endBlock, rawLogs, log } = opts;
+    if (!l1RollupAddress && !nodeUrl) {
+        throw new Error('Either L1 rollup address or node URL must be set');
+    }
+    const rollup = l1RollupAddress ? EthAddress.fromString(l1RollupAddress) : await createAztecNodeClient(nodeUrl).getL1ContractAddresses().then((a)=>a.rollupAddress);
+    const chain = createEthereumChain(l1RpcUrls, chainId).chainInfo;
+    const publicClient = createPublicClient({
+        chain,
+        transport: fallback(l1RpcUrls.map((url)=>http(url, {
+                batch: false
+            })))
+    });
+    const lastBlockNum = endBlock ?? await publicClient.getBlockNumber();
+    debugLog.verbose(`Querying events on rollup at ${rollup.toString()} from ${startBlock} up to ${lastBlockNum}`);
+    // Get all events for L2 proof submissions
+    const events = await getL2ProofVerifiedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
+    // If we only care for raw logs, output them
+    if (rawLogs && !provingTimeout) {
+        log(`l1_block_number, checkpoint_number, prover_id, tx_hash`);
+        for (const event of events){
+            const { l1BlockNumber, checkpointNumber, proverId, txHash } = event;
+            log(`${l1BlockNumber}, ${checkpointNumber}, ${proverId}, ${txHash}`);
+        }
+        return;
+    }
+    // If we don't have a proving timeout, we can just count the number of unique checkpoints per prover
+    if (!provingTimeout) {
+        const stats = groupBy(events, 'proverId');
+        log(`prover_id, total_checkpoints_proven`);
+        for(const proverId in stats){
+            const uniqueCheckpoints = new Set(stats[proverId].map((e)=>e.checkpointNumber));
+            log(`${proverId}, ${uniqueCheckpoints.size}`);
+        }
+        return;
+    }
+    // But if we do, fetch the events for each checkpoint submitted, so we can look up their timestamp
+    const checkpointEvents = await getCheckpointProposedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
+    debugLog.verbose(`First checkpoint within range is ${checkpointEvents[0]?.args.checkpointNumber} at L1 block ${checkpointEvents[0]?.blockNumber}`);
+    // Get the timestamps for every block on every log, both for proof and block submissions
+    const l1BlockNumbers = unique([
+        ...events.map((e)=>e.l1BlockNumber),
+        ...checkpointEvents.map((e)=>e.blockNumber)
+    ]);
+    const l1BlockTimestamps = {};
+    for (const l1Batch of chunk(l1BlockNumbers, Number(batchSize))){
+        const blocks = await Promise.all(l1Batch.map((blockNumber)=>publicClient.getBlock({
+                includeTransactions: false,
+                blockNumber
+            })));
+        debugLog.verbose(`Queried ${blocks.length} L1 blocks between ${l1Batch[0]} and ${l1Batch[l1Batch.length - 1]}`);
+        for (const block of blocks){
+            l1BlockTimestamps[block.number.toString()] = block.timestamp;
+        }
+    }
+    // Map from checkpoint number to the l1 block in which it was submitted
+    const checkpointSubmissions = {};
+    for (const checkpointEvent of checkpointEvents){
+        checkpointSubmissions[checkpointEvent.args.checkpointNumber.toString()] = checkpointEvent.blockNumber;
+    }
+    // If we want raw logs, output them
+    if (rawLogs) {
+        log(`l1_block_number, checkpoint_number, checkpoint_submission_timestamp, proof_timestamp, prover_id, tx_hash`);
+        for (const event of events){
+            const { l1BlockNumber, checkpointNumber, proverId, txHash } = event;
+            const uploadedBlockNumber = checkpointSubmissions[checkpointNumber.toString()];
+            if (!uploadedBlockNumber) {
+                continue;
+            }
+            const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
+            const provenTimestamp = l1BlockTimestamps[l1BlockNumber.toString()];
+            log(`${l1BlockNumber}, ${checkpointNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
+        }
+        return;
+    }
+    // Or calculate stats per prover
+    const stats = mapValues(groupBy(events, 'proverId'), (checkpoints, proverId)=>compactArray(checkpoints.map((e)=>{
+            const provenTimestamp = l1BlockTimestamps[e.l1BlockNumber.toString()];
+            const uploadedBlockNumber = checkpointSubmissions[e.checkpointNumber.toString()];
+            if (!uploadedBlockNumber) {
+                debugLog.verbose(`Skipping ${proverId}'s proof for checkpoint ${e.checkpointNumber} as it was before the start block`);
+                return undefined;
+            }
+            const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
+            const provingTime = provenTimestamp - uploadedTimestamp;
+            debugLog.debug(`prover=${e.proverId} checkpointNumber=${e.checkpointNumber} uploaded=${uploadedTimestamp} proven=${provenTimestamp} time=${provingTime}`);
+            return {
+                provenTimestamp,
+                uploadedTimestamp,
+                provingTime,
+                ...e
+            };
+        })));
+    log(`prover_id, blocks_proven_within_timeout, total_blocks_proven, avg_proving_time`);
+    for(const proverId in stats){
+        const blocks = stats[proverId];
+        const withinTimeout = blocks.filter((b)=>b.provingTime <= provingTimeout);
+        const uniqueBlocksWithinTimeout = new Set(withinTimeout.map((e)=>e.checkpointNumber));
+        const uniqueBlocks = new Set(blocks.map((e)=>e.checkpointNumber));
+        const avgProvingTime = blocks.length === 0 ? 0 : Math.ceil(Number(blocks.reduce((acc, b)=>acc + b.provingTime, 0n)) / blocks.length);
+        log(`${proverId}, ${uniqueBlocksWithinTimeout.size}, ${uniqueBlocks.size}, ${avgProvingTime}`);
+    }
+    return;
+}
+async function getL2ProofVerifiedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup) {
+    let blockNum = startBlock;
+    const events = [];
+    while(blockNum <= lastBlockNum){
+        const end = blockNum + batchSize > lastBlockNum + 1n ? lastBlockNum + 1n : blockNum + batchSize;
+        const newEvents = await retrieveL2ProofVerifiedEvents(publicClient, rollup, blockNum, end);
+        events.push(...newEvents);
+        debugLog.verbose(`Got ${newEvents.length} events querying l2 proof verified from block ${blockNum} to ${end}`);
+        blockNum += batchSize;
+    }
+    return events;
+}
+async function getCheckpointProposedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup) {
+    let blockNum = startBlock;
+    const events = [];
+    while(blockNum <= lastBlockNum){
+        const end = blockNum + batchSize > lastBlockNum + 1n ? lastBlockNum + 1n : blockNum + batchSize;
+        const newEvents = await publicClient.getLogs({
+            address: getAddress(rollup.toString()),
+            event: getAbiItem({
+                abi: RollupAbi,
+                name: 'CheckpointProposed'
+            }),
+            fromBlock: blockNum,
+            toBlock: end
+        });
+        events.push(...newEvents);
+        debugLog.verbose(`Got ${newEvents.length} events querying checkpoints submitted from block ${blockNum} to ${end}`);
+        blockNum += batchSize;
+    }
+    return events;
+}

package/dest/cmds/l1/trigger_seed_snapshot.d.ts

@@ -0,0 +1,6 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { RollupCommandArgs } from './update_l1_validators.js';
+export declare function triggerSeedSnapshot({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log }: RollupCommandArgs & {
+    log: LogFn;
+}): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJpZ2dlcl9zZWVkX3NuYXBzaG90LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY21kcy9sMS90cmlnZ2VyX3NlZWRfc25hcHNob3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFHeEQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUVuRSx3QkFBc0IsbUJBQW1CLENBQUMsRUFDeEMsT0FBTyxFQUNQLE9BQU8sRUFDUCxVQUFVLEVBQ1YsUUFBUSxFQUNSLGFBQWEsRUFDYixHQUFHLEVBQ0osRUFBRSxpQkFBaUIsR0FBRztJQUFFLEdBQUcsRUFBRSxLQUFLLENBQUE7Q0FBRSxpQkFlcEMifQ==

package/dest/cmds/l1/trigger_seed_snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger_seed_snapshot.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/trigger_seed_snapshot.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAGxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,wBAAsB,mBAAmB,CAAC,EACxC,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,GAAG,EACJ,EAAE,iBAAiB,GAAG;IAAE,GAAG,EAAE,KAAK,CAAA;CAAE,iBAepC"}

package/dest/cmds/l1/trigger_seed_snapshot.js

@@ -0,0 +1,20 @@
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { createExtendedL1Client } from '@aztec-labs/ethereum/client';
+import { getContract } from 'viem';
+export async function triggerSeedSnapshot({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log }) {
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+    const rollup = getContract({
+        address: rollupAddress.toString(),
+        abi: RollupAbi,
+        client
+    });
+    log('Triggering seed snapshot for next epoch');
+    const txHash = await rollup.write.checkpointRandao();
+    log(`Sent! | Seed snapshot setup for next epoch | tx hash: ${txHash}`);
+    const receipt = await client.waitForTransactionReceipt({
+        hash: txHash
+    });
+    log(`Done! | Seed snapshot setup for next epoch | tx hash: ${txHash} | status: ${receipt.status}`);
+}

package/dest/cmds/l1/update_l1_validators.d.ts

@@ -0,0 +1,45 @@
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+export interface RollupCommandArgs {
+    rpcUrls: string[];
+    chainId: number;
+    privateKey?: string;
+    mnemonic?: string;
+    rollupAddress: EthAddress;
+    withdrawerAddress?: EthAddress;
+}
+export interface StakingAssetHandlerCommandArgs {
+    rpcUrls: string[];
+    chainId: number;
+    privateKey?: string;
+    mnemonic?: string;
+    stakingAssetHandlerAddress: EthAddress;
+}
+export interface LoggerArgs {
+    log: LogFn;
+    debugLogger: Logger;
+}
+export declare function generateL1Account(): {
+    privateKey: `0x${string}`;
+    address: `0x${string}`;
+};
+export declare function addL1Validator({ rpcUrls, chainId, privateKey, mnemonic, attesterAddress, withdrawerAddress, stakingAssetHandlerAddress, proofParams, blsSecretKey, log, debugLogger }: StakingAssetHandlerCommandArgs & LoggerArgs & {
+    blsSecretKey: bigint;
+    attesterAddress: EthAddress;
+    withdrawerAddress: EthAddress;
+    proofParams: Buffer;
+}): Promise<void>;
+export declare function addL1ValidatorViaRollup({ rpcUrls, chainId, privateKey, mnemonic, attesterAddress, withdrawerAddress, blsSecretKey, moveWithLatestRollup, rollupAddress, log, debugLogger }: RollupCommandArgs & LoggerArgs & {
+    blsSecretKey: bigint;
+    attesterAddress: EthAddress;
+    moveWithLatestRollup: boolean;
+}): Promise<void>;
+export declare function removeL1Validator({ rpcUrls, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, log, debugLogger }: RollupCommandArgs & LoggerArgs & {
+    validatorAddress: EthAddress;
+}): Promise<void>;
+export declare function pruneRollup({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log, debugLogger }: RollupCommandArgs & LoggerArgs): Promise<void>;
+export declare function fastForwardEpochs({ rpcUrls, chainId, rollupAddress, numEpochs, log, debugLogger }: RollupCommandArgs & LoggerArgs & {
+    numEpochs: bigint;
+}): Promise<void>;
+export declare function debugRollup({ rpcUrls, chainId, rollupAddress, log }: RollupCommandArgs & LoggerArgs): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlX2wxX3ZhbGlkYXRvcnMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL3VwZGF0ZV9sMV92YWxpZGF0b3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQU1oRSxNQUFNLFdBQVcsaUJBQWlCO0lBQ2hDLE9BQU8sRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUNsQixPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLFVBQVUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNwQixRQUFRLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbEIsYUFBYSxFQUFFLFVBQVUsQ0FBQztJQUMxQixpQkFBaUIsQ0FBQyxFQUFFLFVBQVUsQ0FBQztDQUNoQztBQUVELE1BQU0sV0FBVyw4QkFBOEI7SUFDN0MsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQ2xCLE9BQU8sRUFBRSxNQUFNLENBQUM7SUFDaEIsVUFBVSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3BCLFFBQVEsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNsQiwwQkFBMEIsRUFBRSxVQUFVLENBQUM7Q0FDeEM7QUFFRCxNQUFNLFdBQVcsVUFBVTtJQUN6QixHQUFHLEVBQUUsS0FBSyxDQUFDO0lBQ1gsV0FBVyxFQUFFLE1BQU0sQ0FBQztDQUNyQjtBQUVELHdCQUFnQixpQkFBaUI7OztFQU9oQztBQUVELHdCQUFzQixjQUFjLENBQUMsRUFDbkMsT0FBTyxFQUNQLE9BQU8sRUFDUCxVQUFVLEVBQ1YsUUFBUSxFQUNSLGVBQWUsRUFDZixpQkFBaUIsRUFDakIsMEJBQTBCLEVBQzFCLFdBQVcsRUFDWCxZQUFZLEVBQ1osR0FBRyxFQUNILFdBQVcsRUFDWixFQUFFLDhCQUE4QixHQUMvQixVQUFVLEdBQUc7SUFDWCxZQUFZLEVBQUUsTUFBTSxDQUFDO0lBQ3JCLGVBQWUsRUFBRSxVQUFVLENBQUM7SUFDNUIsaUJBQWlCLEVBQUUsVUFBVSxDQUFDO0lBQzlCLFdBQVcsRUFBRSxNQUFNLENBQUM7Q0FDckIsaUJBd0ZGO0FBRUQsd0JBQXNCLHVCQUF1QixDQUFDLEVBQzVDLE9BQU8sRUFDUCxPQUFPLEVBQ1AsVUFBVSxFQUNWLFFBQVEsRUFDUixlQUFlLEVBQ2YsaUJBQWlCLEVBQ2pCLFlBQVksRUFDWixvQkFBb0IsRUFDcEIsYUFBYSxFQUNiLEdBQUcsRUFDSCxXQUFXLEVBQ1osRUFBRSxpQkFBaUIsR0FDbEIsVUFBVSxHQUFHO0lBQ1gsWUFBWSxFQUFFLE1BQU0sQ0FBQztJQUNyQixlQUFlLEVBQUUsVUFBVSxDQUFDO0lBQzVCLG9CQUFvQixFQUFFLE9BQU8sQ0FBQztDQUMvQixpQkF1REY7QUFFRCx3QkFBc0IsaUJBQWlCLENBQUMsRUFDdEMsT0FBTyxFQUNQLE9BQU8sRUFDUCxVQUFVLEVBQ1YsUUFBUSxFQUNSLGdCQUFnQixFQUNoQixhQUFhLEVBQ2IsR0FBRyxFQUNILFdBQVcsRUFDWixFQUFFLGlCQUFpQixHQUFHLFVBQVUsR0FBRztJQUFFLGdCQUFnQixFQUFFLFVBQVUsQ0FBQTtDQUFFLGlCQWlCbkU7QUFFRCx3QkFBc0IsV0FBVyxDQUFDLEVBQ2hDLE9BQU8sRUFDUCxPQUFPLEVBQ1AsVUFBVSxFQUNWLFFBQVEsRUFDUixhQUFhLEVBQ2IsR0FBRyxFQUNILFdBQVcsRUFDWixFQUFFLGlCQUFpQixHQUFHLFVBQVUsaUJBZ0JoQztBQUVELHdCQUFzQixpQkFBaUIsQ0FBQyxFQUN0QyxPQUFPLEVBQ1AsT0FBTyxFQUNQLGFBQWEsRUFDYixTQUFTLEVBQ1QsR0FBRyxFQUNILFdBQVcsRUFDWixFQUFFLGlCQUFpQixHQUFHLFVBQVUsR0FBRztJQUFFLFNBQVMsRUFBRSxNQUFNLENBQUE7Q0FBRSxpQkF5QnhEO0FBRUQsd0JBQXNCLFdBQVcsQ0FBQyxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsYUFBYSxFQUFFLEdBQUcsRUFBRSxFQUFFLGlCQUFpQixHQUFHLFVBQVUsaUJBd0J6RyJ9

package/dest/cmds/l1/update_l1_validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update_l1_validators.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/update_l1_validators.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAMhE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,UAAU,CAAC;IAC1B,iBAAiB,CAAC,EAAE,UAAU,CAAC;CAChC;AAED,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0BAA0B,EAAE,UAAU,CAAC;CACxC;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,KAAK,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,iBAAiB;;;EAOhC;AAED,wBAAsB,cAAc,CAAC,EACnC,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,eAAe,EACf,iBAAiB,EACjB,0BAA0B,EAC1B,WAAW,EACX,YAAY,EACZ,GAAG,EACH,WAAW,EACZ,EAAE,8BAA8B,GAC/B,UAAU,GAAG;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,UAAU,CAAC;IAC5B,iBAAiB,EAAE,UAAU,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;CACrB,iBAwFF;AAED,wBAAsB,uBAAuB,CAAC,EAC5C,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,oBAAoB,EACpB,aAAa,EACb,GAAG,EACH,WAAW,EACZ,EAAE,iBAAiB,GAClB,UAAU,GAAG;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,UAAU,CAAC;IAC5B,oBAAoB,EAAE,OAAO,CAAC;CAC/B,iBAuDF;AAED,wBAAsB,iBAAiB,CAAC,EACtC,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,GAAG,EACH,WAAW,EACZ,EAAE,iBAAiB,GAAG,UAAU,GAAG;IAAE,gBAAgB,EAAE,UAAU,CAAA;CAAE,iBAiBnE;AAED,wBAAsB,WAAW,CAAC,EAChC,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,GAAG,EACH,WAAW,EACZ,EAAE,iBAAiB,GAAG,UAAU,iBAgBhC;AAED,wBAAsB,iBAAiB,CAAC,EACtC,OAAO,EACP,OAAO,EACP,aAAa,EACb,SAAS,EACT,GAAG,EACH,WAAW,EACZ,EAAE,iBAAiB,GAAG,UAAU,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,iBAyBxD;AAED,wBAAsB,WAAW,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,EAAE,iBAAiB,GAAG,UAAU,iBAwBzG"}

package/dest/cmds/l1/update_l1_validators.js

@@ -0,0 +1,280 @@
+import { RollupAbi, StakingAssetHandlerAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+import { createEthereumChain, isAnvilTestChain } from '@aztec-labs/ethereum/chain';
+import { createExtendedL1Client, getPublicClient } from '@aztec-labs/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec-labs/ethereum/config';
+import { GSEContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import { createL1TxUtils } from '@aztec-labs/ethereum/l1-tx-utils';
+import { EthCheatCodes } from '@aztec-labs/ethereum/test';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { ZkPassportProofParams } from '@aztec-labs/stdlib/zkpassport';
+import { encodeFunctionData, formatEther, getContract, maxUint256 } from 'viem';
+import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+export function generateL1Account() {
+    const privateKey = generatePrivateKey();
+    const account = privateKeyToAccount(privateKey);
+    return {
+        privateKey,
+        address: account.address
+    };
+}
+export async function addL1Validator({ rpcUrls, chainId, privateKey, mnemonic, attesterAddress, withdrawerAddress, stakingAssetHandlerAddress, proofParams, blsSecretKey, log, debugLogger }) {
+    const dualLog = makeDualLog(log, debugLogger);
+    const account = getAccount(privateKey, mnemonic);
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+    const stakingAssetHandler = getContract({
+        address: stakingAssetHandlerAddress.toString(),
+        abi: StakingAssetHandlerAbi,
+        client: l1Client
+    });
+    const rollupAddress = await stakingAssetHandler.read.getRollup();
+    dualLog(`Adding validator ${attesterAddress} to rollup ${rollupAddress.toString()}`);
+    const rollup = getContract({
+        address: rollupAddress,
+        abi: RollupAbi,
+        client: l1Client
+    });
+    const gseAddress = await rollup.read.getGSE();
+    const gse = new GSEContract(l1Client, gseAddress);
+    const registrationTuple = await gse.makeRegistrationTuple(blsSecretKey);
+    const l1TxUtils = createL1TxUtils(l1Client, {
+        logger: debugLogger
+    });
+    const proofParamsObj = ZkPassportProofParams.fromBuffer(proofParams);
+    // Step 1: Claim STK tokens from the faucet
+    dualLog(`Claiming STK tokens from faucet`);
+    const { receipt: claimReceipt } = await l1TxUtils.sendAndMonitorTransaction({
+        to: stakingAssetHandlerAddress.toString(),
+        data: encodeFunctionData({
+            abi: StakingAssetHandlerAbi,
+            functionName: 'claim',
+            args: [
+                proofParamsObj.toViem()
+            ]
+        }),
+        abi: StakingAssetHandlerAbi
+    });
+    dualLog(`Claim transaction hash: ${claimReceipt.transactionHash}`);
+    await l1Client.waitForTransactionReceipt({
+        hash: claimReceipt.transactionHash
+    });
+    // Step 2: Approve the rollup to spend STK tokens
+    const stakingAssetAddress = await stakingAssetHandler.read.STAKING_ASSET();
+    dualLog(`Approving rollup to spend STK tokens`);
+    const { receipt: approveReceipt } = await l1TxUtils.sendAndMonitorTransaction({
+        to: stakingAssetAddress,
+        data: encodeFunctionData({
+            abi: TestERC20Abi,
+            functionName: 'approve',
+            args: [
+                rollupAddress,
+                maxUint256
+            ]
+        }),
+        abi: TestERC20Abi
+    });
+    await l1Client.waitForTransactionReceipt({
+        hash: approveReceipt.transactionHash
+    });
+    // Step 3: Deposit into the rollup to register as a validator
+    dualLog(`Depositing into rollup to register validator`);
+    const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+        to: rollupAddress,
+        data: encodeFunctionData({
+            abi: RollupAbi,
+            functionName: 'deposit',
+            args: [
+                attesterAddress.toString(),
+                withdrawerAddress.toString(),
+                registrationTuple.publicKeyInG1,
+                registrationTuple.publicKeyInG2,
+                registrationTuple.proofOfPossession,
+                false
+            ]
+        }),
+        abi: RollupAbi
+    });
+    dualLog(`Deposit transaction hash: ${receipt.transactionHash}`);
+    await l1Client.waitForTransactionReceipt({
+        hash: receipt.transactionHash
+    });
+    if (isAnvilTestChain(chainId)) {
+        dualLog(`Funding validator on L1`);
+        const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), debugLogger);
+        await cheatCodes.setBalance(attesterAddress, 10n ** 20n);
+    } else {
+        const balance = await l1Client.getBalance({
+            address: attesterAddress.toString()
+        });
+        dualLog(`Validator balance: ${formatEther(balance)} ETH`);
+        if (balance === 0n) {
+            dualLog(`WARNING: Proposer has no balance. Remember to fund it!`);
+        }
+    }
+}
+export async function addL1ValidatorViaRollup({ rpcUrls, chainId, privateKey, mnemonic, attesterAddress, withdrawerAddress, blsSecretKey, moveWithLatestRollup, rollupAddress, log, debugLogger }) {
+    const dualLog = makeDualLog(log, debugLogger);
+    const account = getAccount(privateKey, mnemonic);
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+    dualLog(`Adding validator ${attesterAddress} to rollup ${rollupAddress.toString()} via direct deposit`);
+    if (!withdrawerAddress) {
+        throw new Error(`Withdrawer address required`);
+    }
+    const rollup = getContract({
+        address: rollupAddress.toString(),
+        abi: RollupAbi,
+        client: l1Client
+    });
+    const gseAddress = await rollup.read.getGSE();
+    const gse = new GSEContract(l1Client, gseAddress);
+    const registrationTuple = await gse.makeRegistrationTuple(blsSecretKey);
+    const l1TxUtils = createL1TxUtils(l1Client, {
+        logger: debugLogger
+    });
+    const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+        to: rollupAddress.toString(),
+        data: encodeFunctionData({
+            abi: RollupAbi,
+            functionName: 'deposit',
+            args: [
+                attesterAddress.toString(),
+                withdrawerAddress.toString(),
+                registrationTuple.publicKeyInG1,
+                registrationTuple.publicKeyInG2,
+                registrationTuple.proofOfPossession,
+                moveWithLatestRollup
+            ]
+        }),
+        abi: StakingAssetHandlerAbi
+    });
+    dualLog(`Transaction hash: ${receipt.transactionHash}`);
+    await l1Client.waitForTransactionReceipt({
+        hash: receipt.transactionHash
+    });
+    if (isAnvilTestChain(chainId)) {
+        dualLog(`Funding validator on L1`);
+        const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), debugLogger);
+        await cheatCodes.setBalance(attesterAddress, 10n ** 20n);
+    } else {
+        const balance = await l1Client.getBalance({
+            address: attesterAddress.toString()
+        });
+        dualLog(`Validator balance: ${formatEther(balance)} ETH`);
+        if (balance === 0n) {
+            dualLog(`WARNING: Proposer has no balance. Remember to fund it!`);
+        }
+    }
+}
+export async function removeL1Validator({ rpcUrls, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, log, debugLogger }) {
+    const dualLog = makeDualLog(log, debugLogger);
+    const account = getAccount(privateKey, mnemonic);
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+    const l1TxUtils = createL1TxUtils(l1Client, {
+        logger: debugLogger
+    });
+    dualLog(`Removing validator ${validatorAddress.toString()} from rollup ${rollupAddress.toString()}`);
+    const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+        to: rollupAddress.toString(),
+        data: encodeFunctionData({
+            abi: RollupAbi,
+            functionName: 'initiateWithdraw',
+            args: [
+                validatorAddress.toString(),
+                validatorAddress.toString()
+            ]
+        })
+    });
+    dualLog(`Transaction hash: ${receipt.transactionHash}`);
+}
+export async function pruneRollup({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log, debugLogger }) {
+    const dualLog = makeDualLog(log, debugLogger);
+    const account = getAccount(privateKey, mnemonic);
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+    const l1TxUtils = createL1TxUtils(l1Client, {
+        logger: debugLogger
+    });
+    dualLog(`Trying prune`);
+    const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+        to: rollupAddress.toString(),
+        data: encodeFunctionData({
+            abi: RollupAbi,
+            functionName: 'prune'
+        })
+    });
+    dualLog(`Transaction hash: ${receipt.transactionHash}`);
+}
+export async function fastForwardEpochs({ rpcUrls, chainId, rollupAddress, numEpochs, log, debugLogger }) {
+    const dualLog = makeDualLog(log, debugLogger);
+    const publicClient = getPublicClient({
+        l1RpcUrls: rpcUrls,
+        l1ChainId: chainId
+    });
+    const rollup = getContract({
+        address: rollupAddress.toString(),
+        abi: RollupAbi,
+        client: publicClient
+    });
+    const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), debugLogger);
+    const currentSlot = await rollup.read.getCurrentSlot();
+    const l2SlotsInEpoch = await rollup.read.getEpochDuration();
+    const timestamp = await rollup.read.getTimestampForSlot([
+        currentSlot + l2SlotsInEpoch * numEpochs
+    ]);
+    dualLog(`Fast forwarding ${numEpochs} epochs to ${timestamp}`);
+    try {
+        await cheatCodes.warp(Number(timestamp), {
+            resetBlockInterval: true
+        });
+        dualLog(`Fast forwarded ${numEpochs} epochs to ${timestamp}`);
+    } catch (error) {
+        if (error instanceof Error && error.message.includes("is lower than or equal to previous block's timestamp")) {
+            dualLog(`Someone else fast forwarded the chain to a point after/equal to the target time`);
+        } else {
+            // Re-throw other errors
+            throw error;
+        }
+    }
+}
+export async function debugRollup({ rpcUrls, chainId, rollupAddress, log }) {
+    const config = getL1ContractsConfigEnvVars();
+    const publicClient = getPublicClient({
+        l1RpcUrls: rpcUrls,
+        l1ChainId: chainId
+    });
+    const rollup = new RollupContract(publicClient, rollupAddress);
+    const pendingNum = await rollup.getCheckpointNumber();
+    log(`Pending block num: ${pendingNum}`);
+    const provenNum = await rollup.getProvenCheckpointNumber();
+    log(`Proven block num: ${provenNum}`);
+    const validators = await rollup.getAttesters();
+    log(`Validators: ${validators.map((v)=>v.toString()).join(', ')}`);
+    const committee = await rollup.getCurrentEpochCommittee();
+    log(`Committee: ${committee?.map((v)=>v.toString()).join(', ')}`);
+    const archive = await rollup.archive();
+    log(`Archive: ${archive}`);
+    const epochNum = await rollup.getCurrentEpochNumber();
+    log(`Current epoch: ${epochNum}`);
+    const slot = await rollup.getSlotNumber();
+    log(`Current slot: ${slot}`);
+    const proposerDuringPrevL1Block = await rollup.getCurrentProposer();
+    log(`Proposer during previous L1 block: ${proposerDuringPrevL1Block}`);
+    const nextBlockTS = BigInt((await publicClient.getBlock()).timestamp + BigInt(config.ethereumSlotDuration));
+    const proposer = await rollup.getProposerAt(nextBlockTS);
+    log(`Proposer NOW: ${proposer.toString()}`);
+}
+function makeDualLog(log, debugLogger) {
+    return (msg)=>{
+        log(msg);
+        debugLogger.info(msg);
+    };
+}
+function getAccount(privateKey, mnemonic) {
+    if (!privateKey && !mnemonic) {
+        throw new Error('Either privateKey or mnemonic must be provided to create a wallet client');
+    }
+    const account = !privateKey ? mnemonicToAccount(mnemonic) : privateKeyToAccount(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}`);
+    return account;
+}

package/dest/cmds/misc/generate_bootnode_enr.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+export declare function generateEncodedBootnodeENR(privateKey: string, p2pIp: string, p2pPort: number, l1ChainId: number, log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGVfYm9vdG5vZGVfZW5yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY21kcy9taXNjL2dlbmVyYXRlX2Jvb3Rub2RlX2Vuci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUd4RCx3QkFBc0IsMEJBQTBCLENBQzlDLFVBQVUsRUFBRSxNQUFNLEVBQ2xCLEtBQUssRUFBRSxNQUFNLEVBQ2IsT0FBTyxFQUFFLE1BQU0sRUFDZixTQUFTLEVBQUUsTUFBTSxFQUNqQixHQUFHLEVBQUUsS0FBSyxpQkFJWCJ9

package/dest/cmds/misc/generate_bootnode_enr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_bootnode_enr.d.ts","sourceRoot":"","sources":["../../../src/cmds/misc/generate_bootnode_enr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAGxD,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,KAAK,iBAIX"}

package/dest/cmds/misc/generate_bootnode_enr.js

@@ -0,0 +1,5 @@
+import { createBootnodeENRandPeerId } from '@aztec-labs/p2p/enr';
+export async function generateEncodedBootnodeENR(privateKey, p2pIp, p2pPort, l1ChainId, log) {
+    const { enr } = await createBootnodeENRandPeerId(privateKey, p2pIp, p2pPort, l1ChainId);
+    log(`ENR: ${enr.encodeTxt()}`);
+}

package/dest/cmds/misc/generate_p2p_private_key.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+export declare function generateP2PPrivateKey(log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGVfcDJwX3ByaXZhdGVfa2V5LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY21kcy9taXNjL2dlbmVyYXRlX3AycF9wcml2YXRlX2tleS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUd4RCx3QkFBc0IscUJBQXFCLENBQUMsR0FBRyxFQUFFLEtBQUssaUJBS3JEIn0=

package/dest/cmds/misc/generate_p2p_private_key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_p2p_private_key.d.ts","sourceRoot":"","sources":["../../../src/cmds/misc/generate_p2p_private_key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAGxD,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,KAAK,iBAKrD"}

package/dest/cmds/misc/generate_p2p_private_key.js

@@ -0,0 +1,7 @@
+import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
+export async function generateP2PPrivateKey(log) {
+    const peerId = await createSecp256k1PeerId();
+    const exportedPeerId = Buffer.from(peerId.privateKey).toString('hex');
+    log(`Private key: ${exportedPeerId}`);
+    log(`Peer Id: ${peerId}`);
+}

package/dest/cmds/misc/generate_secret_key.d.ts

@@ -0,0 +1,5 @@
+import { Fr } from '@aztec-labs/aztec.js/fields';
+export declare function generateSecretKey(): {
+    secretKey: Fr;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGVfc2VjcmV0X2tleS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NtZHMvbWlzYy9nZW5lcmF0ZV9zZWNyZXRfa2V5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVqRCx3QkFBZ0IsaUJBQWlCOztFQUVoQyJ9

package/dest/cmds/misc/generate_secret_key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_secret_key.d.ts","sourceRoot":"","sources":["../../../src/cmds/misc/generate_secret_key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,6BAA6B,CAAC;AAEjD,wBAAgB,iBAAiB;;EAEhC"}

package/dest/cmds/misc/generate_secret_key.js

@@ -0,0 +1,6 @@
+import { Fr } from '@aztec-labs/aztec.js/fields';
+export function generateSecretKey() {
+    return {
+        secretKey: Fr.random()
+    };
+}

package/dest/cmds/misc/index.d.ts

@@ -0,0 +1,4 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { Command } from 'commander';
+export declare function injectCommands(program: Command, log: LogFn): Command;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL21pc2MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBSXpDLHdCQUFnQixjQUFjLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxXQTZEMUQifQ==

package/dest/cmds/misc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/misc/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,WA6D1D"}

package/dest/cmds/misc/index.js

@@ -0,0 +1,32 @@
+import { l1ChainIdOption, prettyPrintJSON } from '../../utils/commands.js';
+export function injectCommands(program, log) {
+    program.command('generate-keys').summary('Generates encryption and signing private keys.').description('Generates and encryption and signing private key pair.').option('--json', 'Output the keys in JSON format').action(async ({ json })=>{
+        const { generateSecretKey } = await import('./generate_secret_key.js');
+        const { secretKey } = generateSecretKey();
+        if (json) {
+            log(prettyPrintJSON({
+                secretKey: secretKey.toString()
+            }));
+        } else {
+            log(`Secret Key: ${secretKey}`);
+        }
+    });
+    program.command('generate-p2p-private-key').summary('Generates a LibP2P peer private key.').description('Generates a private key that can be used for running a node on a LibP2P network.').action(async ()=>{
+        const { generateP2PPrivateKey } = await import('./generate_p2p_private_key.js');
+        await generateP2PPrivateKey(log);
+    });
+    program.command('generate-bootnode-enr').summary('Generates the encoded ENR record for a bootnode.').description('Generates the encoded ENR record for a bootnode.').argument('<privateKey>', 'The peer id private key of the bootnode').argument('<p2pIp>', 'The bootnode P2P IP address').argument('<p2pPort>', 'The bootnode P2P port').addOption(l1ChainIdOption).action(async (privateKey, p2pIp, p2pPort, options)=>{
+        const { generateEncodedBootnodeENR } = await import('./generate_bootnode_enr.js');
+        await generateEncodedBootnodeENR(privateKey, p2pIp, p2pPort, options.l1ChainId, log);
+    });
+    program.command('decode-enr').summary('Decodes an ENR record').description('Decodes and ENR record').argument('<enr>', 'The encoded ENR string').action(async (enr)=>{
+        const { printENR } = await import('@aztec-labs/p2p/enr');
+        await printENR(enr, log);
+    });
+    program.command('update').description('Updates Nodejs and Noir dependencies').argument('[projectPath]', 'Path to the project directory', process.cwd()).option('--contract [paths...]', 'Paths to contracts to update dependencies', []).option('--aztec-version <semver>', 'The version to update Aztec packages to. Defaults to latest', 'latest').action(async (projectPath, options)=>{
+        const { updateProject } = await import('./update.js');
+        const { contract, aztecVersion } = options;
+        await updateProject(projectPath, contract, aztecVersion, log);
+    });
+    return program;
+}