@aztec/aztec 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/cli/cmds/start_node.js

@@ -0,0 +1,109 @@
+import { aztecNodeConfigMappings, getConfigEnvVars as getNodeConfigEnvVars } from '@aztec/aztec-node';
+import { AztecNodeApiSchema, P2PApiSchema } from '@aztec/circuit-types';
+import { NULL_KEY } from '@aztec/ethereum';
+import { initTelemetryClient, telemetryClientConfigMappings } from '@aztec/telemetry-client';
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+import { createAztecNode, deployContractsToL1 } from '../../sandbox.js';
+import { extractNamespacedOptions, extractRelevantOptions } from '../util.js';
+import { validateL1Config } from '../validation.js';
+export async function startNode(options, signalHandlers, services, userLog) {
+    // options specifically namespaced with --node.<option>
+    const nodeSpecificOptions = extractNamespacedOptions(options, 'node');
+    // All options that are relevant to the Aztec Node
+    const nodeConfig = {
+        ...extractRelevantOptions(options, aztecNodeConfigMappings, 'node')
+    };
+    if (options.proverNode) {
+        userLog(`Running a Prover Node within a Node is not yet supported`);
+        process.exit(1);
+    }
+    // Deploy contracts if needed
+    if (nodeSpecificOptions.deployAztecContracts || nodeSpecificOptions.deployAztecContractsSalt) {
+        let account;
+        if (nodeSpecificOptions.publisherPrivateKey) {
+            account = privateKeyToAccount(nodeSpecificOptions.publisherPrivateKey);
+        } else if (options.l1Mnemonic) {
+            account = mnemonicToAccount(options.l1Mnemonic);
+        } else {
+            throw new Error('--node.publisherPrivateKey or --l1-mnemonic is required to deploy L1 contracts');
+        }
+        // REFACTOR: We should not be calling a method from sandbox on the prod start flow
+        await deployContractsToL1(nodeConfig, account, undefined, {
+            assumeProvenThroughBlockNumber: nodeSpecificOptions.assumeProvenThroughBlockNumber,
+            salt: nodeSpecificOptions.deployAztecContractsSalt
+        });
+    } else {
+        await validateL1Config({
+            ...getNodeConfigEnvVars(),
+            ...nodeConfig
+        });
+    }
+    // if no publisher private key, then use l1Mnemonic
+    if (!options.archiver) {
+        // expect archiver url in node config
+        const archiverUrl = nodeConfig.archiverUrl;
+        if (!archiverUrl) {
+            userLog('Archiver Service URL is required to start Aztec Node without --archiver option');
+            throw new Error('Archiver Service URL is required to start Aztec Node without --archiver option');
+        }
+        nodeConfig.archiverUrl = archiverUrl;
+    }
+    if (!options.sequencer) {
+        nodeConfig.disableValidator = true;
+    } else {
+        const sequencerConfig = extractNamespacedOptions(options, 'sequencer');
+        let account;
+        if (!sequencerConfig.publisherPrivateKey || sequencerConfig.publisherPrivateKey === NULL_KEY) {
+            if (!options.l1Mnemonic) {
+                userLog('--sequencer.publisherPrivateKey or --l1-mnemonic is required to start Aztec Node with --sequencer option');
+                throw new Error('Private key or Mnemonic is required to start Aztec Node with --sequencer option');
+            } else {
+                account = mnemonicToAccount(options.l1Mnemonic);
+                const privKey = account.getHdKey().privateKey;
+                nodeConfig.publisherPrivateKey = `0x${Buffer.from(privKey).toString('hex')}`;
+            }
+        } else {
+            nodeConfig.publisherPrivateKey = sequencerConfig.publisherPrivateKey;
+        }
+    }
+    if (nodeConfig.p2pEnabled) {
+        // ensure bootstrapNodes is an array
+        if (nodeConfig.bootstrapNodes && typeof nodeConfig.bootstrapNodes === 'string') {
+            nodeConfig.bootstrapNodes = nodeConfig.bootstrapNodes.split(',');
+        }
+    }
+    const telemetryConfig = extractRelevantOptions(options, telemetryClientConfigMappings, 'tel');
+    const telemetry = initTelemetryClient(telemetryConfig);
+    // Create and start Aztec Node
+    const node = await createAztecNode(nodeConfig, {
+        telemetry
+    });
+    // Add node and p2p to services list
+    services.node = [
+        node,
+        AztecNodeApiSchema
+    ];
+    services.p2p = [
+        node.getP2P(),
+        P2PApiSchema
+    ];
+    // Add node stop function to signal handlers
+    signalHandlers.push(node.stop.bind(node));
+    // Add a PXE client that connects to this node if requested
+    let pxe;
+    if (options.pxe) {
+        const { addPXE } = await import('./start_pxe.js');
+        pxe = await addPXE(options, signalHandlers, services, userLog, {
+            node
+        });
+    }
+    // Add a txs bot if requested
+    if (options.bot) {
+        const { addBot } = await import('./start_bot.js');
+        await addBot(options, signalHandlers, services, {
+            pxe,
+            node,
+            telemetry
+        });
+    }
+}

package/dest/cli/cmds/start_p2p_bootstrap.js

@@ -0,0 +1,20 @@
+import { P2PBootstrapApiSchema } from '@aztec/circuit-types';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { BootstrapNode, bootnodeConfigMappings } from '@aztec/p2p';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+import { extractRelevantOptions } from '../util.js';
+export async function startP2PBootstrap(options, signalHandlers, services, userLog) {
+    // Start a P2P bootstrap node.
+    const config = extractRelevantOptions(options, bootnodeConfigMappings, 'p2p');
+    const telemetryClient = initTelemetryClient(getTelemetryClientConfig());
+    const store = await createStore('p2p-bootstrap', config, createLogger('p2p:bootstrap:store'));
+    const node = new BootstrapNode(store, telemetryClient);
+    await node.start(config);
+    signalHandlers.push(()=>node.stop());
+    services.bootstrap = [
+        node,
+        P2PBootstrapApiSchema
+    ];
+    userLog(`P2P bootstrap node started on ${config.udpListenAddress}`);
+}

package/dest/cli/cmds/start_proof_verifier.js

@@ -0,0 +1,12 @@
+import { ProofVerifier, proofVerifierConfigMappings } from '@aztec/proof-verifier';
+import { initTelemetryClient, telemetryClientConfigMappings } from '@aztec/telemetry-client';
+import { extractRelevantOptions } from '../util.js';
+export async function startProofVerifier(options, signalHandlers, userLog) {
+    const config = extractRelevantOptions(options, proofVerifierConfigMappings, 'proofVerifier');
+    const telemetryConfig = extractRelevantOptions(options, telemetryClientConfigMappings, 'tel');
+    const telemetry = initTelemetryClient(telemetryConfig);
+    const proofVerifier = await ProofVerifier.new(config, telemetry);
+    userLog('Starting proof verifier');
+    proofVerifier.start();
+    signalHandlers.push(()=>proofVerifier.stop());
+}

package/dest/cli/cmds/start_prover_agent.js

@@ -0,0 +1,32 @@
+import { times } from '@aztec/foundation/collection';
+import { buildServerCircuitProver } from '@aztec/prover-client';
+import { InlineProofStore, ProvingAgent, createProvingJobBrokerClient, proverAgentConfigMappings } from '@aztec/prover-client/broker';
+import { getProverNodeAgentConfigFromEnv } from '@aztec/prover-node';
+import { initTelemetryClient, telemetryClientConfigMappings } from '@aztec/telemetry-client';
+import { extractRelevantOptions } from '../util.js';
+export async function startProverAgent(options, signalHandlers, services, userLog) {
+    if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
+        userLog(`Starting a prover agent with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+        process.exit(1);
+    }
+    const config = {
+        ...getProverNodeAgentConfigFromEnv(),
+        ...extractRelevantOptions(options, proverAgentConfigMappings, 'proverAgent')
+    };
+    if (config.realProofs && (!config.bbBinaryPath || !config.acvmBinaryPath)) {
+        process.exit(1);
+    }
+    if (!config.proverBrokerUrl) {
+        process.exit(1);
+    }
+    const broker = createProvingJobBrokerClient(config.proverBrokerUrl);
+    const telemetry = initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
+    const prover = await buildServerCircuitProver(config, telemetry);
+    const proofStore = new InlineProofStore();
+    const agents = times(config.proverAgentCount, ()=>new ProvingAgent(broker, proofStore, prover, config.proverAgentProofTypes, config.proverAgentPollIntervalMs, telemetry));
+    await Promise.all(agents.map((agent)=>agent.start()));
+    signalHandlers.push(async ()=>{
+        await Promise.all(agents.map((agent)=>agent.stop()));
+        await telemetry.stop();
+    });
+}

package/dest/cli/cmds/start_prover_broker.js

@@ -0,0 +1,22 @@
+import { ProvingJobBrokerSchema, createAndStartProvingBroker, proverBrokerConfigMappings } from '@aztec/prover-client/broker';
+import { getProverNodeBrokerConfigFromEnv } from '@aztec/prover-node';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+import { extractRelevantOptions } from '../util.js';
+export async function startProverBroker(options, signalHandlers, services, userLog) {
+    if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
+        userLog(`Starting a prover broker with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+        process.exit(1);
+    }
+    const config = {
+        ...getProverNodeBrokerConfigFromEnv(),
+        ...extractRelevantOptions(options, proverBrokerConfigMappings, 'proverBroker')
+    };
+    const client = initTelemetryClient(getTelemetryClientConfig());
+    const broker = await createAndStartProvingBroker(config, client);
+    services.proverBroker = [
+        broker,
+        ProvingJobBrokerSchema
+    ];
+    signalHandlers.push(()=>broker.stop());
+    return broker;
+}

package/dest/cli/cmds/start_prover_node.js

@@ -0,0 +1,81 @@
+import { P2PApiSchema, ProverNodeApiSchema, createAztecNodeClient } from '@aztec/circuit-types';
+import { NULL_KEY } from '@aztec/ethereum';
+import { ProvingJobConsumerSchema, createProvingJobBrokerClient } from '@aztec/prover-client/broker';
+import { createProverNode, getProverNodeConfigFromEnv, proverNodeConfigMappings } from '@aztec/prover-node';
+import { initTelemetryClient, telemetryClientConfigMappings } from '@aztec/telemetry-client';
+import { mnemonicToAccount } from 'viem/accounts';
+import { extractRelevantOptions } from '../util.js';
+import { validateL1Config } from '../validation.js';
+import { startProverBroker } from './start_prover_broker.js';
+export async function startProverNode(options, signalHandlers, services, userLog) {
+    if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
+        userLog(`Starting a prover-node with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+        process.exit(1);
+    }
+    const proverConfig = {
+        ...getProverNodeConfigFromEnv(),
+        ...extractRelevantOptions(options, proverNodeConfigMappings, 'proverNode')
+    };
+    if (!options.archiver && !proverConfig.archiverUrl) {
+        userLog('--archiver.archiverUrl is required to start a Prover Node without --archiver option');
+        process.exit(1);
+    }
+    if (!proverConfig.publisherPrivateKey || proverConfig.publisherPrivateKey === NULL_KEY) {
+        if (!options.l1Mnemonic) {
+            userLog(`--l1-mnemonic is required to start a Prover Node without --node.publisherPrivateKey`);
+            process.exit(1);
+        }
+        const hdAccount = mnemonicToAccount(options.l1Mnemonic);
+        const privKey = hdAccount.getHdKey().privateKey;
+        proverConfig.publisherPrivateKey = `0x${Buffer.from(privKey).toString('hex')}`;
+    }
+    // TODO(palla/prover-node) L1 contract addresses should not silently default to zero,
+    // they should be undefined if not set and fail loudly.
+    // Load l1 contract addresses from aztec node if not set.
+    const isRollupAddressSet = proverConfig.l1Contracts?.rollupAddress && !proverConfig.l1Contracts.rollupAddress.isZero();
+    const nodeUrl = proverConfig.nodeUrl ?? proverConfig.proverCoordinationNodeUrl;
+    if (nodeUrl && !isRollupAddressSet) {
+        userLog(`Loading L1 contract addresses from aztec node at ${nodeUrl}`);
+        proverConfig.l1Contracts = await createAztecNodeClient(nodeUrl).getL1ContractAddresses();
+    }
+    // If we create an archiver here, validate the L1 config
+    if (options.archiver) {
+        await validateL1Config(proverConfig);
+    }
+    const telemetry = initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
+    let broker;
+    if (proverConfig.proverBrokerUrl) {
+        broker = createProvingJobBrokerClient(proverConfig.proverBrokerUrl);
+    } else if (options.proverBroker) {
+        broker = await startProverBroker(options, signalHandlers, services, userLog);
+    } else {
+        userLog(`--prover-broker-url or --prover-broker is required to start a Prover Node`);
+        process.exit(1);
+    }
+    if (proverConfig.proverAgentCount === 0) {
+        userLog(`Running prover node without local prover agent. Connect one or more prover agents to this node or pass --proverAgent.proverAgentCount`);
+    }
+    const proverNode = await createProverNode(proverConfig, {
+        telemetry,
+        broker
+    });
+    services.proverNode = [
+        proverNode,
+        ProverNodeApiSchema
+    ];
+    const p2p = proverNode.getP2P();
+    if (p2p) {
+        services.p2p = [
+            proverNode.getP2P(),
+            P2PApiSchema
+        ];
+    }
+    if (!proverConfig.proverBrokerUrl) {
+        services.provingJobSource = [
+            proverNode.getProver().getProvingJobSource(),
+            ProvingJobConsumerSchema
+        ];
+    }
+    signalHandlers.push(proverNode.stop.bind(proverNode));
+    await proverNode.start();
+}

package/dest/cli/cmds/start_pxe.js

@@ -0,0 +1,90 @@
+import { Fr, PublicKeys, getContractClassFromArtifact } from '@aztec/aztec.js';
+import { PXESchema, createAztecNodeClient } from '@aztec/circuit-types';
+import { getContractArtifact } from '@aztec/cli/cli-utils';
+import { AztecAddress, allPxeConfigMappings, createPXEService } from '@aztec/pxe';
+import { makeTracedFetch } from '@aztec/telemetry-client';
+import { L2BasicContractsMap, Network } from '@aztec/types/network';
+import { extractRelevantOptions } from '../util.js';
+const contractAddressesUrl = 'http://static.aztec.network';
+export async function startPXE(options, signalHandlers, services, userLog) {
+    await addPXE(options, signalHandlers, services, userLog, {});
+    return services;
+}
+function isValidNetwork(value) {
+    return Object.values(Network).includes(value);
+}
+async function fetchBasicContractAddresses(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch basic contract addresses from ${url}`);
+    }
+    return response.json();
+}
+export async function addPXE(options, signalHandlers, services, userLog, deps = {}) {
+    const pxeConfig = extractRelevantOptions(options, allPxeConfigMappings, 'pxe');
+    let nodeUrl;
+    if (pxeConfig.network) {
+        if (isValidNetwork(pxeConfig.network)) {
+            if (!pxeConfig.apiKey && !pxeConfig.nodeUrl) {
+                userLog(`API Key or Aztec Node URL is required to connect to ${pxeConfig.network}`);
+                process.exit(1);
+            } else if (pxeConfig.apiKey) {
+                nodeUrl = `https://api.aztec.network/${pxeConfig.network}/aztec-node-1/${pxeConfig.apiKey}`;
+            } else if (pxeConfig.nodeUrl) {
+                nodeUrl = pxeConfig.nodeUrl;
+            }
+        } else {
+            userLog(`Network ${pxeConfig.network} is not supported`);
+            process.exit(1);
+        }
+    } else {
+        nodeUrl = pxeConfig.nodeUrl;
+    }
+    if (!nodeUrl && !deps.node && !pxeConfig.network) {
+        userLog('Aztec Node URL (nodeUrl | AZTEC_NODE_URL) option is required to start PXE without --node option');
+        process.exit(1);
+    }
+    const node = deps.node ?? createAztecNodeClient(nodeUrl, makeTracedFetch([
+        1,
+        2,
+        3
+    ], true));
+    const pxe = await createPXEService(node, pxeConfig);
+    // register basic contracts
+    if (pxeConfig.network) {
+        userLog(`Registering basic contracts for ${pxeConfig.network}`);
+        const basicContractsInfo = await fetchBasicContractAddresses(`${contractAddressesUrl}/${pxeConfig.network}/basic_contracts.json`);
+        const l2Contracts = {};
+        for (const [key, artifactName] of Object.entries(L2BasicContractsMap[pxeConfig.network])){
+            l2Contracts[key] = {
+                name: key,
+                address: AztecAddress.fromString(basicContractsInfo[key].address),
+                initHash: Fr.fromHexString(basicContractsInfo[key].initHash),
+                salt: Fr.fromHexString(basicContractsInfo[key].salt),
+                artifact: await getContractArtifact(artifactName, userLog)
+            };
+        }
+        await Promise.all(Object.values(l2Contracts).map(async ({ name, address, artifact, initHash, salt })=>{
+            const instance = {
+                version: 1,
+                salt,
+                initializationHash: initHash,
+                address,
+                deployer: AztecAddress.ZERO,
+                contractClassId: (await getContractClassFromArtifact(artifact)).id,
+                publicKeys: PublicKeys.default()
+            };
+            userLog(`Registering ${name} at ${address.toString()}`);
+            await pxe.registerContract({
+                artifact,
+                instance
+            });
+        }));
+    }
+    // Add PXE to services list
+    services.pxe = [
+        pxe,
+        PXESchema
+    ];
+    return pxe;
+}

package/dest/cli/cmds/start_txe.js

@@ -0,0 +1,11 @@
+import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import { createTXERpcServer } from '@aztec/txe';
+export async function startTXE(options, debugLogger) {
+    debugLogger.info(`Setting up TXE...`);
+    const txeServer = createTXERpcServer(debugLogger);
+    const { port } = await startHttpRpcServer(txeServer, {
+        port: options.port,
+        timeoutMs: 1e3 * 60 * 5
+    });
+    debugLogger.info(`TXE listening on port ${port}`);
+}

package/dest/cli/index.js

@@ -0,0 +1 @@
+export * from './cli.js';

package/dest/cli/util.js

@@ -0,0 +1,154 @@
+import chalk from 'chalk';
+import { aztecStartOptions } from './aztec_start_options.js';
+export const installSignalHandlers = (logFn, cb)=>{
+    const shutdown = async ()=>{
+        logFn('Shutting down...');
+        if (cb) {
+            await Promise.all(cb);
+        }
+        process.exit(0);
+    };
+    process.removeAllListeners('SIGINT');
+    process.removeAllListeners('SIGTERM');
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    process.once('SIGINT', shutdown);
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    process.once('SIGTERM', shutdown);
+};
+/**
+ * Creates logs for the initial accounts
+ * @param accounts - The initial accounts
+ * @param pxe - A PXE instance to get the registered accounts
+ * @returns A string array containing the initial accounts details
+ */ export async function createAccountLogs(accountsWithSecretKeys, pxe) {
+    const registeredAccounts = await pxe.getRegisteredAccounts();
+    const accountLogStrings = [
+        `Initial Accounts:\n\n`
+    ];
+    for (const accountWithSecretKey of accountsWithSecretKeys){
+        const completeAddress = await accountWithSecretKey.account.getCompleteAddress();
+        if (registeredAccounts.find((a)=>a.equals(completeAddress))) {
+            accountLogStrings.push(` Address: ${completeAddress.address.toString()}\n`);
+            accountLogStrings.push(` Partial Address: ${completeAddress.partialAddress.toString()}\n`);
+            accountLogStrings.push(` Secret Key: ${accountWithSecretKey.secretKey.toString()}\n`);
+            accountLogStrings.push(` Master nullifier public key: ${completeAddress.publicKeys.masterNullifierPublicKey.toString()}\n`);
+            accountLogStrings.push(` Master incoming viewing public key: ${completeAddress.publicKeys.masterIncomingViewingPublicKey.toString()}\n\n`);
+            accountLogStrings.push(` Master outgoing viewing public key: ${completeAddress.publicKeys.masterOutgoingViewingPublicKey.toString()}\n\n`);
+            accountLogStrings.push(` Master tagging public key: ${completeAddress.publicKeys.masterTaggingPublicKey.toString()}\n\n`);
+        }
+    }
+    return accountLogStrings;
+}
+export function getMaxLengths(sections) {
+    let maxFlagLength = 0;
+    let maxDefaultLength = 0;
+    Object.values(sections).forEach((options)=>{
+        options.forEach((option)=>{
+            if (option.flag.length > maxFlagLength) {
+                maxFlagLength = option.flag.length;
+            }
+            const defaultLength = option.defaultValue ? option.defaultValue.length : 0;
+            if (defaultLength > maxDefaultLength) {
+                maxDefaultLength = defaultLength;
+            }
+        });
+    });
+    return [
+        maxFlagLength + 1,
+        maxDefaultLength + 1
+    ];
+}
+export function formatHelpLine(option, defaultValue, envVar, maxOptionLength, maxDefaultLength) {
+    const paddedOption = option.padEnd(maxOptionLength + 2, ' ');
+    const paddedDefault = defaultValue.padEnd(maxDefaultLength + 2, ' ');
+    return `${chalk.cyan(paddedOption)}${chalk.yellow(paddedDefault)}${chalk.green(envVar)}`;
+}
+const getDefaultOrEnvValue = (opt)=>{
+    let val;
+    // if the option is set in the environment, use that & parse it
+    if (opt.envVar && process.env[opt.envVar]) {
+        val = process.env[opt.envVar];
+        if (val && opt.parseVal) {
+            return opt.parseVal(val);
+        }
+    // if no env variable, use the default value
+    } else if (opt.defaultValue) {
+        val = opt.defaultValue;
+    }
+    return val;
+};
+// Function to add options dynamically
+export const addOptions = (cmd, options)=>{
+    options.forEach((opt)=>{
+        cmd.option(opt.flag, `${opt.description} (default: ${opt.defaultValue}) ($${opt.envVar})`, opt.parseVal ? opt.parseVal : (val)=>val, getDefaultOrEnvValue(opt));
+    });
+};
+export const printAztecStartHelpText = ()=>{
+    const helpTextLines = [
+        ''
+    ];
+    const [maxFlagLength, maxDefaultLength] = getMaxLengths(aztecStartOptions);
+    Object.keys(aztecStartOptions).forEach((category)=>{
+        helpTextLines.push(chalk.bold.blue(`  ${category}`));
+        helpTextLines.push('');
+        aztecStartOptions[category].forEach((opt)=>{
+            const defaultValueText = opt.defaultValue ? `(default: ${opt.printDefault ? opt.printDefault(opt.defaultValue) : opt.defaultValue})` : '';
+            const envVarText = opt.envVar ? `($${opt.envVar})` : '';
+            const flagText = `${opt.flag}`;
+            const paddedText = formatHelpLine(flagText, defaultValueText, envVarText, maxFlagLength, maxDefaultLength);
+            helpTextLines.push(`    ${paddedText}`);
+            helpTextLines.push(`          ${chalk.white(opt.description)}`);
+            helpTextLines.push('');
+        });
+    });
+    return helpTextLines.join('\n');
+};
+/**
+ * Extracts namespaced options from a key-value map.
+ * @param options - Key-value map of options.
+ * @param namespace - The namespace to extract.
+ * @returns Key-value map of namespaced options.
+ */ export const extractNamespacedOptions = (options, namespace)=>{
+    const extract = `${namespace}.`;
+    const namespacedOptions = {};
+    for(const key in options){
+        if (key.startsWith(extract)) {
+            namespacedOptions[key.replace(extract, '')] = options[key];
+        }
+    }
+    return namespacedOptions;
+};
+/**
+ * Extracts relevant options from a key-value map.
+ * @template T - The type of the relevant options.
+ * @param options - Key-value map of options.
+ * @param mappings - The mappings to extract.
+ * @param namespace - The namespace to extract for.
+ * @returns Key-value map of relevant options.
+ */ export const extractRelevantOptions = (options, mappings, namespace)=>{
+    const relevantOptions = {};
+    // Iterate over each key in the options
+    Object.keys(options).forEach((optionKey)=>{
+        const keyParts = optionKey.split('.');
+        const optionNamespace = keyParts.length > 1 ? keyParts[0] : '';
+        const mainKey = keyParts.length > 1 ? keyParts[1] : keyParts[0];
+        // Check if the key exists in the mappings
+        if (mainKey in mappings) {
+            // Check for duplicates in the options
+            const duplicates = Object.keys(options).filter((optKey)=>{
+                const optKeyParts = optKey.split('.');
+                return optKeyParts[1] === mainKey || optKeyParts[0] === mainKey;
+            });
+            // If duplicates are found, use the namespace to differentiate
+            if (duplicates.length > 1) {
+                if (namespace === optionNamespace) {
+                    relevantOptions[mainKey] = options[optionKey];
+                }
+            } else {
+                // If no duplicates, extract the value without considering the namespace
+                relevantOptions[mainKey] = options[optionKey];
+            }
+        }
+    });
+    return relevantOptions;
+};

package/dest/cli/validation.js

@@ -0,0 +1,25 @@
+import { getL1ContractsAddresses, getL1ContractsConfig, getPublicClient } from '@aztec/ethereum';
+/**
+ * Connects to L1 using the provided L1 RPC URL and reads all addresses and settings from the governance
+ * contract. For each key, compares it against the provided config (if it is not empty) and throws on mismatches.
+ */ export async function validateL1Config(config) {
+    const publicClient = getPublicClient(config);
+    const actualAddresses = await getL1ContractsAddresses(publicClient, config.l1Contracts.governanceAddress);
+    for(const keyStr in actualAddresses){
+        const key = keyStr;
+        const actual = actualAddresses[key];
+        const expected = config.l1Contracts[key];
+        if (expected !== undefined && !expected.isZero() && !actual.equals(expected)) {
+            throw new Error(`Expected L1 contract address ${key} to be ${expected} but found ${actual}`);
+        }
+    }
+    const actualConfig = await getL1ContractsConfig(publicClient, actualAddresses);
+    for(const keyStr in actualConfig){
+        const key = keyStr;
+        const actual = actualConfig[key];
+        const expected = config[key];
+        if (expected !== undefined && actual !== expected) {
+            throw new Error(`Expected L1 setting ${key} to be ${expected} but found ${actual}`);
+        }
+    }
+}

package/dest/examples/token.js

@@ -0,0 +1,53 @@
+import { getSingleKeyAccount } from '@aztec/accounts/single_key';
+import { Fr, createPXEClient } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/foundation/log';
+import { TokenContract } from '@aztec/noir-contracts.js/Token';
+const logger = createLogger('example:token');
+export const alicePrivateKey = Fr.random();
+export const bobPrivateKey = Fr.random();
+const url = 'http://localhost:8080';
+const pxe = createPXEClient(url);
+let aliceWallet;
+let bobWallet;
+const ALICE_MINT_BALANCE = 333n;
+const TRANSFER_AMOUNT = 33n;
+/**
+ * Main function.
+ */ async function main() {
+    logger.info('Running token contract test on HTTP interface.');
+    const aliceAccount = await getSingleKeyAccount(pxe, alicePrivateKey);
+    aliceWallet = await aliceAccount.waitSetup();
+    const bobAccount = await getSingleKeyAccount(pxe, bobPrivateKey);
+    bobWallet = await bobAccount.waitSetup();
+    const alice = aliceWallet.getCompleteAddress();
+    const bob = bobWallet.getCompleteAddress();
+    logger.info(`Created Alice and Bob accounts: ${alice.address.toString()}, ${bob.address.toString()}`);
+    logger.info('Deploying Token...');
+    const token = await TokenContract.deploy(aliceWallet, alice, 'TokenName', 'TokenSymbol', 18).send().deployed();
+    logger.info('Token deployed');
+    // Create the contract abstraction and link it to Alice's and Bob's wallet for future signing
+    const tokenAlice = await TokenContract.at(token.address, aliceWallet);
+    const tokenBob = await TokenContract.at(token.address, bobWallet);
+    // Mint tokens to Alice
+    logger.info(`Minting ${ALICE_MINT_BALANCE} more coins to Alice...`);
+    const from = aliceWallet.getAddress(); // we are setting from to Alice here because of TODO(#9887)
+    await tokenAlice.methods.mint_to_private(from, aliceWallet.getAddress(), ALICE_MINT_BALANCE).send().wait();
+    logger.info(`${ALICE_MINT_BALANCE} tokens were successfully minted by Alice and transferred to private`);
+    const balanceAfterMint = await tokenAlice.methods.balance_of_private(alice).simulate();
+    logger.info(`Tokens successfully minted. New Alice's balance: ${balanceAfterMint}`);
+    // We will now transfer tokens from Alice to Bob
+    logger.info(`Transferring ${TRANSFER_AMOUNT} tokens from Alice to Bob...`);
+    await tokenAlice.methods.transfer(bob, TRANSFER_AMOUNT).send().wait();
+    // Check the new balances
+    const aliceBalance = await tokenAlice.methods.balance_of_private(alice).simulate();
+    logger.info(`Alice's balance ${aliceBalance}`);
+    const bobBalance = await tokenBob.methods.balance_of_private(bob).simulate();
+    logger.info(`Bob's balance ${bobBalance}`);
+}
+main().then(()=>{
+    logger.info('Finished running successfully.');
+    process.exit(0);
+}).catch((err)=>{
+    logger.error('Error in main fn: ', err);
+    process.exit(1);
+});

package/dest/examples/util.js

@@ -0,0 +1,31 @@
+import { EthAddress } from '@aztec/aztec.js';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+/**
+ * Helper function to deploy ETH contracts.
+ * @param walletClient - A viem WalletClient.
+ * @param publicClient - A viem PublicClient.
+ * @param abi - The ETH contract's ABI (as abitype's Abi).
+ * @param bytecode  - The ETH contract's bytecode.
+ * @param args - Constructor arguments for the contract.
+ * @returns The ETH address the contract was deployed to.
+ */ export async function deployL1Contract(walletClient, publicClient, abi, bytecode, args = []) {
+    const hash = await walletClient.deployContract({
+        abi,
+        bytecode,
+        args
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+        hash
+    });
+    const contractAddress = receipt.contractAddress;
+    if (!contractAddress) {
+        throw new Error(`No contract address found in receipt: ${jsonStringify(receipt)}`);
+    }
+    return EthAddress.fromString(receipt.contractAddress);
+}
+/**
+ * Sleep for a given number of milliseconds.
+ * @param ms - the number of milliseconds to sleep for
+ */ export function delay(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}

package/dest/index.js

@@ -0,0 +1 @@
+export { createSandbox } from './sandbox.js';

package/dest/mnemonic.js

@@ -0,0 +1 @@
+export const DefaultMnemonic = 'test test test test test test test test test test test junk';