@aztec/cli-wallet 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/README.md

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

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 { AztecLmdbStore } from '@aztec/kv-store/lmdb';
+import { Argument, Command, Option } from 'commander';
+import { mkdirSync, readFileSync } from 'fs';
+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 = '~/.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((alias)=>{
+        if (alias?.includes(':')) {
+            const value = db.retrieveAlias(alias);
+            log(value);
+        } else {
+            const aliases = 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 bbBinaryPath = prover === 'native' ? resolve(dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/cpp/build/bin/bb') : undefined;
+            const bbWorkingDirectory = dataDir + '/bb';
+            const proverEnabled = prover !== 'none';
+            mkdirSync(bbWorkingDirectory, {
+                recursive: true
+            });
+            await pxeWrapper.init(nodeUrl, join(dataDir, 'pxe'), {
+                ...proverEnabled && {
+                    proverEnabled,
+                    bbBinaryPath,
+                    bbWorkingDirectory
+                }
+            });
+        }
+        db.init(AztecLmdbStore.open(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.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/add_note.js

@@ -0,0 +1,14 @@
+import { ExtendedNote, Note } from '@aztec/circuit-types';
+import { getContractArtifact, parseFields } from '@aztec/cli/utils';
+export async function addNote(wallet, address, contractAddress, noteName, storageFieldName, artifactPath, txHash, noteBody, log) {
+    const fields = parseFields(noteBody);
+    const note = new Note(fields);
+    const contractArtifact = await getContractArtifact(artifactPath, log);
+    const contractNote = contractArtifact.notes[noteName];
+    const storageField = contractArtifact.storageLayout[storageFieldName];
+    if (!contractNote) {
+        throw new Error(`Note ${noteName} not found in contract ${contractArtifact.name}`);
+    }
+    const extendedNote = new ExtendedNote(note, address, contractAddress, storageField.slot, contractNote.id, txHash);
+    await wallet.addNote(extendedNote);
+}

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.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, l1RpcUrl, chainId, privateKey, mnemonic, mint, json, wait, interval = 60_000, log, debugLogger) {
+    // Prepare L1 client
+    const chain = createEthereumChain(l1RpcUrl, chainId);
+    const { publicClient, walletClient } = createL1Clients(chain.rpcUrl, 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.js

@@ -0,0 +1,38 @@
+import { SentTx, TxStatus } from '@aztec/aztec.js';
+import { GasFees, GasSettings } from '@aztec/circuits.js';
+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.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.js

@@ -0,0 +1,98 @@
+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:      0x${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 sendOpts = {
+            ...await feeOpts.toSendOpts(wallet),
+            skipClassRegistration: !publicDeploy,
+            skipPublicDeployment: !publicDeploy,
+            skipInitialization: skipInitialization
+        };
+        if (feeOpts.estimateOnly) {
+            const gas = await (await account.getDeployMethod()).estimateGas({
+                ...sendOpts
+            });
+            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({
+                ...sendOpts
+            });
+            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.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.js

@@ -0,0 +1,83 @@
+import { ContractDeployer, Fr } from '@aztec/aztec.js';
+import { PublicKeys } from '@aztec/circuits.js';
+import { GITHUB_TAG_PREFIX, encodeArgs, getContractArtifact } from '@aztec/cli/utils';
+import { getInitializer } from '@aztec/foundation/abi';
+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: partialAddress.toString(),
+                initializationHash: instance.initializationHash.toString(),
+                salt: salt.toString(),
+                transactionFee: deployed.transactionFee?.toString()
+            });
+        } else {
+            log(`Contract deployed at ${address.toString()}`);
+            log(`Contract partial address ${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: 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 ${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.js

@@ -0,0 +1,84 @@
+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:      0x${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 sendOpts = {
+        ...await feeOpts.toSendOpts(wallet),
+        skipInitialization: false
+    };
+    if (feeOpts.estimateOnly) {
+        const gas = await (await account.getDeployMethod()).estimateGas({
+            ...sendOpts
+        });
+        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({
+            ...sendOpts
+        });
+        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
+    };
+}