@aztec/cli-wallet 0.0.0-test.0

package/dest/cmds/import_test_accounts.js

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

package/dest/cmds/index.d.ts

@@ -0,0 +1,6 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { type Command } from 'commander';
+import type { WalletDB } from '../storage/wallet_db.js';
+import type { PXEWrapper } from '../utils/pxe_wrapper.js';
+export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger, db?: WalletDB, pxeWrapper?: PXEWrapper): Command;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dest/cmds/index.js

@@ -0,0 +1,223 @@
+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 { 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.`);
+        }
+        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);
+    });
+    const createAccountCommand = program.command('create-account').description('Creates an aztec account that can be used for sending transactions. Registers the account on the PXE and deploys an account contract. Uses a Schnorr single-key account which uses the same key for encryption and authentication (not secure for production usage).').summary('Creates an aztec account that can be used for sending transactions.').option('--skip-initialization', 'Skip initializing the account contract. Useful for publicly deploying an existing account.').option('--public-deploy', 'Publicly deploys the account and registers the class if needed.').option('-p, --public-key <string>', 'Public key that identifies a private signing key stored outside of the wallet. Used for ECDSA SSH accounts over the secp256r1 curve.').addOption(pxeOption).addOption(createSecretKeyOption('Secret key for account. Uses random by default.', false, (sk)=>aliasedSecretKeyParser(sk, db)).conflicts('public-key')).addOption(createAliasOption('Alias for the account. Used for easy reference in subsequent commands.', !db)).addOption(createTypeOption(true)).option('--register-only', 'Just register the account on the PXE. Do not deploy or initialize the account contract.').option('--json', 'Emit output as json')// `options.wait` is default true. Passing `--no-wait` will set it to false.
+    // https://github.com/tj/commander.js#other-option-types-negatable-boolean-and-booleanvalue
+    .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction');
+    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;
+        let { publicKey } = options;
+        if (type === 'ecdsasecp256r1ssh' && !publicKey) {
+            const identities = await getIdentities();
+            const answers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'identity',
+                    message: 'What public key to use?',
+                    choices: identities.map((key)=>`${key.type} ${key.publicKey} ${key.comment}`)
+                }
+            ]);
+            publicKey = answers.identity.split(' ')[1];
+        }
+        const 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);
+        if (db) {
+            const { address, alias, secretKey, salt } = accountCreationResult;
+            await db.storeAccount(address, {
+                type,
+                secretKey,
+                salt,
+                alias,
+                publicKey
+            }, log);
+        }
+    });
+    const deployAccountCommand = program.command('deploy-account').description('Deploys an already registered aztec account that can be used for sending transactions.').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');
+    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 account = await createOrRetrieveAccount(client, parsedFromAddress, db);
+        await deployAccount(account, wait, await FeeOptsWithFeePayer.fromCli(options, client, log, db), json, 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");
+    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 account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
+        const wallet = await getWalletWithScopes(account, db);
+        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));
+        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 { 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 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);
+        if (db && sentTx) {
+            const txAlias = alias ? alias : `${functionName}-${sentTx.nonce.toString().slice(-4)}`;
+            await db.storeTx(sentTx, log, txAlias);
+        }
+    });
+    program.command('simulate').description('Simulates the execution of a function on an Aztec contract.').argument('<functionName>', 'Name of function to simulate').addOption(pxeOption).addOption(createArgsOption(false, db)).addOption(createContractAddressOption(db)).addOption(createArtifactOption(db)).addOption(createSecretKeyOption("The sender's secret key", !db, (sk)=>aliasedSecretKeyParser(sk, db)).conflicts('account')).addOption(createAccountOption('Alias or address of the account to simulate from', !db, db)).addOption(createProfileOption()).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 artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+        await simulate(wallet, functionName, args, artifactPath, contractAddress, profile, 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.
+    // 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)=>{
+        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);
+        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)=>{
+        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 artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+        const witness = await createAuthwit(wallet, 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)=>{
+        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 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);
+    });
+    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);
+        if (txHash) {
+            await checkTx(client, txHash, false, log);
+        } else if (db) {
+            const aliases = await db.listAliases('transactions');
+            const totalPages = Math.ceil(aliases.length / pageSize);
+            page = Math.min(page - 1, totalPages - 1);
+            const dataRows = await Promise.all(aliases.slice(page * pageSize, pageSize * (1 + page)).map(async ({ key, value })=>({
+                    alias: key,
+                    txHash: value,
+                    cancellable: (await db.retrieveTxData(TxHash.fromString(value))).cancellable,
+                    status: await checkTx(client, 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(`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)=>{
+        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);
+        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)=>{
+        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 artifactPath = await artifactPathPromise;
+        const instance = await registerContract(wallet, node, address, artifactPath, log);
+        if (db && alias) {
+            await db.storeContract(instance.address, artifactPath, log, alias);
+        }
+    });
+    return program;
+}

package/dest/cmds/register_contract.d.ts

@@ -0,0 +1,4 @@
+import type { AccountWalletWithSecretKey, AztecAddress, AztecNode } 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>;
+//# sourceMappingURL=register_contract.d.ts.map

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

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

package/dest/cmds/register_contract.js

@@ -0,0 +1,14 @@
+import { getContractArtifact } from '@aztec/cli/cli-utils';
+export async function registerContract(wallet, node, address, artifactPath, log) {
+    const contractArtifact = await getContractArtifact(artifactPath, log);
+    const contractInstance = await node.getContract(address);
+    if (!contractInstance) {
+        throw new Error(`Contract not found at address: ${address}`);
+    }
+    await wallet.registerContract({
+        instance: contractInstance,
+        artifact: contractArtifact
+    });
+    log(`Contract registered: at ${contractInstance.address}`);
+    return contractInstance;
+}

package/dest/cmds/register_sender.d.ts

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

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

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

package/dest/cmds/register_sender.js

@@ -0,0 +1,4 @@
+export async function registerSender(wallet, address, log) {
+    await wallet.registerSender(address);
+    log(`Sender registered: ${address}`);
+}

package/dest/cmds/send.d.ts

@@ -0,0 +1,11 @@
+import { type AccountWalletWithSecretKey, 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<{
+    txHash: import("@aztec/aztec.js").TxHash;
+    nonce: Fr;
+    cancellable: boolean;
+    gasSettings: GasSettings;
+} | undefined>;
+//# sourceMappingURL=send.d.ts.map

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

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

package/dest/cmds/send.js

@@ -0,0 +1,49 @@
+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) {
+    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)
+    });
+    printGasEstimates(feeOpts, gasLimits, log);
+    if (feeOpts.estimateOnly) {
+        return;
+    }
+    const nonce = Fr.random();
+    const tx = call.send({
+        ...await feeOpts.toSendOpts(wallet),
+        nonce,
+        cancellable
+    });
+    const txHash = await tx.getTxHash();
+    log(`\nTransaction hash: ${txHash.toString()}`);
+    if (wait) {
+        try {
+            await tx.wait();
+            log('Transaction has been mined');
+            const receipt = await tx.getReceipt();
+            log(` Tx fee: ${receipt.transactionFee}`);
+            log(` Status: ${receipt.status}`);
+            log(` Block number: ${receipt.blockNumber}`);
+            log(` Block hash: ${receipt.blockHash?.toString()}`);
+        } catch (err) {
+            log(`Transaction failed\n ${err.message}`);
+        }
+    } else {
+        log('Transaction pending. Check status with check-tx');
+    }
+    const gasSettings = GasSettings.from({
+        ...feeOpts.gasSettings,
+        ...gasLimits
+    });
+    return {
+        txHash,
+        nonce,
+        cancellable,
+        gasSettings
+    };
+}

package/dest/cmds/simulate.d.ts

@@ -0,0 +1,4 @@
+import { type AccountWalletWithSecretKey, 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>;
+//# sourceMappingURL=simulate.d.ts.map

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

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

package/dest/cmds/simulate.js

@@ -0,0 +1,26 @@
+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) {
+    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'));
+    }
+}

package/dest/storage/wallet_db.d.ts

@@ -0,0 +1,65 @@
+/// <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';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasSettings } from '@aztec/stdlib/gas';
+import type { TxHash } from '@aztec/stdlib/tx';
+import type { AccountType } from '../utils/accounts.js';
+export declare const Aliases: readonly ["accounts", "contracts", "artifacts", "secrets", "transactions", "authwits"];
+export type AliasType = (typeof Aliases)[number];
+export declare class WalletDB {
+    #private;
+    private static instance;
+    private aliasCache;
+    static getInstance(): WalletDB;
+    init(store: AztecAsyncKVStore): Promise<void>;
+    private refreshAliasCache;
+    pushBridgedFeeJuice(recipient: AztecAddress, secret: Fr, amount: bigint, leafIndex: bigint, log: LogFn): Promise<void>;
+    popBridgedFeeJuice(recipient: AztecAddress, log: LogFn): Promise<{
+        amount: bigint;
+        secret: string;
+        leafIndex: bigint;
+    }>;
+    storeAccount(address: AztecAddress, { type, secretKey, salt, alias, publicKey, }: {
+        type: AccountType;
+        secretKey: Fr;
+        salt: Fr;
+        alias: string | undefined;
+        publicKey: string | undefined;
+    }, log: LogFn): Promise<void>;
+    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, }: {
+        txHash: TxHash;
+        nonce: Fr;
+        cancellable: boolean;
+        gasSettings: GasSettings;
+    }, log: LogFn, alias?: string): Promise<void>;
+    retrieveTxData(txHash: TxHash): Promise<{
+        txHash: TxHash;
+        nonce: Fr;
+        cancellable: boolean;
+        gasSettings: GasSettings;
+    }>;
+    tryRetrieveAlias(arg: string): string;
+    retrieveAliasFromCache(arg: string): string;
+    retrieveAlias(arg: string): Promise<string>;
+    listAliases(type?: AliasType): Promise<{
+        key: string;
+        value: string;
+    }[]>;
+    storeAccountMetadata(aliasOrAddress: AztecAddress | string, metadataKey: string, metadata: Buffer): Promise<void>;
+    retrieveAccountMetadata(aliasOrAddress: AztecAddress | string, metadataKey: string): Promise<Buffer>;
+    retrieveAccount(address: AztecAddress | string): Promise<{
+        address: string | AztecAddress;
+        secretKey: Fr;
+        salt: Fr;
+        type: "schnorr" | "ecdsasecp256r1ssh" | "ecdsasecp256k1";
+    }>;
+    storeAlias(type: AliasType, key: string, value: Buffer, log: LogFn): Promise<void>;
+}
+//# sourceMappingURL=wallet_db.d.ts.map

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

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