@aztec/cli 0.16.9 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

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,10 +35,9 @@ 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`.
 
 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.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.js

@@ -0,0 +1,37 @@
+import { getContractClassFromArtifact } from '@aztec/circuits.js';
+import { FunctionSelector, decodeFunctionSignature, decodeFunctionSignatureWithParameterNames } from '@aztec/foundation/abi';
+import { sha256 } from '@aztec/foundation/crypto';
+import { getContractArtifact } from '../../utils/aztec.js';
+export async function inspectContract(contractArtifactFile, debugLogger, log) {
+    const contractArtifact = await getContractArtifact(contractArtifactFile, log);
+    const contractFns = contractArtifact.functions.filter((f)=>f.name !== 'compute_note_hash_and_optionally_a_nullifier');
+    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/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.js

@@ -0,0 +1,193 @@
+import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import { BatchCall, L1FeeJuicePortalManager, createCompatibleClient, retryUntil } from '@aztec/aztec.js';
+import { FEE_FUNDING_FOR_TESTER_ACCOUNT, Fq, Fr } from '@aztec/circuits.js';
+import { createEthereumChain, createL1Clients, deployL1Contract } from '@aztec/ethereum';
+import { getContract } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+const waitOpts = {
+    timeout: 120,
+    provenTimeout: 4800,
+    interval: 1
+};
+export async function bootstrapNetwork(pxeUrl, l1Url, l1ChainId, l1PrivateKey, l1Mnemonic, json, log, debugLog) {
+    const pxe = await createCompatibleClient(pxeUrl, debugLog);
+    // setup a one-off account contract
+    const account = await getSchnorrAccount(pxe, Fr.random(), Fq.random(), Fr.random());
+    const wallet = await account.deploy().getWallet();
+    const l1Clients = createL1Clients(l1Url, l1PrivateKey ? privateKeyToAccount(l1PrivateKey) : l1Mnemonic, createEthereumChain(l1Url, +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);
+    // NOTE: Disabling for now in order to get devnet running
+    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);
+    // 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);
+    await feeJuiceContract.methods.claim(fpcAddress, claimAmount, claimSecret, messageLeafIndex).send().wait({
+        ...waitOpts,
+        proven: true
+    });
+}

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.js

@@ -0,0 +1,12 @@
+import { ETHEREUM_HOST, 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-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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('--json', 'Output the result as JSON').action(async (options)=>{
+        const { bootstrapNetwork } = await import('./bootstrap_network.js');
+        await bootstrapNetwork(options[pxeOption.attributeName()], options.l1RpcUrl, options[l1ChainIdOption.attributeName()], options.l1PrivateKey, options.mnemonic, 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.js

@@ -0,0 +1,22 @@
+import { ETHEREUM_HOST, 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).addOption(l1ChainIdOption).option('--json', 'Output the contract addresses in JSON format').option('--skipProofWait', "Don't wait for proofs to land.").action(async (options)=>{
+        const { setupProtocolContracts } = await import('./setup_protocol_contract.js');
+        await setupProtocolContracts(options.rpcUrl, options.l1ChainId, 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-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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,
+            l1RpcUrl: options.l1RpcUrl,
+            chainId: options.l1ChainId,
+            blockNumber: options.blockNumber,
+            log,
+            debugLogger
+        });
+    });
+    return program;
+}

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, getContract, http } from 'viem';
+import { mnemonicToAccount } from 'viem/accounts';
+export async function sequencers(opts) {
+    const { command, who: maybeWho, mnemonic, rpcUrl, l1RpcUrl, chainId, log, debugLogger } = opts;
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const { l1ContractAddresses } = await client.getNodeInfo();
+    const chain = createEthereumChain(l1RpcUrl, chainId);
+    const publicClient = createPublicClient({
+        chain: chain.chainInfo,
+        transport: http(chain.rpcUrl)
+    });
+    const walletClient = mnemonic ? createWalletClient({
+        account: mnemonicToAccount(mnemonic),
+        chain: chain.chainInfo,
+        transport: http(chain.rpcUrl)
+    }) : 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_protocol_contract.js

@@ -0,0 +1,31 @@
+import { SignerlessWallet, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { DefaultMultiCallEntrypoint } from '@aztec/aztec.js/entrypoint';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { setupCanonicalL2FeeJuice } from '../misc/setup_contracts.js';
+export async function setupProtocolContracts(rpcUrl, l1ChainId, json, skipProofWait, log) {
+    const waitOpts = {
+        timeout: 180,
+        interval: 1,
+        proven: !skipProofWait,
+        provenTimeout: 600
+    };
+    log('setupProtocolContracts: Wait options' + jsonStringify(waitOpts));
+    log('setupProtocolContracts: Creating PXE client...');
+    const pxe = createPXEClient(rpcUrl, makeFetch([
+        1,
+        1,
+        1,
+        1,
+        1
+    ], false));
+    const wallet = new SignerlessWallet(pxe, new DefaultMultiCallEntrypoint(l1ChainId, 1));
+    log('setupProtocolContracts: Getting fee juice portal address...');
+    // Deploy Fee Juice
+    const feeJuicePortalAddress = (await wallet.getNodeInfo()).l1ContractAddresses.feeJuicePortalAddress;
+    log('setupProtocolContracts: Setting up fee juice portal...');
+    await setupCanonicalL2FeeJuice(wallet, feeJuicePortalAddress, waitOpts, log);
+    if (json) {
+        log(JSON.stringify(ProtocolContractAddress, null, 2));
+    }
+}

package/dest/cmds/l1/advance_epoch.js

@@ -0,0 +1,10 @@
+import { CheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+export async function advanceEpoch(l1RpcUrl, rpcUrl, log) {
+    const pxe = createPXEClient(rpcUrl, makeFetch([], true));
+    const rollupAddress = await pxe.getNodeInfo().then((i)=>i.l1ContractAddresses.rollupAddress);
+    const cheat = CheatCodes.createRollup(l1RpcUrl, {
+        rollupAddress
+    });
+    await cheat.advanceToNextEpoch();
+    log(`Warped time to advance to next epoch`);
+}

package/dest/cmds/l1/assume_proven_through.js

@@ -0,0 +1,12 @@
+import { createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { setAssumeProvenThrough } from '../../utils/aztec.js';
+export async function assumeProvenThrough(blockNumberOrLatest, l1RpcUrl, rpcUrl, chainId, privateKey, mnemonic, log) {
+    const chain = createEthereumChain(l1RpcUrl, chainId);
+    const { walletClient } = createL1Clients(chain.rpcUrl, privateKey ?? mnemonic, chain.chainInfo);
+    const pxe = createPXEClient(rpcUrl, makeFetch([], true));
+    const rollupAddress = await pxe.getNodeInfo().then((i)=>i.l1ContractAddresses.rollupAddress);
+    const blockNumber = blockNumberOrLatest ?? await pxe.getBlockNumber();
+    await setAssumeProvenThrough(blockNumber, rollupAddress, walletClient);
+    log(`Assumed proven through block ${blockNumber}`);
+}

package/dest/cmds/l1/bridge_erc20.js

@@ -0,0 +1,31 @@
+import { L1ToL2TokenPortalManager } from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { prettyPrintJSON } from '../../utils/commands.js';
+export async function bridgeERC20(amount, recipient, l1RpcUrl, chainId, privateKey, mnemonic, tokenAddress, portalAddress, privateTransfer, mint, json, log, debugLogger) {
+    // Prepare L1 client
+    const chain = createEthereumChain(l1RpcUrl, chainId);
+    const { publicClient, walletClient } = createL1Clients(chain.rpcUrl, privateKey ?? mnemonic, chain.chainInfo);
+    // Setup portal manager
+    const manager = new L1ToL2TokenPortalManager(portalAddress, tokenAddress, publicClient, walletClient, debugLogger);
+    let claimSecret;
+    let messageHash;
+    if (privateTransfer) {
+        ({ claimSecret, messageHash } = await manager.bridgeTokensPrivate(recipient, amount, mint));
+    } else {
+        ({ claimSecret, messageHash } = await manager.bridgeTokensPublic(recipient, amount, mint));
+    }
+    if (json) {
+        log(prettyPrintJSON({
+            claimAmount: amount,
+            claimSecret: claimSecret
+        }));
+    } else {
+        if (mint) {
+            log(`Minted ${amount} tokens on L1 and pushed to L2 portal`);
+        } else {
+            log(`Bridged ${amount} tokens to L2 portal`);
+        }
+        log(`claimAmount=${amount},claimSecret=${claimSecret}\n,messageHash=${messageHash}`);
+        log(`Note: You need to wait for two L2 blocks before pulling them from the L2 side`);
+    }
+}

package/dest/cmds/l1/create_l1_account.js

@@ -0,0 +1,15 @@
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import { prettyPrintJSON } from '../../utils/commands.js';
+export function createL1Account(json, log) {
+    const privateKey = generatePrivateKey();
+    const account = privateKeyToAccount(privateKey);
+    if (json) {
+        log(prettyPrintJSON({
+            privateKey,
+            address: account.address
+        }));
+    } else {
+        log(`Private Key: ${privateKey}`);
+        log(`Address: ${account.address}`);
+    }
+}

package/dest/cmds/l1/deploy_l1_contracts.js

@@ -0,0 +1,25 @@
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { deployAztecContracts } from '../../utils/aztec.js';
+export async function deployL1Contracts(rpcUrl, chainId, privateKey, mnemonic, mnemonicIndex, salt, json, initialValidators, log, debugLogger) {
+    const config = getL1ContractsConfigEnvVars();
+    const { l1ContractAddresses } = await deployAztecContracts(rpcUrl, chainId, privateKey, mnemonic, mnemonicIndex, salt, initialValidators, config, debugLogger);
+    if (json) {
+        log(JSON.stringify(Object.fromEntries(Object.entries(l1ContractAddresses).map(([k, v])=>[
+                k,
+                v.toString()
+            ])), null, 2));
+    } else {
+        log(`Rollup Address: ${l1ContractAddresses.rollupAddress.toString()}`);
+        log(`Registry Address: ${l1ContractAddresses.registryAddress.toString()}`);
+        log(`L1 -> L2 Inbox Address: ${l1ContractAddresses.inboxAddress.toString()}`);
+        log(`L2 -> L1 Outbox Address: ${l1ContractAddresses.outboxAddress.toString()}`);
+        log(`Fee Juice Address: ${l1ContractAddresses.feeJuiceAddress.toString()}`);
+        log(`Staking Asset Address: ${l1ContractAddresses.stakingAssetAddress.toString()}`);
+        log(`Fee Juice Portal Address: ${l1ContractAddresses.feeJuicePortalAddress.toString()}`);
+        log(`CoinIssuer Address: ${l1ContractAddresses.coinIssuerAddress.toString()}`);
+        log(`RewardDistributor Address: ${l1ContractAddresses.rewardDistributorAddress.toString()}`);
+        log(`GovernanceProposer Address: ${l1ContractAddresses.governanceProposerAddress.toString()}`);
+        log(`Governance Address: ${l1ContractAddresses.governanceAddress.toString()}`);
+        log(`SlashFactory Address: ${l1ContractAddresses.slashFactoryAddress.toString()}`);
+    }
+}