@aztec/cli-wallet 0.86.0 → 0.87.0

package/dest/bin/index.js

@@ -1,4 +1,4 @@
-import { Fr, computeSecretHash, createCompatibleClient, fileURLToPath } from '@aztec/aztec.js';
+import { Fr, ProtocolContractAddress, computeSecretHash, fileURLToPath } from '@aztec/aztec.js';
 import { LOCALHOST } from '@aztec/cli/cli-utils';
 import { createConsoleLogger, createLogger } from '@aztec/foundation/log';
 import { openStoreAt } from '@aztec/kv-store/lmdb-v2';
@@ -33,7 +33,7 @@ function injectInternalCommands(program, log, db) {
         const options = command.optsWithGlobals();
         const { alias } = options;
         const value = Fr.random();
-        const hash = computeSecretHash(value);
+        const hash = await computeSecretHash(value);
         await db.storeAlias('secrets', alias, Buffer.from(value.toString()), log);
         await db.storeAlias('secrets', `${alias}:hash`, Buffer.from(hash.toString()), log);
     });
@@ -49,8 +49,8 @@ function injectInternalCommands(program, log, db) {
         'wasm',
         'native',
         'none'
-    ]).env('PXE_PROVER').default('native')).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, rpcUrl } = command.optsWithGlobals();
+    ]).env('PXE_PROVER').default('native')).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';
@@ -64,19 +64,17 @@ function injectInternalCommands(program, log, db) {
                 bbBinaryPath: prover === 'native' ? bbBinaryPath : undefined,
                 bbWorkingDirectory: prover === 'native' ? bbWorkingDirectory : undefined
             };
-            await pxeWrapper.init(nodeUrl, join(dataDir, 'pxe'), overridePXEConfig);
+            pxeWrapper.prepare(nodeUrl, join(dataDir, 'pxe'), overridePXEConfig);
         }
         await db.init(await openStoreAt(dataDir));
         let protocolContractsRegistered;
         try {
-            protocolContractsRegistered = !!await db.retrieveAlias('contracts:classRegisterer');
+            protocolContractsRegistered = !!await db.retrieveAlias('contracts:ContractClassRegisterer');
         // eslint-disable-next-line no-empty
         } catch  {}
         if (!protocolContractsRegistered) {
             userLog('Registering protocol contract aliases...');
-            const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-            const { protocolContractAddresses } = await client.getPXEInfo();
-            for (const [name, address] of Object.entries(protocolContractAddresses)){
+            for (const [name, address] of Object.entries(ProtocolContractAddress)){
                 await db.storeAlias('contracts', name, Buffer.from(address.toString()), userLog);
                 await db.storeAlias('artifacts', address.toString(), Buffer.from(`${name.slice(0, 1).toUpperCase()}${name.slice(1)}`), userLog);
             }

package/dest/cmds/create_account.d.ts

@@ -3,7 +3,7 @@ import { Fr } from '@aztec/foundation/fields';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import { type AccountType } from '../utils/accounts.js';
 import { type IFeeOpts } from '../utils/options/fees.js';
-export declare function createAccount(client: PXE, accountType: AccountType, secretKey: Fr | undefined, publicKey: string | undefined, alias: string | undefined, registerOnly: boolean, publicDeploy: boolean, skipInitialization: boolean, wait: boolean, feeOpts: IFeeOpts, json: boolean, debugLogger: Logger, log: LogFn): Promise<{
+export declare function createAccount(client: PXE, accountType: AccountType, secretKey: Fr | undefined, publicKey: string | undefined, alias: string | undefined, registerOnly: boolean, publicDeploy: boolean, skipInitialization: boolean, wait: boolean, feeOpts: IFeeOpts, json: boolean, verbose: boolean, debugLogger: Logger, log: LogFn): Promise<{
     alias: string | undefined;
     address: import("@aztec/aztec.js").AztecAddress;
     secretKey: Fr;

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

@@ -1 +1 @@
-{"version":3,"file":"create_account.d.ts","sourceRoot":"","sources":["../../src/cmds/create_account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAwB,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAEjE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,KAAK,WAAW,EAA2B,MAAM,sBAAsB,CAAC;AACjF,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAE5E,wBAAsB,aAAa,CACjC,MAAM,EAAE,GAAG,EACX,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,EAAE,GAAG,SAAS,EACzB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,OAAO,EACrB,kBAAkB,EAAE,OAAO,EAC3B,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK;;;;;GA8GX"}
+{"version":3,"file":"create_account.d.ts","sourceRoot":"","sources":["../../src/cmds/create_account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAwB,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAEjE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,KAAK,WAAW,EAA2B,MAAM,sBAAsB,CAAC;AACjF,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAG5E,wBAAsB,aAAa,CACjC,MAAM,EAAE,GAAG,EACX,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,EAAE,GAAG,SAAS,EACzB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,OAAO,EACrB,kBAAkB,EAAE,OAAO,EAC3B,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK;;;;;GAsHX"}

package/dest/cmds/create_account.js

@@ -2,7 +2,8 @@ import { prettyPrintJSON } from '@aztec/cli/cli-utils';
 import { Fr } from '@aztec/foundation/fields';
 import { createOrRetrieveAccount } from '../utils/accounts.js';
 import { printGasEstimates } from '../utils/options/fees.js';
-export async function createAccount(client, accountType, secretKey, publicKey, alias, registerOnly, publicDeploy, skipInitialization, wait, feeOpts, json, debugLogger, log) {
+import { printProfileResult } from '../utils/profiling.js';
+export async function createAccount(client, accountType, secretKey, publicKey, alias, registerOnly, publicDeploy, skipInitialization, wait, feeOpts, json, verbose, debugLogger, log) {
     secretKey ??= Fr.random();
     const account = await createOrRetrieveAccount(client, undefined /* address, we don't have it yet */ , undefined /* db, as we want to create from scratch */ , secretKey, accountType, Fr.ZERO, publicKey);
     const { salt } = account.getInstance();
@@ -42,22 +43,23 @@ export async function createAccount(client, accountType, secretKey, publicKey, a
             skipInitialization: skipInitialization,
             ...await feeOpts.toDeployAccountOpts(wallet)
         };
+        /*
+     * This is usually handled by accountManager.deploy(), but we're accessing the lower
+     * level method to get gas and timings. That means we have to replicate some of the logic here.
+     * In case we're deploying our own account, we need to hijack the payment method for the fee,
+     * wrapping it in the one that will make use of the freshly deployed account's
+     * entrypoint. For reference, see aztec.js/src/account_manager.ts:deploy()
+     * Also, salt and universalDeploy have to be explicitly provided
+     */ deployOpts.fee = !deployOpts?.deployWallet && deployOpts?.fee ? {
+            ...deployOpts.fee,
+            paymentMethod: await account.getSelfPaymentMethod(deployOpts.fee.paymentMethod)
+        } : deployOpts?.fee;
+        const deployMethod = await account.getDeployMethod(deployOpts.deployWallet);
         if (feeOpts.estimateOnly) {
-            /*
-       * This is usually handled by accountManager.deploy(), but we're accessing the lower
-       * level method to get the gas estimates. That means we have to replicate some of the logic here.
-       * In case we're deploying our own account, we need to hijack the payment method for the fee,
-       * wrapping it in the one that will make use of the freshly deployed account's
-       * entrypoint. For reference, see aztec.js/src/account_manager.ts:deploy()
-       */ const fee = !deployOpts?.deployWallet && deployOpts?.fee ? {
-                ...deployOpts.fee,
-                paymentMethod: await account.getSelfPaymentMethod(deployOpts.fee.paymentMethod)
-            } : deployOpts?.fee;
-            const deployMethod = await account.getDeployMethod(deployOpts.deployWallet);
             const gas = await deployMethod.estimateGas({
                 ...deployOpts,
-                fee,
-                universalDeploy: true
+                universalDeploy: true,
+                contractAddressSalt: salt
             });
             if (json) {
                 out.fee = {
@@ -74,7 +76,15 @@ export async function createAccount(client, accountType, secretKey, publicKey, a
                 printGasEstimates(feeOpts, gas, log);
             }
         } else {
-            tx = account.deploy(deployOpts);
+            const provenTx = await deployMethod.prove({
+                ...deployOpts,
+                universalDeploy: true,
+                contractAddressSalt: salt
+            });
+            if (verbose) {
+                printProfileResult(provenTx.timings, log);
+            }
+            tx = provenTx.send();
             const txHash = await tx.getTxHash();
             debugLogger.debug(`Account contract tx sent with hash ${txHash}`);
             out.txHash = txHash;

package/dest/cmds/deploy.d.ts

@@ -2,5 +2,5 @@ import { type AccountWalletWithSecretKey, Fr } from '@aztec/aztec.js';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import { PublicKeys } from '@aztec/stdlib/keys';
 import { type IFeeOpts } from '../utils/options/fees.js';
-export declare function deploy(wallet: AccountWalletWithSecretKey, artifactPath: string, json: boolean, publicKeys: PublicKeys | undefined, rawArgs: any[], salt: Fr | undefined, initializer: string | undefined, skipPublicDeployment: boolean, skipClassRegistration: boolean, skipInitialization: boolean | undefined, universalDeploy: boolean | undefined, wait: boolean, feeOpts: IFeeOpts, debugLogger: Logger, log: LogFn, logJson: (output: any) => void): Promise<import("@aztec/aztec.js").AztecAddress | undefined>;
+export declare function deploy(wallet: AccountWalletWithSecretKey, artifactPath: string, json: boolean, publicKeys: PublicKeys | undefined, rawArgs: any[], salt: Fr | undefined, initializer: string | undefined, skipPublicDeployment: boolean, skipClassRegistration: boolean, skipInitialization: boolean | undefined, universalDeploy: boolean | undefined, wait: boolean, feeOpts: IFeeOpts, verbose: boolean, debugLogger: Logger, log: LogFn, logJson: (output: any) => void): Promise<import("@aztec/aztec.js").AztecAddress | undefined>;
 //# sourceMappingURL=deploy.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/cmds/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAwC,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAE5G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAE5E,wBAAsB,MAAM,CAC1B,MAAM,EAAE,0BAA0B,EAClC,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,oBAAoB,EAAE,OAAO,EAC7B,qBAAqB,EAAE,OAAO,EAC9B,kBAAkB,EAAE,OAAO,GAAG,SAAS,EACvC,eAAe,EAAE,OAAO,GAAG,SAAS,EACpC,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,QAAQ,EACjB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK,EACV,OAAO,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,+DAkF/B"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/cmds/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAwC,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAE5G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAG5E,wBAAsB,MAAM,CAC1B,MAAM,EAAE,0BAA0B,EAClC,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,oBAAoB,EAAE,OAAO,EAC7B,qBAAqB,EAAE,OAAO,EAC9B,kBAAkB,EAAE,OAAO,GAAG,SAAS,EACvC,eAAe,EAAE,OAAO,GAAG,SAAS,EACpC,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK,EACV,OAAO,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,+DAuF/B"}

package/dest/cmds/deploy.js

@@ -3,7 +3,8 @@ import { encodeArgs, getContractArtifact } from '@aztec/cli/utils';
 import { getAllFunctionAbis, getInitializer } from '@aztec/stdlib/abi';
 import { PublicKeys } from '@aztec/stdlib/keys';
 import { printGasEstimates } from '../utils/options/fees.js';
-export async function deploy(wallet, artifactPath, json, publicKeys, rawArgs, salt, initializer, skipPublicDeployment, skipClassRegistration, skipInitialization, universalDeploy, wait, feeOpts, debugLogger, log, logJson) {
+import { printProfileResult } from '../utils/profiling.js';
+export async function deploy(wallet, artifactPath, json, publicKeys, rawArgs, salt, initializer, skipPublicDeployment, skipClassRegistration, skipInitialization, universalDeploy, wait, feeOpts, verbose, debugLogger, log, logJson) {
     salt ??= Fr.random();
     const contractArtifact = await getContractArtifact(artifactPath, log);
     const hasInitializer = getAllFunctionAbis(contractArtifact).some((fn)=>fn.isInitializer);
@@ -33,7 +34,11 @@ export async function deploy(wallet, artifactPath, json, publicKeys, rawArgs, sa
         printGasEstimates(feeOpts, gas, log);
         return;
     }
-    const tx = deploy.send(deployOpts);
+    const provenTx = await deploy.prove(deployOpts);
+    if (verbose) {
+        printProfileResult(provenTx.timings, log);
+    }
+    const tx = provenTx.send();
     const txHash = await tx.getTxHash();
     debugLogger.debug(`Deploy tx sent with hash ${txHash}`);
     if (wait) {

package/dest/cmds/deploy_account.d.ts

@@ -1,7 +1,7 @@
 import type { AccountManager } from '@aztec/aztec.js';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import { type IFeeOpts } from '../utils/options/fees.js';
-export declare function deployAccount(account: AccountManager, wait: boolean, registerClass: boolean, feeOpts: IFeeOpts, json: boolean, debugLogger: Logger, log: LogFn): Promise<{
+export declare function deployAccount(account: AccountManager, wait: boolean, registerClass: boolean, publicDeploy: boolean, feeOpts: IFeeOpts, json: boolean, verbose: boolean, debugLogger: Logger, log: LogFn): Promise<{
     address: import("@aztec/aztec.js").AztecAddress;
     secretKey: import("@aztec/aztec.js").Fr;
     salt: import("@aztec/aztec.js").Fr;

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

@@ -1 +1 @@
-{"version":3,"file":"deploy_account.d.ts","sourceRoot":"","sources":["../../src/cmds/deploy_account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAwB,MAAM,iBAAiB,CAAC;AAE5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAE5E,wBAAsB,aAAa,CACjC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,OAAO,EACtB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK;;;;GA8FX"}
+{"version":3,"file":"deploy_account.d.ts","sourceRoot":"","sources":["../../src/cmds/deploy_account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAwB,MAAM,iBAAiB,CAAC;AAE5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAG5E,wBAAsB,aAAa,CACjC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,OAAO,EACtB,YAAY,EAAE,OAAO,EACrB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK;;;;GAqGX"}

package/dest/cmds/deploy_account.js

@@ -1,6 +1,7 @@
 import { prettyPrintJSON } from '@aztec/cli/cli-utils';
 import { printGasEstimates } from '../utils/options/fees.js';
-export async function deployAccount(account, wait, registerClass, feeOpts, json, debugLogger, log) {
+import { printProfileResult } from '../utils/profiling.js';
+export async function deployAccount(account, wait, registerClass, publicDeploy, feeOpts, json, verbose, debugLogger, log) {
     const out = {};
     const { address, partialAddress, publicKeys } = await account.getCompleteAddress();
     const { initializationHash, deployer, salt } = account.getInstance();
@@ -27,27 +28,27 @@ export async function deployAccount(account, wait, registerClass, feeOpts, json,
     let tx;
     let txReceipt;
     const deployOpts = {
-        skipInitialization: false,
-        skipPublicDeployment: false,
+        skipPublicDeployment: !publicDeploy,
         skipClassRegistration: !registerClass,
         ...await feeOpts.toDeployAccountOpts(wallet)
     };
+    /*
+   * This is usually handled by accountManager.deploy(), but we're accessing the lower
+   * level method to get gas and timings. That means we have to replicate some of the logic here.
+   * In case we're deploying our own account, we need to hijack the payment method for the fee,
+   * wrapping it in the one that will make use of the freshly deployed account's
+   * entrypoint. For reference, see aztec.js/src/account_manager.ts:deploy()
+   * Also, salt and universalDeploy have to be explicitly provided
+   */ deployOpts.fee = !deployOpts?.deployWallet && deployOpts?.fee ? {
+        ...deployOpts.fee,
+        paymentMethod: await account.getSelfPaymentMethod(deployOpts.fee.paymentMethod)
+    } : deployOpts?.fee;
+    const deployMethod = await account.getDeployMethod(deployOpts.deployWallet);
     if (feeOpts.estimateOnly) {
-        /*
-     * This is usually handled by accountManager.deploy(), but we're accessing the lower
-     * level method to get the gas estimates. That means we have to replicate some of the logic here.
-     * In case we're deploying our own account, we need to hijack the payment method for the fee,
-     * wrapping it in the one that will make use of the freshly deployed account's
-     * entrypoint. For reference, see aztec.js/src/account_manager.ts:deploy()
-     */ const fee = !deployOpts?.deployWallet && deployOpts?.fee ? {
-            ...deployOpts.fee,
-            paymentMethod: await account.getSelfPaymentMethod(deployOpts.fee.paymentMethod)
-        } : deployOpts?.fee;
-        const deployMethod = await account.getDeployMethod(deployOpts.deployWallet);
         const gas = await deployMethod.estimateGas({
             ...deployOpts,
-            fee,
-            universalDeploy: true
+            universalDeploy: true,
+            contractAddressSalt: salt
         });
         if (json) {
             out.fee = {
@@ -64,7 +65,15 @@ export async function deployAccount(account, wait, registerClass, feeOpts, json,
             printGasEstimates(feeOpts, gas, log);
         }
     } else {
-        tx = account.deploy(deployOpts);
+        const provenTx = await deployMethod.prove({
+            ...deployOpts,
+            universalDeploy: true,
+            contractAddressSalt: salt
+        });
+        if (verbose) {
+            printProfileResult(provenTx.timings, log);
+        }
+        tx = provenTx.send();
         const txHash = await tx.getTxHash();
         debugLogger.debug(`Account contract tx sent with hash ${txHash}`);
         out.txHash = txHash;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cmds/index.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAI3D,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAGjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAuBxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,EACnB,EAAE,CAAC,EAAE,QAAQ,EACb,UAAU,CAAC,EAAE,UAAU,WAgpBxB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cmds/index.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAI3D,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAGjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAwBxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,EACnB,EAAE,CAAC,EAAE,QAAQ,EACb,UAAU,CAAC,EAAE,UAAU,WA4qBxB"}

package/dest/cmds/index.js

@@ -8,7 +8,7 @@ import { Option } from 'commander';
 import inquirer from 'inquirer';
 import { createOrRetrieveAccount } from '../utils/accounts.js';
 import { FeeOpts, FeeOptsWithFeePayer } from '../utils/options/fees.js';
-import { ARTIFACT_DESCRIPTION, aliasedAddressParser, aliasedSecretKeyParser, aliasedTxHashParser, artifactPathFromPromiseOrAlias, artifactPathParser, cleanupAuthWitnesses, createAccountOption, createAliasOption, createArgsOption, createArtifactOption, createAuthwitnessOption, createContractAddressOption, createDebugExecutionStepsDirOption, createTypeOption, integerArgParser, parseGasFees, parsePaymentMethod } from '../utils/options/index.js';
+import { ARTIFACT_DESCRIPTION, aliasedAddressParser, aliasedSecretKeyParser, aliasedTxHashParser, artifactPathFromPromiseOrAlias, artifactPathParser, cleanupAuthWitnesses, createAccountOption, createAliasOption, createArgsOption, createArtifactOption, createAuthwitnessOption, createContractAddressOption, createDebugExecutionStepsDirOption, createTypeOption, createVerboseOption, integerArgParser, parseGasFees, parsePaymentMethod } from '../utils/options/index.js';
 export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
     program.command('import-test-accounts').description('Import test accounts from pxe.').addOption(pxeOption).option('--json', 'Emit output as json').action(async (options)=>{
         if (!db) {
@@ -16,16 +16,16 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
         }
         const { importTestAccounts } = await import('./import_test_accounts.js');
         const { rpcUrl, json } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         await importTestAccounts(client, 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 single-key account which uses the same key for encryption and authentication (not secure for production usage).').summary('Creates an aztec account that can be used for sending transactions.').option('--skip-initialization', 'Skip initializing the account contract. Useful for publicly deploying an existing account.').option('--public-deploy', 'Publicly deploys the account and registers the class if needed.').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(pxeOption).addOption(createSecretKeyOption('Secret key for account. Uses random by default.', false, (sk)=>aliasedSecretKeyParser(sk, db)).conflicts('public-key')).addOption(createAliasOption('Alias for the account. Used for easy reference in subsequent commands.', !db)).addOption(createTypeOption(true)).option('--register-only', 'Just register the account on the PXE. 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('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction').addOption(createVerboseOption());
     addOptions(createAccountCommand, FeeOptsWithFeePayer.getOptions()).action(async (_options, command)=>{
         const { createAccount } = await import('./create_account.js');
         const options = command.optsWithGlobals();
-        const { type, secretKey, wait, registerOnly, skipInitialization, publicDeploy, rpcUrl, alias, json } = options;
+        const { type, secretKey, wait, registerOnly, skipInitialization, publicDeploy, rpcUrl, alias, json, verbose } = options;
         let { publicKey } = options;
         if (type === 'ecdsasecp256r1ssh' && !publicKey) {
             const identities = await getIdentities();
@@ -39,8 +39,8 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
             ]);
             publicKey = answers.identity.split(' ')[1];
         }
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const accountCreationResult = await createAccount(client, type, secretKey, publicKey, alias, registerOnly, skipInitialization, publicDeploy, wait, await FeeOptsWithFeePayer.fromCli(options, client, log, db), json, debugLogger, log);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const accountCreationResult = await createAccount(client, type, secretKey, publicKey, alias, registerOnly, skipInitialization, publicDeploy, wait, await FeeOptsWithFeePayer.fromCli(options, client, log, db), json, verbose, debugLogger, log);
         if (db) {
             const { address, alias, secretKey, salt } = accountCreationResult;
             await db.storeAccount(address, {
@@ -54,70 +54,72 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
     });
     const deployAccountCommand = program.command('deploy-account').description('Deploys an already registered aztec account that can be used for sending transactions.').addOption(createAccountOption('Alias or address of the account to deploy', !db, db)).addOption(pxeOption).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('--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', 'Publicly deploy this account contract (only useful if it contains public functions').addOption(createVerboseOption());
     addOptions(deployAccountCommand, FeeOptsWithFeePayer.getOptions()).action(async (_options, command)=>{
         const { deployAccount } = await import('./deploy_account.js');
         const options = command.optsWithGlobals();
-        const { rpcUrl, wait, from: parsedFromAddress, json, registerClass } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const { rpcUrl, wait, from: parsedFromAddress, json, registerClass, publicDeploy, verbose } = options;
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db);
-        await deployAccount(account, wait, registerClass, await FeeOptsWithFeePayer.fromCli(options, client, log, db), json, debugLogger, log);
+        await deployAccount(account, wait, registerClass, publicDeploy, await FeeOptsWithFeePayer.fromCli(options, client, log, db), 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.', parseFieldFromHexString).option('--universal', 'Do not mix the sender address into the deployment.').addOption(pxeOption).addOption(createArgsOption(true, db)).addOption(createSecretKeyOption("The sender's secret key", !db, (sk)=>aliasedSecretKeyParser(sk, db)).conflicts('account')).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");
+    .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(createVerboseOption());
     addOptions(deployCommand, FeeOpts.getOptions()).action(async (artifactPathPromise, _options, command)=>{
         const { deploy } = await import('./deploy.js');
         const options = command.optsWithGlobals();
-        const { json, publicKey, args, salt, wait, secretKey, classRegistration, init, publicDeployment, universal, rpcUrl, from: parsedFromAddress, alias } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const { json, publicKey, args, salt, wait, secretKey, classRegistration, init, publicDeployment, universal, rpcUrl, from: parsedFromAddress, alias, verbose } = options;
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
         const wallet = await account.getWallet();
         const artifactPath = await artifactPathPromise;
         debugLogger.info(`Using wallet with address ${wallet.getCompleteAddress().address.toString()}`);
-        const address = await deploy(wallet, artifactPath, json, publicKey, args, salt, typeof init === 'string' ? init : undefined, !publicDeployment, !classRegistration, typeof init === 'string' ? false : init, universal, wait, await FeeOpts.fromCli(options, client, log, db), debugLogger, log, logJson(log));
+        const address = await deploy(wallet, artifactPath, json, publicKey, args, salt, typeof init === 'string' ? init : undefined, !publicDeployment, !classRegistration, typeof init === 'string' ? false : init, universal, wait, await FeeOpts.fromCli(options, client, log, db), verbose, debugLogger, log, logJson(log));
         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(pxeOption).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(createSecretKeyOption("The sender's secret key", !db, (sk)=>aliasedSecretKeyParser(sk, db)).conflicts('account')).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('--no-cancel', 'Do not allow the transaction to be cancelled. This makes for cheaper transactions.');
+    const sendCommand = program.command('send').description('Calls a function on an Aztec contract.').argument('<functionName>', 'Name of function to execute').addOption(pxeOption).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(createSecretKeyOption("The sender's secret key", !db, (sk)=>aliasedSecretKeyParser(sk, db)).conflicts('account')).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('--no-cancel', 'Do not allow the transaction to be cancelled. This makes for cheaper transactions.').addOption(createVerboseOption());
     addOptions(sendCommand, FeeOpts.getOptions()).action(async (functionName, _options, command)=>{
         const { send } = await import('./send.js');
         const options = command.optsWithGlobals();
-        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, wait, rpcUrl, secretKey, alias, cancel, authWitness: authWitnessArray } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, wait, rpcUrl, secretKey, alias, cancel, authWitness: authWitnessArray, verbose } = options;
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
         const wallet = await account.getWallet();
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
         debugLogger.info(`Using wallet with address ${wallet.getCompleteAddress().address.toString()}`);
         const authWitnesses = cleanupAuthWitnesses(authWitnessArray);
-        const sentTx = await send(wallet, functionName, args, artifactPath, contractAddress, wait, cancel, await FeeOpts.fromCli(options, client, log, db), authWitnesses, log);
+        const sentTx = await send(wallet, functionName, args, artifactPath, contractAddress, wait, cancel, await FeeOpts.fromCli(options, client, log, db), authWitnesses, verbose, log);
         if (db && sentTx) {
             const txAlias = alias ? alias : `${functionName}-${sentTx.nonce.toString().slice(-4)}`;
             await db.storeTx(sentTx, log, txAlias);
         }
     });
-    program.command('simulate').description('Simulates the execution of a function on an Aztec contract.').argument('<functionName>', 'Name of function to simulate').addOption(pxeOption).addOption(createArgsOption(false, db)).addOption(createContractAddressOption(db)).addOption(createArtifactOption(db)).addOption(createSecretKeyOption("The sender's secret key", !db, (sk)=>aliasedSecretKeyParser(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)).action(async (functionName, _options, command)=>{
+    const simulateCommand = program.command('simulate').description('Simulates the execution of a function on an Aztec contract.').argument('<functionName>', 'Name of function to simulate').addOption(pxeOption).addOption(createArgsOption(false, db)).addOption(createContractAddressOption(db)).addOption(createArtifactOption(db)).addOption(createSecretKeyOption("The sender's secret key", !db, (sk)=>aliasedSecretKeyParser(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, FeeOpts.getOptions()).action(async (functionName, _options, command)=>{
         const { simulate } = await import('./simulate.js');
         const options = command.optsWithGlobals();
-        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, rpcUrl, secretKey, authWitness } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, rpcUrl, secretKey, verbose, authWitness } = options;
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
         const wallet = await account.getWallet();
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
         const authWitnesses = cleanupAuthWitnesses(authWitness);
-        await simulate(wallet, functionName, args, artifactPath, contractAddress, authWitnesses, log);
+        await simulate(wallet, functionName, args, artifactPath, contractAddress, await FeeOpts.fromCli(options, client, log, db), authWitnesses, verbose, log);
     });
-    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(pxeOption).addOption(createArgsOption(false, db)).addOption(createContractAddressOption(db)).addOption(createArtifactOption(db)).addOption(createDebugExecutionStepsDirOption()).addOption(createSecretKeyOption("The sender's secret key", !db, (sk)=>aliasedSecretKeyParser(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)).action(async (functionName, _options, command)=>{
+    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(pxeOption).addOption(createArgsOption(false, db)).addOption(createContractAddressOption(db)).addOption(createArtifactOption(db)).addOption(createDebugExecutionStepsDirOption()).addOption(createSecretKeyOption("The sender's secret key", !db, (sk)=>aliasedSecretKeyParser(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));
+    addOptions(profileCommand, FeeOpts.getOptions()).action(async (functionName, _options, command)=>{
         const { profile } = await import('./profile.js');
         const options = command.optsWithGlobals();
         const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, rpcUrl, secretKey, debugExecutionStepsDir, authWitness } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
         const wallet = await account.getWallet();
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
         const authWitnesses = cleanupAuthWitnesses(authWitness);
-        await profile(wallet, functionName, args, artifactPath, contractAddress, debugExecutionStepsDir, authWitnesses, log);
+        await profile(wallet, functionName, args, artifactPath, contractAddress, debugExecutionStepsDir, await FeeOptsWithFeePayer.fromCli(options, client, 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
@@ -126,7 +128,7 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
     .option('--no-wait', 'Wait for the brigded 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 { rpcUrl, l1ChainId, l1RpcUrls, l1PrivateKey, mnemonic, mint, json, wait, interval: intervalS } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const [secret, messageLeafIndex] = await bridgeL1FeeJuice(amount, recipient, client, l1RpcUrls, l1ChainId, l1PrivateKey, mnemonic, mint, json, wait, intervalS * 1000, log, debugLogger);
         if (db) {
             await db.pushBridgedFeeJuice(recipient, secret, amount, messageLeafIndex, log);
@@ -136,7 +138,7 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
         const { createAuthwit } = await import('./create_authwit.js');
         const options = command.optsWithGlobals();
         const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, rpcUrl, secretKey, alias } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
         const wallet = await account.getWallet();
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
@@ -149,7 +151,7 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
         const { authorizeAction } = await import('./authorize_action.js');
         const options = command.optsWithGlobals();
         const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, rpcUrl, secretKey } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
         const wallet = await account.getWallet();
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
@@ -159,7 +161,7 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
         const { checkTx } = await import('./check_tx.js');
         const { rpcUrl, pageSize } = options;
         let { page } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         if (txHash) {
             await checkTx(client, txHash, false, log);
         } else if (db) {
@@ -188,7 +190,7 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
     program.command('cancel-tx').description('Cancels a pending tx by reusing its nonce with a higher fee and an empty payload').argument('<txHash>', 'A transaction hash to cancel.', (txHash)=>aliasedTxHashParser(txHash, db)).addOption(pxeOption).addOption(createSecretKeyOption("The sender's secret key", !db, (sk)=>aliasedSecretKeyParser(sk, db)).conflicts('account')).addOption(createAccountOption('Alias or address of the account to simulate from', !db, db)).addOption(FeeOpts.paymentMethodOption().default('method=fee_juice')).option('-i --increased-fees <da=1,l2=1>', 'The amounts by which the fees are increased', (value)=>parseGasFees(value), new GasFees(1, 1)).option('--max-fees-per-gas <da=100,l2=100>', 'Maximum fees per gas unit for DA and L2 computation.', (value)=>parseGasFees(value)).action(async (txHash, options)=>{
         const { cancelTx } = await import('./cancel_tx.js');
         const { from: parsedFromAddress, rpcUrl, secretKey, payment, increasedFees, maxFeesPerGas } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
         const wallet = await account.getWallet();
         const txData = await db?.retrieveTxData(txHash);
@@ -201,7 +203,7 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
     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(pxeOption).addOption(createAccountOption('Alias or address of the account to simulate from', !db, 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 { from: parsedFromAddress, rpcUrl, secretKey, alias } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
         const wallet = await account.getWallet();
         await registerSender(wallet, address, log);
@@ -212,7 +214,7 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
     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(pxeOption).addOption(createAccountOption('Alias or address of the account to simulate from', !db, 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 { from: parsedFromAddress, rpcUrl, nodeUrl, secretKey, alias, init, publicKey, salt, deployer, args } = command.optsWithGlobals();
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const node = pxeWrapper?.getNode() ?? createAztecNodeClient(nodeUrl);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
         const wallet = await account.getWallet();

package/dest/cmds/profile.d.ts

@@ -1,4 +1,5 @@
 import { type AccountWalletWithSecretKey, AuthWitness, type AztecAddress } from '@aztec/aztec.js';
 import type { LogFn } from '@aztec/foundation/log';
-export declare function profile(wallet: AccountWalletWithSecretKey, functionName: string, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, debugOutputPath: string | undefined, authWitnesses: AuthWitness[], log: LogFn): Promise<void>;
+import type { IFeeOpts } from '../utils/options/fees.js';
+export declare function profile(wallet: AccountWalletWithSecretKey, functionName: string, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, debugOutputPath: string | undefined, feeOpts: IFeeOpts, authWitnesses: AuthWitness[], log: LogFn): Promise<void>;
 //# sourceMappingURL=profile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/cmds/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAE,WAAW,EAAE,KAAK,YAAY,EAAY,MAAM,iBAAiB,CAAC;AAE5G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AA6BnD,wBAAsB,OAAO,CAC3B,MAAM,EAAE,0BAA0B,EAClC,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,GAAG,EAAE,EACrB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,YAAY,EAC7B,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,aAAa,EAAE,WAAW,EAAE,EAC5B,GAAG,EAAE,KAAK,iBAeX"}
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/cmds/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAE,WAAW,EAAE,KAAK,YAAY,EAAY,MAAM,iBAAiB,CAAC;AAE5G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAMnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD,wBAAsB,OAAO,CAC3B,MAAM,EAAE,0BAA0B,EAClC,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,QAAQ,EACjB,aAAa,EAAE,WAAW,EAAE,EAC5B,GAAG,EAAE,KAAK,iBAmBX"}

package/dest/cmds/profile.js

@@ -3,28 +3,18 @@ import { prepTx } from '@aztec/cli/utils';
 import { serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
 import { promises as fs } from 'fs';
 import path from 'path';
-import { format } from 'util';
-function printProfileResult(result, log) {
-    // TODO(AD): this is a bit misleading - the maximum gate count of any piece is as important
-    // as the total gate count. We should probably print both.
-    log(format('\nGate count per circuit:'));
-    let acc = 0;
-    result.executionSteps.forEach((r)=>{
-        acc += r.gateCount;
-        log(format('  ', r.functionName.padEnd(50), 'Gates:', r.gateCount.toLocaleString(), '\tSubtotal:', acc.toLocaleString()));
-    });
-    log(format('\nTotal gates:', acc.toLocaleString()));
-}
-export async function profile(wallet, functionName, functionArgsIn, contractArtifactPath, contractAddress, debugOutputPath, authWitnesses, log) {
-    const profileMode = debugOutputPath ? 'full' : 'gates';
+import { printProfileResult } from '../utils/profiling.js';
+export async function profile(wallet, functionName, functionArgsIn, contractArtifactPath, contractAddress, debugOutputPath, feeOpts, authWitnesses, log) {
     const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
     const contract = await Contract.at(contractAddress, contractArtifact, wallet);
     const call = contract.methods[functionName](...functionArgs);
     const result = await call.profile({
-        profileMode,
-        authWitnesses
+        ...await feeOpts.toSendOpts(wallet),
+        profileMode: 'full',
+        authWitnesses,
+        skipProofGeneration: false
     });
-    printProfileResult(result, log);
+    printProfileResult(result.timings, log, result.executionSteps);
     if (debugOutputPath) {
         const ivcInputsPath = path.join(debugOutputPath, 'ivc-inputs.msgpack');
         log(`Debug output written to ${ivcInputsPath}.`);

package/dest/cmds/register_contract.d.ts

@@ -1,4 +1,4 @@
 import { type AccountWalletWithSecretKey, type AztecAddress, type AztecNode, type Fr, PublicKeys } from '@aztec/aztec.js';
 import type { LogFn } from '@aztec/foundation/log';
-export declare function registerContract(wallet: AccountWalletWithSecretKey, node: AztecNode, address: AztecAddress, artifactPath: string, log: LogFn, initializer?: string, publicKeys?: PublicKeys, rawArgs?: any[], salt?: Fr, deployer?: AztecAddress | undefined): Promise<import("@aztec/aztec.js").ContractInstanceWithAddress>;
+export declare function registerContract(wallet: AccountWalletWithSecretKey, node: AztecNode, address: AztecAddress, artifactPath: string, log: LogFn, initializer?: string, publicKeys?: PublicKeys, rawArgs?: any[], salt?: Fr, deployer?: AztecAddress): Promise<import("@aztec/aztec.js").ContractInstanceWithAddress>;
 //# sourceMappingURL=register_contract.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"register_contract.d.ts","sourceRoot":"","sources":["../../src/cmds/register_contract.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,EAAE,EACP,UAAU,EAEX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,0BAA0B,EAClC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,YAAY,EACrB,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,KAAK,EACV,WAAW,CAAC,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,UAAU,EACvB,OAAO,CAAC,EAAE,GAAG,EAAE,EACf,IAAI,CAAC,EAAE,EAAE,EACT,QAAQ,CAAC,EAAE,YAAY,GAAG,SAAS,kEAsBpC"}
+{"version":3,"file":"register_contract.d.ts","sourceRoot":"","sources":["../../src/cmds/register_contract.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,EAAE,EACP,UAAU,EAEX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,0BAA0B,EAClC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,YAAY,EACrB,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,KAAK,EACV,WAAW,CAAC,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,UAAU,EACvB,OAAO,CAAC,EAAE,GAAG,EAAE,EACf,IAAI,CAAC,EAAE,EAAE,EACT,QAAQ,CAAC,EAAE,YAAY,kEAsBxB"}

package/dest/cmds/send.d.ts

@@ -2,7 +2,7 @@ import { type AccountWalletWithSecretKey, AuthWitness, type AztecAddress, Fr } f
 import type { LogFn } from '@aztec/foundation/log';
 import { GasSettings } from '@aztec/stdlib/gas';
 import { type IFeeOpts } from '../utils/options/fees.js';
-export declare function send(wallet: AccountWalletWithSecretKey, functionName: string, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, wait: boolean, cancellable: boolean, feeOpts: IFeeOpts, authWitnesses: AuthWitness[], log: LogFn): Promise<{
+export declare function send(wallet: AccountWalletWithSecretKey, functionName: string, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, wait: boolean, cancellable: boolean, feeOpts: IFeeOpts, authWitnesses: AuthWitness[], verbose: boolean, log: LogFn): Promise<{
     txHash: import("@aztec/aztec.js").TxHash;
     nonce: Fr;
     cancellable: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../src/cmds/send.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,WAAW,EACX,KAAK,YAAY,EAEjB,EAAE,EAEH,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAE5E,wBAAsB,IAAI,CACxB,MAAM,EAAE,0BAA0B,EAClC,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,GAAG,EAAE,EACrB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,OAAO,EACpB,OAAO,EAAE,QAAQ,EACjB,aAAa,EAAE,WAAW,EAAE,EAC5B,GAAG,EAAE,KAAK;;;;;eAqDX"}
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../src/cmds/send.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,WAAW,EACX,KAAK,YAAY,EAEjB,EAAE,EAEH,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAG5E,wBAAsB,IAAI,CACxB,MAAM,EAAE,0BAA0B,EAClC,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,GAAG,EAAE,EACrB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,OAAO,EACpB,OAAO,EAAE,QAAQ,EACjB,aAAa,EAAE,WAAW,EAAE,EAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,KAAK;;;;;eA0DX"}

package/dest/cmds/send.js

@@ -2,7 +2,8 @@ import { Contract, Fr } from '@aztec/aztec.js';
 import { prepTx } from '@aztec/cli/utils';
 import { GasSettings } from '@aztec/stdlib/gas';
 import { printGasEstimates } from '../utils/options/fees.js';
-export async function send(wallet, functionName, functionArgsIn, contractArtifactPath, contractAddress, wait, cancellable, feeOpts, authWitnesses, log) {
+import { printProfileResult } from '../utils/profiling.js';
+export async function send(wallet, functionName, functionArgsIn, contractArtifactPath, contractAddress, wait, cancellable, feeOpts, authWitnesses, verbose, log) {
     const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
     const contract = await Contract.at(contractAddress, contractArtifact, wallet);
     const call = contract.methods[functionName](...functionArgs);
@@ -18,7 +19,11 @@ export async function send(wallet, functionName, functionArgsIn, contractArtifac
     if (feeOpts.estimateOnly) {
         return;
     }
-    const tx = call.send(sendOptions);
+    const provenTx = await call.prove(sendOptions);
+    if (verbose) {
+        printProfileResult(provenTx.timings, log);
+    }
+    const tx = provenTx.send();
     const txHash = await tx.getTxHash();
     log(`\nTransaction hash: ${txHash.toString()}`);
     if (wait) {

package/dest/cmds/simulate.d.ts

@@ -1,4 +1,5 @@
 import { type AccountWalletWithSecretKey, AuthWitness, type AztecAddress } from '@aztec/aztec.js';
 import type { LogFn } from '@aztec/foundation/log';
-export declare function simulate(wallet: AccountWalletWithSecretKey, functionName: string, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, authWitnesses: AuthWitness[], log: LogFn): Promise<void>;
+import type { IFeeOpts } from '../utils/options/fees.js';
+export declare function simulate(wallet: AccountWalletWithSecretKey, functionName: string, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, feeOpts: IFeeOpts, authWitnesses: AuthWitness[], verbose: boolean, log: LogFn): Promise<void>;
 //# sourceMappingURL=simulate.d.ts.map