@aztec-labs/cli-wallet 6.0.0-nightly.20260829

package/src/cmds/authorize_action.ts

@@ -0,0 +1,47 @@
+import type { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import { SetPublicAuthwitContractInteraction } from '@aztec-labs/aztec.js/authorization';
+import { Contract } from '@aztec-labs/aztec.js/contracts';
+import type { Wallet } from '@aztec-labs/aztec.js/wallet';
+import { prepTx } from '@aztec-labs/cli/utils';
+import type { LogFn } from '@aztec-labs/foundation/log';
+
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+
+export async function authorizeAction(
+  wallet: Wallet,
+  from: AztecAddress,
+  functionName: string,
+  caller: AztecAddress,
+  functionArgsIn: any[],
+  contractArtifactPath: string,
+  contractAddress: AztecAddress,
+  log: LogFn,
+) {
+  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 = Contract.at(contractAddress, contractArtifact, wallet);
+  const action = contract.methods[functionName](...functionArgs);
+
+  const setAuthwitnessInteraction = await SetPublicAuthwitContractInteraction.create(
+    wallet,
+    from,
+    { caller, action },
+    true,
+  );
+  const witness = await setAuthwitnessInteraction.send({ wait: { timeout: DEFAULT_TX_TIMEOUT_S } });
+
+  log(`Authorized action ${functionName} on contract ${contractAddress} for caller ${caller}`);
+
+  return witness;
+}

package/src/cmds/bridge_fee_juice.ts

@@ -0,0 +1,92 @@
+import { L1FeeJuicePortalManager } from '@aztec-labs/aztec.js/ethereum';
+import type { AztecNode } from '@aztec-labs/aztec.js/node';
+import { ProtocolContractAddress } from '@aztec-labs/aztec.js/protocol';
+import { prettyPrintJSON } from '@aztec-labs/cli/utils';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { createExtendedL1Client } from '@aztec-labs/ethereum/client';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { getNonNullifiedL1ToL2MessageWitness } from '@aztec-labs/stdlib/messaging';
+
+export async function bridgeL1FeeJuice(
+  amount: bigint,
+  recipient: AztecAddress,
+  node: AztecNode,
+  l1RpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mint: boolean,
+  json: boolean,
+  wait: boolean,
+  interval = 60_000,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  // Prepare L1 client
+  const chain = createEthereumChain(l1RpcUrls, chainId);
+  const client = createExtendedL1Client(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+
+  // Setup portal manager
+  const portal = await L1FeeJuicePortalManager.new(node, client, 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: number) => {
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          void getNonNullifiedL1ToL2MessageWitness(
+            node,
+            ProtocolContractAddress.FeeJuice,
+            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] as const;
+}

package/src/cmds/check_tx.ts

@@ -0,0 +1,220 @@
+import type { ContractArtifact } from '@aztec-labs/aztec.js/abi';
+import { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import type { AztecNode } from '@aztec-labs/aztec.js/node';
+import { ProtocolContractAddress } from '@aztec-labs/aztec.js/protocol';
+import type { TxHash } from '@aztec-labs/aztec.js/tx';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import {
+  computeSiloedPrivateInitializationNullifier,
+  computeSiloedPublicInitializationNullifier,
+  siloNullifier,
+} from '@aztec-labs/stdlib/hash';
+import { NoteDao } from '@aztec-labs/stdlib/note';
+
+import type { CLIWallet } from '../utils/wallet.js';
+
+export async function checkTx(
+  wallet: CLIWallet,
+  aztecNode: AztecNode,
+  txHash: TxHash,
+  statusOnly: boolean,
+  log: LogFn,
+) {
+  if (statusOnly) {
+    const receipt = await aztecNode.getTxReceipt(txHash);
+    return receipt.status;
+  } else {
+    await inspectTx(wallet, aztecNode, txHash, log);
+  }
+}
+
+// The rest of the code here was copied over here from CLI because in CLI I needed to prune the inspect function of the PXE
+// dependency when dropping PXE JSON RPC Server.
+
+async function inspectTx(wallet: CLIWallet, aztecNode: AztecNode, txHash: TxHash, log: LogFn) {
+  const receipt = await aztecNode.getTxReceipt(txHash, { includeTxEffect: true });
+  // Base tx data
+  log(`Tx ${txHash.toString()}`);
+  log(` Status: ${receipt.status}`);
+  if (receipt.executionResult) {
+    log(` Execution result: ${receipt.executionResult}`);
+  }
+  if (receipt.error) {
+    log(` Error: ${receipt.error}`);
+  }
+
+  if (!receipt.isMined() || !receipt.txEffect) {
+    return;
+  }
+
+  const effects = receipt.txEffect;
+  const artifactMap = await getKnownArtifacts(wallet);
+
+  log(` Block: ${receipt.blockNumber} (${receipt.blockHash?.toString()})`);
+  if (receipt.transactionFee) {
+    log(` Fee: ${receipt.transactionFee.toString()}`);
+  }
+
+  // Public logs
+  const publicLogs = effects.publicLogs;
+  if (publicLogs.length > 0) {
+    log(' Logs:');
+    for (const publicLog of publicLogs) {
+      log(`  ${publicLog.toHumanReadable()}`);
+    }
+  }
+
+  // Public data writes
+  const writes = effects.publicDataWrites;
+  if (writes.length > 0) {
+    log(' Public data writes:');
+    for (const write of writes) {
+      log(`  Leaf ${write.leafSlot.toString()} = ${write.value.toString()}`);
+    }
+  }
+
+  // Created notes
+  const notes = effects.noteHashes;
+  if (notes.length > 0) {
+    log(' Created notes:');
+    log(`  Total: ${notes.length}`);
+    for (const note of notes) {
+      log(`  Note hash: ${note.toShortString()}`);
+    }
+  }
+
+  // Nullifiers
+  const nullifierCount = effects.nullifiers.length;
+  const { deployNullifiers, initNullifiers, classNullifiers } = await getKnownNullifiers(wallet, artifactMap);
+  const accounts = (await wallet.getAccounts()).map(a => a.item);
+  if (nullifierCount > 0) {
+    log(' Nullifiers:');
+    for (const nullifier of effects.nullifiers) {
+      const deployed = deployNullifiers[nullifier.toString()];
+      const note = deployed
+        ? (await wallet.getNotes({ siloedNullifier: nullifier, contractAddress: deployed, scopes: accounts }))[0]
+        : undefined;
+      const initialized = initNullifiers[nullifier.toString()];
+      const registered = classNullifiers[nullifier.toString()];
+      if (nullifier.toBuffer().equals(txHash.toBuffer())) {
+        log(`  Transaction hash nullifier ${nullifier.toShortString()}`);
+      } else if (note) {
+        inspectNote(note, artifactMap, log, `Nullifier ${nullifier.toShortString()} for note`);
+      } else if (deployed) {
+        log(
+          `  Contract ${toFriendlyAddress(deployed, artifactMap)} deployed via nullifier ${nullifier.toShortString()}`,
+        );
+      } else if (initialized) {
+        log(
+          `  Contract ${toFriendlyAddress(
+            initialized,
+            artifactMap,
+          )} initialized via nullifier ${nullifier.toShortString()}`,
+        );
+      } else if (registered) {
+        log(`  Class ${registered} registered via nullifier ${nullifier.toShortString()}`);
+      } else {
+        log(`  Unknown nullifier ${nullifier.toString()}`);
+      }
+    }
+  }
+
+  // L2 to L1 messages
+  if (effects.l2ToL1Msgs.length > 0) {
+    log(` L2 to L1 messages:`);
+    for (const msg of effects.l2ToL1Msgs) {
+      log(`  ${msg.toString()}`);
+    }
+  }
+}
+
+function inspectNote(note: NoteDao, artifactMap: ArtifactMap, log: LogFn, text = 'Note') {
+  const artifact = artifactMap[note.contractAddress.toString()];
+  const contract = artifact?.name ?? note.contractAddress.toString();
+  log(`  ${text} at ${contract}`);
+  for (const field of note.note.items) {
+    log(`    ${field.toString()}`);
+  }
+}
+
+function toFriendlyAddress(address: AztecAddress, artifactMap: ArtifactMap) {
+  const artifact = artifactMap[address.toString()];
+  if (!artifact) {
+    return address.toString();
+  }
+
+  return `${artifact.name}<${address.toString()}>`;
+}
+
+async function getKnownNullifiers(wallet: CLIWallet, artifactMap: ArtifactMap) {
+  const knownContracts = await wallet.getContracts();
+
+  const [contractResults, classResults] = await Promise.all([
+    Promise.all(knownContracts.map(contract => getContractNullifiers(wallet, contract))),
+    Promise.all(Object.values(artifactMap).map(artifact => getClassNullifier(artifact))),
+  ]);
+
+  const initNullifiers: Record<string, AztecAddress> = {};
+  const deployNullifiers: Record<string, AztecAddress> = {};
+  const classNullifiers: Record<string, string> = {};
+
+  for (const { contract, deployNullifier, privateInitNullifier, publicInitNullifier } of contractResults) {
+    deployNullifiers[deployNullifier.toString()] = contract;
+    if (privateInitNullifier) {
+      initNullifiers[privateInitNullifier.toString()] = contract;
+    }
+    initNullifiers[publicInitNullifier.toString()] = contract;
+  }
+  for (const { nullifier, label } of classResults) {
+    classNullifiers[nullifier.toString()] = label;
+  }
+
+  return { initNullifiers, deployNullifiers, classNullifiers };
+}
+
+async function getContractNullifiers(wallet: CLIWallet, contract: AztecAddress) {
+  const deployerAddress = ProtocolContractAddress.ContractInstanceRegistry;
+  const deployNullifier = await siloNullifier(deployerAddress, contract.toField());
+
+  const metadata = await wallet.getContractMetadata(contract);
+  const privateInitNullifier = metadata.instance
+    ? await computeSiloedPrivateInitializationNullifier(contract, metadata.instance.initializationHash)
+    : undefined;
+  const publicInitNullifier = await computeSiloedPublicInitializationNullifier(contract);
+
+  return { contract, deployNullifier, privateInitNullifier, publicInitNullifier };
+}
+
+async function getClassNullifier(artifact: ContractArtifactWithClassId) {
+  const classRegistryAddress = ProtocolContractAddress.ContractClassRegistry;
+  const nullifier = await siloNullifier(classRegistryAddress, artifact.classId);
+  return { nullifier, label: `${artifact.name}Class<${artifact.classId}>` };
+}
+
+type ArtifactMap = Record<string, ContractArtifactWithClassId>;
+type ContractArtifactWithClassId = ContractArtifact & { classId: Fr };
+
+async function getKnownArtifacts(wallet: CLIWallet): Promise<ArtifactMap> {
+  const knownContractAddresses = await wallet.getContracts();
+  const knownContracts = await Promise.all(
+    knownContractAddresses.map(contractAddress => wallet.getContractMetadata(contractAddress)),
+  );
+  const classIdFor = (metadata: (typeof knownContracts)[number]): Fr | undefined =>
+    metadata.updatedContractClassId ?? metadata.instance?.originalContractClassId;
+  const classIds = [...new Set(knownContracts.map(classIdFor))];
+  const knownArtifacts = (
+    await Promise.all(classIds.map(classId => (classId ? wallet.getContractArtifact(classId) : undefined)))
+  ).map((artifact, index) => (artifact ? { ...artifact, classId: classIds[index] } : undefined));
+  const map: Record<string, ContractArtifactWithClassId> = {};
+  for (const metadata of knownContracts) {
+    const classId = classIdFor(metadata);
+    if (metadata.instance && classId) {
+      const artifact = knownArtifacts.find(a => a?.classId?.equals(classId)) as ContractArtifactWithClassId;
+      if (artifact) {
+        map[metadata.instance.address.toString()] = artifact;
+      }
+    }
+  }
+  return map;
+}

package/src/cmds/create_account.ts

@@ -0,0 +1,176 @@
+import { deriveSecretKeyFromSigningKey } from '@aztec-labs/accounts/utils';
+import { NO_FROM } from '@aztec-labs/aztec.js/account';
+import { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import { NO_WAIT } from '@aztec-labs/aztec.js/contracts';
+import { type AztecNode, waitForTx } from '@aztec-labs/aztec.js/node';
+import type { DeployAccountOptions } from '@aztec-labs/aztec.js/wallet';
+import { prettyPrintJSON } from '@aztec-labs/cli/cli-utils';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec-labs/foundation/curves/grumpkin';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+import { type TxHash, type TxReceipt, TxStatus } from '@aztec-labs/stdlib/tx';
+
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+import type { AccountType } from '../utils/constants.js';
+import { CLIFeeArgs } from '../utils/options/fees.js';
+import { printProfileResult } from '../utils/profiling.js';
+import { CLIWallet } from '../utils/wallet.js';
+
+export async function createAccount(
+  wallet: CLIWallet,
+  aztecNode: AztecNode,
+  accountType: AccountType,
+  signingKey: GrumpkinScalar | undefined,
+  salt: Fr | undefined,
+  publicKey: string | undefined,
+  alias: string | undefined,
+  deployer: AztecAddress | undefined,
+  registerOnly: boolean,
+  skipInitialization: boolean,
+  publicDeploy: boolean,
+  registerClass: boolean,
+  wait: boolean,
+  feeOpts: CLIFeeArgs,
+  waitForStatus: TxStatus,
+  json: boolean,
+  verbose: boolean,
+  debugLogger: Logger,
+  log: LogFn,
+) {
+  let secretKey: Fr;
+  if (accountType === 'ecdsasecp256r1ssh') {
+    // SSH accounts sign with a key held in the agent, and so we cannot derive their privacy secret key from it. Instead
+    // we pick a random value.
+    secretKey = Fr.random();
+  } else {
+    signingKey ??= GrumpkinScalar.random();
+    secretKey = await deriveSecretKeyFromSigningKey(signingKey);
+  }
+
+  const account = await wallet.createAccount(accountType, signingKey, secretKey, salt, publicKey);
+  const instanceSalt = account.getInstance().salt;
+  const { address, publicKeys, partialAddress } = await account.getCompleteAddress();
+
+  const out: Record<string, any> = {};
+  if (json) {
+    out.address = address;
+    out.publicKey = publicKeys;
+    if (signingKey) {
+      out.signingKey = signingKey;
+    }
+    if (secretKey) {
+      out.secretKey = secretKey;
+    }
+    out.partialAddress = partialAddress;
+    out.salt = instanceSalt;
+    out.initHash = account.getInstance().initializationHash;
+  } else {
+    log(`\nNew account:\n`);
+    log(`Address:         ${address.toString()}`);
+    log(`Public key:      ${publicKeys.toString()}`);
+    if (signingKey) {
+      log(`Signing key:     ${signingKey.toString()}`);
+    }
+    if (secretKey) {
+      log(`Secret key:     ${secretKey.toString()}`);
+    }
+    log(`Partial address: ${partialAddress.toString()}`);
+    log(`Salt:            ${instanceSalt.toString()}`);
+    log(`Init hash:       ${account.getInstance().initializationHash.toString()}`);
+  }
+
+  let txHash: TxHash | undefined;
+  let txReceipt: TxReceipt | undefined;
+  // Initializerless accounts have no deployment tx — creating one only registers it locally — so there is
+  // nothing to deploy on-chain.
+  if (!registerOnly && accountType !== 'schnorr_initializerless') {
+    const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(aztecNode, wallet, address);
+
+    const delegatedDeployment = deployer && !account.address.equals(deployer);
+    const from = delegatedDeployment ? deployer : NO_FROM;
+
+    const deployAccountOpts: DeployAccountOptions = {
+      skipClassPublication: !registerClass,
+      skipInstancePublication: !publicDeploy,
+      skipInitialization,
+      from,
+      fee: { paymentMethod, gasSettings },
+    };
+
+    const localStart = performance.now();
+    const deployMethod = await account.getDeployMethod();
+    const sim = await deployMethod.simulate({
+      ...deployAccountOpts,
+      includeMetadata: true,
+    });
+    // includeMetadata: true guarantees these fields are present
+    const estimatedGas = await wallet.estimateGasLimits(sim.gasUsed!);
+    const stats = sim.stats!;
+
+    if (feeOpts.estimateOnly) {
+      if (json) {
+        out.fee = {
+          gasLimits: {
+            da: estimatedGas.gasLimits.daGas,
+            l2: estimatedGas.gasLimits.l2Gas,
+          },
+          teardownGasLimits: {
+            da: estimatedGas.teardownGasLimits.daGas,
+            l2: estimatedGas.teardownGasLimits,
+          },
+        };
+      }
+    } else {
+      if (verbose) {
+        printProfileResult(stats, log);
+      }
+
+      if (!json) {
+        log(`\nWaiting for account contract deployment...`);
+      }
+      const sendOpts = {
+        ...deployAccountOpts,
+        fee: deployAccountOpts.fee
+          ? {
+              ...deployAccountOpts.fee,
+              gasSettings: estimatedGas,
+            }
+          : undefined,
+      };
+
+      ({ txHash } = await deployMethod.send({ ...sendOpts, wait: NO_WAIT }));
+      const localTimeMs = performance.now() - localStart;
+
+      if (wait) {
+        const nodeStart = performance.now();
+        txReceipt = await waitForTx(aztecNode, txHash, { timeout: DEFAULT_TX_TIMEOUT_S, waitForStatus });
+        const nodeTimeMs = performance.now() - nodeStart;
+
+        out.txReceipt = {
+          status: txReceipt.status,
+          transactionFee: txReceipt.transactionFee,
+        };
+
+        if (!json) {
+          log(` Local processing time: ${(localTimeMs / 1000).toFixed(1)}s`);
+          log(` Node inclusion time: ${(nodeTimeMs / 1000).toFixed(1)}s`);
+        }
+      }
+      debugLogger.debug(`Account contract tx sent with hash ${txHash.toString()}`);
+      out.txHash = txHash;
+    }
+  }
+
+  if (json) {
+    log(prettyPrintJSON(out));
+  } else {
+    if (txHash) {
+      log(`Deploy tx hash:  ${txHash.toString()}`);
+    }
+    if (txReceipt) {
+      log(`Deploy tx fee:   ${txReceipt.transactionFee}`);
+    }
+  }
+
+  return { alias, address, signingKey, secretKey, salt: instanceSalt };
+}

package/src/cmds/create_authwit.ts

@@ -0,0 +1,39 @@
+import type { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import { Contract } from '@aztec-labs/aztec.js/contracts';
+import { prepTx } from '@aztec-labs/cli/utils';
+import type { LogFn } from '@aztec-labs/foundation/log';
+
+import type { CLIWallet } from '../utils/wallet.js';
+
+export async function createAuthwit(
+  wallet: CLIWallet,
+  from: AztecAddress,
+  functionName: string,
+  caller: AztecAddress,
+  functionArgsIn: any[],
+  contractArtifactPath: string,
+  contractAddress: AztecAddress,
+  log: LogFn,
+) {
+  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 = Contract.at(contractAddress, contractArtifact, wallet);
+  const call = await contract.methods[functionName](...functionArgs).getFunctionCall();
+
+  const witness = await wallet.createAuthWit(from, { caller, call });
+
+  log(`Created authorization witness for action ${functionName} on contract ${contractAddress} for caller ${caller}`);
+
+  return witness;
+}