@aztec-labs/cli-wallet 6.0.0-nightly.20260829

package/dest/cmds/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/cmds/deploy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAInE,OAAO,EAAE,EAAE,EAAE,MAAM,6BAA6B,CAAC;AACjD,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,2BAA2B,CAAC;AAEtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEhE,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,wBAAsB,MAAM,CAC1B,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,YAAY,EACtB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,OAAO,EAAE,GAAG,EAAE,EACd,IAAI,EAAE,EAAE,GAAG,SAAS,EACpB,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,uBAAuB,EAAE,OAAO,EAChC,oBAAoB,EAAE,OAAO,EAC7B,kBAAkB,EAAE,OAAO,GAAG,SAAS,EACvC,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,UAAU,EACnB,aAAa,EAAE,QAAQ,EACvB,OAAO,EAAE,OAAO,EAChB,OAAO,oBAA+B,EACtC,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK,EACV,SAAS,CAAC,EAAE,OAAO,yBAsHpB"}

package/dest/cmds/deploy.js

@@ -0,0 +1,129 @@
+import { NO_FROM } from '@aztec-labs/aztec.js/account';
+import { NO_WAIT } from '@aztec-labs/aztec.js/contracts';
+import { ContractDeployer } from '@aztec-labs/aztec.js/deployment';
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import { waitForTx } from '@aztec-labs/aztec.js/node';
+import { encodeArgs, getContractArtifact, prettyPrintJSON } from '@aztec-labs/cli/utils';
+import { getAllFunctionAbis, getInitializer } from '@aztec-labs/stdlib/abi';
+import { PublicKeys } from '@aztec-labs/stdlib/keys';
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+import { printProfileResult } from '../utils/profiling.js';
+export async function deploy(wallet, node, deployer, artifactPath, json, publicKeys, rawArgs, salt, initializer, skipInstancePublication, skipClassPublication, skipInitialization, wait, feeOpts, waitForStatus, verbose, timeout = DEFAULT_TX_TIMEOUT_S, debugLogger, log, universal) {
+    const out = {};
+    salt ??= Fr.random();
+    const contractArtifact = await getContractArtifact(artifactPath, log);
+    const hasInitializer = getAllFunctionAbis(contractArtifact).some((fn)=>fn.isInitializer);
+    const constructorArtifact = hasInitializer ? getInitializer(contractArtifact, initializer) : undefined;
+    // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)?
+    const contractDeployer = new ContractDeployer(contractArtifact, wallet, initializer);
+    let args = [];
+    if (rawArgs.length > 0) {
+        if (!constructorArtifact) {
+            throw new Error(`Cannot process constructor arguments as no constructor was found`);
+        }
+        debugLogger.debug(`Input arguments: ${rawArgs.map((x)=>`"${x}"`).join(', ')}`);
+        args = encodeArgs(rawArgs, constructorArtifact.parameters);
+        debugLogger.debug(`Encoded arguments: ${args.join(', ')}`);
+    }
+    const deployInteraction = contractDeployer.deploy(args, {
+        salt,
+        publicKeys: publicKeys ?? PublicKeys.default(),
+        ...universal ? {
+            universalDeploy: true
+        } : {}
+    });
+    const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(node, wallet, deployer);
+    const deployOpts = {
+        fee: {
+            gasSettings,
+            paymentMethod
+        },
+        from: deployer ?? NO_FROM,
+        skipClassPublication,
+        skipInitialization,
+        skipInstancePublication
+    };
+    const localStart = performance.now();
+    const sim = await deployInteraction.simulate({
+        ...deployOpts,
+        includeMetadata: true
+    });
+    // includeMetadata: true guarantees these fields are present
+    const estimatedGas = await wallet.estimateGasLimits(sim.gasUsed);
+    const stats = sim.stats;
+    if (feeOpts.estimateOnly) {
+        if (json) {
+            out.fee = {
+                gasLimits: {
+                    da: estimatedGas.gasLimits.daGas,
+                    l2: estimatedGas.gasLimits.l2Gas
+                },
+                teardownGasLimits: {
+                    da: estimatedGas.teardownGasLimits.daGas,
+                    l2: estimatedGas.teardownGasLimits
+                }
+            };
+        }
+    } else {
+        if (verbose) {
+            printProfileResult(stats, log);
+        }
+        const instance = await deployInteraction.getInstance();
+        const address = instance.address;
+        const partialAddress = await deployInteraction.getPartialAddress();
+        const { txHash } = await deployInteraction.send({
+            ...deployOpts,
+            wait: NO_WAIT
+        });
+        const localTimeMs = performance.now() - localStart;
+        debugLogger.debug(`Deploy tx sent with hash ${txHash.toString()}`);
+        out.hash = txHash;
+        if (wait) {
+            const nodeStart = performance.now();
+            const receipt = await waitForTx(node, txHash, {
+                timeout,
+                waitForStatus
+            });
+            const nodeTimeMs = performance.now() - nodeStart;
+            if (!json) {
+                log(`Contract deployed at ${address.toString()}`);
+                log(`Contract partial address ${partialAddress.toString()}`);
+                log(`Contract init hash ${instance.initializationHash.toString()}`);
+                log(`Deployment tx hash: ${txHash.toString()}`);
+                log(`Deployment salt: ${salt.toString()}`);
+                log(`Deployer: ${instance.deployer.toString()}`);
+                log(`Transaction fee: ${receipt.transactionFee?.toString()}`);
+                log(` Local processing time: ${(localTimeMs / 1000).toFixed(1)}s`);
+                log(` Node inclusion time: ${(nodeTimeMs / 1000).toFixed(1)}s`);
+            } else {
+                out.contract = {
+                    address: address.toString(),
+                    partialAddress: partialAddress.toString(),
+                    initializationHash: instance.initializationHash.toString(),
+                    salt: salt.toString(),
+                    transactionFee: receipt.transactionFee?.toString()
+                };
+            }
+        } else {
+            if (!json) {
+                log(`Contract deployed at ${address.toString()}`);
+                log(`Contract partial address ${partialAddress.toString()}`);
+                log(`Contract init hash ${instance.initializationHash.toString()}`);
+                log(`Deployment tx hash: ${txHash.toString()}`);
+                log(`Deployment salt: ${salt.toString()}`);
+                log(`Deployer: ${instance.deployer.toString()}`);
+            } else {
+                out.contract = {
+                    address: address.toString(),
+                    partialAddress: partialAddress.toString(),
+                    initializationHash: instance.initializationHash.toString(),
+                    salt: salt.toString()
+                };
+            }
+        }
+    }
+    if (json) {
+        log(prettyPrintJSON(out));
+    }
+    return await deployInteraction.getAddress();
+}

package/dest/cmds/deploy_account.d.ts

@@ -0,0 +1,8 @@
+import { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import { type AztecNode } from '@aztec-labs/aztec.js/node';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+import type { TxStatus } from '@aztec-labs/stdlib/tx';
+import type { CLIFeeArgs } from '../utils/options/fees.js';
+import type { CLIWallet } from '../utils/wallet.js';
+export declare function deployAccount(wallet: CLIWallet, aztecNode: AztecNode, address: AztecAddress, wait: boolean, deployer: AztecAddress | undefined, registerClass: boolean, publicDeploy: boolean, skipInitialization: boolean, feeOpts: CLIFeeArgs, waitForStatus: TxStatus, json: boolean, verbose: boolean, debugLogger: Logger, log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwbG95X2FjY291bnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbWRzL2RlcGxveV9hY2NvdW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUU5RCxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQWEsTUFBTSwyQkFBMkIsQ0FBQztBQUd0RSxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQXFCLFFBQVEsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBR3pFLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTNELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELHdCQUFzQixhQUFhLENBQ2pDLE1BQU0sRUFBRSxTQUFTLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLE9BQU8sRUFBRSxZQUFZLEVBQ3JCLElBQUksRUFBRSxPQUFPLEVBQ2IsUUFBUSxFQUFFLFlBQVksR0FBRyxTQUFTLEVBQ2xDLGFBQWEsRUFBRSxPQUFPLEVBQ3RCLFlBQVksRUFBRSxPQUFPLEVBQ3JCLGtCQUFrQixFQUFFLE9BQU8sRUFDM0IsT0FBTyxFQUFFLFVBQVUsRUFDbkIsYUFBYSxFQUFFLFFBQVEsRUFDdkIsSUFBSSxFQUFFLE9BQU8sRUFDYixPQUFPLEVBQUUsT0FBTyxFQUNoQixXQUFXLEVBQUUsTUFBTSxFQUNuQixHQUFHLEVBQUUsS0FBSyxpQkErR1gifQ==

package/dest/cmds/deploy_account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy_account.d.ts","sourceRoot":"","sources":["../../src/cmds/deploy_account.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,2BAA2B,CAAC;AAGtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAqB,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,wBAAsB,aAAa,CACjC,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,YAAY,GAAG,SAAS,EAClC,aAAa,EAAE,OAAO,EACtB,YAAY,EAAE,OAAO,EACrB,kBAAkB,EAAE,OAAO,EAC3B,OAAO,EAAE,UAAU,EACnB,aAAa,EAAE,QAAQ,EACvB,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK,iBA+GX"}

package/dest/cmds/deploy_account.js

@@ -0,0 +1,111 @@
+import { NO_FROM } from '@aztec-labs/aztec.js/account';
+import { NO_WAIT } from '@aztec-labs/aztec.js/contracts';
+import { waitForTx } from '@aztec-labs/aztec.js/node';
+import { prettyPrintJSON } from '@aztec-labs/cli/cli-utils';
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+import { printProfileResult } from '../utils/profiling.js';
+export async function deployAccount(wallet, aztecNode, address, wait, deployer, registerClass, publicDeploy, skipInitialization, feeOpts, waitForStatus, json, verbose, debugLogger, log) {
+    const out = {};
+    const account = await wallet.retrieveAccount(address);
+    const { partialAddress, publicKeys } = await account.getCompleteAddress();
+    const { initializationHash, salt } = account.getInstance();
+    if (json) {
+        out.address = address;
+        out.partialAddress = partialAddress;
+        out.salt = salt;
+        out.initHash = initializationHash;
+        out.deployer = deployer;
+    } else {
+        log(`\nNew account:\n`);
+        log(`Address:         ${address.toString()}`);
+        log(`Public key:      ${publicKeys.toString()}`);
+        log(`Partial address: ${partialAddress.toString()}`);
+        log(`Salt:            ${salt.toString()}`);
+        log(`Init hash:       ${initializationHash.toString()}`);
+    }
+    let txHash;
+    let txReceipt;
+    const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(aztecNode, wallet, address);
+    const delegatedDeployment = deployer && !account.address.equals(deployer);
+    const from = delegatedDeployment ? deployer : NO_FROM;
+    const deployAccountOpts = {
+        skipClassPublication: !registerClass,
+        skipInstancePublication: !publicDeploy,
+        skipInitialization,
+        from,
+        fee: {
+            paymentMethod,
+            gasSettings
+        }
+    };
+    const localStart = performance.now();
+    const deployMethod = await account.getDeployMethod();
+    const sim = await deployMethod.simulate({
+        ...deployAccountOpts,
+        includeMetadata: true
+    });
+    // includeMetadata: true guarantees these fields are present
+    const estimatedGas = await wallet.estimateGasLimits(sim.gasUsed);
+    const stats = sim.stats;
+    if (feeOpts.estimateOnly) {
+        if (json) {
+            out.fee = {
+                gasLimits: {
+                    da: estimatedGas.gasLimits.daGas,
+                    l2: estimatedGas.gasLimits.l2Gas
+                },
+                teardownGasLimits: {
+                    da: estimatedGas.teardownGasLimits.daGas,
+                    l2: estimatedGas.teardownGasLimits
+                }
+            };
+        }
+    } else {
+        if (verbose) {
+            printProfileResult(stats, log);
+        }
+        if (!json) {
+            log(`\nWaiting for account contract deployment...`);
+        }
+        const sendOpts = {
+            ...deployAccountOpts,
+            fee: deployAccountOpts.fee ? {
+                ...deployAccountOpts.fee,
+                gasSettings: estimatedGas
+            } : undefined
+        };
+        ({ txHash } = await deployMethod.send({
+            ...sendOpts,
+            wait: NO_WAIT
+        }));
+        const localTimeMs = performance.now() - localStart;
+        if (wait) {
+            const nodeStart = performance.now();
+            txReceipt = await waitForTx(aztecNode, txHash, {
+                timeout: DEFAULT_TX_TIMEOUT_S,
+                waitForStatus
+            });
+            const nodeTimeMs = performance.now() - nodeStart;
+            out.txReceipt = {
+                status: txReceipt.status,
+                transactionFee: txReceipt.transactionFee
+            };
+            if (!json) {
+                log(` Local processing time: ${(localTimeMs / 1000).toFixed(1)}s`);
+                log(` Node inclusion time: ${(nodeTimeMs / 1000).toFixed(1)}s`);
+            }
+        }
+        debugLogger.debug(`Account contract tx sent with hash ${txHash.toString()}`);
+        out.txHash = txHash;
+    }
+    if (json) {
+        log(prettyPrintJSON(out));
+    } else {
+        if (txHash) {
+            log(`Deploy tx hash:  ${txHash.toString()}`);
+        }
+        if (txReceipt) {
+            log(`Deploy tx fee:   ${txReceipt.transactionFee}`);
+        }
+    }
+}

package/dest/cmds/get_fee_juice_balance.d.ts

@@ -0,0 +1,5 @@
+import type { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import type { AztecNode } from '@aztec-labs/aztec.js/node';
+import type { LogFn } from '@aztec-labs/foundation/log';
+export declare function getFeeJuiceBalanceCmd(node: AztecNode, address: AztecAddress, json: boolean, exact: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X2ZlZV9qdWljZV9iYWxhbmNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY21kcy9nZXRfZmVlX2p1aWNlX2JhbGFuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbkUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFHM0QsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFtQnhELHdCQUFzQixxQkFBcUIsQ0FDekMsSUFBSSxFQUFFLFNBQVMsRUFDZixPQUFPLEVBQUUsWUFBWSxFQUNyQixJQUFJLEVBQUUsT0FBTyxFQUNiLEtBQUssRUFBRSxPQUFPLEVBQ2QsR0FBRyxFQUFFLEtBQUssaUJBUVgifQ==

package/dest/cmds/get_fee_juice_balance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_fee_juice_balance.d.ts","sourceRoot":"","sources":["../../src/cmds/get_fee_juice_balance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAG3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAmBxD,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,KAAK,iBAQX"}

package/dest/cmds/get_fee_juice_balance.js

@@ -0,0 +1,27 @@
+import { getFeeJuiceBalance } from '@aztec-labs/aztec.js/utils';
+import { prettyPrintJSON } from '@aztec-labs/cli/cli-utils';
+const FEE_JUICE_DECIMALS = 18;
+const FEE_JUICE_UNIT = 10n ** BigInt(FEE_JUICE_DECIMALS);
+/** Formats a raw FeeJuice balance (18 decimals) for human-readable display. */ function formatFeeJuice(raw, exact) {
+    const whole = raw / FEE_JUICE_UNIT;
+    const fractional = raw % FEE_JUICE_UNIT;
+    const fracStr = fractional.toString().padStart(FEE_JUICE_DECIMALS, '0');
+    if (exact) {
+        return `${whole}.${fracStr} FJ`;
+    }
+    if (fractional === 0n) {
+        return `${whole} FJ`;
+    }
+    return `${whole}.${fracStr.replace(/0+$/, '')} FJ`;
+}
+export async function getFeeJuiceBalanceCmd(node, address, json, exact, log) {
+    const balance = await getFeeJuiceBalance(address, node);
+    if (json) {
+        log(prettyPrintJSON({
+            address: address.toString(),
+            balance: balance.toString()
+        }));
+    } else {
+        log(`Fee Juice balance for ${address.toString()}: ${formatFeeJuice(balance, exact)}`);
+    }
+}

package/dest/cmds/import_test_accounts.d.ts

@@ -0,0 +1,5 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { WalletDB } from '../storage/wallet_db.js';
+import type { CLIWallet } from '../utils/wallet.js';
+export declare function importTestAccounts(wallet: CLIWallet, db: WalletDB, json: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1wb3J0X3Rlc3RfYWNjb3VudHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbWRzL2ltcG9ydF90ZXN0X2FjY291bnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRXhELE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELHdCQUFzQixrQkFBa0IsQ0FBQyxNQUFNLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxpQkE2Q2xHIn0=

package/dest/cmds/import_test_accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import_test_accounts.d.ts","sourceRoot":"","sources":["../../src/cmds/import_test_accounts.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAExD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,iBA6ClG"}

package/dest/cmds/import_test_accounts.js

@@ -0,0 +1,40 @@
+import { getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import { prettyPrintJSON } from '@aztec-labs/cli/cli-utils';
+export async function importTestAccounts(wallet, db, json, log) {
+    const testAccounts = await getInitialTestAccountsData();
+    const out = {};
+    await Promise.all(testAccounts.map(async (account, i)=>{
+        const alias = `test${i}`;
+        const secret = testAccounts[i].secret;
+        const salt = new Fr(account.salt);
+        const address = account.address;
+        await db.storeAccount(address, {
+            type: 'schnorr_initializerless',
+            signingKey: account.signingKey,
+            secretKey: secret,
+            salt,
+            alias,
+            publicKey: undefined
+        }, log);
+        if (json) {
+            out[alias] = {
+                alias,
+                address,
+                secret,
+                salt
+            };
+        } else {
+            log(`\nTest account:`);
+            log(`Alias:           ${alias}`);
+            log(`Address:         ${address}`);
+            log(`Secret key:      ${secret}`);
+            log(`Salt:            ${salt}`);
+        }
+    }));
+    if (json) {
+        log(prettyPrintJSON(out));
+    } else {
+        log(`\n${testAccounts.length} test accounts imported to wallet db.\n`);
+    }
+}

package/dest/cmds/index.d.ts

@@ -0,0 +1,6 @@
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+import { type Command } from 'commander';
+import type { WalletDB } from '../storage/wallet_db.js';
+import type { CliWalletAndNodeWrapper } from '../utils/cli_wallet_and_node_wrapper.js';
+export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger, walletAndNodeWrapper: CliWalletAndNodeWrapper, db: WalletDB): Command;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbWRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWFBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUVoRSxPQUFPLEVBQUUsS0FBSyxPQUFPLEVBQVUsTUFBTSxXQUFXLENBQUM7QUFHakQsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQW1DdkYsd0JBQWdCLGNBQWMsQ0FDNUIsT0FBTyxFQUFFLE9BQU8sRUFDaEIsR0FBRyxFQUFFLEtBQUssRUFDVixXQUFXLEVBQUUsTUFBTSxFQUNuQixvQkFBb0IsRUFBRSx1QkFBdUIsRUFDN0MsRUFBRSxFQUFFLFFBQVEsV0FncUJiIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cmds/index.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEhE,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAGjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAmCvF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,EACnB,oBAAoB,EAAE,uBAAuB,EAC7C,EAAE,EAAE,QAAQ,WAgqBb"}

package/dest/cmds/index.js

@@ -0,0 +1,208 @@
+import { getIdentities } from '@aztec-labs/accounts/utils';
+import { TxHash } from '@aztec-labs/aztec.js/tx';
+import { ETHEREUM_HOSTS, PRIVATE_KEY, addOptions, createSigningKeyOption, l1ChainIdOption, parseBigint, parseFieldFromHexString, parsePublicKey } from '@aztec-labs/cli/utils';
+import { randomBytes } from '@aztec-labs/foundation/crypto/random';
+import { TxStatus } from '@aztec-labs/stdlib/tx';
+import { Option } from 'commander';
+import inquirer from 'inquirer';
+import { ARTIFACT_DESCRIPTION, CLIFeeArgs, aliasedAddressParser, aliasedSigningKeyParser, aliasedTxHashParser, artifactPathFromPromiseOrAlias, artifactPathParser, cleanupAuthWitnesses, createAccountOption, createAliasOption, createArgsOption, createArtifactOption, createAuthwitnessOption, createContractAddressOption, createDebugExecutionStepsDirOption, createTypeOption, createVerboseOption, integerArgParser } from '../utils/options/index.js';
+function parseWaitForStatus(status) {
+    switch(status){
+        case 'proposed':
+            return TxStatus.PROPOSED;
+        case 'checkpointed':
+            return TxStatus.CHECKPOINTED;
+        default:
+            throw new Error(`Invalid wait-for-status: ${status}. Use 'proposed' or 'checkpointed'.`);
+    }
+}
+// TODO: This function is only used in 1 place so we could just inline this
+export function injectCommands(program, log, debugLogger, walletAndNodeWrapper, db) {
+    program.command('import-test-accounts').description('Import test accounts from pxe.').option('--json', 'Emit output as json').action(async (options)=>{
+        const { json } = options;
+        const wallet = walletAndNodeWrapper.wallet;
+        const { importTestAccounts } = await import('./import_test_accounts.js');
+        await importTestAccounts(wallet, db, json, log);
+    });
+    const createAccountCommand = program.command('create-account').description('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 account which uses an immutable key for authentication.').summary('Creates an aztec account that can be used for sending transactions.').addOption(createAccountOption('Alias or address of the account performing the deployment', !db, db)).option('--skip-initialization', 'Skip initializing the account contract. Useful for publicly deploying an existing account.').option('--public-deploy', 'Publishes the account contract instance (and the class, if needed). Needed if the contract contains public functions.').option('--register-class', 'Register the contract class (useful for when the contract class has not been deployed yet).').option('-p, --public-key <string>', 'Public key that identifies a private signing key stored outside of the wallet. Used for ECDSA SSH accounts over the secp256r1 curve.').addOption(createSigningKeyOption('Signing key for account. Uses random by default.', false, (sk)=>aliasedSigningKeyParser(sk, db)).conflicts('public-key')).addOption(createAliasOption('Alias for the account. Used for easy reference in subsequent commands.', !db)).addOption(createTypeOption(true)).option('-s, --salt <hex string>', 'Optional deployment salt as a hex string for generating the deployment address. Defaults to 0.', parseFieldFromHexString).option('--register-only', 'Just register the account on the Wallet. Do not deploy or initialize the account contract.').option('--json', 'Emit output as json')// `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').option('--wait-for-status <status>', "Tx status to wait for: 'proposed' or 'checkpointed'", 'proposed').addOption(createVerboseOption());
+    addOptions(createAccountCommand, CLIFeeArgs.getOptions()).action(async (_options, command)=>{
+        const { createAccount } = await import('./create_account.js');
+        const options = command.optsWithGlobals();
+        const { type, from: parsedFromAddress, signingKey, salt, wait, waitForStatus: waitForStatusStr, registerOnly, skipInitialization, publicDeploy, registerClass, alias, json, verbose } = options;
+        let { publicKey } = options;
+        if (type === 'ecdsasecp256r1ssh' && !publicKey) {
+            const identities = await getIdentities();
+            const answers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'identity',
+                    message: 'What public key to use?',
+                    choices: identities.map((key)=>`${key.type} ${key.publicKey} ${key.comment}`)
+                }
+            ]);
+            publicKey = answers.identity.split(' ')[1];
+        }
+        const { wallet, node } = walletAndNodeWrapper;
+        const accountCreationResult = await createAccount(wallet, node, type, signingKey, salt, publicKey, alias, parsedFromAddress, registerOnly, skipInitialization, publicDeploy, registerClass, wait, CLIFeeArgs.parse(options, log, db), parseWaitForStatus(waitForStatusStr), json, verbose, debugLogger, log);
+        if (db) {
+            const { address, alias, signingKey, secretKey, salt } = accountCreationResult;
+            await db.storeAccount(address, {
+                type,
+                signingKey,
+                secretKey,
+                salt,
+                alias,
+                publicKey
+            }, log);
+        }
+    });
+    const deployAccountCommand = program.command('deploy-account').description('Deploys an already registered aztec account that can be used for sending transactions.').argument('<address>', 'The address of the contract to register', (address)=>aliasedAddressParser('accounts', address, db)).addOption(createAccountOption('Alias or address of the account performing the deployment', !db, db)).option('--json', 'Emit output as json')// `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').option('--register-class', 'Register the contract class (useful for when the contract class has not been deployed yet).').option('--public-deploy', 'Publishes the account contract instance (and the class, if needed). Needed if the contract contains public functions.').option('--skip-initialization', 'Skip initializing the account contract. Useful for publicly deploying an existing account.').option('--wait-for-status <status>', "Tx status to wait for: 'proposed' or 'checkpointed'", 'proposed').addOption(createVerboseOption());
+    addOptions(deployAccountCommand, CLIFeeArgs.getOptions()).action(async (parsedAccount, _options, command)=>{
+        const { deployAccount } = await import('./deploy_account.js');
+        const options = command.optsWithGlobals();
+        const { wait, waitForStatus: waitForStatusStr, from: parsedFromAddress, json, registerClass, skipInitialization, publicDeploy, verbose } = options;
+        const { wallet, node } = walletAndNodeWrapper;
+        await deployAccount(wallet, node, parsedAccount, wait, parsedFromAddress, registerClass, publicDeploy, skipInitialization, CLIFeeArgs.parse(options, log, db), parseWaitForStatus(waitForStatusStr), json, verbose, debugLogger, log);
+    });
+    const deployCommand = program.command('deploy').description('Deploys a compiled Aztec.nr contract to Aztec.').argument('[artifact]', ARTIFACT_DESCRIPTION, artifactPathParser).option('--init <string>', 'The contract initializer function to call', 'constructor').option('--no-init', 'Leave the contract uninitialized').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 <hex string>', 'Optional deployment salt as a hex string for generating the deployment address. Defaults to random.', parseFieldFromHexString).option('--universal', 'Do not mix the sender address into the deployment.').addOption(createArgsOption(true, db)).addOption(createAccountOption('Alias or address of the account to deploy from', !db, db)).addOption(createAliasOption('Alias for the contract. Used for easy reference subsequent commands.', !db)).option('--json', 'Emit output as json')// `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').option('--no-class-registration', "Don't register this contract class").option('--no-public-deployment', "Don't emit this contract's public bytecode").addOption(new Option('--timeout <number>', 'The amount of time in seconds to wait for the deployment to post to L2').conflicts('wait')).option('--wait-for-status <status>', "Tx status to wait for: 'proposed' or 'checkpointed'", 'proposed').addOption(createVerboseOption());
+    addOptions(deployCommand, CLIFeeArgs.getOptions()).action(async (artifactPathPromise, _options, command)=>{
+        const { deploy } = await import('./deploy.js');
+        const options = command.optsWithGlobals();
+        const { json, publicKey, args, salt, wait, waitForStatus: waitForStatusStr, classRegistration, init, publicDeployment, universal, from: parsedFromAddress, alias, timeout, verbose } = options;
+        const { wallet, node } = walletAndNodeWrapper;
+        const artifactPath = await artifactPathPromise;
+        debugLogger.info(`Using wallet with address ${parsedFromAddress?.toString() ?? '<none>'}`);
+        const address = await deploy(wallet, node, parsedFromAddress, artifactPath, json, publicKey, args, salt, typeof init === 'string' ? init : undefined, !publicDeployment, !classRegistration, typeof init === 'string' ? false : init, wait, CLIFeeArgs.parse(options, log, db), parseWaitForStatus(waitForStatusStr), verbose, timeout, debugLogger, log, universal);
+        if (db && address) {
+            await db.storeContract(address, artifactPath, log, alias);
+        }
+    });
+    const sendCommand = program.command('send').description('Calls a function on an Aztec contract.').argument('<functionName>', 'Name of function to execute').addOption(createArgsOption(false, db)).addOption(createArtifactOption(db)).addOption(createContractAddressOption(db)).addOption(createAliasOption('Alias for the transaction hash. Used for easy reference in subsequent commands.', !db)).addOption(createAuthwitnessOption('Authorization witness to use for the transaction. If using multiple, pass a comma separated string', !db, db)).addOption(createAccountOption('Alias or address of the account to send the transaction from', !db, db)).option('--no-wait', 'Print transaction hash without waiting for it to be mined').option('--wait-for-status <status>', "Tx status to wait for: 'proposed' or 'checkpointed'", 'proposed').addOption(createVerboseOption());
+    addOptions(sendCommand, CLIFeeArgs.getOptions()).action(async (functionName, _options, command)=>{
+        const { send } = await import('./send.js');
+        const options = command.optsWithGlobals();
+        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, wait, waitForStatus: waitForStatusStr, alias, authWitness: authWitnessArray, verbose } = options;
+        const { wallet, node } = walletAndNodeWrapper;
+        const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+        debugLogger.info(`Using wallet with address ${parsedFromAddress.toString()}`);
+        const authWitnesses = cleanupAuthWitnesses(authWitnessArray);
+        const sentTx = await send(wallet, node, parsedFromAddress, functionName, args, artifactPath, contractAddress, wait, alias, CLIFeeArgs.parse(options, log, db), authWitnesses, parseWaitForStatus(waitForStatusStr), verbose, log);
+        if (db && sentTx) {
+            const txAlias = alias ? alias : `${functionName}-${randomBytes(16).toString('hex')}`;
+            await db.storeTx(sentTx, log, txAlias);
+        }
+    });
+    const simulateCommand = program.command('simulate').description('Simulates the execution of a function on an Aztec contract.').argument('<functionName>', 'Name of function to simulate').addOption(createArgsOption(false, db)).addOption(createContractAddressOption(db)).addOption(createArtifactOption(db)).addOption(createSigningKeyOption("The sender's signing key", !db, (sk)=>aliasedSigningKeyParser(sk, db)).conflicts('account')).addOption(createAuthwitnessOption('Authorization witness to use for the simulation', !db, db)).addOption(createAccountOption('Alias or address of the account to simulate from', !db, db)).addOption(createVerboseOption());
+    addOptions(simulateCommand, CLIFeeArgs.getOptions()).action(async (functionName, _options, command)=>{
+        const { simulate } = await import('./simulate.js');
+        const options = command.optsWithGlobals();
+        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, verbose, authWitness } = options;
+        const { wallet, node } = walletAndNodeWrapper;
+        const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+        const authWitnesses = cleanupAuthWitnesses(authWitness);
+        await simulate(wallet, node, parsedFromAddress, functionName, args, artifactPath, contractAddress, CLIFeeArgs.parse(options, log, db), authWitnesses, verbose, log);
+    });
+    const profileCommand = program.command('profile').description('Profiles a private function by counting the unconditional operations in its execution steps').argument('<functionName>', 'Name of function to simulate').addOption(createArgsOption(false, db)).addOption(createContractAddressOption(db)).addOption(createArtifactOption(db)).addOption(createDebugExecutionStepsDirOption()).addOption(createAuthwitnessOption('Authorization witness to use for the simulation', !db, db)).addOption(createAccountOption('Alias or address of the account to simulate from', !db, db));
+    addOptions(profileCommand, CLIFeeArgs.getOptions()).action(async (functionName, _options, command)=>{
+        const { profile } = await import('./profile.js');
+        const options = command.optsWithGlobals();
+        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, debugExecutionStepsDir, authWitness } = options;
+        const { wallet, node } = walletAndNodeWrapper;
+        const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+        const authWitnesses = cleanupAuthWitnesses(authWitness);
+        await profile(wallet, node, parsedFromAddress, functionName, args, artifactPath, contractAddress, debugExecutionStepsDir, CLIFeeArgs.parse(options, log, db), authWitnesses, log);
+    });
+    program.command('bridge-fee-juice').description('Mints L1 Fee Juice and pushes them to L2.').argument('<amount>', 'The amount of Fee Juice to mint and bridge.', parseBigint).argument('<recipient>', 'Aztec address of the recipient.', (address)=>aliasedAddressParser('accounts', address, db)).requiredOption('--l1-rpc-urls <string>', 'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)', (arg)=>arg.split(','), [
+        ETHEREUM_HOSTS
+    ]).option('-m, --mnemonic <string>', 'The mnemonic to use for deriving the Ethereum address that will mint and bridge', 'test test test test test test test test test test test junk').option('--mint', 'Mint the tokens on L1', false).option('--l1-private-key <string>', 'The private key to the eth account bridging', PRIVATE_KEY).addOption(l1ChainIdOption).option('--json', 'Output the claim in JSON format')// `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', 'Wait for the bridged funds to be available in L2, polling every 60 seconds').addOption(new Option('--interval <number>', 'The polling interval in seconds for the bridged funds').default('60').conflicts('wait')).action(async (amount, recipient, options)=>{
+        const { bridgeL1FeeJuice } = await import('./bridge_fee_juice.js');
+        const { l1ChainId, l1RpcUrls, l1PrivateKey, mnemonic, mint, json, wait, interval: intervalS } = options;
+        const [secret, messageLeafIndex] = await bridgeL1FeeJuice(amount, recipient, walletAndNodeWrapper.node, l1RpcUrls, l1ChainId, l1PrivateKey, mnemonic, mint, json, wait, intervalS * 1000, log, debugLogger);
+        if (db) {
+            await db.pushBridgedFeeJuice(recipient, secret, amount, messageLeafIndex, log);
+        }
+    });
+    program.command('get-fee-juice-balance').description('Checks the Fee Juice balance for a given address.').argument('<address>', 'Aztec address or alias to check balance for', (address)=>aliasedAddressParser('accounts', address, db)).option('--json', 'Emit output as json').option('--exact', 'Show exact balance with all 18 decimal places').action(async (address, options)=>{
+        const { getFeeJuiceBalanceCmd } = await import('./get_fee_juice_balance.js');
+        const { json, exact } = options;
+        await getFeeJuiceBalanceCmd(walletAndNodeWrapper.node, address, json, exact, log);
+    });
+    program.command('create-authwit').description('Creates an authorization witness that can be privately sent to a caller so they can perform an action on behalf of the provided account').argument('<functionName>', 'Name of function to authorize').argument('<caller>', 'Account to be authorized to perform the action', (address)=>aliasedAddressParser('accounts', address, db)).addOption(createArgsOption(false, db)).addOption(createContractAddressOption(db)).addOption(createArtifactOption(db)).addOption(createAccountOption('Alias or address of the account to simulate from', !db, db)).addOption(createAliasOption('Alias for the authorization witness. Used for easy reference in subsequent commands.', !db)).action(async (functionName, caller, _options, command)=>{
+        const { createAuthwit } = await import('./create_authwit.js');
+        const options = command.optsWithGlobals();
+        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, alias } = options;
+        const wallet = walletAndNodeWrapper.wallet;
+        const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+        const witness = await createAuthwit(wallet, parsedFromAddress, functionName, caller, args, artifactPath, contractAddress, log);
+        if (db) {
+            await db.storeAuthwitness(witness, log, alias);
+        }
+    });
+    program.command('authorize-action').description('Authorizes a public call on the caller, so they can perform an action on behalf of the provided account').argument('<functionName>', 'Name of function to authorize').argument('<caller>', 'Account to be authorized to perform the action', (address)=>aliasedAddressParser('accounts', address, db)).addOption(createArgsOption(false, db)).addOption(createContractAddressOption(db)).addOption(createArtifactOption(db)).addOption(createAccountOption('Alias or address of the account to simulate from', !db, db)).action(async (functionName, caller, _options, command)=>{
+        const { authorizeAction } = await import('./authorize_action.js');
+        const options = command.optsWithGlobals();
+        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress } = options;
+        const wallet = walletAndNodeWrapper.wallet;
+        const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+        await authorizeAction(wallet, parsedFromAddress, functionName, caller, args, artifactPath, contractAddress, log);
+    });
+    program.command('get-tx').description('Gets the status of the recent txs, or a detailed view if a specific transaction hash is provided').argument('[txHash]', 'A transaction hash to get the receipt for.', (txHash)=>aliasedTxHashParser(txHash, db)).option('-p, --page <number>', 'The page number to display', (value)=>integerArgParser(value, '--page', 1), 1).option('-s, --page-size <number>', 'The number of transactions to display per page', (value)=>integerArgParser(value, '--page-size', 1), 10).action(async (txHash, options)=>{
+        const { checkTx } = await import('./check_tx.js');
+        const { pageSize } = options;
+        let { page } = options;
+        const wallet = walletAndNodeWrapper.wallet;
+        const node = walletAndNodeWrapper.node;
+        if (txHash) {
+            await checkTx(wallet, node, txHash, false, log);
+        } else if (db) {
+            const aliases = await db.listAliases('transactions');
+            const totalPages = Math.ceil(aliases.length / pageSize);
+            page = Math.min(page - 1, totalPages - 1);
+            const dataRows = await Promise.all(aliases.slice(page * pageSize, pageSize * (1 + page)).map(async ({ key, value })=>({
+                    alias: key,
+                    txHash: value,
+                    status: await checkTx(wallet, node, TxHash.fromString(value), true, log)
+                })));
+            log(`Recent transactions:`);
+            log('');
+            log(`${'Alias'.padEnd(32, ' ')} | ${'TxHash'.padEnd(64, ' ')} | ${'Cancellable'.padEnd(12, ' ')} | Status`);
+            log(''.padEnd(32 + 64 + 20, '-'));
+            for (const { alias, txHash, status } of dataRows){
+                log(`${alias.padEnd(32, ' ')} | ${txHash} | ${status}`);
+                log(''.padEnd(32 + 64 + 20, '-'));
+            }
+            log(`Displaying ${Math.min(pageSize, aliases.length)} rows, page ${page + 1}/${totalPages}`);
+        } else {
+            log('Recent transactions are not available, please provide a specific transaction hash');
+        }
+    });
+    program.command('register-sender').description("Registers a sender's address in the wallet, so the note synching process will look for notes sent by them").argument('[address]', 'The address of the sender to register', (address)=>aliasedAddressParser('accounts', address, db)).addOption(createAliasOption('Alias for the sender. Used for easy reference in subsequent commands.', !db)).action(async (address, options)=>{
+        const { registerSender } = await import('./register_sender.js');
+        const { alias } = options;
+        const wallet = walletAndNodeWrapper.wallet;
+        await registerSender(wallet, address, log);
+        if (db && alias) {
+            await db.storeSender(address, alias, log);
+        }
+    });
+    program.command('register-contract').description("Registers a contract in this wallet's PXE").argument('[address]', 'The address of the contract to register', (address)=>aliasedAddressParser('accounts', address, db)).argument('[artifact]', ARTIFACT_DESCRIPTION, artifactPathParser).option('--init <string>', 'The contract initializer function to call', 'constructor').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 <hex string>', 'Optional deployment salt as a hex string for generating the deployment address.', parseFieldFromHexString).option('--deployer <string>', 'The address of the account that deployed the contract', (address)=>aliasedAddressParser('accounts', address, db)).addOption(createArgsOption(true, db)).addOption(createAliasOption('Alias for the contact. Used for easy reference in subsequent commands.', !db)).action(async (address, artifactPathPromise, _options, command)=>{
+        const { registerContract } = await import('./register_contract.js');
+        const { alias, init, publicKey, salt, deployer, args } = command.optsWithGlobals();
+        const wallet = walletAndNodeWrapper.wallet;
+        const node = walletAndNodeWrapper.node;
+        const artifactPath = await artifactPathPromise;
+        const instance = await registerContract(wallet, node, address, artifactPath, log, init, publicKey, args, salt, deployer);
+        if (db && alias) {
+            await db.storeContract(instance.address, artifactPath, log, alias);
+        }
+    });
+    return program;
+}

package/dest/cmds/profile.d.ts

@@ -0,0 +1,8 @@
+import type { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import { AuthWitness } from '@aztec-labs/aztec.js/authorization';
+import type { AztecNode } from '@aztec-labs/aztec.js/node';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { CLIFeeArgs } from '../utils/options/fees.js';
+import type { CLIWallet } from '../utils/wallet.js';
+export declare function profile(wallet: CLIWallet, node: AztecNode, from: AztecAddress, functionName: string, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, debugOutputPath: string | undefined, feeOpts: CLIFeeArgs, authWitnesses: AuthWitness[], log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZmlsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NtZHMvcHJvZmlsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNuRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFFakUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFM0QsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFLeEQsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFM0QsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFcEQsd0JBQXNCLE9BQU8sQ0FDM0IsTUFBTSxFQUFFLFNBQVMsRUFDakIsSUFBSSxFQUFFLFNBQVMsRUFDZixJQUFJLEVBQUUsWUFBWSxFQUNsQixZQUFZLEVBQUUsTUFBTSxFQUNwQixjQUFjLEVBQUUsR0FBRyxFQUFFLEVBQ3JCLG9CQUFvQixFQUFFLE1BQU0sRUFDNUIsZUFBZSxFQUFFLFlBQVksRUFDN0IsZUFBZSxFQUFFLE1BQU0sR0FBRyxTQUFTLEVBQ25DLE9BQU8sRUFBRSxVQUFVLEVBQ25CLGFBQWEsRUFBRSxXQUFXLEVBQUUsRUFDNUIsR0FBRyxFQUFFLEtBQUssaUJBcUJYIn0=

package/dest/cmds/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/cmds/profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAKxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,wBAAsB,OAAO,CAC3B,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,YAAY,EAClB,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,GAAG,EAAE,EACrB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,YAAY,EAC7B,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,OAAO,EAAE,UAAU,EACnB,aAAa,EAAE,WAAW,EAAE,EAC5B,GAAG,EAAE,KAAK,iBAqBX"}