@aztec/cli-wallet 0.0.0-test.0

package/dest/utils/options/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/options/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC"}

package/dest/utils/options/index.js

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

package/dest/utils/options/options.d.ts

@@ -0,0 +1,20 @@
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Option } from 'commander';
+import type { AliasType, WalletDB } from '../../storage/wallet_db.js';
+export declare 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 declare function integerArgParser(value: string, argName: string, min?: number, max?: number): number;
+export declare function aliasedTxHashParser(txHash: string, db?: WalletDB): import("@aztec/aztec.js").TxHash;
+export declare function aliasedAuthWitParser(witness: string, db?: WalletDB): AuthWitness;
+export declare function aliasedAddressParser(defaultPrefix: AliasType, address: string, db?: WalletDB): AztecAddress;
+export declare function aliasedSecretKeyParser(sk: string, db?: WalletDB): import("@aztec/aztec.js").Fr;
+export declare function createAliasOption(description: string, hide: boolean): Option;
+export declare function createAccountOption(description: string, hide: boolean, db?: WalletDB): Option;
+export declare function createTypeOption(mandatory: boolean): Option;
+export declare function createArgsOption(isConstructor: boolean, db?: WalletDB): Option;
+export declare function createContractAddressOption(db?: WalletDB): Option;
+export declare function artifactPathParser(filePath: string, db?: WalletDB): Promise<string>;
+export declare function artifactPathFromPromiseOrAlias(artifactPathPromise: Promise<string>, contractAddress: AztecAddress, db?: WalletDB): Promise<string>;
+export declare function createArtifactOption(db?: WalletDB): Option;
+export declare function createProfileOption(): Option;
+//# sourceMappingURL=options.d.ts.map

package/dest/utils/options/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/utils/options/options.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAKtE,eAAO,MAAM,oBAAoB,wKACsI,CAAC;AAExK,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,GAAG,SAA0B,EAC7B,GAAG,SAA0B,UAU9B;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,oCAQhE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,eAQlE;AAED,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,gBAQ5F;AAED,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,gCAQ/D;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,UAEnE;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,QAAQ,UAIpF;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,UAMlD;AAED,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,QAAQ,UAQrE;AAED,wBAAgB,2BAA2B,CAAC,EAAE,CAAC,EAAE,QAAQ,UAIxD;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,mBAajE;AAED,wBAAsB,8BAA8B,CAClD,mBAAmB,EAAE,OAAO,CAAC,MAAM,CAAC,EACpC,eAAe,EAAE,YAAY,EAC7B,EAAE,CAAC,EAAE,QAAQ,mBAWd;AAED,wBAAgB,oBAAoB,CAAC,EAAE,CAAC,EAAE,QAAQ,UAIjD;AAED,wBAAgB,mBAAmB,WAKlC"}

package/dest/utils/options/options.js

@@ -0,0 +1,122 @@
+import { parseAztecAddress, parseSecretKey, parseTxHash } from '@aztec/cli/utils';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+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.d.ts

@@ -0,0 +1,10 @@
+import { type PXEServiceConfig } from '@aztec/pxe/server';
+import { type AztecNode, type PXE } from '@aztec/stdlib/interfaces/client';
+export declare class PXEWrapper {
+    private static pxe;
+    private static node;
+    getPXE(): PXE | undefined;
+    getNode(): AztecNode | undefined;
+    init(nodeUrl: string, dataDir: string, overridePXEServiceConfig?: Partial<PXEServiceConfig>): Promise<void>;
+}
+//# sourceMappingURL=pxe_wrapper.d.ts.map

package/dest/utils/pxe_wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pxe_wrapper.d.ts","sourceRoot":"","sources":["../../src/utils/pxe_wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAyC,MAAM,mBAAmB,CAAC;AACjG,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,GAAG,EAAyB,MAAM,iCAAiC,CAAC;AAMlG,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAC,GAAG,CAAkB;IACpC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAwB;IAE3C,MAAM,IAAI,GAAG,GAAG,SAAS;IAIzB,OAAO,IAAI,SAAS,GAAG,SAAS;IAI1B,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,wBAAwB,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC;CAMlG"}

package/dest/utils/pxe_wrapper.js

@@ -0,0 +1,21 @@
+import { createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+/*
+ * 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,102 @@
+{
+  "name": "@aztec/cli-wallet",
+  "version": "0.0.0-test.0",
+  "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": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/accounts": "0.0.0-test.0",
+    "@aztec/aztec.js": "0.0.0-test.0",
+    "@aztec/cli": "0.0.0-test.0",
+    "@aztec/ethereum": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/kv-store": "0.0.0-test.0",
+    "@aztec/noir-contracts.js": "0.0.0-test.0",
+    "@aztec/pxe": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "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,127 @@
+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 { openStoreAt } from '@aztec/kv-store/lmdb-v2';
+import type { PXEServiceConfig } from '@aztec/pxe/config';
+
+import { Argument, Command, Option } from 'commander';
+import { mkdirSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+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 = join(homedir(), '.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(async alias => {
+      if (alias?.includes(':')) {
+        const value = await db.retrieveAlias(alias);
+        log(value);
+      } else {
+        const aliases = await 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 proverEnabled = prover !== 'none';
+
+        const bbBinaryPath =
+          prover === 'native'
+            ? resolve(dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/cpp/build/bin/bb')
+            : undefined;
+        const bbWorkingDirectory = dataDir + '/bb';
+        mkdirSync(bbWorkingDirectory, { recursive: true });
+
+        const overridePXEConfig: Partial<PXEServiceConfig> = {
+          proverEnabled,
+          bbBinaryPath: prover === 'native' ? bbBinaryPath : undefined,
+          bbWorkingDirectory: prover === 'native' ? bbWorkingDirectory : undefined,
+        };
+
+        await pxeWrapper.init(nodeUrl, join(dataDir, 'pxe'), overridePXEConfig);
+      }
+      await db.init(await openStoreAt(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, AuthWitness, 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/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;
+}

package/src/cmds/bridge_fee_juice.ts

@@ -0,0 +1,88 @@
+import { L1FeeJuicePortalManager, type PXE } from '@aztec/aztec.js';
+import { prettyPrintJSON } from '@aztec/cli/utils';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+export async function bridgeL1FeeJuice(
+  amount: bigint,
+  recipient: AztecAddress,
+  pxe: PXE,
+  l1RpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mint: boolean,
+  json: boolean,
+  wait: boolean,
+  interval = 60_000,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  // Prepare L1 client
+  const chain = createEthereumChain(l1RpcUrls, chainId);
+  const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+
+  const {
+    protocolContractAddresses: { feeJuice: feeJuiceAddress },
+  } = await pxe.getPXEInfo();
+
+  // Setup portal manager
+  const portal = await L1FeeJuicePortalManager.new(pxe, publicClient, walletClient, debugLogger);
+  const { claimAmount, claimSecret, messageHash, messageLeafIndex } = await portal.bridgeTokensPublic(
+    recipient,
+    amount,
+    mint,
+  );
+
+  if (json) {
+    const out = {
+      claimAmount,
+      claimSecret,
+      messageLeafIndex,
+    };
+    log(prettyPrintJSON(out));
+  } else {
+    if (mint) {
+      log(`Minted ${claimAmount} fee juice on L1 and pushed to L2 portal`);
+    } else {
+      log(`Bridged ${claimAmount} fee juice to L2 portal`);
+    }
+    log(
+      `claimAmount=${claimAmount},claimSecret=${claimSecret},messageHash=${messageHash},messageLeafIndex=${messageLeafIndex}\n`,
+    );
+    log(`Note: You need to wait for two L2 blocks before pulling them from the L2 side`);
+    if (wait) {
+      log(
+        `This command will now continually poll every ${
+          interval / 1000
+        }s for the inclusion of the newly created L1 to L2 message`,
+      );
+    }
+  }
+
+  if (wait) {
+    const delayedCheck = (delay: number) => {
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          void pxe
+            .getL1ToL2MembershipWitness(feeJuiceAddress, Fr.fromHexString(messageHash), claimSecret)
+            .then(witness => resolve(witness))
+            .catch(err => reject(err));
+        }, delay);
+      });
+    };
+
+    let witness;
+
+    while (!witness) {
+      witness = await delayedCheck(interval);
+      if (!witness) {
+        log(`No L1 to L2 message found yet, checking again in ${interval / 1000}s`);
+      }
+    }
+  }
+
+  return [claimSecret, messageLeafIndex] as const;
+}

package/src/cmds/cancel_tx.ts

@@ -0,0 +1,62 @@
+import { type AccountWalletWithSecretKey, type FeePaymentMethod, SentTx, type TxHash, TxStatus } from '@aztec/aztec.js';
+import type { FeeOptions } from '@aztec/aztec.js/entrypoint';
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn } from '@aztec/foundation/log';
+import { GasFees, GasSettings } from '@aztec/stdlib/gas';
+
+export async function cancelTx(
+  wallet: AccountWalletWithSecretKey,
+  {
+    txHash,
+    gasSettings: prevTxGasSettings,
+    nonce,
+    cancellable,
+  }: { txHash: TxHash; gasSettings: GasSettings; nonce: Fr; cancellable: boolean },
+  paymentMethod: FeePaymentMethod,
+  increasedFees: GasFees,
+  maxFeesPerGas: GasFees | undefined,
+  log: LogFn,
+) {
+  const receipt = await wallet.getTxReceipt(txHash);
+  if (receipt.status !== TxStatus.PENDING || !cancellable) {
+    log(`Transaction is in status ${receipt.status} and cannot be cancelled`);
+    return;
+  }
+
+  const maxPriorityFeesPerGas = new GasFees(
+    prevTxGasSettings.maxPriorityFeesPerGas.feePerDaGas.add(increasedFees.feePerDaGas),
+    prevTxGasSettings.maxPriorityFeesPerGas.feePerL2Gas.add(increasedFees.feePerL2Gas),
+  );
+
+  const fee: FeeOptions = {
+    paymentMethod,
+    gasSettings: GasSettings.from({
+      ...prevTxGasSettings,
+      maxPriorityFeesPerGas,
+      maxFeesPerGas: maxFeesPerGas ?? prevTxGasSettings.maxFeesPerGas,
+    }),
+  };
+
+  const txRequest = await wallet.createTxExecutionRequest({
+    calls: [],
+    fee,
+    nonce,
+    cancellable: true,
+  });
+  const txSimulationResult = await wallet.simulateTx(txRequest, true);
+  const txProvingResult = await wallet.proveTx(txRequest, txSimulationResult.privateExecutionResult);
+  const sentTx = new SentTx(wallet, wallet.sendTx(txProvingResult.toTx()));
+  try {
+    await sentTx.wait();
+
+    log('Transaction has been cancelled');
+
+    const cancelReceipt = await sentTx.getReceipt();
+    log(` Tx fee: ${cancelReceipt.transactionFee}`);
+    log(` Status: ${cancelReceipt.status}`);
+    log(` Block number: ${cancelReceipt.blockNumber}`);
+    log(` Block hash: ${cancelReceipt.blockHash?.toString()}`);
+  } catch (err: any) {
+    log(`Could not cancel transaction\n ${err.message}`);
+  }
+}

package/src/cmds/check_tx.ts

@@ -0,0 +1,12 @@
+import type { PXE, TxHash } from '@aztec/aztec.js';
+import { inspectTx } from '@aztec/cli/inspect';
+import type { LogFn } from '@aztec/foundation/log';
+
+export async function checkTx(client: PXE, txHash: TxHash, statusOnly: boolean, log: LogFn) {
+  if (statusOnly) {
+    const receipt = await client.getTxReceipt(txHash);
+    return receipt.status;
+  } else {
+    await inspectTx(client, txHash, log, { includeBlockInfo: true });
+  }
+}