@aztec/aztec 0.0.0-test.0

package/dest/sandbox/sandbox.d.ts

@@ -0,0 +1,76 @@
+#!/usr/bin/env -S node --no-warnings
+import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { type BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import { Fr } from '@aztec/foundation/fields';
+import { type LogFn } from '@aztec/foundation/log';
+import { type PXEServiceConfig } from '@aztec/pxe/server';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { type HDAccount, type PrivateKeyAccount } from 'viem';
+/**
+ * Function to deploy our L1 contracts to the sandbox L1
+ * @param aztecNodeConfig - The Aztec Node Config
+ * @param hdAccount - Account for publishing L1 contracts
+ */
+export declare function deployContractsToL1(aztecNodeConfig: AztecNodeConfig, hdAccount: HDAccount | PrivateKeyAccount, contractDeployLogger?: import("@aztec/aztec.js").Logger, opts?: {
+    assumeProvenThroughBlockNumber?: number;
+    salt?: number;
+    genesisArchiveRoot?: Fr;
+    genesisBlockHash?: Fr;
+}): Promise<{
+    rollupAddress: import("@aztec/aztec.js").EthAddress;
+    registryAddress: import("@aztec/aztec.js").EthAddress;
+    inboxAddress: import("@aztec/aztec.js").EthAddress;
+    outboxAddress: import("@aztec/aztec.js").EthAddress;
+    feeJuiceAddress: import("@aztec/aztec.js").EthAddress;
+    feeJuicePortalAddress: import("@aztec/aztec.js").EthAddress;
+    coinIssuerAddress: import("@aztec/aztec.js").EthAddress;
+    rewardDistributorAddress: import("@aztec/aztec.js").EthAddress;
+    governanceProposerAddress: import("@aztec/aztec.js").EthAddress;
+    governanceAddress: import("@aztec/aztec.js").EthAddress;
+    stakingAssetAddress: import("@aztec/aztec.js").EthAddress;
+} & {
+    slashFactoryAddress?: import("@aztec/aztec.js").EthAddress | undefined;
+} & {
+    rollupAddress: import("@aztec/aztec.js").EthAddress;
+} & {
+    rollupAddress: import("@aztec/aztec.js").EthAddress;
+}>;
+/** Sandbox settings. */
+export type SandboxConfig = AztecNodeConfig & {
+    /** Mnemonic used to derive the L1 deployer private key.*/
+    l1Mnemonic: string;
+    /** Salt used to deploy L1 contracts.*/
+    l1Salt: string;
+    /** Whether to expose PXE service on sandbox start.*/
+    noPXE: boolean;
+    /** Whether to deploy test accounts on sandbox start.*/
+    testAccounts: boolean;
+};
+/**
+ * Create and start a new Aztec Node and PXE. Deploys L1 contracts.
+ * Does not start any HTTP services nor populate any initial accounts.
+ * @param config - Optional Sandbox settings.
+ */
+export declare function createSandbox(config: Partial<SandboxConfig> | undefined, userLog: LogFn): Promise<{
+    node: AztecNodeService;
+    pxe: import("@aztec/pxe/server").PXEService;
+    stop: () => Promise<void>;
+}>;
+/**
+ * Create and start a new Aztec RPC HTTP Server
+ * @param config - Optional Aztec node settings.
+ */
+export declare function createAztecNode(config?: Partial<AztecNodeConfig>, deps?: {
+    telemetry?: TelemetryClient;
+    blobSinkClient?: BlobSinkClientInterface;
+}, options?: {
+    prefilledPublicData?: PublicDataTreeLeaf[];
+}): Promise<AztecNodeService>;
+/**
+ * Create and start a new Aztec PXE HTTP Server
+ * @param config - Optional PXE settings.
+ */
+export declare function createAztecPXE(node: AztecNode, config?: Partial<PXEServiceConfig>): Promise<import("@aztec/pxe/server").PXEService>;
+//# sourceMappingURL=sandbox.d.ts.map

package/dest/sandbox/sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../../src/sandbox/sandbox.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,KAAK,eAAe,EAAE,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AAE7F,OAAO,EAAE,KAAK,uBAAuB,EAAwB,MAAM,yBAAyB,CAAC;AAU7F,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,KAAK,EAAgB,MAAM,uBAAuB,CAAC;AAGjE,OAAO,EAAE,KAAK,gBAAgB,EAAyC,MAAM,mBAAmB,CAAC;AACjG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,iBAAiB,EAA2D,MAAM,MAAM,CAAC;AAavH;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,SAAS,GAAG,iBAAiB,EACxC,oBAAoB,mCAAS,EAC7B,IAAI,GAAE;IAAE,8BAA8B,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,EAAE,CAAC;IAAC,gBAAgB,CAAC,EAAE,EAAE,CAAA;CAAO;;;;;;;;;;;;;;;;;;GA6BtH;AAED,wBAAwB;AACxB,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG;IAC5C,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,EAAE,OAAO,CAAC;IACf,uDAAuD;IACvD,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,MAAM,oCAA6B,EAAE,OAAO,EAAE,KAAK;;;;GAkGtF;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM,EACrC,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,eAAe,CAAC;IAAC,cAAc,CAAC,EAAE,uBAAuB,CAAA;CAAO,EACpF,OAAO,GAAE;IAAE,mBAAmB,CAAC,EAAE,kBAAkB,EAAE,CAAA;CAAO,6BAY7D;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,GAAE,OAAO,CAAC,gBAAgB,CAAM,mDAI3F"}

package/dest/sandbox/sandbox.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env -S node --no-warnings
+import { getSchnorrWallet } from '@aztec/accounts/schnorr';
+import { deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
+import { AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
+import { AnvilTestWatcher, EthCheatCodes, SignerlessWallet } from '@aztec/aztec.js';
+import { createBlobSinkClient } from '@aztec/blob-sink/client';
+import { setupCanonicalL2FeeJuice } from '@aztec/cli/setup-contracts';
+import { GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH } from '@aztec/constants';
+import { NULL_KEY, createEthereumChain, deployL1Contracts, getL1ContractsConfigEnvVars, waitForPublicClient } from '@aztec/ethereum';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+import { getGenesisValues } from '@aztec/world-state/testing';
+import { createPublicClient, fallback, http as httpViemTransport } from 'viem';
+import { mnemonicToAccount } from 'viem/accounts';
+import { foundry } from 'viem/chains';
+import { createAccountLogs } from '../cli/util.js';
+import { DefaultMnemonic } from '../mnemonic.js';
+import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
+import { getSponsoredFPCAddress, setupSponsoredFPC } from './sponsored_fpc.js';
+const logger = createLogger('sandbox');
+const localAnvil = foundry;
+/**
+ * Function to deploy our L1 contracts to the sandbox L1
+ * @param aztecNodeConfig - The Aztec Node Config
+ * @param hdAccount - Account for publishing L1 contracts
+ */ export async function deployContractsToL1(aztecNodeConfig, hdAccount, contractDeployLogger = logger, opts = {}) {
+    const chain = aztecNodeConfig.l1RpcUrls.length > 0 ? createEthereumChain(aztecNodeConfig.l1RpcUrls, aztecNodeConfig.l1ChainId) : {
+        chainInfo: localAnvil
+    };
+    await waitForPublicClient(aztecNodeConfig);
+    const l1Contracts = await deployL1Contracts(aztecNodeConfig.l1RpcUrls, hdAccount, chain.chainInfo, contractDeployLogger, {
+        ...getL1ContractsConfigEnvVars(),
+        ...aztecNodeConfig,
+        l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
+        vkTreeRoot: getVKTreeRoot(),
+        protocolContractTreeRoot,
+        genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
+        genesisBlockHash: opts.genesisBlockHash ?? new Fr(GENESIS_BLOCK_HASH),
+        salt: opts.salt
+    });
+    aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
+    return aztecNodeConfig.l1Contracts;
+}
+/**
+ * Create and start a new Aztec Node and PXE. Deploys L1 contracts.
+ * Does not start any HTTP services nor populate any initial accounts.
+ * @param config - Optional Sandbox settings.
+ */ export async function createSandbox(config = {}, userLog) {
+    // sandbox is meant for test envs. We should only need one l1RpcUrl
+    const l1RpcUrl = config.l1RpcUrls?.[0];
+    if (!l1RpcUrl) {
+        throw new Error('An L1 RPC URL is required');
+    }
+    if ((config.l1RpcUrls?.length || 0) > 1) {
+        logger.warn(`Multiple L1 RPC URLs provided. Sandbox will only use the first one: ${l1RpcUrl}`);
+    }
+    const aztecNodeConfig = {
+        ...getConfigEnvVars(),
+        ...config
+    };
+    const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
+    if (!aztecNodeConfig.publisherPrivateKey || aztecNodeConfig.publisherPrivateKey === NULL_KEY) {
+        const privKey = hdAccount.getHdKey().privateKey;
+        aztecNodeConfig.publisherPrivateKey = `0x${Buffer.from(privKey).toString('hex')}`;
+    }
+    if (!aztecNodeConfig.validatorPrivateKey || aztecNodeConfig.validatorPrivateKey === NULL_KEY) {
+        const privKey = hdAccount.getHdKey().privateKey;
+        aztecNodeConfig.validatorPrivateKey = `0x${Buffer.from(privKey).toString('hex')}`;
+    }
+    const initialAccounts = await (async ()=>{
+        if (config.testAccounts) {
+            if (aztecNodeConfig.p2pEnabled) {
+                userLog(`Not setting up test accounts as we are connecting to a network`);
+            } else if (config.noPXE) {
+                userLog(`Not setting up test accounts as we are not exposing a PXE`);
+            } else {
+                return await getInitialTestAccounts();
+            }
+        }
+        return [];
+    })();
+    const bananaFPC = await getBananaFPCAddress(initialAccounts);
+    const sponsoredFPC = await getSponsoredFPCAddress();
+    const fundedAddresses = initialAccounts.length ? [
+        ...initialAccounts.map((a)=>a.address),
+        bananaFPC,
+        sponsoredFPC
+    ] : [];
+    const { genesisArchiveRoot, genesisBlockHash, prefilledPublicData } = await getGenesisValues(fundedAddresses);
+    let watcher = undefined;
+    if (!aztecNodeConfig.p2pEnabled) {
+        const l1ContractAddresses = await deployContractsToL1(aztecNodeConfig, hdAccount, undefined, {
+            assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
+            genesisArchiveRoot,
+            genesisBlockHash,
+            salt: config.l1Salt ? parseInt(config.l1Salt) : undefined
+        });
+        const chain = aztecNodeConfig.l1RpcUrls.length > 0 ? createEthereumChain([
+            l1RpcUrl
+        ], aztecNodeConfig.l1ChainId) : {
+            chainInfo: localAnvil
+        };
+        const publicClient = createPublicClient({
+            chain: chain.chainInfo,
+            transport: fallback([
+                httpViemTransport(l1RpcUrl)
+            ])
+        });
+        watcher = new AnvilTestWatcher(new EthCheatCodes([
+            l1RpcUrl
+        ]), l1ContractAddresses.rollupAddress, publicClient);
+        watcher.setIsSandbox(true);
+        await watcher.start();
+    }
+    const telemetry = initTelemetryClient(getTelemetryClientConfig());
+    // Create a local blob sink client inside the sandbox, no http connectivity
+    const blobSinkClient = createBlobSinkClient();
+    const node = await createAztecNode(aztecNodeConfig, {
+        telemetry,
+        blobSinkClient
+    }, {
+        prefilledPublicData
+    });
+    const pxe = await createAztecPXE(node);
+    await setupCanonicalL2FeeJuice(new SignerlessWallet(pxe), aztecNodeConfig.l1Contracts.feeJuicePortalAddress, undefined, logger.info);
+    if (initialAccounts.length) {
+        userLog('Setting up funded test accounts...');
+        const accounts = await deployFundedSchnorrAccounts(pxe, initialAccounts);
+        const accountsWithSecrets = accounts.map((account, i)=>({
+                account,
+                secretKey: initialAccounts[i].secret
+            }));
+        const accLogs = await createAccountLogs(accountsWithSecrets, pxe);
+        userLog(accLogs.join(''));
+        const deployer = await getSchnorrWallet(pxe, initialAccounts[0].address, initialAccounts[0].signingKey);
+        await setupBananaFPC(initialAccounts, deployer, userLog);
+        await setupSponsoredFPC(deployer, userLog);
+    }
+    const stop = async ()=>{
+        await node.stop();
+        await watcher?.stop();
+    };
+    return {
+        node,
+        pxe,
+        stop
+    };
+}
+/**
+ * Create and start a new Aztec RPC HTTP Server
+ * @param config - Optional Aztec node settings.
+ */ export async function createAztecNode(config = {}, deps = {}, options = {}) {
+    // TODO(#12272): will clean this up. This is criminal.
+    const { l1Contracts, ...rest } = getConfigEnvVars();
+    const aztecNodeConfig = {
+        ...rest,
+        ...config,
+        l1Contracts: {
+            ...l1Contracts,
+            ...config.l1Contracts
+        }
+    };
+    logger.info('createAztecNode', aztecNodeConfig);
+    const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps, options);
+    return node;
+}
+/**
+ * Create and start a new Aztec PXE HTTP Server
+ * @param config - Optional PXE settings.
+ */ export async function createAztecPXE(node, config = {}) {
+    const pxeServiceConfig = {
+        ...getPXEServiceConfig(),
+        ...config
+    };
+    const pxe = await createPXEService(node, pxeServiceConfig);
+    return pxe;
+}

package/dest/sandbox/sponsored_fee_payment_method.d.ts

@@ -0,0 +1,23 @@
+import type { FeePaymentMethod } from '@aztec/aztec.js';
+import { type FunctionCall } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+/**
+ * A payment method that uses the SponsoredFPCContract to pay the fee unconditionally.
+ */
+export declare class SponsoredFeePaymentMethod implements FeePaymentMethod {
+    /**
+     * Contract which will pay the fee.
+     */
+    private paymentContract;
+    constructor(
+    /**
+     * Contract which will pay the fee.
+     */
+    paymentContract: AztecAddress);
+    static new(pxe: PXE): Promise<SponsoredFeePaymentMethod>;
+    getAsset(): Promise<AztecAddress>;
+    getFeePayer(): Promise<AztecAddress>;
+    getFunctionCalls(): Promise<FunctionCall[]>;
+}
+//# sourceMappingURL=sponsored_fee_payment_method.d.ts.map

package/dest/sandbox/sponsored_fee_payment_method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sponsored_fee_payment_method.d.ts","sourceRoot":"","sources":["../../src/sandbox/sponsored_fee_payment_method.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,EAAE,KAAK,YAAY,EAAkC,MAAM,mBAAmB,CAAC;AACtF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAI3D;;GAEG;AACH,qBAAa,yBAA0B,YAAW,gBAAgB;IAE9D;;OAEG;IACH,OAAO,CAAC,eAAe;;IAHvB;;OAEG;IACK,eAAe,EAAE,YAAY;WAG1B,GAAG,CAAC,GAAG,EAAE,GAAG;IAKzB,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC;IAIjC,WAAW,IAAI,OAAO,CAAC,YAAY,CAAC;IAI9B,gBAAgB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;CAalD"}

package/dest/sandbox/sponsored_fee_payment_method.js

@@ -0,0 +1,36 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { getDeployedSponsoredFPCAddress } from './sponsored_fpc.js';
+/**
+ * A payment method that uses the SponsoredFPCContract to pay the fee unconditionally.
+ */ export class SponsoredFeePaymentMethod {
+    paymentContract;
+    constructor(/**
+     * Contract which will pay the fee.
+     */ paymentContract){
+        this.paymentContract = paymentContract;
+    }
+    static async new(pxe) {
+        const sponsoredFPC = await getDeployedSponsoredFPCAddress(pxe);
+        return new SponsoredFeePaymentMethod(sponsoredFPC);
+    }
+    getAsset() {
+        return Promise.resolve(ProtocolContractAddress.FeeJuice);
+    }
+    getFeePayer() {
+        return Promise.resolve(this.paymentContract);
+    }
+    async getFunctionCalls() {
+        return [
+            {
+                name: 'sponsor_unconditionally',
+                to: this.paymentContract,
+                selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'),
+                type: FunctionType.PRIVATE,
+                isStatic: false,
+                args: [],
+                returnTypes: []
+            }
+        ];
+    }
+}

package/dest/sandbox/sponsored_fpc.d.ts

@@ -0,0 +1,6 @@
+import { type PXE, type Wallet } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+export declare function getSponsoredFPCAddress(): Promise<import("@aztec/aztec.js").AztecAddress>;
+export declare function setupSponsoredFPC(deployer: Wallet, log: LogFn): Promise<void>;
+export declare function getDeployedSponsoredFPCAddress(pxe: PXE): Promise<import("@aztec/aztec.js").AztecAddress>;
+//# sourceMappingURL=sponsored_fpc.d.ts.map

package/dest/sandbox/sponsored_fpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sponsored_fpc.d.ts","sourceRoot":"","sources":["../../src/sandbox/sponsored_fpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,GAAG,EACR,KAAK,MAAM,EAEZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAWnD,wBAAsB,sBAAsB,oDAE3C;AAED,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,iBAMnE;AAED,wBAAsB,8BAA8B,CAAC,GAAG,EAAE,GAAG,mDAO5D"}

package/dest/sandbox/sponsored_fpc.js

@@ -0,0 +1,26 @@
+import { Fr, getContractInstanceFromDeployParams } from '@aztec/aztec.js';
+import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
+const SPONSORED_FPC_SALT = new Fr(0);
+async function getSponsoredFPCInstance() {
+    return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, {
+        salt: SPONSORED_FPC_SALT
+    });
+}
+export async function getSponsoredFPCAddress() {
+    return (await getSponsoredFPCInstance()).address;
+}
+export async function setupSponsoredFPC(deployer, log) {
+    const deployed = await SponsoredFPCContract.deploy(deployer).send({
+        contractAddressSalt: SPONSORED_FPC_SALT,
+        universalDeploy: true
+    }).deployed();
+    log(`SponsoredFPC: ${deployed.address}`);
+}
+export async function getDeployedSponsoredFPCAddress(pxe) {
+    const fpc = await getSponsoredFPCAddress();
+    const contracts = await pxe.getContracts();
+    if (!contracts.find((c)=>c.equals(fpc))) {
+        throw new Error('SponsoredFPC not deployed.');
+    }
+    return fpc;
+}

package/dest/splash.d.ts

@@ -0,0 +1,3 @@
+export declare const splash: string;
+export declare const github = "https://github.com/AztecProtocol";
+//# sourceMappingURL=splash.d.ts.map

package/dest/splash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splash.d.ts","sourceRoot":"","sources":["../src/splash.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,EAAE,MAOkB,CAAC;AAExC,eAAO,MAAM,MAAM,qCAAqC,CAAC"}

package/dest/splash.js

@@ -0,0 +1,2 @@
+export const splash = '\n' + '               _\n' + '    /\\        | |\n' + '   /  \\    ___| |_ ___  ___ \n' + '  / /\\ \\  |_  / __/ _ \\/ __|\n' + ' / ____ \\  / /| ||  __/ (__ \n' + '/_/___ \\_\\/___|\\__\\___|\\___|\n';
+export const github = 'https://github.com/AztecProtocol';

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@aztec/aztec",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js"
+  },
+  "bin": "./dest/bin/index.js",
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Aztec Packages",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "start": "node --no-warnings ./dest/bin",
+    "start:debug": "node --inspect=0.0.0.0:9221 --no-warnings ./dest/bin",
+    "start:sandbox": "ETHEREUM_HOSTS=http://0.0.0.0:8545/ && yarn start start --sandbox",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "build:dev": "tsc -b --watch",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "run:example:token": "LOG_LEVEL='verbose' node ./dest/examples/token.js"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "dependencies": {
+    "@aztec/accounts": "0.0.0-test.0",
+    "@aztec/archiver": "0.0.0-test.0",
+    "@aztec/aztec-faucet": "0.0.0-test.0",
+    "@aztec/aztec-node": "0.0.0-test.0",
+    "@aztec/aztec.js": "0.0.0-test.0",
+    "@aztec/bb-prover": "0.0.0-test.0",
+    "@aztec/blob-sink": "0.0.0-test.0",
+    "@aztec/bot": "0.0.0-test.0",
+    "@aztec/builder": "0.0.0-test.0",
+    "@aztec/cli": "0.0.0-test.0",
+    "@aztec/cli-wallet": "0.0.0-test.0",
+    "@aztec/constants": "0.0.0-test.0",
+    "@aztec/entrypoints": "0.0.0-test.0",
+    "@aztec/ethereum": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/kv-store": "0.0.0-test.0",
+    "@aztec/noir-contracts.js": "0.0.0-test.0",
+    "@aztec/noir-protocol-circuits-types": "0.0.0-test.0",
+    "@aztec/p2p": "0.0.0-test.0",
+    "@aztec/p2p-bootstrap": "0.0.0-test.0",
+    "@aztec/protocol-contracts": "0.0.0-test.0",
+    "@aztec/prover-client": "0.0.0-test.0",
+    "@aztec/prover-node": "0.0.0-test.0",
+    "@aztec/pxe": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "@aztec/telemetry-client": "0.0.0-test.0",
+    "@aztec/txe": "0.0.0-test.0",
+    "@aztec/world-state": "0.0.0-test.0",
+    "@types/chalk": "^2.2.0",
+    "abitype": "^0.8.11",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "koa": "^2.14.2",
+    "koa-router": "^12.0.0",
+    "viem": "2.22.8"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/koa": "^2.13.6",
+    "jest": "^29.5.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/bin/index.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+//
+import { injectCommands as injectBuilderCommands } from '@aztec/builder';
+import { injectCommands as injectWalletCommands } from '@aztec/cli-wallet';
+import { injectCommands as injectContractCommands } from '@aztec/cli/contracts';
+import { injectCommands as injectDevnetCommands } from '@aztec/cli/devnet';
+import { injectCommands as injectInfrastructureCommands } from '@aztec/cli/infrastructure';
+import { injectCommands as injectL1Commands } from '@aztec/cli/l1';
+import { injectCommands as injectMiscCommands } from '@aztec/cli/misc';
+import { injectCommands as injectPXECommands } from '@aztec/cli/pxe';
+import { createConsoleLogger, createLogger } from '@aztec/foundation/log';
+import { fileURLToPath } from '@aztec/foundation/url';
+
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+
+import { injectAztecCommands } from '../cli/index.js';
+
+const userLog = createConsoleLogger();
+const debugLogger = createLogger('cli');
+
+/** CLI & full node main entrypoint */
+async function main() {
+  const shutdown = () => {
+    process.exit(0);
+  };
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
+
+  const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+  const cliVersion: string = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+  let program = new Command('aztec');
+  program.description('Aztec command line interface').version(cliVersion);
+  program = injectAztecCommands(program, userLog, debugLogger);
+  program = injectBuilderCommands(program);
+  program = injectContractCommands(program, userLog, debugLogger);
+  program = injectInfrastructureCommands(program, userLog, debugLogger);
+  program = injectL1Commands(program, userLog, debugLogger);
+  program = injectPXECommands(program, userLog, debugLogger);
+  program = injectMiscCommands(program, userLog);
+  program = injectDevnetCommands(program, userLog, debugLogger);
+  program = injectWalletCommands(program, userLog, debugLogger);
+
+  await program.parseAsync(process.argv);
+}
+
+main().catch(err => {
+  debugLogger.error(`Error in command execution`);
+  debugLogger.error(err + '\n' + err.stack);
+  // See https://nodejs.org/api/process.html#processexitcode
+  process.exitCode = 1;
+  throw err;
+});

package/src/cli/aztec_start_action.ts

@@ -0,0 +1,114 @@
+import {
+  type NamespacedApiHandlers,
+  createNamespacedSafeJsonRpcServer,
+  startHttpRpcServer,
+} from '@aztec/foundation/json-rpc/server';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { fileURLToPath } from '@aztec/foundation/url';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import { AztecNodeApiSchema, PXESchema } from '@aztec/stdlib/interfaces/client';
+import { getVersioningMiddleware } from '@aztec/stdlib/versioning';
+import { getOtelJsonRpcPropagationMiddleware } from '@aztec/telemetry-client';
+
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+
+import { createSandbox } from '../sandbox/index.js';
+import { github, splash } from '../splash.js';
+import { enrichEnvironmentWithChainConfig } from './chain_l2_config.js';
+import { extractNamespacedOptions, installSignalHandlers } from './util.js';
+import { getVersions } from './versioning.js';
+
+const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+const cliVersion: string = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+
+export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logger) {
+  // list of 'stop' functions to call when process ends
+  const signalHandlers: Array<() => Promise<void>> = [];
+  const services: NamespacedApiHandlers = {};
+  let config: ChainConfig | undefined = undefined;
+
+  if (options.sandbox) {
+    const sandboxOptions = extractNamespacedOptions(options, 'sandbox');
+    const nodeOptions = extractNamespacedOptions(options, 'node');
+    userLog(`${splash}\n${github}\n\n`);
+    userLog(`Setting up Aztec Sandbox ${cliVersion}, please stand by...`);
+
+    const { node, pxe, stop } = await createSandbox(
+      {
+        l1Mnemonic: options.l1Mnemonic,
+        l1RpcUrls: options.l1RpcUrls,
+        l1Salt: nodeOptions.deployAztecContractsSalt,
+        noPXE: sandboxOptions.noPXE,
+        testAccounts: sandboxOptions.testAccounts,
+      },
+      userLog,
+    );
+
+    // Start Node and PXE JSON-RPC server
+    signalHandlers.push(stop);
+    services.node = [node, AztecNodeApiSchema];
+    if (!sandboxOptions.noPXE) {
+      services.pxe = [pxe, PXESchema];
+    } else {
+      userLog(`Not exposing PXE API through JSON-RPC server`);
+    }
+  } else {
+    // If a network is specified, enrich the environment with the chain config
+    if (options.network) {
+      await enrichEnvironmentWithChainConfig(options.network);
+    }
+    if (options.node) {
+      const { startNode } = await import('./cmds/start_node.js');
+      ({ config } = await startNode(options, signalHandlers, services, userLog));
+    } else if (options.bot) {
+      const { startBot } = await import('./cmds/start_bot.js');
+      await startBot(options, signalHandlers, services, userLog);
+    } else if (options.proverNode) {
+      const { startProverNode } = await import('./cmds/start_prover_node.js');
+      ({ config } = await startProverNode(options, signalHandlers, services, userLog));
+    } else if (options.blobSink) {
+      const { startBlobSink } = await import('./cmds/start_blob_sink.js');
+      await startBlobSink(options, signalHandlers, userLog);
+    } else if (options.pxe) {
+      const { startPXE } = await import('./cmds/start_pxe.js');
+      ({ config } = await startPXE(options, signalHandlers, services, userLog));
+    } else if (options.archiver) {
+      const { startArchiver } = await import('./cmds/start_archiver.js');
+      ({ config } = await startArchiver(options, signalHandlers, services));
+    } else if (options.p2pBootstrap) {
+      const { startP2PBootstrap } = await import('./cmds/start_p2p_bootstrap.js');
+      ({ config } = await startP2PBootstrap(options, signalHandlers, services, userLog));
+    } else if (options.proverAgent) {
+      const { startProverAgent } = await import('./cmds/start_prover_agent.js');
+      await startProverAgent(options, signalHandlers, services, userLog);
+    } else if (options.proverBroker) {
+      const { startProverBroker } = await import('./cmds/start_prover_broker.js');
+      await startProverBroker(options, signalHandlers, services, userLog);
+    } else if (options.txe) {
+      const { startTXE } = await import('./cmds/start_txe.js');
+      await startTXE(options, debugLogger);
+    } else if (options.sequencer) {
+      userLog(`Cannot run a standalone sequencer without a node`);
+      process.exit(1);
+    } else if (options.faucet) {
+      const { startFaucet } = await import('./cmds/start_faucet.js');
+      await startFaucet(options, signalHandlers, services, userLog);
+    } else {
+      userLog(`No module specified to start`);
+      process.exit(1);
+    }
+  }
+
+  installSignalHandlers(debugLogger.info, signalHandlers);
+  const versions = getVersions(config);
+  if (Object.entries(services).length > 0) {
+    const rpcServer = createNamespacedSafeJsonRpcServer(services, {
+      http200OnError: false,
+      log: debugLogger,
+      middlewares: [getOtelJsonRpcPropagationMiddleware(), getVersioningMiddleware(versions)],
+    });
+    const { port } = await startHttpRpcServer(rpcServer, { port: options.port });
+    debugLogger.info(`Aztec Server listening on port ${port}`, versions);
+  }
+}