@aztec/cli-wallet 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/cmds/index.js

@@ -1,31 +1,25 @@
 import { getIdentities } from '@aztec/accounts/utils';
-import { createCompatibleClient } from '@aztec/aztec.js/rpc';
-import { TxHash } from '@aztec/aztec.js/tx_hash';
-import { ETHEREUM_HOSTS, PRIVATE_KEY, addOptions, createSecretKeyOption, l1ChainIdOption, logJson, parseBigint, parseFieldFromHexString, parsePublicKey, pxeOption } from '@aztec/cli/utils';
-import { GasFees } from '@aztec/stdlib/gas';
-import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import { TxHash } from '@aztec/aztec.js/tx';
+import { ETHEREUM_HOSTS, PRIVATE_KEY, addOptions, createSecretKeyOption, l1ChainIdOption, parseBigint, parseFieldFromHexString, parsePublicKey } from '@aztec/cli/utils';
+import { randomBytes } from '@aztec/foundation/crypto';
 import { Option } from 'commander';
 import inquirer from 'inquirer';
-import { addScopeToWallet, createOrRetrieveAccount, getWalletWithScopes } from '../utils/accounts.js';
-import { FeeOpts, FeeOptsWithFeePayer } from '../utils/options/fees.js';
-import { ARTIFACT_DESCRIPTION, aliasedAddressParser, aliasedAuthWitParser, aliasedSecretKeyParser, aliasedTxHashParser, artifactPathFromPromiseOrAlias, artifactPathParser, createAccountOption, createAliasOption, createArgsOption, createArtifactOption, createContractAddressOption, createProfileOption, createTypeOption, 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) {
-            throw new Error(`A db is required to store the imported test accounts.`);
-        }
+import { ARTIFACT_DESCRIPTION, CLIFeeArgs, aliasedAddressParser, aliasedSecretKeyParser, aliasedTxHashParser, artifactPathFromPromiseOrAlias, artifactPathParser, cleanupAuthWitnesses, createAccountOption, createAliasOption, createArgsOption, createArtifactOption, createAuthwitnessOption, createContractAddressOption, createDebugExecutionStepsDirOption, createTypeOption, createVerboseOption, integerArgParser } from '../utils/options/index.js';
+// 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');
-        const { rpcUrl, json } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        await importTestAccounts(client, db, json, log);
+        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 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.
+    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.').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(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 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');
-    addOptions(createAccountCommand, FeeOptsWithFeePayer.getOptions()).action(async (_options, command)=>{
+    .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction').addOption(createVerboseOption());
+    addOptions(createAccountCommand, CLIFeeArgs.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, from: parsedFromAddress, secretKey, wait, registerOnly, skipInitialization, publicDeploy, registerClass, alias, json, verbose } = options;
         let { publicKey } = options;
         if (type === 'ecdsasecp256r1ssh' && !publicKey) {
             const identities = await getIdentities();
@@ -39,8 +33,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 { wallet, node } = walletAndNodeWrapper;
+        const accountCreationResult = await createAccount(wallet, node, type, secretKey, publicKey, alias, parsedFromAddress, registerOnly, skipInitialization, publicDeploy, registerClass, wait, CLIFeeArgs.parse(options, log, db), json, verbose, debugLogger, log);
         if (db) {
             const { address, alias, secretKey, salt } = accountCreationResult;
             await db.storeAccount(address, {
@@ -52,113 +46,105 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
             }, log);
         }
     });
-    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.
+    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');
-    addOptions(deployAccountCommand, FeeOptsWithFeePayer.getOptions()).action(async (_options, command)=>{
+    .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.').addOption(createVerboseOption());
+    addOptions(deployAccountCommand, CLIFeeArgs.getOptions()).action(async (parsedAccount, _options, command)=>{
         const { deployAccount } = await import('./deploy_account.js');
         const options = command.optsWithGlobals();
-        const { rpcUrl, wait, from: parsedFromAddress, json } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const account = await createOrRetrieveAccount(client, parsedFromAddress, db);
-        await deployAccount(account, wait, await FeeOptsWithFeePayer.fromCli(options, client, log, db), json, debugLogger, log);
+        const { wait, 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), 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.
+    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(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");
-    addOptions(deployCommand, FeeOpts.getOptions()).action(async (artifactPathPromise, _options, command)=>{
+    .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')).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, secretKey, classRegistration, init, publicDeployment, universal, rpcUrl, from: parsedFromAddress, alias } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
+        const { json, publicKey, args, salt, wait, classRegistration, init, publicDeployment, universal, from: parsedFromAddress, alias, timeout, verbose } = options;
+        const { wallet, node } = walletAndNodeWrapper;
         const artifactPath = await artifactPathPromise;
-        debugLogger.info(`Using wallet with address ${wallet.getCompleteAddress().address.toString()}`);
-        const address = await deploy(client, 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));
+        debugLogger.info(`Using wallet with address ${parsedFromAddress.toString()}`);
+        const address = await deploy(wallet, node, universal ? undefined : parsedFromAddress, artifactPath, json, publicKey, args, salt, typeof init === 'string' ? init : undefined, !publicDeployment, !classRegistration, typeof init === 'string' ? false : init, wait, CLIFeeArgs.parse(options, log, db), timeout, verbose, debugLogger, 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(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.');
-    addOptions(sendCommand, FeeOpts.getOptions()).action(async (functionName, _options, command)=>{
+    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').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, rpcUrl, secretKey, alias, cancel } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
+        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, wait, alias, authWitness: authWitnessArray, verbose } = options;
+        const { wallet, node } = walletAndNodeWrapper;
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
-        debugLogger.info(`Using wallet with address ${wallet.getCompleteAddress().address.toString()}`);
-        const sentTx = await send(wallet, functionName, args, artifactPath, contractAddress, wait, cancel, await FeeOpts.fromCli(options, client, log, db), log);
+        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, verbose, log);
         if (db && sentTx) {
-            const txAlias = alias ? alias : `${functionName}-${sentTx.nonce.toString().slice(-4)}`;
+            const txAlias = alias ? alias : `${functionName}-${randomBytes(16).toString()}`;
             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(createAccountOption('Alias or address of the account to simulate from', !db, db)).addOption(createProfileOption()).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(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, CLIFeeArgs.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, profile } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
+        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);
-        await simulate(wallet, functionName, args, artifactPath, contractAddress, profile, log);
+        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(pxeOption).addOption(l1ChainIdOption).option('--json', 'Output the claim in JSON format')// `options.wait` is default true. Passing `--no-wait` will set it to false.
+    ]).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 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)=>{
+    .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 { rpcUrl, l1ChainId, l1RpcUrls, l1PrivateKey, mnemonic, mint, json, wait, interval: intervalS } = options;
-        const client = 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);
+        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('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(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(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)=>{
+    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, rpcUrl, secretKey, alias } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
+        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, functionName, caller, args, artifactPath, contractAddress, log);
+        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(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(createAccountOption('Alias or address of the account to simulate from', !db, db)).action(async (functionName, caller, _options, command)=>{
+    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, rpcUrl, secretKey } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
+        const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress } = options;
+        const wallet = walletAndNodeWrapper.wallet;
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
-        await authorizeAction(wallet, functionName, caller, args, artifactPath, contractAddress, log);
+        await authorizeAction(wallet, parsedFromAddress, functionName, caller, args, artifactPath, contractAddress, log);
     });
-    program.command('add-authwit').description('Adds an authorization witness to the provided account, granting PXE access to the notes of the authorizer so that it can be verified').argument('<authwit>', 'Authorization witness to add to the account', (witness)=>aliasedAuthWitParser(witness, db)).argument('<authorizer>', 'Account that provides the authorization to perform the action', (address)=>aliasedAddressParser('accounts', address, 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(createAliasOption('Alias for the authorization witness. Used for easy reference in subsequent commands.', !db)).action(async (authwit, authorizer, _options, command)=>{
-        const { addAuthwit } = await import('./add_authwit.js');
-        const options = command.optsWithGlobals();
-        const { from: parsedFromAddress, rpcUrl, secretKey } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
-        await addAuthwit(wallet, authwit, authorizer, log);
-        await addScopeToWallet(wallet, authorizer, db);
-    });
-    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)).addOption(pxeOption).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)=>{
+    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 { rpcUrl, pageSize } = options;
+        const { pageSize } = options;
         let { page } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const wallet = walletAndNodeWrapper.wallet;
+        const node = walletAndNodeWrapper.node;
         if (txHash) {
-            await checkTx(client, txHash, false, log);
+            await checkTx(wallet, node, txHash, false, log);
         } else if (db) {
             const aliases = await db.listAliases('transactions');
             const totalPages = Math.ceil(aliases.length / pageSize);
@@ -166,55 +152,37 @@ export function injectCommands(program, log, debugLogger, db, pxeWrapper) {
             const dataRows = await Promise.all(aliases.slice(page * pageSize, pageSize * (1 + page)).map(async ({ key, value })=>({
                     alias: key,
                     txHash: value,
-                    cancellable: (await db.retrieveTxData(TxHash.fromString(value))).cancellable,
-                    status: await checkTx(client, TxHash.fromString(value), true, log)
+                    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 + 12 + 20, '-'));
-            for (const { alias, txHash, status, cancellable } of dataRows){
-                log(`${alias.padEnd(32, ' ')} | ${txHash} | ${cancellable.toString()?.padEnd(12, ' ')} | ${status}`);
-                log(''.padEnd(32 + 64 + 12 + 20, '-'));
+            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('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 account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
-        const txData = await db?.retrieveTxData(txHash);
-        if (!txData) {
-            throw new Error('Transaction data not found in the database, cannot reuse nonce');
-        }
-        const paymentMethod = await parsePaymentMethod(payment, false, log, db)(wallet);
-        await cancelTx(wallet, txData, paymentMethod, increasedFees, maxFeesPerGas, log);
-    });
-    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)=>{
+    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 { from: parsedFromAddress, rpcUrl, secretKey, alias } = options;
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
+        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).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)=>{
+    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 { from: parsedFromAddress, rpcUrl, nodeUrl, secretKey, alias } = command.optsWithGlobals();
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
-        const node = pxeWrapper?.getNode() ?? createAztecNodeClient(nodeUrl);
-        const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
+        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);
+        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);
         }

package/dest/cmds/profile.d.ts

@@ -0,0 +1,8 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { AuthWitness } from '@aztec/aztec.js/authorization';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { LogFn } from '@aztec/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=profile.d.ts.map

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,2BAA2B,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAMnD,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"}

package/dest/cmds/profile.js

@@ -0,0 +1,28 @@
+import { Contract } from '@aztec/aztec.js/contracts';
+import { prepTx } from '@aztec/cli/utils';
+import { serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { printProfileResult } from '../utils/profiling.js';
+export async function profile(wallet, node, from, 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 { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(node, wallet, from);
+    const result = await call.profile({
+        fee: {
+            gasSettings,
+            paymentMethod
+        },
+        from,
+        profileMode: 'full',
+        authWitnesses,
+        skipProofGeneration: false
+    });
+    printProfileResult(result.stats, log, true, result.executionSteps);
+    if (debugOutputPath) {
+        const ivcInputsPath = path.join(debugOutputPath, 'ivc-inputs.msgpack');
+        log(`Debug output written to ${ivcInputsPath}.`);
+        await fs.writeFile(ivcInputsPath, serializePrivateExecutionSteps(result.executionSteps));
+    }
+}

package/dest/cmds/register_contract.d.ts

@@ -1,4 +1,8 @@
-import type { AccountWalletWithSecretKey, AztecAddress, AztecNode } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import { PublicKeys } from '@aztec/aztec.js/keys';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import type { LogFn } from '@aztec/foundation/log';
-export declare function registerContract(wallet: AccountWalletWithSecretKey, node: AztecNode, address: AztecAddress, artifactPath: string, log: LogFn): Promise<import("@aztec/aztec.js").ContractInstanceWithAddress>;
+export declare function registerContract(wallet: Wallet, node: AztecNode, address: AztecAddress, artifactPath: string, log: LogFn, initializer?: string, publicKeys?: PublicKeys, rawArgs?: any[], salt?: Fr, deployer?: AztecAddress): Promise<import("@aztec/aztec.js/contracts").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,KAAK,EAAE,0BAA0B,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE3F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,0BAA0B,EAClC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,YAAY,EACrB,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,KAAK,kEAUX"}
+{"version":3,"file":"register_contract.d.ts","sourceRoot":"","sources":["../../src/cmds/register_contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,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,4EAsBxB"}

package/dest/cmds/register_contract.js

@@ -1,14 +1,27 @@
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { PublicKeys } from '@aztec/aztec.js/keys';
 import { getContractArtifact } from '@aztec/cli/cli-utils';
-export async function registerContract(wallet, node, address, artifactPath, log) {
+import { getAllFunctionAbis, getInitializer } from '@aztec/stdlib/abi';
+export async function registerContract(wallet, node, address, artifactPath, log, initializer, publicKeys, rawArgs, salt, deployer) {
     const contractArtifact = await getContractArtifact(artifactPath, log);
-    const contractInstance = await node.getContract(address);
+    const hasInitializer = getAllFunctionAbis(contractArtifact).some((fn)=>fn.isInitializer);
+    const constructorArtifact = hasInitializer ? getInitializer(contractArtifact, initializer) : undefined;
+    let contractInstance = await node.getContract(address);
     if (!contractInstance) {
-        throw new Error(`Contract not found at address: ${address}`);
+        log(`Contract not found in the node at ${address}. Computing instance locally...`);
+        contractInstance = await getContractInstanceFromInstantiationParams(contractArtifact, {
+            constructorArtifact,
+            publicKeys: publicKeys ?? PublicKeys.default(),
+            constructorArgs: rawArgs,
+            salt: salt ?? Fr.ZERO,
+            deployer
+        });
     }
-    await wallet.registerContract({
-        instance: contractInstance,
-        artifact: contractArtifact
-    });
+    if (!contractInstance.address.equals(address)) {
+        throw new Error(`Contract address mismatch: expected ${address}, got ${contractInstance.address}`);
+    }
+    await wallet.registerContract(contractInstance, contractArtifact);
     log(`Contract registered: at ${contractInstance.address}`);
     return contractInstance;
 }

package/dest/cmds/register_sender.d.ts

@@ -1,4 +1,5 @@
-import type { AccountWalletWithSecretKey, AztecAddress } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import type { LogFn } from '@aztec/foundation/log';
-export declare function registerSender(wallet: AccountWalletWithSecretKey, address: AztecAddress, log: LogFn): Promise<void>;
+export declare function registerSender(wallet: Wallet, address: AztecAddress, log: LogFn): Promise<void>;
 //# sourceMappingURL=register_sender.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"register_sender.d.ts","sourceRoot":"","sources":["../../src/cmds/register_sender.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,cAAc,CAAC,MAAM,EAAE,0BAA0B,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,KAAK,iBAGzG"}
+{"version":3,"file":"register_sender.d.ts","sourceRoot":"","sources":["../../src/cmds/register_sender.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,KAAK,iBAGrF"}

package/dest/cmds/send.d.ts

@@ -1,11 +1,10 @@
-import { type AccountWalletWithSecretKey, type AztecAddress, Fr } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { AuthWitness } from '@aztec/aztec.js/authorization';
+import type { AztecNode } from '@aztec/aztec.js/node';
 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, log: LogFn): Promise<{
-    txHash: import("@aztec/aztec.js").TxHash;
-    nonce: Fr;
-    cancellable: boolean;
-    gasSettings: GasSettings;
+import { CLIFeeArgs } from '../utils/options/fees.js';
+import type { CLIWallet } from '../utils/wallet.js';
+export declare function send(wallet: CLIWallet, node: AztecNode, from: AztecAddress, functionName: string, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, wait: boolean, cancellable: boolean, feeOpts: CLIFeeArgs, authWitnesses: AuthWitness[], verbose: boolean, log: LogFn): Promise<{
+    txHash: import("@aztec/aztec.js/tx").TxHash;
 } | undefined>;
 //# sourceMappingURL=send.d.ts.map

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,EAAE,KAAK,0BAA0B,EAAE,KAAK,YAAY,EAAY,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAEnG,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,GAAG,EAAE,KAAK;;;;;eA6CX"}
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../src/cmds/send.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,wBAAsB,IAAI,CACxB,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,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,OAAO,EACpB,OAAO,EAAE,UAAU,EACnB,aAAa,EAAE,WAAW,EAAE,EAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,KAAK;;eAkDX"}

package/dest/cmds/send.js

@@ -1,29 +1,47 @@
-import { Contract, Fr } from '@aztec/aztec.js';
+import { Contract } from '@aztec/aztec.js/contracts';
 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, log) {
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+import { printProfileResult } from '../utils/profiling.js';
+export async function send(wallet, node, from, 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);
-    const gasLimits = await call.estimateGas({
-        ...await feeOpts.toSendOpts(wallet)
+    const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(node, wallet, from);
+    const sendOptions = {
+        fee: {
+            paymentMethod,
+            gasSettings
+        },
+        from,
+        authWitnesses
+    };
+    const { estimatedGas, stats } = await call.simulate({
+        ...sendOptions,
+        fee: {
+            ...sendOptions.fee,
+            estimateGas: true
+        }
     });
-    printGasEstimates(feeOpts, gasLimits, log);
     if (feeOpts.estimateOnly) {
         return;
     }
-    const nonce = Fr.random();
     const tx = call.send({
-        ...await feeOpts.toSendOpts(wallet),
-        nonce,
-        cancellable
+        ...sendOptions,
+        fee: {
+            ...sendOptions.fee,
+            gasSettings: estimatedGas
+        }
     });
+    if (verbose) {
+        printProfileResult(stats, log);
+    }
     const txHash = await tx.getTxHash();
     log(`\nTransaction hash: ${txHash.toString()}`);
     if (wait) {
         try {
-            await tx.wait();
+            await tx.wait({
+                timeout: DEFAULT_TX_TIMEOUT_S
+            });
             log('Transaction has been mined');
             const receipt = await tx.getReceipt();
             log(` Tx fee: ${receipt.transactionFee}`);
@@ -36,14 +54,7 @@ export async function send(wallet, functionName, functionArgsIn, contractArtifac
     } else {
         log('Transaction pending. Check status with check-tx');
     }
-    const gasSettings = GasSettings.from({
-        ...feeOpts.gasSettings,
-        ...gasLimits
-    });
     return {
-        txHash,
-        nonce,
-        cancellable,
-        gasSettings
+        txHash
     };
 }

package/dest/cmds/simulate.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"simulate.d.ts","sourceRoot":"","sources":["../../src/cmds/simulate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAE,KAAK,YAAY,EAAgC,MAAM,iBAAiB,CAAC;AAEnH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAkBnD,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,0BAA0B,EAClC,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,GAAG,EAAE,EACrB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,YAAY,EAC7B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,KAAK,iBAcX"}
+{"version":3,"file":"simulate.d.ts","sourceRoot":"","sources":["../../src/cmds/simulate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAKnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,wBAAsB,QAAQ,CAC5B,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,OAAO,EAAE,UAAU,EACnB,aAAa,EAAE,WAAW,EAAE,EAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,KAAK,iBAgCX"}