@aztec/cli 0.17.0 → 0.77.0-testnet-ignition.17

package/README.md

@@ -4,19 +4,13 @@ The Aztec CLI `aztec-cli` is a command-line interface (CLI) tool for interacting
 
 ## Installation
 
-To use `aztec-cli`, you need to have Node.js installed on your system. Follow these steps to install and set up the CLI tool:
+1. In your terminal, download the sandbox by running
 
-1. Install Node.js: Visit the official Node.js website (https://nodejs.org) and download the installer for your operating system. Follow the installation instructions to install Node.js.
-
-2. Install `aztec-cli` package: Open a terminal or command prompt and run the following command to install `aztec-cli` globally on your system:
-
-   ```shell
-   npm install -g @aztec/cli
-   ```
-
-   This will install the `aztec-cli` globally, making it accessible from any location in your terminal.
+```
+bash -i <(curl -s https://install.aztec.network)
+```
 
-3. Verify the installation: After the installation is complete, run the following command to verify that `aztec-cli` is installed correctly:
+2. Verify the installation: After the installation is complete, run the following command to verify that `aztec-cli` is installed correctly:
 
    ```shell
    aztec-cli --version
@@ -41,11 +35,10 @@ Replace `<command>` with the actual command you want to execute and `[options]`
 Some options can be set globally as environment variables to avoid having to re-enter them every time you call `aztec-cli.`
 These options are:
 
-- `PRIVATE_KEY` -> `-k, --private-key` for all commands that require a private key.
+- `SECRET_KEY` -> `-sk, --secret-key` for all commands that require an Aztec secret key.
 - `PUBLIC_KEY` -> `-k, --public-key` for all commands that require a public key.
 - `PXE_URL` -> `-u, --rpc-url` for commands that require a PXE
-- `API_KEY` -> `a, --api-key` for `deploy-l1-contracts`.
-- `ETHEREUM_RPC_HOST` -> `-u, --rpc-url` for `deploy-l1-contracts`.
+- `ETHEREUM_HOSTS` -> `-u, --rpc-urls` or `--l1-rpc-urls` for `deploy-l1-contracts`.
 
 So if for example you are running your Private eXecution Environment (PXE) remotely you can do:
 
@@ -76,7 +69,7 @@ aztec-cli deploy-l1-contracts [rpcUrl] [options]
 
 Options:
 
-- `-a, --api-key <string>`: API key for the Ethereum host.
+- `-a, --l1-chain-id <string>`: Chain ID for the Ethereum host.
 - `-p, --private-key <string>`: The private key to use for deployment.
 - `-m, --mnemonic <string>`: The mnemonic to use in deployment. Default: `test test test test test test test test test test test junk`.
 
@@ -395,6 +388,7 @@ Syntax:
 ```shell
 aztec-cli get-logs --fromBlock <number>
 ```
+
 Options:
 
 - `-u, --rpc-url <string>`: URL of PXE Service. Default: `http://localhost:8080`.
@@ -428,7 +422,7 @@ This command retrieves and displays the current Aztec L2 block number.
 
 ### example-contracts
 
-Lists the contracts available in [@aztec/noir-contracts](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts)
+Lists the contracts available in [@aztec/noir-contracts](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-contracts)
 
 Syntax:
 

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

@@ -0,0 +1,4 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { Command } from 'commander';
+export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger): Command;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/contracts/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WA6B/E"}

package/dest/cmds/contracts/index.js

@@ -0,0 +1,12 @@
+export function injectCommands(program, log, debugLogger) {
+    program.command('inspect-contract').description('Shows list of external callable functions for a contract').argument('<contractArtifactFile>', `A compiled Noir contract's artifact in JSON format or name of a contract artifact exported by @aztec/noir-contracts.js`).action(async (contractArtifactFile)=>{
+        const { inspectContract } = await import('./inspect_contract.js');
+        await inspectContract(contractArtifactFile, debugLogger, log);
+    });
+    // Helper for users to decode hex strings into structs if needed.
+    program.command('parse-parameter-struct').description("Helper for parsing an encoded string into a contract's parameter struct.").argument('<encodedString>', 'The encoded hex string').requiredOption('-c, --contract-artifact <fileLocation>', "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts.js").requiredOption('-p, --parameter <parameterName>', 'The name of the struct parameter to decode into').action(async (encodedString, options)=>{
+        const { parseParameterStruct } = await import('./parse_parameter_struct.js');
+        await parseParameterStruct(encodedString, options.contractArtifact, options.parameter, log);
+    });
+    return program;
+}

package/dest/cmds/contracts/inspect_contract.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+export declare function inspectContract(contractArtifactFile: string, debugLogger: Logger, log: LogFn): Promise<void>;
+//# sourceMappingURL=inspect_contract.d.ts.map

package/dest/cmds/contracts/inspect_contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect_contract.d.ts","sourceRoot":"","sources":["../../../src/cmds/contracts/inspect_contract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAW3D,wBAAsB,eAAe,CAAC,oBAAoB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,iBA2BlG"}

package/dest/cmds/contracts/inspect_contract.js

@@ -0,0 +1,37 @@
+import { sha256 } from '@aztec/foundation/crypto';
+import { FunctionSelector, decodeFunctionSignature, decodeFunctionSignatureWithParameterNames } from '@aztec/stdlib/abi';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { getContractArtifact } from '../../utils/aztec.js';
+export async function inspectContract(contractArtifactFile, debugLogger, log) {
+    const contractArtifact = await getContractArtifact(contractArtifactFile, log);
+    const contractFns = contractArtifact.functions;
+    if (contractFns.length === 0) {
+        log(`No functions found for contract ${contractArtifact.name}`);
+    }
+    const contractClass = await getContractClassFromArtifact(contractArtifact);
+    const bytecodeLengthInFields = 1 + Math.ceil(contractClass.packedBytecode.length / 31);
+    log(`Contract class details:`);
+    log(`\tidentifier: ${contractClass.id.toString()}`);
+    log(`\tartifact hash: ${contractClass.artifactHash.toString()}`);
+    log(`\tprivate function tree root: ${contractClass.privateFunctionsRoot.toString()}`);
+    log(`\tpublic bytecode commitment: ${contractClass.publicBytecodeCommitment.toString()}`);
+    log(`\tpublic bytecode length: ${contractClass.packedBytecode.length} bytes (${bytecodeLengthInFields} fields)`);
+    const externalFunctions = contractFns.filter((f)=>!f.isInternal);
+    if (externalFunctions.length > 0) {
+        log(`\nExternal functions:`);
+        await Promise.all(externalFunctions.map((f)=>logFunction(f, log)));
+    }
+    const internalFunctions = contractFns.filter((f)=>f.isInternal);
+    if (internalFunctions.length > 0) {
+        log(`\nInternal functions:`);
+        await Promise.all(internalFunctions.map((f)=>logFunction(f, log)));
+    }
+}
+async function logFunction(fn, log) {
+    const signatureWithParameterNames = decodeFunctionSignatureWithParameterNames(fn.name, fn.parameters);
+    const signature = decodeFunctionSignature(fn.name, fn.parameters);
+    const selector = await FunctionSelector.fromSignature(signature);
+    const bytecodeSize = fn.bytecode.length;
+    const bytecodeHash = sha256(fn.bytecode).toString('hex');
+    log(`${fn.functionType} ${signatureWithParameterNames} \n\tfunction signature: ${signature}\n\tselector: ${selector}\n\tbytecode: ${bytecodeSize} bytes (sha256 ${bytecodeHash})`);
+}

package/dest/cmds/{parse_parameter_struct.d.ts → contracts/parse_parameter_struct.d.ts}

@@ -1,6 +1,3 @@
-import { LogFn } from '@aztec/foundation/log';
-/**
- *
- */
+import type { LogFn } from '@aztec/foundation/log';
 export declare function parseParameterStruct(encodedString: string, contractArtifactPath: string, parameterName: string, log: LogFn): Promise<void>;
 //# sourceMappingURL=parse_parameter_struct.d.ts.map

package/dest/cmds/contracts/parse_parameter_struct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_parameter_struct.d.ts","sourceRoot":"","sources":["../../../src/cmds/contracts/parse_parameter_struct.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAMnD,wBAAsB,oBAAoB,CACxC,aAAa,EAAE,MAAM,EACrB,oBAAoB,EAAE,MAAM,EAC5B,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,KAAK,iBAeX"}

package/dest/cmds/contracts/parse_parameter_struct.js

@@ -0,0 +1,13 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { getContractArtifact } from '../../utils/aztec.js';
+import { parseStructString } from '../../utils/encoding.js';
+export async function parseParameterStruct(encodedString, contractArtifactPath, parameterName, log) {
+    const contractArtifact = await getContractArtifact(contractArtifactPath, log);
+    const parameterAbitype = contractArtifact.functions.map(({ parameters })=>parameters).flat().find(({ name, type })=>name === parameterName && type.kind === 'struct');
+    if (!parameterAbitype) {
+        log(`No struct parameter found with name ${parameterName}`);
+        return;
+    }
+    const data = parseStructString(encodedString, parameterAbitype.type);
+    log(`\nStruct Data: \n${jsonStringify(data, true)}\n`);
+}

package/dest/cmds/devnet/bootstrap_network.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+export declare function bootstrapNetwork(pxeUrl: string, l1Urls: string[], l1ChainId: string, l1PrivateKey: `0x${string}` | undefined, l1Mnemonic: string, addressIndex: number, json: boolean, log: LogFn, debugLog: Logger): Promise<void>;
+//# sourceMappingURL=bootstrap_network.d.ts.map

package/dest/cmds/devnet/bootstrap_network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap_network.d.ts","sourceRoot":"","sources":["../../../src/cmds/devnet/bootstrap_network.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAiB3D,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EAAE,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,EACvC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,KAAK,EACV,QAAQ,EAAE,MAAM,iBA4EjB"}

package/dest/cmds/devnet/bootstrap_network.js

@@ -0,0 +1,196 @@
+import { getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
+import { BatchCall, Fr, L1FeeJuicePortalManager, createCompatibleClient, retryUntil } from '@aztec/aztec.js';
+import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
+import { createEthereumChain, createL1Clients, deployL1Contract } from '@aztec/ethereum';
+import { getContract } from 'viem';
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+const waitOpts = {
+    timeout: 120,
+    provenTimeout: 4800,
+    interval: 1
+};
+export async function bootstrapNetwork(pxeUrl, l1Urls, l1ChainId, l1PrivateKey, l1Mnemonic, addressIndex, json, log, debugLog) {
+    const pxe = await createCompatibleClient(pxeUrl, debugLog);
+    const [wallet] = await getDeployedTestAccountsWallets(pxe);
+    const l1Clients = createL1Clients(l1Urls, l1PrivateKey ? privateKeyToAccount(l1PrivateKey) : // Note that this account needs to be funded on L1 !
+    mnemonicToAccount(l1Mnemonic, {
+        addressIndex
+    }), createEthereumChain(l1Urls, +l1ChainId).chainInfo);
+    const { erc20Address, portalAddress } = await deployERC20(l1Clients);
+    const { token, bridge } = await deployToken(wallet, portalAddress);
+    await initPortal(pxe, l1Clients, erc20Address, portalAddress, bridge.address);
+    const fpcAdmin = wallet.getAddress();
+    const fpc = await deployFPC(wallet, token.address, fpcAdmin);
+    const counter = await deployCounter(wallet);
+    await fundFPC(counter.address, wallet, l1Clients, fpc.address, debugLog);
+    if (json) {
+        log(JSON.stringify({
+            devCoinL1: erc20Address.toString(),
+            devCoinPortalL1: portalAddress.toString(),
+            devCoin: {
+                address: token.address.toString(),
+                initHash: token.initHash.toString(),
+                salt: token.salt.toString()
+            },
+            devCoinBridge: {
+                address: bridge.address.toString(),
+                initHash: bridge.initHash.toString(),
+                salt: bridge.salt.toString()
+            },
+            devCoinFpc: {
+                address: fpc.address.toString(),
+                initHash: fpc.initHash.toString(),
+                salt: fpc.salt.toString()
+            },
+            counter: {
+                address: counter.address.toString(),
+                initHash: counter.initHash.toString(),
+                salt: counter.salt.toString()
+            }
+        }, null, 2));
+    } else {
+        log(`DevCoin L1: ${erc20Address}`);
+        log(`DevCoin L1 Portal: ${portalAddress}`);
+        log(`DevCoin L2: ${token.address}`);
+        log(`DevCoin L2 init hash: ${token.initHash}`);
+        log(`DevCoin L2 salt: ${token.salt}`);
+        log(`DevCoin L2 Bridge: ${bridge.address}`);
+        log(`DevCoin L2 Bridge init hash: ${bridge.initHash}`);
+        log(`DevCoin L2 Bridge salt: ${bridge.salt}`);
+        log(`DevCoin FPC: ${fpc.address}`);
+        log(`DevCoin FPC init hash: ${fpc.initHash}`);
+        log(`DevCoin FPC salt: ${fpc.salt}`);
+        log(`Counter: ${counter.address}`);
+        log(`Counter init hash: ${counter.initHash}`);
+        log(`Counter salt: ${counter.salt}`);
+    }
+}
+/**
+ * Step 1. Deploy the L1 contracts, but don't initialize
+ */ async function deployERC20({ walletClient, publicClient }) {
+    const { TestERC20Abi, TestERC20Bytecode, TokenPortalAbi, TokenPortalBytecode } = await import('@aztec/l1-artifacts');
+    const erc20 = {
+        contractAbi: TestERC20Abi,
+        contractBytecode: TestERC20Bytecode
+    };
+    const portal = {
+        contractAbi: TokenPortalAbi,
+        contractBytecode: TokenPortalBytecode
+    };
+    const { address: erc20Address } = await deployL1Contract(walletClient, publicClient, erc20.contractAbi, erc20.contractBytecode, [
+        'DevCoin',
+        'DEV',
+        walletClient.account.address
+    ]);
+    const { address: portalAddress } = await deployL1Contract(walletClient, publicClient, portal.contractAbi, portal.contractBytecode);
+    return {
+        erc20Address,
+        portalAddress
+    };
+}
+/**
+ * Step 2. Deploy the L2 contracts
+ */ async function deployToken(wallet, l1Portal) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { TokenContract } = await import('@aztec/noir-contracts.js/Token');
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { TokenBridgeContract } = await import('@aztec/noir-contracts.js/TokenBridge');
+    const devCoin = await TokenContract.deploy(wallet, wallet.getAddress(), 'DevCoin', 'DEV', 18).send({
+        universalDeploy: true
+    }).deployed(waitOpts);
+    const bridge = await TokenBridgeContract.deploy(wallet, devCoin.address, l1Portal).send({
+        universalDeploy: true
+    }).deployed(waitOpts);
+    await new BatchCall(wallet, [
+        await devCoin.methods.set_minter(bridge.address, true).request(),
+        await devCoin.methods.set_admin(bridge.address).request()
+    ]).send().wait(waitOpts);
+    return {
+        token: {
+            address: devCoin.address,
+            initHash: devCoin.instance.initializationHash,
+            salt: devCoin.instance.salt
+        },
+        bridge: {
+            address: bridge.address,
+            initHash: bridge.instance.initializationHash,
+            salt: bridge.instance.salt
+        }
+    };
+}
+/**
+ * Step 3. Initialize DevCoin's L1 portal
+ */ async function initPortal(pxe, { walletClient, publicClient }, erc20, portal, bridge) {
+    const { TokenPortalAbi } = await import('@aztec/l1-artifacts');
+    const { l1ContractAddresses: { registryAddress } } = await pxe.getNodeInfo();
+    const contract = getContract({
+        abi: TokenPortalAbi,
+        address: portal.toString(),
+        client: walletClient
+    });
+    const hash = await contract.write.initialize([
+        registryAddress.toString(),
+        erc20.toString(),
+        bridge.toString()
+    ]);
+    await publicClient.waitForTransactionReceipt({
+        hash
+    });
+}
+async function deployFPC(wallet, tokenAddress, admin) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { FPCContract } = await import('@aztec/noir-contracts.js/FPC');
+    const fpc = await FPCContract.deploy(wallet, tokenAddress, admin).send({
+        universalDeploy: true
+    }).deployed(waitOpts);
+    const info = {
+        address: fpc.address,
+        initHash: fpc.instance.initializationHash,
+        salt: fpc.instance.salt
+    };
+    return info;
+}
+async function deployCounter(wallet) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { CounterContract } = await import('@aztec/noir-contracts.js/Counter');
+    const counter = await CounterContract.deploy(wallet, 1, wallet.getAddress()).send({
+        universalDeploy: true
+    }).deployed(waitOpts);
+    const info = {
+        address: counter.address,
+        initHash: counter.instance.initializationHash,
+        salt: counter.instance.salt
+    };
+    return info;
+}
+// NOTE: Disabling for now in order to get devnet running
+async function fundFPC(counterAddress, wallet, l1Clients, fpcAddress, debugLog) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { FeeJuiceContract } = await import('@aztec/noir-contracts.js/FeeJuice');
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { CounterContract } = await import('@aztec/noir-contracts.js/Counter');
+    const { protocolContractAddresses: { feeJuice } } = await wallet.getPXEInfo();
+    const feeJuiceContract = await FeeJuiceContract.at(feeJuice, wallet);
+    const feeJuicePortal = await L1FeeJuicePortalManager.new(wallet, l1Clients.publicClient, l1Clients.walletClient, debugLog);
+    const amount = FEE_FUNDING_FOR_TESTER_ACCOUNT;
+    const { claimAmount, claimSecret, messageLeafIndex, messageHash } = await feeJuicePortal.bridgeTokensPublic(fpcAddress, amount, true);
+    await retryUntil(async ()=>await wallet.isL1ToL2MessageSynced(Fr.fromHexString(messageHash)), 'message sync', 600, 1);
+    const counter = await CounterContract.at(counterAddress, wallet);
+    debugLog.info('Incrementing Counter');
+    // TODO (alexg) remove this once sequencer builds blocks continuously
+    // advance the chain
+    await counter.methods.increment(wallet.getAddress(), wallet.getAddress()).send().wait(waitOpts);
+    await counter.methods.increment(wallet.getAddress(), wallet.getAddress()).send().wait(waitOpts);
+    debugLog.info('Claiming FPC');
+    await feeJuiceContract.methods.claim(fpcAddress, claimAmount, claimSecret, messageLeafIndex).send().wait({
+        ...waitOpts,
+        proven: true
+    });
+    debugLog.info('Finished claiming FPC');
+}

package/dest/cmds/devnet/faucet.d.ts

@@ -0,0 +1,4 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+export declare function dripFaucet(faucetUrl: string, asset: string, account: EthAddress, json: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=faucet.d.ts.map

package/dest/cmds/devnet/faucet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faucet.d.ts","sourceRoot":"","sources":["../../../src/cmds/devnet/faucet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAInD,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,KAAK,GACT,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/dest/cmds/devnet/faucet.js

@@ -0,0 +1,26 @@
+import { prettyPrintJSON } from '../../utils/commands.js';
+export async function dripFaucet(faucetUrl, asset, account, json, log) {
+    const url = new URL(`/drip/${account.toString()}`, faucetUrl);
+    url.searchParams.set('asset', asset);
+    const res = await fetch(url);
+    if (res.status === 200) {
+        if (json) {
+            log(prettyPrintJSON({
+                ok: true
+            }));
+        } else {
+            log(`Dripped ${asset} for ${account.toString()}`);
+        }
+    } else {
+        if (json) {
+            log(prettyPrintJSON({
+                ok: false
+            }));
+        } else if (res.status === 429) {
+            log(`Rate limited when dripping ${asset} for ${account.toString()}`);
+        } else {
+            log(`Failed to drip ${asset} for ${account.toString()}`);
+        }
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { Command } from 'commander';
+export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger): Command;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/devnet/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WAqD/E"}

package/dest/cmds/devnet/index.js

@@ -0,0 +1,14 @@
+import { ETHEREUM_HOSTS, l1ChainIdOption, parseEthereumAddress, pxeOption } from '../../utils/commands.js';
+export function injectCommands(program, log, debugLogger) {
+    program.command('bootstrap-network').description('Bootstrap a new network').addOption(pxeOption).addOption(l1ChainIdOption).requiredOption('--l1-rpc-urls <string>', 'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)', (arg)=>arg.split(','), [
+        ETHEREUM_HOSTS
+    ]).option('--l1-private-key <string>', 'The private key to use for deployment', process.env.PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').option('-ai, --address-index <number>', 'The address index to use when calculating an address', (arg)=>BigInt(arg), 0n).option('--json', 'Output the result as JSON').action(async (options)=>{
+        const { bootstrapNetwork } = await import('./bootstrap_network.js');
+        await bootstrapNetwork(options[pxeOption.attributeName()], options.l1RpcUrls, options[l1ChainIdOption.attributeName()], options.l1PrivateKey, options.mnemonic, options.addressIndex, options.json, log, debugLogger);
+    });
+    program.command('drip-faucet').description('Drip the faucet').requiredOption('-u, --faucet-url <string>', 'Url of the faucet', 'http://localhost:8082').requiredOption('-t, --token <string>', 'The asset to drip', 'eth').requiredOption('-a, --address <string>', 'The Ethereum address to drip to', parseEthereumAddress).option('--json', 'Output the result as JSON').action(async (options)=>{
+        const { dripFaucet } = await import('./faucet.js');
+        await dripFaucet(options.faucetUrl, options.token, options.address, options.json, log);
+    });
+    return program;
+}

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

@@ -0,0 +1,4 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { Command } from 'commander';
+export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger): Command;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/infrastructure/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WAgD/E"}

package/dest/cmds/infrastructure/index.js

@@ -0,0 +1,24 @@
+import { ETHEREUM_HOSTS, l1ChainIdOption, parseOptionalInteger, pxeOption } from '../../utils/commands.js';
+export function injectCommands(program, log, debugLogger) {
+    program.command('setup-protocol-contracts').description('Bootstrap the blockchain by initializing all the protocol contracts').addOption(pxeOption).option('--testAccounts', 'Deploy funded test accounts.').option('--json', 'Output the contract addresses in JSON format').option('--skipProofWait', "Don't wait for proofs to land.").action(async (options)=>{
+        const { setupL2Contracts } = await import('./setup_l2_contract.js');
+        await setupL2Contracts(options.rpcUrl, options.testAccounts, options.json, options.skipProofWait, log);
+    });
+    program.command('sequencers').argument('<command>', 'Command to run: list, add, remove, who-next').argument('[who]', 'Who to add/remove').description('Manages or queries registered sequencers on the L1 rollup contract.').requiredOption('--l1-rpc-urls <string>', 'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)', (arg)=>arg.split(','), [
+        ETHEREUM_HOSTS
+    ]).option('-m, --mnemonic <string>', 'The mnemonic for the sender of the tx', 'test test test test test test test test test test test junk').option('--block-number <number>', 'Block number to query next sequencer for', parseOptionalInteger).addOption(pxeOption).addOption(l1ChainIdOption).action(async (command, who, options)=>{
+        const { sequencers } = await import('./sequencers.js');
+        await sequencers({
+            command: command,
+            who,
+            mnemonic: options.mnemonic,
+            rpcUrl: options.rpcUrl,
+            l1RpcUrls: options.l1RpcUrls.split(','),
+            chainId: options.l1ChainId,
+            blockNumber: options.blockNumber,
+            log,
+            debugLogger
+        });
+    });
+    return program;
+}

package/dest/cmds/infrastructure/sequencers.d.ts

@@ -0,0 +1,13 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+export declare function sequencers(opts: {
+    command: 'list' | 'add' | 'remove' | 'who-next';
+    who?: string;
+    mnemonic?: string;
+    rpcUrl: string;
+    l1RpcUrls: string[];
+    chainId: number;
+    blockNumber?: number;
+    log: LogFn;
+    debugLogger: Logger;
+}): Promise<void>;
+//# sourceMappingURL=sequencers.d.ts.map

package/dest/cmds/infrastructure/sequencers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencers.d.ts","sourceRoot":"","sources":["../../../src/cmds/infrastructure/sequencers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAM3D,wBAAsB,UAAU,CAAC,IAAI,EAAE;IACrC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,UAAU,CAAC;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,KAAK,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB,iBAoFA"}

package/dest/cmds/infrastructure/sequencers.js

@@ -0,0 +1,93 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { createEthereumChain, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
+import { mnemonicToAccount } from 'viem/accounts';
+export async function sequencers(opts) {
+    const { command, who: maybeWho, mnemonic, rpcUrl, l1RpcUrls, chainId, log, debugLogger } = opts;
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const { l1ContractAddresses } = await client.getNodeInfo();
+    const chain = createEthereumChain(l1RpcUrls, chainId);
+    const publicClient = createPublicClient({
+        chain: chain.chainInfo,
+        transport: fallback(l1RpcUrls.map((url)=>http(url)))
+    });
+    const walletClient = mnemonic ? createWalletClient({
+        account: mnemonicToAccount(mnemonic),
+        chain: chain.chainInfo,
+        transport: fallback(l1RpcUrls.map((url)=>http(url)))
+    }) : undefined;
+    const rollup = getContract({
+        address: l1ContractAddresses.rollupAddress.toString(),
+        abi: RollupAbi,
+        client: publicClient
+    });
+    const writeableRollup = walletClient ? getContract({
+        address: l1ContractAddresses.rollupAddress.toString(),
+        abi: RollupAbi,
+        client: walletClient
+    }) : undefined;
+    const who = maybeWho ?? walletClient?.account.address.toString();
+    if (command === 'list') {
+        const sequencers = await rollup.read.getAttesters();
+        if (sequencers.length === 0) {
+            log(`No sequencers registered on rollup`);
+        } else {
+            log(`Registered sequencers on rollup:`);
+            for (const sequencer of sequencers){
+                log(' ' + sequencer.toString());
+            }
+        }
+    } else if (command === 'add') {
+        if (!who || !writeableRollup || !walletClient) {
+            throw new Error(`Missing sequencer address`);
+        }
+        log(`Adding ${who} as sequencer`);
+        const stakingAsset = getContract({
+            address: await rollup.read.getStakingAsset(),
+            abi: TestERC20Abi,
+            client: walletClient
+        });
+        const config = getL1ContractsConfigEnvVars();
+        await Promise.all([
+            await stakingAsset.write.mint([
+                walletClient.account.address,
+                config.minimumStake
+            ], {}),
+            await stakingAsset.write.approve([
+                rollup.address,
+                config.minimumStake
+            ], {})
+        ].map((txHash)=>publicClient.waitForTransactionReceipt({
+                hash: txHash
+            })));
+        const hash = await writeableRollup.write.deposit([
+            who,
+            who,
+            who,
+            config.minimumStake
+        ]);
+        await publicClient.waitForTransactionReceipt({
+            hash
+        });
+        log(`Added in tx ${hash}`);
+    } else if (command === 'remove') {
+        if (!who || !writeableRollup) {
+            throw new Error(`Missing sequencer address`);
+        }
+        log(`Removing ${who} as sequencer`);
+        const hash = await writeableRollup.write.initiateWithdraw([
+            who,
+            who
+        ]);
+        await publicClient.waitForTransactionReceipt({
+            hash
+        });
+        log(`Removed in tx ${hash}`);
+    } else if (command === 'who-next') {
+        const next = await rollup.read.getCurrentProposer();
+        log(`Sequencer expected to build is ${next}`);
+    } else {
+        throw new Error(`Unknown command ${command}`);
+    }
+}

package/dest/cmds/infrastructure/setup_l2_contract.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec/foundation/log';
+export declare function setupL2Contracts(rpcUrl: string, testAccounts: boolean, json: boolean, skipProofWait: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=setup_l2_contract.d.ts.map

package/dest/cmds/infrastructure/setup_l2_contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup_l2_contract.d.ts","sourceRoot":"","sources":["../../../src/cmds/infrastructure/setup_l2_contract.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAKnD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,OAAO,EACrB,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,OAAO,EACtB,GAAG,EAAE,KAAK,iBAiCX"}

package/dest/cmds/infrastructure/setup_l2_contract.js

@@ -0,0 +1,43 @@
+import { deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
+import { SignerlessWallet, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { setupCanonicalL2FeeJuice } from '../misc/setup_contracts.js';
+export async function setupL2Contracts(rpcUrl, testAccounts, json, skipProofWait, log) {
+    const waitOpts = {
+        timeout: 180,
+        interval: 1,
+        proven: !skipProofWait,
+        provenTimeout: 600
+    };
+    log('setupL2Contracts: Wait options' + jsonStringify(waitOpts));
+    log('setupL2Contracts: Creating PXE client...');
+    const pxe = createPXEClient(rpcUrl, {}, makeFetch([
+        1,
+        1,
+        1,
+        1,
+        1
+    ], false));
+    const wallet = new SignerlessWallet(pxe);
+    log('setupL2Contracts: Getting fee juice portal address...');
+    // Deploy Fee Juice
+    const feeJuicePortalAddress = (await wallet.getNodeInfo()).l1ContractAddresses.feeJuicePortalAddress;
+    log('setupL2Contracts: Setting up fee juice portal...');
+    await setupCanonicalL2FeeJuice(wallet, feeJuicePortalAddress, waitOpts, log);
+    let deployedAccounts = [];
+    if (testAccounts) {
+        log('setupL2Contracts: Deploying test accounts...');
+        deployedAccounts = await getInitialTestAccounts();
+        await deployFundedSchnorrAccounts(pxe, deployedAccounts, waitOpts);
+    }
+    if (json) {
+        const toPrint = {
+            ...ProtocolContractAddress
+        };
+        deployedAccounts.forEach((a, i)=>{
+            toPrint[`testAccount${i}`] = a.address;
+        });
+        log(JSON.stringify(toPrint, null, 2));
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec/foundation/log';
+export declare function advanceEpoch(l1RpcUrls: string[], rpcUrl: string, log: LogFn): Promise<void>;
+//# sourceMappingURL=advance_epoch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"advance_epoch.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/advance_epoch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,iBAQjF"}