@aztec/cli-wallet 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/dest/cmds/index.js

@@ -1,3 +1,4 @@
+import { CopyCatAccountWallet } from '@aztec/accounts/copy-cat';
 import { getIdentities } from '@aztec/accounts/utils';
 import { createCompatibleClient } from '@aztec/aztec.js/rpc';
 import { TxHash } from '@aztec/aztec.js/tx_hash';
@@ -6,9 +7,9 @@ import { GasFees } from '@aztec/stdlib/gas';
 import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
 import { Option } from 'commander';
 import inquirer from 'inquirer';
-import { addScopeToWallet, createOrRetrieveAccount, getWalletWithScopes } from '../utils/accounts.js';
+import { createOrRetrieveAccount } 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';
+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 +17,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.
+    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', 'Publishes the account contract instance (and the class, if needed). Needed if the contract contains public functions.').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 +40,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,57 +55,73 @@ 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('--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.').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 } = 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, 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(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, 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, timeout, verbose } = options;
+        const client = await pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
         const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-        const wallet = await getWalletWithScopes(account, db);
+        const wallet = await account.getWallet();
         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));
+        const address = await deploy(wallet, universal ? undefined : wallet.getAddress(), artifactPath, json, publicKey, args, salt, typeof init === 'string' ? init : undefined, !publicDeployment, !classRegistration, typeof init === 'string' ? false : init, wait, await FeeOpts.fromCli(options, client, log, db), timeout, 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(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 } = 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 getWalletWithScopes(account, db);
+        const wallet = await account.getWallet();
         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);
+        const authWitnesses = cleanupAuthWitnesses(authWitnessArray);
+        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)}`;
+            const txAlias = alias ? alias : `${functionName}-${sentTx.txNonce.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(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(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, profile } = 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 getWalletWithScopes(account, db);
+        const originalWallet = await account.getWallet();
+        const wallet = await CopyCatAccountWallet.create(client, originalWallet);
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
-        await simulate(wallet, functionName, args, artifactPath, contractAddress, profile, log);
+        const authWitnesses = cleanupAuthWitnesses(authWitness);
+        await simulate(wallet, functionName, args, artifactPath, contractAddress, await FeeOpts.fromCli(options, client, 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(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 = 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, 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
@@ -113,7 +130,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);
@@ -123,9 +140,9 @@ 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 getWalletWithScopes(account, db);
+        const wallet = await account.getWallet();
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
         const witness = await createAuthwit(wallet, functionName, caller, args, artifactPath, contractAddress, log);
         if (db) {
@@ -136,27 +153,17 @@ 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 getWalletWithScopes(account, db);
+        const wallet = await account.getWallet();
         const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
-        await authorizeAction(wallet, 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);
+        await authorizeAction(wallet, wallet.getAddress(), functionName, caller, args, artifactPath, contractAddress, log);
     });
     program.command('get-tx').description('Gets the status of the recent txs, or a detailed view if a specific transaction hash is provided').argument('[txHash]', 'A transaction hash to get the receipt for.', (txHash)=>aliasedTxHashParser(txHash, db)).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)=>{
         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) {
@@ -185,9 +192,9 @@ 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 getWalletWithScopes(account, db);
+        const wallet = await account.getWallet();
         const txData = await db?.retrieveTxData(txHash);
         if (!txData) {
             throw new Error('Transaction data not found in the database, cannot reuse nonce');
@@ -198,23 +205,23 @@ 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 getWalletWithScopes(account, db);
+        const wallet = await account.getWallet();
         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(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 } = command.optsWithGlobals();
-        const client = pxeWrapper?.getPXE() ?? await createCompatibleClient(rpcUrl, debugLogger);
+        const { from: parsedFromAddress, rpcUrl, nodeUrl, secretKey, alias, init, publicKey, salt, deployer, args } = command.optsWithGlobals();
+        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 getWalletWithScopes(account, db);
+        const wallet = await account.getWallet();
         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,5 @@
+import { type AccountWalletWithSecretKey, AuthWitness, type AztecAddress } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+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

@@ -0,0 +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;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

@@ -0,0 +1,23 @@
+import { Contract } from '@aztec/aztec.js';
+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, 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({
+        ...await feeOpts.toSendOpts(wallet),
+        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,4 @@
-import type { AccountWalletWithSecretKey, AztecAddress, AztecNode } from '@aztec/aztec.js';
+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): 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,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,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/register_contract.js

@@ -1,9 +1,23 @@
+import { PublicKeys, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js';
 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,
+            deployer
+        });
+    }
+    if (!contractInstance.address.equals(address)) {
+        throw new Error(`Contract address mismatch: expected ${address}, got ${contractInstance.address}`);
     }
     await wallet.registerContract({
         instance: contractInstance,

package/dest/cmds/send.d.ts

@@ -1,10 +1,10 @@
-import { type AccountWalletWithSecretKey, type AztecAddress, Fr } from '@aztec/aztec.js';
+import { type AccountWalletWithSecretKey, AuthWitness, type AztecAddress, Fr } from '@aztec/aztec.js';
 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<{
+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;
+    txNonce: Fr;
     cancellable: boolean;
     gasSettings: GasSettings;
 } | undefined>;

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,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;AAI5E,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,28 +2,36 @@ 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, log) {
+import { printProfileResult } from '../utils/profiling.js';
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/pxe_wrapper.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);
-    const gasLimits = await call.estimateGas({
-        ...await feeOpts.toSendOpts(wallet)
-    });
+    const txNonce = Fr.random();
+    const sendOptions = {
+        ...await feeOpts.toSendOpts(wallet),
+        authWitnesses,
+        cancellable,
+        txNonce
+    };
+    const gasLimits = await call.estimateGas(sendOptions);
     printGasEstimates(feeOpts, gasLimits, log);
     if (feeOpts.estimateOnly) {
         return;
     }
-    const nonce = Fr.random();
-    const tx = call.send({
-        ...await feeOpts.toSendOpts(wallet),
-        nonce,
-        cancellable
-    });
+    const provenTx = await call.prove(sendOptions);
+    if (verbose) {
+        printProfileResult(provenTx.stats, log);
+    }
+    const tx = provenTx.send();
     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}`);
@@ -42,7 +50,7 @@ export async function send(wallet, functionName, functionArgsIn, contractArtifac
     });
     return {
         txHash,
-        nonce,
+        txNonce,
         cancellable,
         gasSettings
     };

package/dest/cmds/simulate.d.ts

@@ -1,4 +1,5 @@
-import { type AccountWalletWithSecretKey, type AztecAddress } from '@aztec/aztec.js';
+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, profile: boolean, 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

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,EAAE,KAAK,0BAA0B,EAAE,WAAW,EAAE,KAAK,YAAY,EAAY,MAAM,iBAAiB,CAAC;AAE5G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAKnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD,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,QAAQ,EACjB,aAAa,EAAE,WAAW,EAAE,EAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,KAAK,iBA8BX"}

package/dest/cmds/simulate.js

@@ -1,26 +1,27 @@
 import { Contract } from '@aztec/aztec.js';
 import { prepTx } from '@aztec/cli/utils';
 import { format } from 'util';
-function printProfileResult(result, log) {
-    log(format('\nSimulation result:'));
-    log(format('Return value:', JSON.stringify(result.returnValues, null, 2)));
-    log(format('\nGate count per circuit:'));
-    let acc = 0;
-    result.gateCounts.forEach((r)=>{
-        acc += r.gateCount;
-        log(format('  ', r.circuitName.padEnd(50), 'Gates:', r.gateCount.toLocaleString(), '\tAcc:', acc.toLocaleString()));
-    });
-    log(format('\nTotal gates:', acc.toLocaleString()));
-}
-export async function simulate(wallet, functionName, functionArgsIn, contractArtifactPath, contractAddress, profile, log) {
+import { printAuthorizations } from '../utils/authorizations.js';
+import { printProfileResult } from '../utils/profiling.js';
+export async function simulate(wallet, functionName, functionArgsIn, contractArtifactPath, contractAddress, 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);
-    if (profile) {
-        const result = await call.simulateWithProfile();
-        printProfileResult(result, log);
-    } else {
-        const result = await call.simulate();
-        log(format('\nSimulation result: ', result, '\n'));
+    const simulationResult = await call.simulate({
+        ...await feeOpts.toSendOpts(wallet),
+        authWitnesses,
+        includeMetadata: true
+    });
+    if (verbose) {
+        await printAuthorizations(simulationResult.offchainEffects, async (address)=>{
+            const metadata = await wallet.getContractMetadata(address);
+            if (!metadata.contractInstance) {
+                return undefined;
+            }
+            const classMetadata = await wallet.getContractClassMetadata(metadata.contractInstance.currentContractClassId, true);
+            return classMetadata.artifact;
+        }, log);
+        printProfileResult(simulationResult.stats, log);
     }
+    log(format('\nSimulation result: ', simulationResult.result, '\n'));
 }

package/dest/storage/wallet_db.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { Fr } from '@aztec/foundation/fields';
 import type { LogFn } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
@@ -33,15 +31,15 @@ export declare class WalletDB {
     storeSender(address: AztecAddress, alias: string, log: LogFn): Promise<void>;
     storeContract(address: AztecAddress, artifactPath: string, log: LogFn, alias?: string): Promise<void>;
     storeAuthwitness(authWit: AuthWitness, log: LogFn, alias?: string): Promise<void>;
-    storeTx({ txHash, nonce, cancellable, gasSettings, }: {
+    storeTx({ txHash, txNonce, cancellable, gasSettings, }: {
         txHash: TxHash;
-        nonce: Fr;
+        txNonce: Fr;
         cancellable: boolean;
         gasSettings: GasSettings;
     }, log: LogFn, alias?: string): Promise<void>;
     retrieveTxData(txHash: TxHash): Promise<{
         txHash: TxHash;
-        nonce: Fr;
+        txNonce: Fr;
         cancellable: boolean;
         gasSettings: GasSettings;
     }>;
@@ -53,12 +51,12 @@ export declare class WalletDB {
         value: string;
     }[]>;
     storeAccountMetadata(aliasOrAddress: AztecAddress | string, metadataKey: string, metadata: Buffer): Promise<void>;
-    retrieveAccountMetadata(aliasOrAddress: AztecAddress | string, metadataKey: string): Promise<Buffer>;
+    retrieveAccountMetadata(aliasOrAddress: AztecAddress | string, metadataKey: string): Promise<Buffer<ArrayBufferLike>>;
     retrieveAccount(address: AztecAddress | string): Promise<{
         address: string | AztecAddress;
         secretKey: Fr;
         salt: Fr;
-        type: "schnorr" | "ecdsasecp256r1ssh" | "ecdsasecp256k1";
+        type: "schnorr" | "ecdsasecp256r1" | "ecdsasecp256r1ssh" | "ecdsasecp256k1";
     }>;
     storeAlias(type: AliasType, key: string, value: Buffer, log: LogFn): Promise<void>;
 }

package/dest/storage/wallet_db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wallet_db.d.ts","sourceRoot":"","sources":["../../src/storage/wallet_db.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGxD,eAAO,MAAM,OAAO,wFAAyF,CAAC;AAC9G,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,qBAAa,QAAQ;;IAMnB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAW;IAElC,OAAO,CAAC,UAAU,CAA6B;IAE/C,MAAM,CAAC,WAAW;IAQZ,IAAI,CAAC,KAAK,EAAE,iBAAiB;YASrB,iBAAiB;IAIzB,mBAAmB,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK;IAWtG,kBAAkB,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,EAAE,KAAK;;;;;IActD,YAAY,CAChB,OAAO,EAAE,YAAY,EACrB,EACE,IAAI,EACJ,SAAS,EACT,IAAI,EACJ,KAAK,EACL,SAAS,GACV,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,EAAE,CAAC;QAAC,IAAI,EAAE,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,EAC3G,GAAG,EAAE,KAAK;IAkBN,WAAW,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK;IAO5D,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,MAAM;IAarF,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,MAAM;IAUjE,OAAO,CACX,EACE,MAAM,EACN,KAAK,EACL,WAAW,EACX,WAAW,GACZ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,EAAE,CAAC;QAAC,WAAW,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,WAAW,CAAA;KAAE,EAChF,GAAG,EAAE,KAAK,EACV,KAAK,CAAC,EAAE,MAAM;IAcV,cAAc,CAAC,MAAM,EAAE,MAAM;;;;;;IAanC,gBAAgB,CAAC,GAAG,EAAE,MAAM;IAQrB,sBAAsB,CAAC,GAAG,EAAE,MAAM;IAcnC,aAAa,CAAC,GAAG,EAAE,MAAM;IAazB,WAAW,CAAC,IAAI,CAAC,EAAE,SAAS;;;;IAa5B,oBAAoB,CAAC,cAAc,EAAE,YAAY,GAAG,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAKjG,uBAAuB,CAAC,cAAc,EAAE,YAAY,GAAG,MAAM,EAAE,WAAW,EAAE,MAAM;IASlF,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;;;;;;IAW9C,UAAU,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK;CAOzE"}
+{"version":3,"file":"wallet_db.d.ts","sourceRoot":"","sources":["../../src/storage/wallet_db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGxD,eAAO,MAAM,OAAO,wFAAyF,CAAC;AAC9G,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,qBAAa,QAAQ;;IAMnB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAW;IAElC,OAAO,CAAC,UAAU,CAA6B;IAE/C,MAAM,CAAC,WAAW;IAQZ,IAAI,CAAC,KAAK,EAAE,iBAAiB;YASrB,iBAAiB;IAIzB,mBAAmB,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK;IAWtG,kBAAkB,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,EAAE,KAAK;;;;;IActD,YAAY,CAChB,OAAO,EAAE,YAAY,EACrB,EACE,IAAI,EACJ,SAAS,EACT,IAAI,EACJ,KAAK,EACL,SAAS,GACV,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,EAAE,CAAC;QAAC,IAAI,EAAE,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,EAC3G,GAAG,EAAE,KAAK;IAkBN,WAAW,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK;IAO5D,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,MAAM;IAarF,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,MAAM;IAUjE,OAAO,CACX,EACE,MAAM,EACN,OAAO,EACP,WAAW,EACX,WAAW,GACZ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,EAAE,CAAC;QAAC,WAAW,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,WAAW,CAAA;KAAE,EAClF,GAAG,EAAE,KAAK,EACV,KAAK,CAAC,EAAE,MAAM;IAcV,cAAc,CAAC,MAAM,EAAE,MAAM;;;;;;IAanC,gBAAgB,CAAC,GAAG,EAAE,MAAM;IAQrB,sBAAsB,CAAC,GAAG,EAAE,MAAM;IAcnC,aAAa,CAAC,GAAG,EAAE,MAAM;IAazB,WAAW,CAAC,IAAI,CAAC,EAAE,SAAS;;;;IAa5B,oBAAoB,CAAC,cAAc,EAAE,YAAY,GAAG,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAKjG,uBAAuB,CAAC,cAAc,EAAE,YAAY,GAAG,MAAM,EAAE,WAAW,EAAE,MAAM;IASlF,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;;;;;;IAW9C,UAAU,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK;CAOzE"}

package/dest/storage/wallet_db.js

@@ -100,11 +100,11 @@ export class WalletDB {
         log(`Authorization witness stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
         await this.refreshAliasCache();
     }
-    async storeTx({ txHash, nonce, cancellable, gasSettings }, log, alias) {
+    async storeTx({ txHash, txNonce, cancellable, gasSettings }, log, alias) {
         if (alias) {
             await this.#aliases.set(`transactions:${alias}`, Buffer.from(txHash.toString()));
         }
-        await this.#transactions.set(`${txHash.toString()}:nonce`, nonce.toBuffer());
+        await this.#transactions.set(`${txHash.toString()}:txNonce`, txNonce.toBuffer());
         await this.#transactions.set(`${txHash.toString()}:cancellable`, Buffer.from(cancellable ? 'true' : 'false'));
         await this.#transactions.set(`${txHash.toString()}:gasSettings`, gasSettings.toBuffer());
         await this.#aliases.set(`transactions:last`, Buffer.from(txHash.toString()));
@@ -112,16 +112,16 @@ export class WalletDB {
         await this.refreshAliasCache();
     }
     async retrieveTxData(txHash) {
-        const nonceBuffer = await this.#transactions.getAsync(`${txHash.toString()}:nonce`);
-        if (!nonceBuffer) {
-            throw new Error(`Could not find ${txHash.toString()}:nonce. Transaction with hash "${txHash.toString()}" does not exist on this wallet.`);
+        const txNonceBuffer = await this.#transactions.getAsync(`${txHash.toString()}:txNonce`);
+        if (!txNonceBuffer) {
+            throw new Error(`Could not find ${txHash.toString()}:txNonce. Transaction with hash "${txHash.toString()}" does not exist on this wallet.`);
         }
-        const nonce = Fr.fromBuffer(nonceBuffer);
+        const txNonce = Fr.fromBuffer(txNonceBuffer);
         const cancellable = (await this.#transactions.getAsync(`${txHash.toString()}:cancellable`)).toString() === 'true';
         const gasBuffer = await this.#transactions.getAsync(`${txHash.toString()}:gasSettings`);
         return {
             txHash,
-            nonce,
+            txNonce,
             cancellable,
             gasSettings: GasSettings.fromBuffer(gasBuffer)
         };
@@ -129,7 +129,7 @@ export class WalletDB {
     tryRetrieveAlias(arg) {
         try {
             return this.retrieveAliasFromCache(arg);
-        } catch (e) {
+        } catch  {
             return arg;
         }
     }

package/dest/utils/accounts.d.ts

@@ -1,11 +1,9 @@
-import type { AccountManager, AccountWalletWithSecretKey } from '@aztec/aztec.js';
+import type { AccountManager } from '@aztec/aztec.js';
 import { Fr } from '@aztec/foundation/fields';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { PXE } from '@aztec/stdlib/interfaces/client';
 import type { WalletDB } from '../storage/wallet_db.js';
-export declare const AccountTypes: readonly ["schnorr", "ecdsasecp256r1ssh", "ecdsasecp256k1"];
+export declare const AccountTypes: readonly ["schnorr", "ecdsasecp256r1", "ecdsasecp256r1ssh", "ecdsasecp256k1"];
 export type AccountType = (typeof AccountTypes)[number];
-export declare function createOrRetrieveAccount(pxe: PXE, address?: AztecAddress, db?: WalletDB, secretKey?: Fr, type?: AccountType, salt?: Fr, publicKey?: string | undefined): Promise<AccountManager>;
-export declare function addScopeToWallet(wallet: AccountWalletWithSecretKey, scope: AztecAddress, db?: WalletDB): Promise<void>;
-export declare function getWalletWithScopes(account: AccountManager, db?: WalletDB): Promise<AccountWalletWithSecretKey>;
+export declare function createOrRetrieveAccount(pxe: PXE, address?: AztecAddress, db?: WalletDB, secretKey?: Fr, type?: AccountType, salt?: Fr, publicKey?: string): Promise<AccountManager>;
 //# sourceMappingURL=accounts.d.ts.map