@aztec/cli-wallet 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/utils/options/fees.js

@@ -0,0 +1,189 @@
+import { AztecAddress, Fr, Gas, GasFees, GasSettings } from '@aztec/circuits.js';
+import { Option } from 'commander';
+import { aliasedAddressParser } from './options.js';
+export function printGasEstimates(feeOpts, gasEstimates, log) {
+    log(`Estimated gas usage:    ${formatGasEstimate(gasEstimates)}`);
+    log(`Maximum total tx fee:   ${getEstimatedCost(gasEstimates, feeOpts.gasSettings.maxFeesPerGas)}`);
+}
+function formatGasEstimate(estimate) {
+    return `da=${estimate.gasLimits.daGas},l2=${estimate.gasLimits.l2Gas},teardownDA=${estimate.teardownGasLimits.daGas},teardownL2=${estimate.teardownGasLimits.l2Gas}`;
+}
+function getEstimatedCost(estimate, maxFeesPerGas) {
+    return GasSettings.default({
+        ...estimate,
+        maxFeesPerGas
+    }).getFeeLimit().toBigInt();
+}
+export class FeeOpts {
+    estimateOnly;
+    gasSettings;
+    paymentMethodFactory;
+    estimateGas;
+    constructor(estimateOnly, gasSettings, paymentMethodFactory, estimateGas){
+        this.estimateOnly = estimateOnly;
+        this.gasSettings = gasSettings;
+        this.paymentMethodFactory = paymentMethodFactory;
+        this.estimateGas = estimateGas;
+    }
+    async toSendOpts(sender) {
+        return {
+            fee: {
+                estimateGas: this.estimateGas,
+                gasSettings: this.gasSettings,
+                paymentMethod: await this.paymentMethodFactory(sender)
+            }
+        };
+    }
+    static paymentMethodOption() {
+        return new Option('--payment <method=name,asset=address,fpc=address,claimSecret=string,claimAmount=string,feeRecipient=string>', 'Fee payment method and arguments. Valid methods are: none, fee_juice, fpc-public, fpc-private.');
+    }
+    static getOptions() {
+        return [
+            new Option('--gas-limits <da=100,l2=100,teardownDA=10,teardownL2=10>', 'Gas limits for the tx.'),
+            FeeOpts.paymentMethodOption(),
+            new Option('--max-fees-per-gas <da=100,l2=100>', 'Maximum fees per gas unit for DA and L2 computation.'),
+            new Option('--max-priority-fees-per-gas <da=0,l2=0>', 'Maximum priority fees per gas unit for DA and L2 computation.'),
+            new Option('--no-estimate-gas', 'Whether to automatically estimate gas limits for the tx.'),
+            new Option('--estimate-gas-only', 'Only report gas estimation for the tx, do not send it.')
+        ];
+    }
+    static async fromCli(args, pxe, log, db) {
+        const estimateOnly = args.estimateGasOnly;
+        const gasLimits = args.gasLimits ? parseGasLimits(args.gasLimits) : {};
+        const maxFeesPerGas = args.maxFeesPerGas ? parseGasFees(args.maxFeesPerGas) : await pxe.getCurrentBaseFees();
+        const maxPriorityFeesPerGas = args.maxPriorityFeesPerGas ? parseGasFees(args.maxPriorityFeesPerGas) : undefined;
+        const gasSettings = GasSettings.default({
+            ...gasLimits,
+            maxFeesPerGas,
+            maxPriorityFeesPerGas
+        });
+        if (!args.gasLimits && !args.payment) {
+            return new NoFeeOpts(estimateOnly, gasSettings);
+        }
+        const defaultPaymentMethod = async ()=>{
+            const { NoFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+            return new NoFeePaymentMethod();
+        };
+        return new FeeOpts(estimateOnly, gasSettings, args.payment ? parsePaymentMethod(args.payment, log, db) : defaultPaymentMethod, !!args.estimateGas);
+    }
+}
+class NoFeeOpts {
+    estimateOnly;
+    gasSettings;
+    constructor(estimateOnly, gasSettings){
+        this.estimateOnly = estimateOnly;
+        this.gasSettings = gasSettings;
+    }
+    toSendOpts() {
+        return Promise.resolve({});
+    }
+}
+export function parsePaymentMethod(payment, log, db) {
+    const parsed = payment.split(',').reduce((acc, item)=>{
+        const [dimension, value] = item.split('=');
+        acc[dimension] = value ?? 1;
+        return acc;
+    }, {});
+    const getFpcOpts = (parsed, db)=>{
+        if (!parsed.fpc) {
+            throw new Error('Missing "fpc" in payment option');
+        }
+        if (!parsed.asset) {
+            throw new Error('Missing "asset" in payment option');
+        }
+        const fpc = aliasedAddressParser('contracts', parsed.fpc, db);
+        return [
+            AztecAddress.fromString(parsed.asset),
+            fpc
+        ];
+    };
+    return async (sender)=>{
+        switch(parsed.method){
+            case 'none':
+                {
+                    log('Using no fee payment');
+                    const { NoFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+                    return new NoFeePaymentMethod();
+                }
+            case 'native':
+                {
+                    if (parsed.claim || parsed.claimSecret && parsed.claimAmount && parsed.messageLeafIndex) {
+                        let claimAmount, claimSecret, messageLeafIndex;
+                        if (parsed.claim && db) {
+                            ({ amount: claimAmount, secret: claimSecret, leafIndex: messageLeafIndex } = await db.popBridgedFeeJuice(sender.getAddress(), log));
+                        } else {
+                            ({ claimAmount, claimSecret, messageLeafIndex } = parsed);
+                        }
+                        log(`Using Fee Juice for fee payments with claim for ${claimAmount} tokens`);
+                        const { FeeJuicePaymentMethodWithClaim } = await import('@aztec/aztec.js/fee');
+                        return new FeeJuicePaymentMethodWithClaim(sender.getAddress(), {
+                            claimAmount: (typeof claimAmount === 'string' ? Fr.fromHexString(claimAmount) : new Fr(claimAmount)).toBigInt(),
+                            claimSecret: Fr.fromHexString(claimSecret),
+                            messageLeafIndex: BigInt(messageLeafIndex)
+                        });
+                    } else {
+                        log(`Using Fee Juice for fee payment`);
+                        const { FeeJuicePaymentMethod } = await import('@aztec/aztec.js/fee');
+                        return new FeeJuicePaymentMethod(sender.getAddress());
+                    }
+                }
+            case 'fpc-public':
+                {
+                    const [asset, fpc] = getFpcOpts(parsed, db);
+                    log(`Using public fee payment with asset ${asset} via paymaster ${fpc}`);
+                    const { PublicFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+                    return new PublicFeePaymentMethod(fpc, sender);
+                }
+            case 'fpc-private':
+                {
+                    const [asset, fpc] = getFpcOpts(parsed, db);
+                    log(`Using private fee payment with asset ${asset} via paymaster ${fpc}`);
+                    const { PrivateFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+                    return new PrivateFeePaymentMethod(fpc, sender);
+                }
+            case undefined:
+                throw new Error('Missing "method" in payment option');
+            default:
+                throw new Error(`Invalid fee payment method: ${payment}`);
+        }
+    };
+}
+function parseGasLimits(gasLimits) {
+    const parsed = gasLimits.split(',').reduce((acc, limit)=>{
+        const [dimension, value] = limit.split('=');
+        acc[dimension] = parseInt(value, 10);
+        return acc;
+    }, {});
+    const expected = [
+        'da',
+        'l2',
+        'teardownDA',
+        'teardownL2'
+    ];
+    for (const dimension of expected){
+        if (!(dimension in parsed)) {
+            throw new Error(`Missing gas limit for ${dimension}`);
+        }
+    }
+    return {
+        gasLimits: new Gas(parsed.da, parsed.l2),
+        teardownGasLimits: new Gas(parsed.teardownDA, parsed.teardownL2)
+    };
+}
+export function parseGasFees(gasFees) {
+    const parsed = gasFees.split(',').reduce((acc, fee)=>{
+        const [dimension, value] = fee.split('=');
+        acc[dimension] = parseInt(value, 10);
+        return acc;
+    }, {});
+    const expected = [
+        'da',
+        'l2'
+    ];
+    for (const dimension of expected){
+        if (!(dimension in parsed)) {
+            throw new Error(`Missing gas fee for ${dimension}`);
+        }
+    }
+    return new GasFees(parsed.da, parsed.l2);
+}

package/dest/utils/options/index.js

@@ -0,0 +1,2 @@
+export * from './fees.js';
+export * from './options.js';

package/dest/utils/options/options.js

@@ -0,0 +1,122 @@
+import { AuthWitness } from '@aztec/circuit-types';
+import { parseAztecAddress, parseSecretKey, parseTxHash } from '@aztec/cli/utils';
+import { Option } from 'commander';
+import { readdir, stat } from 'fs/promises';
+import { AccountTypes } from '../accounts.js';
+const TARGET_DIR = 'target';
+export const ARTIFACT_DESCRIPTION = "Path to a compiled Aztec contract's artifact in JSON format. If executed inside a nargo workspace, a package and contract name can be specified as package@contract";
+export function integerArgParser(value, argName, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+    const parsed = parseInt(value, 10);
+    if (parsed < min) {
+        throw new Error(`${argName} must be greater than ${min}`);
+    }
+    if (parsed > max) {
+        throw new Error(`${argName} must be less than ${max}`);
+    }
+    return parsed;
+}
+export function aliasedTxHashParser(txHash, db) {
+    try {
+        return parseTxHash(txHash);
+    } catch (err) {
+        const prefixed = txHash.includes(':') ? txHash : `transactions:${txHash}`;
+        const rawTxHash = db ? db.tryRetrieveAlias(prefixed) : txHash;
+        return parseTxHash(rawTxHash);
+    }
+}
+export function aliasedAuthWitParser(witness, db) {
+    try {
+        return AuthWitness.fromString(witness);
+    } catch (err) {
+        const prefixed = witness.includes(':') ? witness : `authwits:${witness}`;
+        const rawAuthWitness = db ? db.tryRetrieveAlias(prefixed) : witness;
+        return AuthWitness.fromString(rawAuthWitness);
+    }
+}
+export function aliasedAddressParser(defaultPrefix, address, db) {
+    if (address.startsWith('0x')) {
+        return parseAztecAddress(address);
+    } else {
+        const prefixed = address.includes(':') ? address : `${defaultPrefix}:${address}`;
+        const rawAddress = db ? db.tryRetrieveAlias(prefixed) : address;
+        return parseAztecAddress(rawAddress);
+    }
+}
+export function aliasedSecretKeyParser(sk, db) {
+    if (sk.startsWith('0x')) {
+        return parseSecretKey(sk);
+    } else {
+        const prefixed = `${sk.startsWith('accounts') ? '' : 'accounts'}:${sk.endsWith(':sk') ? sk : `${sk}:sk`}`;
+        const rawSk = db ? db.tryRetrieveAlias(prefixed) : sk;
+        return parseSecretKey(rawSk);
+    }
+}
+export function createAliasOption(description, hide) {
+    return new Option(`-a, --alias <string>`, description).hideHelp(hide);
+}
+export function createAccountOption(description, hide, db) {
+    return new Option(`-f, --from <string>`, description).hideHelp(hide).argParser((address)=>aliasedAddressParser('accounts', address, db));
+}
+export function createTypeOption(mandatory) {
+    return new Option('-t, --type <string>', 'Type of account to create').choices(AccountTypes).default('schnorr').conflicts('account-or-address').makeOptionMandatory(mandatory);
+}
+export function createArgsOption(isConstructor, db) {
+    return new Option('--args [args...]', `${isConstructor ? 'Constructor' : 'Function'}  arguments`).argParser((arg, prev)=>{
+        const next = db?.tryRetrieveAlias(arg) || arg;
+        prev.push(next);
+        return prev;
+    }).default([]);
+}
+export function createContractAddressOption(db) {
+    return new Option('-ca, --contract-address <address>', 'Aztec address of the contract.').argParser((address)=>aliasedAddressParser('contracts', address, db)).makeOptionMandatory(true);
+}
+export function artifactPathParser(filePath, db) {
+    if (filePath.includes('@')) {
+        const [pkg, contractName] = filePath.split('@');
+        return contractArtifactFromWorkspace(pkg, contractName);
+    } else if (!new RegExp(/^(\.|\/|[A-Z]:).*\.json$/).test(filePath)) {
+        filePath = db ? db.tryRetrieveAlias(`artifacts:${filePath}`) : filePath;
+    }
+    if (!filePath) {
+        throw new Error('This command has to be called from a nargo workspace or contract artifact path should be provided');
+    }
+    return Promise.resolve(filePath);
+}
+export async function artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db) {
+    let artifactPath = await artifactPathPromise;
+    if (db && !artifactPath) {
+        artifactPath = db.tryRetrieveAlias(`artifacts:${contractAddress.toString()}`);
+        if (!artifactPath) {
+            throw new Error(`No artifact found for contract address ${contractAddress}, please provide it via the -c option`);
+        }
+    }
+    return artifactPath;
+}
+export function createArtifactOption(db) {
+    return new Option('-c, --contract-artifact <fileLocation>', ARTIFACT_DESCRIPTION).argParser((filePath)=>artifactPathParser(filePath, db)).makeOptionMandatory(false);
+}
+export function createProfileOption() {
+    return new Option('-p, --profile', 'Run the real prover and get the gate count for each function in the transaction.').default(false);
+}
+async function contractArtifactFromWorkspace(pkg, contractName) {
+    const cwd = process.cwd();
+    try {
+        await stat(`${cwd}/Nargo.toml`);
+    } catch (e) {
+        throw new Error('Invalid contract artifact argument provided. To use this option, command should be called from a nargo workspace');
+    }
+    const filesInTarget = await readdir(`${cwd}/${TARGET_DIR}`);
+    const bestMatch = filesInTarget.filter((file)=>{
+        if (pkg && contractName) {
+            return file === `${pkg}-${contractName}.json`;
+        } else {
+            return file.endsWith('.json') && (file.includes(pkg || '') || file.includes(contractName || ''));
+        }
+    });
+    if (bestMatch.length === 0) {
+        throw new Error('No contract artifacts found in target directory with the specified criteria');
+    } else if (bestMatch.length > 1) {
+        throw new Error(`Multiple contract artifacts found in target directory with the specified criteria ${bestMatch.join(', ')}`);
+    }
+    return `${cwd}/${TARGET_DIR}/${bestMatch[0]}`;
+}

package/dest/utils/pxe_wrapper.js

@@ -0,0 +1,21 @@
+import { createAztecNodeClient } from '@aztec/circuit-types';
+import { createPXEService, getPXEServiceConfig } from '@aztec/pxe';
+/*
+ * Wrapper class for PXE service, avoids initialization issues due to
+ * closures when providing PXE service to injected commander.js commands
+ */ export class PXEWrapper {
+    static pxe;
+    static node;
+    getPXE() {
+        return PXEWrapper.pxe;
+    }
+    getNode() {
+        return PXEWrapper.node;
+    }
+    async init(nodeUrl, dataDir, overridePXEServiceConfig) {
+        PXEWrapper.node = createAztecNodeClient(nodeUrl);
+        const pxeConfig = Object.assign(getPXEServiceConfig(), overridePXEServiceConfig);
+        pxeConfig.dataDirectory = dataDir;
+        PXEWrapper.pxe = await createPXEService(PXEWrapper.node, pxeConfig);
+    }
+}

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@aztec/cli-wallet",
+  "version": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+  "type": "module",
+  "exports": {
+    ".": "./dest/cmds/index.js",
+    "./cli": "./dest/bin/index.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/cmds/index.ts"
+    ],
+    "name": "Aztec CLI wallet",
+    "tsconfig": "./tsconfig.json"
+  },
+  "bin": {
+    "aztec-wallet": "./dest/bin/index.js"
+  },
+  "scripts": {
+    "start": "node --no-warnings ./dest/bin",
+    "start:debug": "node --inspect=0.0.0.0:9221 --no-warnings ./dest/bin",
+    "dev": "LOG_LEVEL=debug && node ./dest/bin",
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "preset": "ts-jest/presets/default-esm",
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 30000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/accounts": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/aztec.js": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/circuit-types": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/circuits.js": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/cli": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/ethereum": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/foundation": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/kv-store": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/noir-contracts.js": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/pxe": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "commander": "^12.1.0",
+    "inquirer": "^10.1.8",
+    "source-map-support": "^0.5.21",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.7.23",
+    "@types/source-map-support": "^0.5.10",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.5",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/bin/index.ts

@@ -0,0 +1,121 @@
+import { Fr, computeSecretHash, fileURLToPath } from '@aztec/aztec.js';
+import { LOCALHOST } from '@aztec/cli/cli-utils';
+import { type LogFn, createConsoleLogger, createLogger } from '@aztec/foundation/log';
+import { AztecLmdbStore } from '@aztec/kv-store/lmdb';
+
+import { Argument, Command, Option } from 'commander';
+import { mkdirSync, readFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+
+import { injectCommands } from '../cmds/index.js';
+import { Aliases, WalletDB } from '../storage/wallet_db.js';
+import { createAliasOption } from '../utils/options/index.js';
+import { PXEWrapper } from '../utils/pxe_wrapper.js';
+
+const userLog = createConsoleLogger();
+const debugLogger = createLogger('wallet');
+
+const { WALLET_DATA_DIRECTORY = '~/.aztec/wallet', PXE_PROVER = 'none' } = process.env;
+
+function injectInternalCommands(program: Command, log: LogFn, db: WalletDB) {
+  program
+    .command('alias')
+    .description('Aliases information for easy reference.')
+    .addArgument(new Argument('<type>', 'Type of alias to create').choices(Aliases))
+    .argument('<key>', 'Key to alias.')
+    .argument('<value>', 'Value to assign to the alias.')
+    .action(async (type, key, value) => {
+      value = db.tryRetrieveAlias(value) || value;
+      await db.storeAlias(type, key, value, log);
+    });
+
+  program
+    .command('get-alias')
+    .description('Shows stored aliases')
+    .addArgument(new Argument('[alias]', 'Alias to retrieve'))
+    .action(alias => {
+      if (alias?.includes(':')) {
+        const value = db.retrieveAlias(alias);
+        log(value);
+      } else {
+        const aliases = db.listAliases(alias);
+        for (const { key, value } of aliases) {
+          log(`${key} -> ${value}`);
+        }
+      }
+    });
+
+  program
+    .command('create-secret')
+    .description('Creates an aliased secret to use in other commands')
+    .addOption(createAliasOption('Key to alias the secret with', false).makeOptionMandatory(true))
+    .action(async (_options, command) => {
+      const options = command.optsWithGlobals();
+      const { alias } = options;
+      const value = Fr.random();
+      const hash = computeSecretHash(value);
+
+      await db.storeAlias('secrets', alias, Buffer.from(value.toString()), log);
+      await db.storeAlias('secrets', `${alias}:hash`, Buffer.from(hash.toString()), log);
+    });
+
+  return program;
+}
+
+/** CLI wallet main entrypoint */
+async function main() {
+  const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+  const walletVersion: string = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+
+  const db = WalletDB.getInstance();
+  const pxeWrapper = new PXEWrapper();
+
+  const program = new Command('wallet');
+  program
+    .description('Aztec wallet')
+    .version(walletVersion)
+    .option('-d, --data-dir <string>', 'Storage directory for wallet data', WALLET_DATA_DIRECTORY)
+    .option('-p, --prover <string>', 'wasm|native|none', PXE_PROVER)
+    .addOption(
+      new Option('--remote-pxe', 'Connect to an external PXE RPC server, instead of the local one')
+        .env('REMOTE_PXE')
+        .default(false)
+        .conflicts('rpc-url'),
+    )
+    .addOption(
+      new Option('-n, --node-url <string>', 'URL of the Aztec node to connect to')
+        .env('AZTEC_NODE_URL')
+        .default(`http://${LOCALHOST}:8080`),
+    )
+    .hook('preSubcommand', async command => {
+      const { dataDir, remotePxe, nodeUrl, prover } = command.optsWithGlobals();
+
+      if (!remotePxe) {
+        debugLogger.info('Using local PXE service');
+
+        const bbBinaryPath =
+          prover === 'native'
+            ? resolve(dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/cpp/build/bin/bb')
+            : undefined;
+        const bbWorkingDirectory = dataDir + '/bb';
+        const proverEnabled = prover !== 'none';
+
+        mkdirSync(bbWorkingDirectory, { recursive: true });
+
+        await pxeWrapper.init(nodeUrl, join(dataDir, 'pxe'), {
+          ...(proverEnabled && { proverEnabled, bbBinaryPath, bbWorkingDirectory }), // only override if we're profiling
+        });
+      }
+      db.init(AztecLmdbStore.open(dataDir));
+    });
+
+  injectCommands(program, userLog, debugLogger, db, pxeWrapper);
+  injectInternalCommands(program, userLog, db);
+  await program.parseAsync(process.argv);
+}
+
+main().catch(err => {
+  debugLogger.error(`Error in command execution`);
+  debugLogger.error(err + '\n' + err.stack);
+  process.exit(1);
+});

package/src/cmds/add_authwit.ts

@@ -0,0 +1,13 @@
+import { type AccountWalletWithSecretKey, type AuthWitness, type AztecAddress } from '@aztec/aztec.js';
+import { type LogFn } from '@aztec/foundation/log';
+
+export async function addAuthwit(
+  wallet: AccountWalletWithSecretKey,
+  authwit: AuthWitness,
+  authorizer: AztecAddress,
+  log: LogFn,
+) {
+  await wallet.addAuthWitness(authwit);
+
+  log(`Added authorization witness from ${authorizer}`);
+}

package/src/cmds/add_note.ts

@@ -0,0 +1,30 @@
+import { type AccountWalletWithSecretKey, type AztecAddress } from '@aztec/aztec.js';
+import { ExtendedNote, Note, type TxHash } from '@aztec/circuit-types';
+import { getContractArtifact, parseFields } from '@aztec/cli/utils';
+import { type LogFn } from '@aztec/foundation/log';
+
+export async function addNote(
+  wallet: AccountWalletWithSecretKey,
+  address: AztecAddress,
+  contractAddress: AztecAddress,
+  noteName: string,
+  storageFieldName: string,
+  artifactPath: string,
+  txHash: TxHash,
+  noteBody: string[],
+  log: LogFn,
+) {
+  const fields = parseFields(noteBody);
+  const note = new Note(fields);
+  const contractArtifact = await getContractArtifact(artifactPath, log);
+
+  const contractNote = contractArtifact.notes[noteName];
+  const storageField = contractArtifact.storageLayout[storageFieldName];
+
+  if (!contractNote) {
+    throw new Error(`Note ${noteName} not found in contract ${contractArtifact.name}`);
+  }
+
+  const extendedNote = new ExtendedNote(note, address, contractAddress, storageField.slot, contractNote.id, txHash);
+  await wallet.addNote(extendedNote);
+}

package/src/cmds/authorize_action.ts

@@ -0,0 +1,36 @@
+import { type AccountWalletWithSecretKey, type AztecAddress, Contract } from '@aztec/aztec.js';
+import { prepTx } from '@aztec/cli/utils';
+import { type LogFn } from '@aztec/foundation/log';
+
+export async function authorizeAction(
+  wallet: AccountWalletWithSecretKey,
+  functionName: string,
+  caller: AztecAddress,
+  functionArgsIn: any[],
+  contractArtifactPath: string,
+  contractAddress: AztecAddress,
+  log: LogFn,
+) {
+  const { functionArgs, contractArtifact, isPrivate } = await prepTx(
+    contractArtifactPath,
+    functionName,
+    functionArgsIn,
+    log,
+  );
+
+  if (isPrivate) {
+    throw new Error(
+      'Cannot authorize private function. To allow a third party to call a private function, please create an authorization witness via the create-authwit command',
+    );
+  }
+
+  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+  const action = contract.methods[functionName](...functionArgs);
+
+  const setAuthwitnessInteraction = await wallet.setPublicAuthWit({ caller, action }, true);
+  const witness = await setAuthwitnessInteraction.send().wait();
+
+  log(`Authorized action ${functionName} on contract ${contractAddress} for caller ${caller}`);
+
+  return witness;
+}