@aztec/cli-wallet 0.0.0-test.0

package/README.md

@@ -0,0 +1,2 @@
+# Aztec wallet Documentation
+

package/dest/bin/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":""}

package/dest/bin/index.js

@@ -0,0 +1,75 @@
+import { Fr, computeSecretHash, fileURLToPath } from '@aztec/aztec.js';
+import { LOCALHOST } from '@aztec/cli/cli-utils';
+import { createConsoleLogger, createLogger } from '@aztec/foundation/log';
+import { openStoreAt } from '@aztec/kv-store/lmdb-v2';
+import { Argument, Command, Option } from 'commander';
+import { mkdirSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join, resolve } from 'path';
+import { injectCommands } from '../cmds/index.js';
+import { Aliases, WalletDB } from '../storage/wallet_db.js';
+import { createAliasOption } from '../utils/options/index.js';
+import { PXEWrapper } from '../utils/pxe_wrapper.js';
+const userLog = createConsoleLogger();
+const debugLogger = createLogger('wallet');
+const { WALLET_DATA_DIRECTORY = join(homedir(), '.aztec/wallet'), PXE_PROVER = 'none' } = process.env;
+function injectInternalCommands(program, log, db) {
+    program.command('alias').description('Aliases information for easy reference.').addArgument(new Argument('<type>', 'Type of alias to create').choices(Aliases)).argument('<key>', 'Key to alias.').argument('<value>', 'Value to assign to the alias.').action(async (type, key, value)=>{
+        value = db.tryRetrieveAlias(value) || value;
+        await db.storeAlias(type, key, value, log);
+    });
+    program.command('get-alias').description('Shows stored aliases').addArgument(new Argument('[alias]', 'Alias to retrieve')).action(async (alias)=>{
+        if (alias?.includes(':')) {
+            const value = await db.retrieveAlias(alias);
+            log(value);
+        } else {
+            const aliases = await db.listAliases(alias);
+            for (const { key, value } of aliases){
+                log(`${key} -> ${value}`);
+            }
+        }
+    });
+    program.command('create-secret').description('Creates an aliased secret to use in other commands').addOption(createAliasOption('Key to alias the secret with', false).makeOptionMandatory(true)).action(async (_options, command)=>{
+        const options = command.optsWithGlobals();
+        const { alias } = options;
+        const value = Fr.random();
+        const hash = computeSecretHash(value);
+        await db.storeAlias('secrets', alias, Buffer.from(value.toString()), log);
+        await db.storeAlias('secrets', `${alias}:hash`, Buffer.from(hash.toString()), log);
+    });
+    return program;
+}
+/** CLI wallet main entrypoint */ async function main() {
+    const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+    const walletVersion = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+    const db = WalletDB.getInstance();
+    const pxeWrapper = new PXEWrapper();
+    const program = new Command('wallet');
+    program.description('Aztec wallet').version(walletVersion).option('-d, --data-dir <string>', 'Storage directory for wallet data', WALLET_DATA_DIRECTORY).option('-p, --prover <string>', 'wasm|native|none', PXE_PROVER).addOption(new Option('--remote-pxe', 'Connect to an external PXE RPC server, instead of the local one').env('REMOTE_PXE').default(false).conflicts('rpc-url')).addOption(new Option('-n, --node-url <string>', 'URL of the Aztec node to connect to').env('AZTEC_NODE_URL').default(`http://${LOCALHOST}:8080`)).hook('preSubcommand', async (command)=>{
+        const { dataDir, remotePxe, nodeUrl, prover } = command.optsWithGlobals();
+        if (!remotePxe) {
+            debugLogger.info('Using local PXE service');
+            const proverEnabled = prover !== 'none';
+            const bbBinaryPath = prover === 'native' ? resolve(dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/cpp/build/bin/bb') : undefined;
+            const bbWorkingDirectory = dataDir + '/bb';
+            mkdirSync(bbWorkingDirectory, {
+                recursive: true
+            });
+            const overridePXEConfig = {
+                proverEnabled,
+                bbBinaryPath: prover === 'native' ? bbBinaryPath : undefined,
+                bbWorkingDirectory: prover === 'native' ? bbWorkingDirectory : undefined
+            };
+            await pxeWrapper.init(nodeUrl, join(dataDir, 'pxe'), overridePXEConfig);
+        }
+        await db.init(await openStoreAt(dataDir));
+    });
+    injectCommands(program, userLog, debugLogger, db, pxeWrapper);
+    injectInternalCommands(program, userLog, db);
+    await program.parseAsync(process.argv);
+}
+main().catch((err)=>{
+    debugLogger.error(`Error in command execution`);
+    debugLogger.error(err + '\n' + err.stack);
+    process.exit(1);
+});

package/dest/cmds/add_authwit.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"add_authwit.d.ts","sourceRoot":"","sources":["../../src/cmds/add_authwit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC7F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,UAAU,CAC9B,MAAM,EAAE,0BAA0B,EAClC,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,YAAY,EACxB,GAAG,EAAE,KAAK,iBAKX"}

package/dest/cmds/add_authwit.js

@@ -0,0 +1,4 @@
+export async function addAuthwit(wallet, authwit, authorizer, log) {
+    await wallet.addAuthWitness(authwit);
+    log(`Added authorization witness from ${authorizer}`);
+}

package/dest/cmds/authorize_action.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 authorizeAction(wallet: AccountWalletWithSecretKey, functionName: string, caller: AztecAddress, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, log: LogFn): Promise<import("@aztec/aztec.js").FieldsOf<import("@aztec/aztec.js").TxReceipt>>;
+//# sourceMappingURL=authorize_action.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"authorize_action.d.ts","sourceRoot":"","sources":["../../src/cmds/authorize_action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAE,KAAK,YAAY,EAAY,MAAM,iBAAiB,CAAC;AAE/F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,eAAe,CACnC,MAAM,EAAE,0BAA0B,EAClC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,YAAY,EACpB,cAAc,EAAE,GAAG,EAAE,EACrB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,YAAY,EAC7B,GAAG,EAAE,KAAK,oFAwBX"}

package/dest/cmds/authorize_action.js

@@ -0,0 +1,17 @@
+import { Contract } from '@aztec/aztec.js';
+import { prepTx } from '@aztec/cli/utils';
+export async function authorizeAction(wallet, functionName, caller, functionArgsIn, contractArtifactPath, contractAddress, log) {
+    const { functionArgs, contractArtifact, isPrivate } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
+    if (isPrivate) {
+        throw new Error('Cannot authorize private function. To allow a third party to call a private function, please create an authorization witness via the create-authwit command');
+    }
+    const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+    const action = contract.methods[functionName](...functionArgs);
+    const setAuthwitnessInteraction = await wallet.setPublicAuthWit({
+        caller,
+        action
+    }, true);
+    const witness = await setAuthwitnessInteraction.send().wait();
+    log(`Authorized action ${functionName} on contract ${contractAddress} for caller ${caller}`);
+    return witness;
+}

package/dest/cmds/bridge_fee_juice.d.ts

@@ -0,0 +1,6 @@
+import { type PXE } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+export declare function bridgeL1FeeJuice(amount: bigint, recipient: AztecAddress, pxe: PXE, l1RpcUrls: string[], chainId: number, privateKey: string | undefined, mnemonic: string, mint: boolean, json: boolean, wait: boolean, interval: number | undefined, log: LogFn, debugLogger: Logger): Promise<readonly [Fr, bigint]>;
+//# sourceMappingURL=bridge_fee_juice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bridge_fee_juice.d.ts","sourceRoot":"","sources":["../../src/cmds/bridge_fee_juice.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAGpE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,YAAY,EACvB,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,EACb,QAAQ,oBAAS,EACjB,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,kCAmEpB"}

package/dest/cmds/bridge_fee_juice.js

@@ -0,0 +1,52 @@
+import { L1FeeJuicePortalManager } from '@aztec/aztec.js';
+import { prettyPrintJSON } from '@aztec/cli/utils';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { Fr } from '@aztec/foundation/fields';
+export async function bridgeL1FeeJuice(amount, recipient, pxe, l1RpcUrls, chainId, privateKey, mnemonic, mint, json, wait, interval = 60_000, log, debugLogger) {
+    // Prepare L1 client
+    const chain = createEthereumChain(l1RpcUrls, chainId);
+    const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+    const { protocolContractAddresses: { feeJuice: feeJuiceAddress } } = await pxe.getPXEInfo();
+    // Setup portal manager
+    const portal = await L1FeeJuicePortalManager.new(pxe, publicClient, walletClient, debugLogger);
+    const { claimAmount, claimSecret, messageHash, messageLeafIndex } = await portal.bridgeTokensPublic(recipient, amount, mint);
+    if (json) {
+        const out = {
+            claimAmount,
+            claimSecret,
+            messageLeafIndex
+        };
+        log(prettyPrintJSON(out));
+    } else {
+        if (mint) {
+            log(`Minted ${claimAmount} fee juice on L1 and pushed to L2 portal`);
+        } else {
+            log(`Bridged ${claimAmount} fee juice to L2 portal`);
+        }
+        log(`claimAmount=${claimAmount},claimSecret=${claimSecret},messageHash=${messageHash},messageLeafIndex=${messageLeafIndex}\n`);
+        log(`Note: You need to wait for two L2 blocks before pulling them from the L2 side`);
+        if (wait) {
+            log(`This command will now continually poll every ${interval / 1000}s for the inclusion of the newly created L1 to L2 message`);
+        }
+    }
+    if (wait) {
+        const delayedCheck = (delay)=>{
+            return new Promise((resolve, reject)=>{
+                setTimeout(()=>{
+                    void pxe.getL1ToL2MembershipWitness(feeJuiceAddress, Fr.fromHexString(messageHash), claimSecret).then((witness)=>resolve(witness)).catch((err)=>reject(err));
+                }, delay);
+            });
+        };
+        let witness;
+        while(!witness){
+            witness = await delayedCheck(interval);
+            if (!witness) {
+                log(`No L1 to L2 message found yet, checking again in ${interval / 1000}s`);
+            }
+        }
+    }
+    return [
+        claimSecret,
+        messageLeafIndex
+    ];
+}

package/dest/cmds/cancel_tx.d.ts

@@ -0,0 +1,11 @@
+import { type AccountWalletWithSecretKey, type FeePaymentMethod, type TxHash } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn } from '@aztec/foundation/log';
+import { GasFees, GasSettings } from '@aztec/stdlib/gas';
+export declare function cancelTx(wallet: AccountWalletWithSecretKey, { txHash, gasSettings: prevTxGasSettings, nonce, cancellable, }: {
+    txHash: TxHash;
+    gasSettings: GasSettings;
+    nonce: Fr;
+    cancellable: boolean;
+}, paymentMethod: FeePaymentMethod, increasedFees: GasFees, maxFeesPerGas: GasFees | undefined, log: LogFn): Promise<void>;
+//# sourceMappingURL=cancel_tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cancel_tx.d.ts","sourceRoot":"","sources":["../../src/cmds/cancel_tx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAE,KAAK,gBAAgB,EAAU,KAAK,MAAM,EAAY,MAAM,iBAAiB,CAAC;AAExH,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEzD,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,0BAA0B,EAClC,EACE,MAAM,EACN,WAAW,EAAE,iBAAiB,EAC9B,KAAK,EACL,WAAW,GACZ,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,EAChF,aAAa,EAAE,gBAAgB,EAC/B,aAAa,EAAE,OAAO,EACtB,aAAa,EAAE,OAAO,GAAG,SAAS,EAClC,GAAG,EAAE,KAAK,iBA4CX"}

package/dest/cmds/cancel_tx.js

@@ -0,0 +1,38 @@
+import { SentTx, TxStatus } from '@aztec/aztec.js';
+import { GasFees, GasSettings } from '@aztec/stdlib/gas';
+export async function cancelTx(wallet, { txHash, gasSettings: prevTxGasSettings, nonce, cancellable }, paymentMethod, increasedFees, maxFeesPerGas, log) {
+    const receipt = await wallet.getTxReceipt(txHash);
+    if (receipt.status !== TxStatus.PENDING || !cancellable) {
+        log(`Transaction is in status ${receipt.status} and cannot be cancelled`);
+        return;
+    }
+    const maxPriorityFeesPerGas = new GasFees(prevTxGasSettings.maxPriorityFeesPerGas.feePerDaGas.add(increasedFees.feePerDaGas), prevTxGasSettings.maxPriorityFeesPerGas.feePerL2Gas.add(increasedFees.feePerL2Gas));
+    const fee = {
+        paymentMethod,
+        gasSettings: GasSettings.from({
+            ...prevTxGasSettings,
+            maxPriorityFeesPerGas,
+            maxFeesPerGas: maxFeesPerGas ?? prevTxGasSettings.maxFeesPerGas
+        })
+    };
+    const txRequest = await wallet.createTxExecutionRequest({
+        calls: [],
+        fee,
+        nonce,
+        cancellable: true
+    });
+    const txSimulationResult = await wallet.simulateTx(txRequest, true);
+    const txProvingResult = await wallet.proveTx(txRequest, txSimulationResult.privateExecutionResult);
+    const sentTx = new SentTx(wallet, wallet.sendTx(txProvingResult.toTx()));
+    try {
+        await sentTx.wait();
+        log('Transaction has been cancelled');
+        const cancelReceipt = await sentTx.getReceipt();
+        log(` Tx fee: ${cancelReceipt.transactionFee}`);
+        log(` Status: ${cancelReceipt.status}`);
+        log(` Block number: ${cancelReceipt.blockNumber}`);
+        log(` Block hash: ${cancelReceipt.blockHash?.toString()}`);
+    } catch (err) {
+        log(`Could not cancel transaction\n ${err.message}`);
+    }
+}

package/dest/cmds/check_tx.d.ts

@@ -0,0 +1,4 @@
+import type { PXE, TxHash } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+export declare function checkTx(client: PXE, txHash: TxHash, statusOnly: boolean, log: LogFn): Promise<import("@aztec/aztec.js").TxStatus | undefined>;
+//# sourceMappingURL=check_tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check_tx.d.ts","sourceRoot":"","sources":["../../src/cmds/check_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,2DAOzF"}

package/dest/cmds/check_tx.js

@@ -0,0 +1,11 @@
+import { inspectTx } from '@aztec/cli/inspect';
+export async function checkTx(client, txHash, statusOnly, log) {
+    if (statusOnly) {
+        const receipt = await client.getTxReceipt(txHash);
+        return receipt.status;
+    } else {
+        await inspectTx(client, txHash, log, {
+            includeBlockInfo: true
+        });
+    }
+}

package/dest/cmds/create_account.d.ts

@@ -0,0 +1,12 @@
+import type { PXE } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { type AccountType } from '../utils/accounts.js';
+import { type IFeeOpts } from '../utils/options/fees.js';
+export declare function createAccount(client: PXE, accountType: AccountType, secretKey: Fr | undefined, publicKey: string | undefined, alias: string | undefined, registerOnly: boolean, publicDeploy: boolean, skipInitialization: boolean, wait: boolean, feeOpts: IFeeOpts, json: boolean, debugLogger: Logger, log: LogFn): Promise<{
+    alias: string | undefined;
+    address: import("@aztec/aztec.js").AztecAddress;
+    secretKey: Fr;
+    salt: Fr;
+}>;
+//# sourceMappingURL=create_account.d.ts.map

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

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

package/dest/cmds/create_account.js

@@ -0,0 +1,94 @@
+import { prettyPrintJSON } from '@aztec/cli/cli-utils';
+import { Fr } from '@aztec/foundation/fields';
+import { createOrRetrieveAccount } from '../utils/accounts.js';
+import { printGasEstimates } from '../utils/options/fees.js';
+export async function createAccount(client, accountType, secretKey, publicKey, alias, registerOnly, publicDeploy, skipInitialization, wait, feeOpts, json, debugLogger, log) {
+    secretKey ??= Fr.random();
+    const account = await createOrRetrieveAccount(client, undefined /* address, we don't have it yet */ , undefined /* db, as we want to create from scratch */ , secretKey, accountType, Fr.ZERO, publicKey);
+    const salt = account.getInstance().salt;
+    const { address, publicKeys, partialAddress } = await account.getCompleteAddress();
+    const out = {};
+    if (json) {
+        out.address = address;
+        out.publicKey = publicKeys;
+        if (secretKey) {
+            out.secretKey = secretKey;
+        }
+        out.partialAddress = partialAddress;
+        out.salt = salt;
+        out.initHash = account.getInstance().initializationHash;
+        out.deployer = account.getInstance().deployer;
+    } else {
+        log(`\nNew account:\n`);
+        log(`Address:         ${address.toString()}`);
+        log(`Public key:      ${publicKeys.toString()}`);
+        if (secretKey) {
+            log(`Secret key:     ${secretKey.toString()}`);
+        }
+        log(`Partial address: ${partialAddress.toString()}`);
+        log(`Salt:            ${salt.toString()}`);
+        log(`Init hash:       ${account.getInstance().initializationHash.toString()}`);
+        log(`Deployer:        ${account.getInstance().deployer.toString()}`);
+    }
+    let tx;
+    let txReceipt;
+    if (registerOnly) {
+        await account.register();
+    } else {
+        const wallet = await account.getWallet();
+        const deployOpts = {
+            skipClassRegistration: !publicDeploy,
+            skipPublicDeployment: !publicDeploy,
+            skipInitialization: skipInitialization,
+            ...await feeOpts.toDeployAccountOpts(wallet)
+        };
+        if (feeOpts.estimateOnly) {
+            const gas = await (await account.getDeployMethod(deployOpts.deployWallet)).estimateGas(deployOpts);
+            if (json) {
+                out.fee = {
+                    gasLimits: {
+                        da: gas.gasLimits.daGas,
+                        l2: gas.gasLimits.l2Gas
+                    },
+                    teardownGasLimits: {
+                        da: gas.teardownGasLimits.daGas,
+                        l2: gas.teardownGasLimits
+                    }
+                };
+            } else {
+                printGasEstimates(feeOpts, gas, log);
+            }
+        } else {
+            tx = account.deploy(deployOpts);
+            const txHash = await tx.getTxHash();
+            debugLogger.debug(`Account contract tx sent with hash ${txHash}`);
+            out.txHash = txHash;
+            if (wait) {
+                if (!json) {
+                    log(`\nWaiting for account contract deployment...`);
+                }
+                txReceipt = await tx.wait();
+                out.txReceipt = {
+                    status: txReceipt.status,
+                    transactionFee: txReceipt.transactionFee
+                };
+            }
+        }
+    }
+    if (json) {
+        log(prettyPrintJSON(out));
+    } else {
+        if (tx) {
+            log(`Deploy tx hash:  ${await tx.getTxHash()}`);
+        }
+        if (txReceipt) {
+            log(`Deploy tx fee:   ${txReceipt.transactionFee}`);
+        }
+    }
+    return {
+        alias,
+        address,
+        secretKey,
+        salt
+    };
+}

package/dest/cmds/create_authwit.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 createAuthwit(wallet: AccountWalletWithSecretKey, functionName: string, caller: AztecAddress, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, log: LogFn): Promise<import("@aztec/aztec.js").AuthWitness>;
+//# sourceMappingURL=create_authwit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_authwit.d.ts","sourceRoot":"","sources":["../../src/cmds/create_authwit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAE,KAAK,YAAY,EAAY,MAAM,iBAAiB,CAAC;AAE/F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,aAAa,CACjC,MAAM,EAAE,0BAA0B,EAClC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,YAAY,EACpB,cAAc,EAAE,GAAG,EAAE,EACrB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,YAAY,EAC7B,GAAG,EAAE,KAAK,kDAuBX"}

package/dest/cmds/create_authwit.js

@@ -0,0 +1,16 @@
+import { Contract } from '@aztec/aztec.js';
+import { prepTx } from '@aztec/cli/utils';
+export async function createAuthwit(wallet, functionName, caller, functionArgsIn, contractArtifactPath, contractAddress, log) {
+    const { functionArgs, contractArtifact, isPrivate } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
+    if (!isPrivate) {
+        throw new Error('Cannot create an authwit for a public function. To allow a third party to call a public function, please authorize the action via the authorize-action command');
+    }
+    const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+    const action = contract.methods[functionName](...functionArgs);
+    const witness = await wallet.createAuthWit({
+        caller,
+        action
+    });
+    log(`Created authorization witness for action ${functionName} on contract ${contractAddress} for caller ${caller}`);
+    return witness;
+}

package/dest/cmds/deploy.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/cmds/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAuC,EAAE,EAAE,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAErH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAE5E,wBAAsB,MAAM,CAC1B,MAAM,EAAE,GAAG,EACX,MAAM,EAAE,0BAA0B,EAClC,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,OAAO,EAAE,GAAG,EAAE,EACd,IAAI,EAAE,EAAE,GAAG,SAAS,EACpB,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,oBAAoB,EAAE,OAAO,EAC7B,qBAAqB,EAAE,OAAO,EAC9B,kBAAkB,EAAE,OAAO,GAAG,SAAS,EACvC,eAAe,EAAE,OAAO,GAAG,SAAS,EACpC,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,QAAQ,EACjB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK,EACV,OAAO,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,+DAuF/B"}

package/dest/cmds/deploy.js

@@ -0,0 +1,83 @@
+import { ContractDeployer, Fr } from '@aztec/aztec.js';
+import { GITHUB_TAG_PREFIX, encodeArgs, getContractArtifact } from '@aztec/cli/utils';
+import { getInitializer } from '@aztec/stdlib/abi';
+import { PublicKeys } from '@aztec/stdlib/keys';
+import { printGasEstimates } from '../utils/options/fees.js';
+export async function deploy(client, wallet, artifactPath, json, publicKeys, rawArgs, salt, initializer, skipPublicDeployment, skipClassRegistration, skipInitialization, universalDeploy, wait, feeOpts, debugLogger, log, logJson) {
+    salt ??= Fr.random();
+    const contractArtifact = await getContractArtifact(artifactPath, log);
+    const constructorArtifact = getInitializer(contractArtifact, initializer);
+    const nodeInfo = await client.getNodeInfo();
+    const expectedAztecNrVersion = `${GITHUB_TAG_PREFIX}-v${nodeInfo.nodeVersion}`;
+    if (contractArtifact.aztecNrVersion && contractArtifact.aztecNrVersion !== expectedAztecNrVersion) {
+        log(`\nWarning: Contract was compiled with a different version of Aztec.nr: ${contractArtifact.aztecNrVersion}. Consider updating Aztec.nr to ${expectedAztecNrVersion}\n`);
+    }
+    const deployer = new ContractDeployer(contractArtifact, wallet, publicKeys ?? PublicKeys.default(), initializer);
+    let args = [];
+    if (rawArgs.length > 0) {
+        if (!constructorArtifact) {
+            throw new Error(`Cannot process constructor arguments as no constructor was found`);
+        }
+        debugLogger.debug(`Input arguments: ${rawArgs.map((x)=>`"${x}"`).join(', ')}`);
+        args = encodeArgs(rawArgs, constructorArtifact.parameters);
+        debugLogger.debug(`Encoded arguments: ${args.join(', ')}`);
+    }
+    const deploy = deployer.deploy(...args);
+    const deployOpts = {
+        ...await feeOpts.toSendOpts(wallet),
+        contractAddressSalt: salt,
+        universalDeploy,
+        skipClassRegistration,
+        skipInitialization,
+        skipPublicDeployment
+    };
+    if (feeOpts.estimateOnly) {
+        const gas = await deploy.estimateGas(deployOpts);
+        printGasEstimates(feeOpts, gas, log);
+        return;
+    }
+    const tx = deploy.send(deployOpts);
+    const txHash = await tx.getTxHash();
+    debugLogger.debug(`Deploy tx sent with hash ${txHash}`);
+    if (wait) {
+        const deployed = await tx.wait();
+        const { address, partialAddress, instance } = deployed.contract;
+        if (json) {
+            logJson({
+                address: address.toString(),
+                partialAddress: (await partialAddress).toString(),
+                initializationHash: instance.initializationHash.toString(),
+                salt: salt.toString(),
+                transactionFee: deployed.transactionFee?.toString()
+            });
+        } else {
+            log(`Contract deployed at ${address.toString()}`);
+            log(`Contract partial address ${(await partialAddress).toString()}`);
+            log(`Contract init hash ${instance.initializationHash.toString()}`);
+            log(`Deployment tx hash: ${txHash.toString()}`);
+            log(`Deployment salt: ${salt.toString()}`);
+            log(`Deployment fee: ${deployed.transactionFee}`);
+        }
+    } else {
+        const { address, partialAddress } = deploy;
+        const instance = await deploy.getInstance();
+        if (json) {
+            logJson({
+                address: address?.toString() ?? 'N/A',
+                partialAddress: (await partialAddress)?.toString() ?? 'N/A',
+                txHash: txHash.toString(),
+                initializationHash: instance.initializationHash.toString(),
+                salt: salt.toString(),
+                deployer: instance.deployer.toString()
+            });
+        } else {
+            log(`Contract deployed at ${address?.toString()}`);
+            log(`Contract partial address ${(await partialAddress)?.toString()}`);
+            log(`Contract init hash ${instance.initializationHash.toString()}`);
+            log(`Deployment tx hash: ${txHash.toString()}`);
+            log(`Deployment salt: ${salt.toString()}`);
+            log(`Deployer: ${instance.deployer.toString()}`);
+        }
+    }
+    return deploy.address;
+}

package/dest/cmds/deploy_account.d.ts

@@ -0,0 +1,9 @@
+import type { AccountManager } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { type IFeeOpts } from '../utils/options/fees.js';
+export declare function deployAccount(account: AccountManager, wait: boolean, feeOpts: IFeeOpts, json: boolean, debugLogger: Logger, log: LogFn): Promise<{
+    address: import("@aztec/aztec.js").AztecAddress;
+    secretKey: import("@aztec/aztec.js").Fr;
+    salt: import("@aztec/aztec.js").Fr;
+}>;
+//# sourceMappingURL=deploy_account.d.ts.map

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

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

package/dest/cmds/deploy_account.js

@@ -0,0 +1,80 @@
+import { prettyPrintJSON } from '@aztec/cli/cli-utils';
+import { printGasEstimates } from '../utils/options/fees.js';
+export async function deployAccount(account, wait, feeOpts, json, debugLogger, log) {
+    const out = {};
+    const { address, partialAddress, publicKeys } = await account.getCompleteAddress();
+    const { initializationHash, deployer, salt } = account.getInstance();
+    const wallet = await account.getWallet();
+    const secretKey = wallet.getSecretKey();
+    if (json) {
+        out.address = address;
+        out.partialAddress = partialAddress;
+        out.salt = salt;
+        out.initHash = initializationHash;
+        out.deployer = deployer;
+    } else {
+        log(`\nNew account:\n`);
+        log(`Address:         ${address.toString()}`);
+        log(`Public key:      ${publicKeys.toString()}`);
+        if (secretKey) {
+            log(`Secret key:     ${secretKey.toString()}`);
+        }
+        log(`Partial address: ${partialAddress.toString()}`);
+        log(`Salt:            ${salt.toString()}`);
+        log(`Init hash:       ${initializationHash.toString()}`);
+        log(`Deployer:        ${deployer.toString()}`);
+    }
+    let tx;
+    let txReceipt;
+    const deployOpts = {
+        ...await feeOpts.toDeployAccountOpts(wallet),
+        skipInitialization: false
+    };
+    if (feeOpts.estimateOnly) {
+        const gas = await (await account.getDeployMethod(deployOpts.deployWallet)).estimateGas(deployOpts);
+        if (json) {
+            out.fee = {
+                gasLimits: {
+                    da: gas.gasLimits.daGas,
+                    l2: gas.gasLimits.l2Gas
+                },
+                teardownGasLimits: {
+                    da: gas.teardownGasLimits.daGas,
+                    l2: gas.teardownGasLimits
+                }
+            };
+        } else {
+            printGasEstimates(feeOpts, gas, log);
+        }
+    } else {
+        tx = account.deploy(deployOpts);
+        const txHash = await tx.getTxHash();
+        debugLogger.debug(`Account contract tx sent with hash ${txHash}`);
+        out.txHash = txHash;
+        if (wait) {
+            if (!json) {
+                log(`\nWaiting for account contract deployment...`);
+            }
+            txReceipt = await tx.wait();
+            out.txReceipt = {
+                status: txReceipt.status,
+                transactionFee: txReceipt.transactionFee
+            };
+        }
+    }
+    if (json) {
+        log(prettyPrintJSON(out));
+    } else {
+        if (tx) {
+            log(`Deploy tx hash:  ${await tx.getTxHash()}`);
+        }
+        if (txReceipt) {
+            log(`Deploy tx fee:   ${txReceipt.transactionFee}`);
+        }
+    }
+    return {
+        address,
+        secretKey,
+        salt
+    };
+}

package/dest/cmds/import_test_accounts.d.ts

@@ -0,0 +1,5 @@
+import { type PXE } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+import type { WalletDB } from '../storage/wallet_db.js';
+export declare function importTestAccounts(client: PXE, db: WalletDB, json: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=import_test_accounts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"import_test_accounts.d.ts","sourceRoot":"","sources":["../../src/cmds/import_test_accounts.ts"],"names":[],"mappings":"AAEA,OAAO,EAAM,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,iBAsC5F"}