@aztec/cli 0.7.10 → 0.8.4

package/src/client.ts

@@ -1,4 +1,4 @@
-import { AztecRPC, createAztecRpcClient } from '@aztec/aztec.js';
+import { PXE, createPXEClient } from '@aztec/aztec.js';
 import { DebugLogger } from '@aztec/foundation/log';
 import { fileURLToPath } from '@aztec/foundation/url';
 
@@ -7,51 +7,42 @@ import { dirname, resolve } from 'path';
 import { gtr, ltr, satisfies, valid } from 'semver';
 
 /**
- * Creates an Aztec RPC client with a given set of retries on non-server errors.
- * @param rpcUrl - URL of the RPC server.
- * @returns An RPC client.
- */
-export function createClient(rpcUrl: string) {
-  return createAztecRpcClient(rpcUrl);
-}
-
-/**
- * Creates an Aztec RPC client with a given set of retries on non-server errors.
- * Checks that the RPC server matches the expected version, and warns if not.
- * @param rpcUrl - URL of the RPC server.
+ * Creates a PXE client with a given set of retries on non-server errors.
+ * Checks that PXE matches the expected version, and warns if not.
+ * @param rpcUrl - URL of the RPC server wrapping the PXE.
  * @param logger - Debug logger to warn version incompatibilities.
- * @returns An RPC client.
+ * @returns A PXE client.
  */
 export async function createCompatibleClient(rpcUrl: string, logger: DebugLogger) {
-  const client = createClient(rpcUrl);
+  const pxe = createPXEClient(rpcUrl);
   const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../package.json');
   const packageJsonContents = JSON.parse(readFileSync(packageJsonPath).toString());
   const expectedVersionRange = packageJsonContents.version; // During sandbox, we'll expect exact matches
 
   try {
-    await checkServerVersion(client, expectedVersionRange);
+    await checkServerVersion(pxe, expectedVersionRange);
   } catch (err) {
     if (err instanceof VersionMismatchError) {
-      logger.debug(err.message);
+      logger.warn(err.message);
     } else {
       throw err;
     }
   }
 
-  return client;
+  return pxe;
 }
 
 /** Mismatch between server and client versions. */
 class VersionMismatchError extends Error {}
 
 /**
- * Checks that the RPC server version matches the expected one by this CLI. Throws if not.
- * @param rpc - RPC server connection.
+ * Checks that Private eXecution Environment (PXE) version matches the expected one by this CLI. Throws if not.
+ * @param pxe - PXE client.
  * @param expectedVersionRange - Expected version by CLI.
  */
-export async function checkServerVersion(rpc: AztecRPC, expectedVersionRange: string) {
+export async function checkServerVersion(pxe: PXE, expectedVersionRange: string) {
   const serverName = 'Aztec Sandbox';
-  const { sandboxVersion } = await rpc.getNodeInfo();
+  const { sandboxVersion } = await pxe.getNodeInfo();
   if (!sandboxVersion) {
     throw new VersionMismatchError(`Couldn't determine ${serverName} version. You may run into issues.`);
   }

package/src/encoding.ts

@@ -91,7 +91,9 @@ function encodeArg(arg: string, abiType: ABIType, name: string): any {
 export function encodeArgs(args: any[], params: ABIParameter[]) {
   if (args.length !== params.length) {
     throw new Error(
-      `Invalid number of args provided. Expected: ${params.length}, received: ${args.length}\nReceived args: ${args}`,
+      `Invalid args provided.\nExpected args: [${params
+        .map(param => param.name + ': ' + param.type.kind)
+        .join(', ')}]\nReceived args: ${args.join(', ')}`,
     );
   }
   return args.map((arg: any, index) => {

package/src/index.ts

@@ -1,10 +1,9 @@
 import {
-  AztecAddress,
   Contract,
   ContractDeployer,
   Fr,
   GrumpkinScalar,
-  Point,
+  NotePreimage,
   generatePublicKey,
   getSchnorrAccount,
   isContractDeployed,
@@ -14,12 +13,13 @@ import { JsonStringify } from '@aztec/foundation/json-rpc';
 import { DebugLogger, LogFn } from '@aztec/foundation/log';
 import { fileURLToPath } from '@aztec/foundation/url';
 import { compileContract, generateNoirInterface, generateTypescriptInterface } from '@aztec/noir-compiler/cli';
-import { CompleteAddress, ContractData, L2BlockL2Logs, TxHash } from '@aztec/types';
+import { CompleteAddress, ContractData, L2BlockL2Logs } from '@aztec/types';
 
-import { Command } from 'commander';
+import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
+import { Command, Option } from 'commander';
 import { readFileSync } from 'fs';
-import startCase from 'lodash.startcase';
 import { dirname, resolve } from 'path';
+import { format } from 'util';
 import { mnemonicToAccount } from 'viem/accounts';
 
 import { createCompatibleClient } from './client.js';
@@ -31,19 +31,20 @@ import {
   getContractAbi,
   getExampleContractArtifacts,
   getTxSender,
+  parseAztecAddress,
+  parseField,
+  parseFields,
+  parsePartialAddress,
+  parsePrivateKey,
+  parsePublicKey,
+  parseSaltFromHexString,
+  parseTxHash,
   prepTx,
 } from './utils.js';
 
 const accountCreationSalt = Fr.ZERO;
 
-const stripLeadingHex = (hex: string) => {
-  if (hex.length > 2 && hex.startsWith('0x')) {
-    return hex.substring(2);
-  }
-  return hex;
-};
-
-const { ETHEREUM_HOST, AZTEC_RPC_HOST, PRIVATE_KEY, API_KEY } = process.env;
+const { ETHEREUM_HOST = 'http://localhost:8545', PRIVATE_KEY, API_KEY } = process.env;
 
 /**
  * Returns commander program that defines the CLI.
@@ -59,36 +60,46 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
 
   program.name('aztec-cli').description('CLI for interacting with Aztec.').version(version);
 
+  const pxeOption = new Option('-u, --rpc-url <string>', 'URL of the PXE')
+    .env('PXE_URL')
+    .default('http://localhost:8080')
+    .makeOptionMandatory(true);
+
+  const createPrivateKeyOption = (description: string, mandatory: boolean) =>
+    new Option('-k, --private-key <string>', description)
+      .env('PRIVATE_KEY')
+      .argParser(parsePrivateKey)
+      .makeOptionMandatory(mandatory);
+
   program
     .command('deploy-l1-contracts')
     .description('Deploys all necessary Ethereum contracts for Aztec.')
-    .option(
+    .requiredOption(
       '-u, --rpc-url <string>',
       'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
-      ETHEREUM_HOST || 'http://localhost:8545',
+      ETHEREUM_HOST,
     )
     .option('-a, --api-key <string>', 'Api key for the ethereum host', API_KEY)
-    .option('-p, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .requiredOption('-p, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
     .option(
       '-m, --mnemonic <string>',
       'The mnemonic to use in deployment',
       'test test test test test test test test test test test junk',
     )
     .action(async options => {
-      const { rollupAddress, registryAddress, inboxAddress, outboxAddress, contractDeploymentEmitterAddress } =
-        await deployAztecContracts(
-          options.rpcUrl,
-          options.apiKey ?? '',
-          options.privateKey,
-          options.mnemonic,
-          debugLogger,
-        );
+      const { l1ContractAddresses } = await deployAztecContracts(
+        options.rpcUrl,
+        options.apiKey ?? '',
+        options.privateKey,
+        options.mnemonic,
+        debugLogger,
+      );
       log('\n');
-      log(`Rollup Address: ${rollupAddress.toString()}`);
-      log(`Registry Address: ${registryAddress.toString()}`);
-      log(`L1 -> L2 Inbox Address: ${inboxAddress.toString()}`);
-      log(`L2 -> L1 Outbox address: ${outboxAddress.toString()}`);
-      log(`Contract Deployment Emitter Address: ${contractDeploymentEmitterAddress.toString()}`);
+      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(`Contract Deployment Emitter Address: ${l1ContractAddresses.contractDeploymentEmitterAddress.toString()}`);
       log('\n');
     });
 
@@ -118,23 +129,30 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
       log(`\nPrivate Key: ${privKey}\nPublic Key: ${publicKey.toString()}\n`);
     });
 
+  program
+    .command('generate-p2p-private-key')
+    .summary('Generates a LibP2P peer private key.')
+    .description('Generates a private key that can be used for running a node on a LibP2P network.')
+    .action(async () => {
+      const peerId = await createSecp256k1PeerId();
+      const exportedPeerId = Buffer.from(peerId.privateKey!).toString('hex');
+      log(`Private key: ${exportedPeerId}`);
+      log(`Peer Id: ${peerId}`);
+    });
+
   program
     .command('create-account')
     .description(
-      'Creates an aztec account that can be used for sending transactions. Registers the account on the RPC server and deploys an account contract. Uses a Schnorr single-key account which uses the same key for encryption and authentication (not secure for production usage).',
+      'Creates an aztec account that can be used for sending transactions. Registers the account on the PXE and deploys an account contract. Uses a Schnorr single-key account which uses the same key for encryption and authentication (not secure for production usage).',
     )
     .summary('Creates an aztec account that can be used for sending transactions.')
-    .option(
-      '-k, --private-key <string>',
-      'Private key for note encryption and transaction signing. Uses random by default.',
-      PRIVATE_KEY,
+    .addOption(
+      createPrivateKeyOption('Private key for note encryption and transaction signing. Uses random by default.', false),
     )
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .addOption(pxeOption)
     .action(async options => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const privateKey = options.privateKey
-        ? GrumpkinScalar.fromString(stripLeadingHex(options.privateKey))
-        : GrumpkinScalar.random();
+      const privateKey = options.privateKey ?? GrumpkinScalar.random();
 
       const account = getSchnorrAccount(client, privateKey, privateKey, accountCreationSalt);
       const wallet = await account.waitDeploy();
@@ -155,46 +173,57 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
       "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
     )
     .option('-a, --args <constructorArgs...>', 'Contract constructor arguments', [])
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .addOption(pxeOption)
     .option(
       '-k, --public-key <string>',
       'Optional encryption public key for this address. Set this value only if this contract is expected to receive private notes, which will be encrypted using this public key.',
+      parsePublicKey,
     )
-    .option('-s, --salt <string>', 'Optional deployment salt as a hex string for generating the deployment address.')
-    .action(async (abiPath, options: any) => {
+    .option(
+      '-s, --salt <hex string>',
+      'Optional deployment salt as a hex string for generating the deployment address.',
+      parseSaltFromHexString,
+    )
+    // `options.wait` is default true. Passing `--no-wait` will set it to false.
+    // https://github.com/tj/commander.js#other-option-types-negatable-boolean-and-booleanvalue
+    .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction')
+    .action(async (abiPath, { rpcUrl, publicKey, args: rawArgs, salt, wait }) => {
       const contractAbi = await getContractAbi(abiPath, log);
       const constructorAbi = contractAbi.functions.find(({ name }) => name === 'constructor');
 
-      const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const publicKey = options.publicKey ? Point.fromString(options.publicKey) : undefined;
-      const salt = options.salt ? Fr.fromBuffer(Buffer.from(stripLeadingHex(options.salt), 'hex')) : undefined;
+      const client = await createCompatibleClient(rpcUrl, debugLogger);
       const deployer = new ContractDeployer(contractAbi, client, publicKey);
 
       const constructor = getAbiFunction(contractAbi, 'constructor');
       if (!constructor) throw new Error(`Constructor not found in contract ABI`);
-      if (constructor.parameters.length !== options.args.length) {
-        throw new Error(
-          `Invalid number of args passed (expected ${constructor.parameters.length} but got ${options.args.length})`,
-        );
-      }
 
-      debugLogger(`Input arguments: ${options.args.map((x: any) => `"${x}"`).join(', ')}`);
-      const args = encodeArgs(options.args, constructorAbi!.parameters);
+      debugLogger(`Input arguments: ${rawArgs.map((x: any) => `"${x}"`).join(', ')}`);
+      const args = encodeArgs(rawArgs, constructorAbi!.parameters);
       debugLogger(`Encoded arguments: ${args.join(', ')}`);
+
       const tx = deployer.deploy(...args).send({ contractAddressSalt: salt });
-      debugLogger(`Deploy tx sent with hash ${await tx.getTxHash()}`);
-      const deployed = await tx.wait();
-      log(`\nContract deployed at ${deployed.contractAddress!.toString()}\n`);
+      const txHash = await tx.getTxHash();
+      debugLogger(`Deploy tx sent with hash ${txHash}`);
+      if (wait) {
+        const deployed = await tx.wait();
+        log(`\nContract deployed at ${deployed.contractAddress!.toString()}\n`);
+      } else {
+        log(`\nDeployment transaction hash: ${txHash}\n`);
+      }
     });
 
   program
     .command('check-deploy')
     .description('Checks if a contract is deployed to the specified Aztec address.')
-    .requiredOption('-ca, --contract-address <address>', 'An Aztec address to check if contract has been deployed to.')
-    .option('-u, --rpc-url <url>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .requiredOption(
+      '-ca, --contract-address <address>',
+      'An Aztec address to check if contract has been deployed to.',
+      parseAztecAddress,
+    )
+    .addOption(pxeOption)
     .action(async options => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const address = AztecAddress.fromString(options.contractAddress);
+      const address = options.contractAddress;
       const isDeployed = await isContractDeployed(client, address);
       if (isDeployed) log(`\nContract found at ${address.toString()}\n`);
       else log(`\nNo contract found at ${address.toString()}\n`);
@@ -203,14 +232,13 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
   program
     .command('get-tx-receipt')
     .description('Gets the receipt for the specified transaction hash.')
-    .argument('<txHash>', 'A transaction hash to get the receipt for.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
-    .action(async (_txHash, options) => {
+    .argument('<txHash>', 'A transaction hash to get the receipt for.', parseTxHash)
+    .addOption(pxeOption)
+    .action(async (txHash, options) => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const txHash = TxHash.fromString(_txHash);
       const receipt = await client.getTxReceipt(txHash);
       if (!receipt) {
-        log(`No receipt found for transaction hash ${_txHash}`);
+        log(`No receipt found for transaction hash ${txHash.toString()}`);
       } else {
         log(`\nTransaction receipt: \n${JsonStringify(receipt, true)}\n`);
       }
@@ -219,15 +247,14 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
   program
     .command('get-contract-data')
     .description('Gets information about the Aztec contract deployed at the specified address.')
-    .argument('<contractAddress>', 'Aztec address of the contract.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .argument('<contractAddress>', 'Aztec address of the contract.', parseAztecAddress)
+    .addOption(pxeOption)
     .option('-b, --include-bytecode <boolean>', "Include the contract's public function bytecode, if any.", false)
     .action(async (contractAddress, options) => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const address = AztecAddress.fromString(contractAddress);
       const contractDataWithOrWithoutBytecode = options.includeBytecode
-        ? await client.getExtendedContractData(address)
-        : await client.getContractData(address);
+        ? await client.getExtendedContractData(contractAddress)
+        : await client.getContractData(contractAddress);
 
       if (!contractDataWithOrWithoutBytecode) {
         log(`No contract data found at ${contractAddress}`);
@@ -253,7 +280,7 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .description('Gets all the unencrypted logs from L2 blocks in the range specified.')
     .option('-f, --from <blockNum>', 'Initial block number for getting logs (defaults to 1).')
     .option('-l, --limit <blockCount>', 'How many blocks to fetch (defaults to 100).')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .addOption(pxeOption)
     .action(async options => {
       const { from, limit } = options;
       const fromBlock = from ? parseInt(from) : 1;
@@ -271,25 +298,25 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
 
   program
     .command('register-recipient')
-    .description('Register a recipient in the Aztec RPC.')
-    .requiredOption('-a, --address <aztecAddress>', "The account's Aztec address.")
-    .requiredOption('-p, --public-key <publicKey>', 'The account public key.')
-    .requiredOption('-pa, --partial-address <partialAddress', 'The partially computed address of the account contract.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
-    .action(async options => {
-      const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const address = AztecAddress.fromString(options.address);
-      const publicKey = Point.fromString(options.publicKey);
-      const partialAddress = Fr.fromString(options.partialAddress);
-
+    .description('Register a recipient in the PXE.')
+    .requiredOption('-a, --address <aztecAddress>', "The account's Aztec address.", parseAztecAddress)
+    .requiredOption('-p, --public-key <publicKey>', 'The account public key.', parsePublicKey)
+    .requiredOption(
+      '-pa, --partial-address <partialAddress>',
+      'The partially computed address of the account contract.',
+      parsePartialAddress,
+    )
+    .addOption(pxeOption)
+    .action(async ({ address, publicKey, partialAddress, rpcUrl }) => {
+      const client = await createCompatibleClient(rpcUrl, debugLogger);
       await client.registerRecipient(await CompleteAddress.create(address, publicKey, partialAddress));
-      log(`\nRegistered details for account with address: ${options.address}\n`);
+      log(`\nRegistered details for account with address: ${address}\n`);
     });
 
   program
     .command('get-accounts')
-    .description('Gets all the Aztec accounts stored in the Aztec RPC.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .description('Gets all the Aztec accounts stored in the PXE.')
+    .addOption(pxeOption)
     .action(async (options: any) => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
       const accounts = await client.getRegisteredAccounts();
@@ -306,15 +333,14 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
   program
     .command('get-account')
     .description('Gets an account given its Aztec address.')
-    .argument('<address>', 'The Aztec address to get account for')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
-    .action(async (_address, options) => {
+    .argument('<address>', 'The Aztec address to get account for', parseAztecAddress)
+    .addOption(pxeOption)
+    .action(async (address, options) => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const address = AztecAddress.fromString(_address);
       const account = await client.getRegisteredAccount(address);
 
       if (!account) {
-        log(`Unknown account ${_address}`);
+        log(`Unknown account ${address.toString()}`);
       } else {
         log(account.toReadableString());
       }
@@ -322,8 +348,8 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
 
   program
     .command('get-recipients')
-    .description('Gets all the recipients stored in the Aztec RPC.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .description('Gets all the recipients stored in the PXE.')
+    .addOption(pxeOption)
     .action(async (options: any) => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
       const recipients = await client.getRecipients();
@@ -340,15 +366,14 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
   program
     .command('get-recipient')
     .description('Gets a recipient given its Aztec address.')
-    .argument('<address>', 'The Aztec address to get recipient for')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
-    .action(async (_address, options) => {
+    .argument('<address>', 'The Aztec address to get recipient for', parseAztecAddress)
+    .addOption(pxeOption)
+    .action(async (address, options) => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const address = AztecAddress.fromString(_address);
       const recipient = await client.getRecipient(address);
 
       if (!recipient) {
-        log(`Unknown recipient ${_address}`);
+        log(`Unknown recipient ${address.toString()}`);
       } else {
         log(recipient.toReadableString());
       }
@@ -357,45 +382,37 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
   program
     .command('send')
     .description('Calls a function on an Aztec contract.')
-    .argument('<functionName>', 'Name of Function to view')
+    .argument('<functionName>', 'Name of function to execute')
     .option('-a, --args [functionArgs...]', 'Function arguments', [])
     .requiredOption(
       '-c, --contract-abi <fileLocation>',
       "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
     )
-    .requiredOption('-ca, --contract-address <address>', 'Aztec address of the contract.')
-    .option('-k, --private-key <string>', "The sender's private key.", PRIVATE_KEY)
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
-
+    .requiredOption('-ca, --contract-address <address>', 'Aztec address of the contract.', parseAztecAddress)
+    .addOption(createPrivateKeyOption("The sender's private key.", true))
+    .addOption(pxeOption)
+    .option('--no-wait', 'Print transaction hash without waiting for it to be mined')
     .action(async (functionName, options) => {
-      const { contractAddress, functionArgs, contractAbi } = await prepTx(
-        options.contractAbi,
-        options.contractAddress,
-        functionName,
-        options.args,
-        log,
-      );
-
-      const fnAbi = getAbiFunction(contractAbi, functionName);
-      if (fnAbi.parameters.length !== options.args.length) {
-        throw Error(
-          `Invalid number of args passed. Expected ${fnAbi.parameters.length}; Received: ${options.args.length}`,
-        );
-      }
-
-      const privateKey = GrumpkinScalar.fromString(stripLeadingHex(options.privateKey));
+      const { functionArgs, contractAbi } = await prepTx(options.contractAbi, functionName, options.args, log);
+      const { contractAddress, privateKey } = options;
 
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
       const wallet = await getSchnorrAccount(client, privateKey, privateKey, accountCreationSalt).getWallet();
       const contract = await Contract.at(contractAddress, contractAbi, wallet);
       const tx = contract.methods[functionName](...functionArgs).send();
-      await tx.wait();
-      log('\nTransaction has been mined');
-      const receipt = await tx.getReceipt();
       log(`Transaction hash: ${(await tx.getTxHash()).toString()}`);
-      log(`Status: ${receipt.status}\n`);
-      log(`Block number: ${receipt.blockNumber}`);
-      log(`Block hash: ${receipt.blockHash?.toString('hex')}`);
+      if (options.wait) {
+        await tx.wait();
+
+        log('Transaction has been mined');
+
+        const receipt = await tx.getReceipt();
+        log(`Status: ${receipt.status}\n`);
+        log(`Block number: ${receipt.blockNumber}`);
+        log(`Block hash: ${receipt.blockHash?.toString('hex')}`);
+      } else {
+        log('\nTransaction pending. Check status with get-tx-receipt');
+      }
     });
 
   program
@@ -403,23 +420,18 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .description(
       'Simulates the execution of a view (read-only) function on a deployed contract, without modifying state.',
     )
-    .argument('<functionName>', 'Name of Function to view')
+    .argument('<functionName>', 'Name of function to call')
     .option('-a, --args [functionArgs...]', 'Function arguments', [])
     .requiredOption(
       '-c, --contract-abi <fileLocation>',
       "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
     )
-    .requiredOption('-ca, --contract-address <address>', 'Aztec address of the contract.')
+    .requiredOption('-ca, --contract-address <address>', 'Aztec address of the contract.', parseAztecAddress)
     .option('-f, --from <string>', 'Aztec address of the caller. If empty, will use the first account from RPC.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .addOption(pxeOption)
     .action(async (functionName, options) => {
-      const { contractAddress, functionArgs, contractAbi } = await prepTx(
-        options.contractAbi,
-        options.contractAddress,
-        functionName,
-        options.args,
-        log,
-      );
+      const { functionArgs, contractAbi } = await prepTx(options.contractAbi, functionName, options.args, log);
+
       const fnAbi = getAbiFunction(contractAbi, functionName);
       if (fnAbi.parameters.length !== options.args.length) {
         throw Error(
@@ -428,8 +440,23 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
       }
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
       const from = await getTxSender(client, options.from);
-      const result = await client.viewTx(functionName, functionArgs, contractAddress, from);
-      log('\nView result: ', result, '\n');
+      const result = await client.viewTx(functionName, functionArgs, options.contractAddress, from);
+      log(format('\nView result: ', result, '\n'));
+    });
+
+  program
+    .command('add-note')
+    .description('Adds a note to the database in the PXE.')
+    .argument('<address>', 'The Aztec address of the note owner.', parseAztecAddress)
+    .argument('<contractAddress>', 'Aztec address of the contract.', parseAztecAddress)
+    .argument('<storageSlot>', 'The storage slot of the note.', parseField)
+    .argument('<txHash>', 'The tx hash of the tx containing the note.', parseTxHash)
+    .requiredOption('-p, --preimage [notePreimage...]', 'Note preimage.', [])
+    .addOption(pxeOption)
+    .action(async (address, contractAddress, storageSlot, txHash, options) => {
+      const preimage = new NotePreimage(parseFields(options.preimage));
+      const client = await createCompatibleClient(options.rpcUrl, debugLogger);
+      await client.addNote(address, contractAddress, storageSlot, preimage, txHash);
     });
 
   // Helper for users to decode hex strings into structs if needed.
@@ -459,7 +486,7 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
   program
     .command('block-number')
     .description('Gets the current Aztec L2 block number.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .addOption(pxeOption)
     .action(async (options: any) => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
       const num = await client.getBlockNumber();
@@ -490,12 +517,16 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
   program
     .command('get-node-info')
     .description('Gets the information of an aztec node at a URL.')
-    .requiredOption('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .addOption(pxeOption)
     .action(async options => {
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
       const info = await client.getNodeInfo();
       log(`\nNode Info:\n`);
-      Object.entries(info).map(([key, value]) => log(`${startCase(key)}: ${value}`));
+      log(`Sandbox Version: ${info.sandboxVersion}\n`);
+      log(`Compatible Nargo Version: ${info.compatibleNargoVersion}\n`);
+      log(`Chain Id: ${info.chainId}\n`);
+      log(`Protocol Version: ${info.protocolVersion}\n`);
+      log(`Rollup Address: ${info.l1ContractAddresses.rollupAddress.toString()}`);
     });
 
   program