@aztec/cli-wallet 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/utils/profiling.ts

@@ -0,0 +1,158 @@
+import type { LogFn } from '@aztec/foundation/log';
+import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
+import type { ProvingStats, ProvingTimings, SimulationStats, SimulationTimings } from '@aztec/stdlib/tx';
+
+import { format } from 'util';
+
+const FN_NAME_PADDING = 60;
+const COLUMN_MIN_WIDTH = 13;
+const COLUMN_MAX_WIDTH = 15;
+
+const ORACLE_NAME_PADDING = 50;
+
+export function printProfileResult(
+  stats: ProvingStats | SimulationStats,
+  log: LogFn,
+  printOracles: boolean = false,
+  executionSteps?: PrivateExecutionStep[],
+) {
+  log(format('\nPer circuit breakdown:\n'));
+  log(
+    format(
+      '  ',
+      'Function name'.padEnd(FN_NAME_PADDING),
+      'Time'.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+      executionSteps ? 'Gates'.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH) : '',
+      executionSteps ? 'Subtotal'.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH) : '',
+    ),
+  );
+  log(
+    format(
+      ''.padEnd(
+        FN_NAME_PADDING +
+          COLUMN_MAX_WIDTH +
+          COLUMN_MAX_WIDTH +
+          (executionSteps ? COLUMN_MAX_WIDTH + COLUMN_MAX_WIDTH : 0),
+        '-',
+      ),
+    ),
+  );
+  let acc = 0;
+  let biggest: PrivateExecutionStep | undefined = executionSteps?.[0];
+
+  const timings = stats.timings;
+  timings.perFunction.forEach((fn, i) => {
+    const currentExecutionStep = executionSteps?.[i];
+    if (currentExecutionStep && biggest && currentExecutionStep.gateCount! > biggest.gateCount!) {
+      biggest = currentExecutionStep;
+    }
+    acc += currentExecutionStep ? currentExecutionStep.gateCount! : 0;
+
+    log(
+      format(
+        ' - ',
+        fn.functionName.padEnd(FN_NAME_PADDING),
+        `${fn.time.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+        currentExecutionStep
+          ? currentExecutionStep.gateCount!.toLocaleString().padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH)
+          : '',
+        currentExecutionStep ? acc.toLocaleString().padStart(COLUMN_MAX_WIDTH) : '',
+      ),
+    );
+    if (printOracles && fn.oracles) {
+      log('');
+      for (const [oracleName, { times }] of Object.entries(fn.oracles)) {
+        const calls = times.length;
+        const min = Math.min(...times);
+        const max = Math.max(...times);
+        const total = times.reduce((acc, time) => acc + time, 0);
+        const avg = total / calls;
+        log(
+          format(
+            '    ',
+            oracleName.padEnd(ORACLE_NAME_PADDING),
+            `${calls} calls`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+            `${total.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+            `min: ${min.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+            `avg: ${avg.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+            `max: ${max.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+          ),
+        );
+      }
+    }
+    log('');
+  });
+
+  if (biggest) {
+    log(
+      format(
+        '\nTotal gates:',
+        acc.toLocaleString(),
+        `(Biggest circuit: ${biggest.functionName} -> ${biggest.gateCount!.toLocaleString()})`,
+      ),
+    );
+  }
+
+  if (stats.nodeRPCCalls) {
+    log(format('\nRPC calls:\n'));
+    for (const [method, { times }] of Object.entries(stats.nodeRPCCalls)) {
+      const calls = times.length;
+      const total = times.reduce((acc, time) => acc + time, 0);
+      const avg = total / calls;
+      const min = Math.min(...times);
+      const max = Math.max(...times);
+      log(
+        format(
+          method.padEnd(ORACLE_NAME_PADDING),
+          `${calls} calls`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+          `${total.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+          `min: ${min.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+          `avg: ${avg.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+          `max: ${max.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH),
+        ),
+      );
+    }
+  }
+
+  log(format('\nSync time:'.padEnd(25), `${timings.sync?.toFixed(2)}ms`.padStart(16)));
+  log(
+    format(
+      'Private simulation time:'.padEnd(25),
+      `${timings.perFunction.reduce((acc, { time }) => acc + time, 0).toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH),
+    ),
+  );
+  if ((timings as ProvingTimings).proving) {
+    log(
+      format(
+        'Proving time:'.padEnd(25),
+        `${(timings as ProvingTimings).proving?.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH),
+      ),
+    );
+  }
+  if ((timings as SimulationTimings).publicSimulation) {
+    log(
+      format(
+        'Public simulation time:'.padEnd(25),
+        `${(timings as SimulationTimings).publicSimulation?.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH),
+      ),
+    );
+  }
+
+  if ((timings as SimulationTimings).validation) {
+    log(
+      format(
+        'Validation time:'.padEnd(25),
+        `${(timings as SimulationTimings).validation?.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH),
+      ),
+    );
+  }
+
+  log(
+    format(
+      'Total time:'.padEnd(25),
+      `${timings.total.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH),
+      `(${timings.unaccounted.toFixed(2)}ms unaccounted)`,
+    ),
+  );
+  log('\n');
+}

package/src/utils/wallet.ts

@@ -0,0 +1,264 @@
+import { EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import { getIdentities } from '@aztec/accounts/utils';
+import { type Account, type AccountContract, SignerlessAccount } from '@aztec/aztec.js/account';
+import {
+  type InteractionFeeOptions,
+  getContractInstanceFromInstantiationParams,
+  getGasLimits,
+} from '@aztec/aztec.js/contracts';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { UniqueNote } from '@aztec/aztec.js/note';
+import { AccountManager, type Aliased, BaseWallet, type SimulateOptions } from '@aztec/aztec.js/wallet';
+import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn } from '@aztec/foundation/log';
+import type { PXEConfig } from '@aztec/pxe/config';
+import type { PXE } from '@aztec/pxe/server';
+import { createPXE, getPXEConfig } from '@aztec/pxe/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import type { NotesFilter } from '@aztec/stdlib/note';
+import type { TxProvingResult, TxSimulationResult } from '@aztec/stdlib/tx';
+
+import type { WalletDB } from '../storage/wallet_db.js';
+import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
+import { printGasEstimates } from './options/fees.js';
+
+export const AccountTypes = ['schnorr', 'ecdsasecp256r1', 'ecdsasecp256r1ssh', 'ecdsasecp256k1'] as const;
+export type AccountType = (typeof AccountTypes)[number];
+
+export const BASE_FEE_PADDING = 0.5;
+
+export class CLIWallet extends BaseWallet {
+  private accountCache = new Map<string, Account>();
+
+  constructor(
+    pxe: PXE,
+    node: AztecNode,
+    private userLog: LogFn,
+    private db?: WalletDB,
+  ) {
+    super(pxe, node);
+    this.cancellableTransactions = true;
+  }
+
+  static async create(
+    node: AztecNode,
+    log: LogFn,
+    db?: WalletDB,
+    overridePXEConfig?: Partial<PXEConfig>,
+  ): Promise<CLIWallet> {
+    const pxeConfig = Object.assign(getPXEConfig(), overridePXEConfig);
+    const pxe = await createPXE(node, pxeConfig);
+    return new CLIWallet(pxe, node, log, db);
+  }
+
+  override async getAccounts(): Promise<Aliased<AztecAddress>[]> {
+    const accounts = (await this.db?.listAliases('accounts')) ?? [];
+    return Promise.resolve(accounts.map(({ key, value }) => ({ alias: value, item: AztecAddress.fromString(key) })));
+  }
+
+  private async createCancellationTxExecutionRequest(
+    from: AztecAddress,
+    txNonce: Fr,
+    increasedFee: InteractionFeeOptions,
+  ) {
+    const feeOptions = await this.getDefaultFeeOptions(from, increasedFee);
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    const fromAccount = await this.getAccountFromAddress(from);
+    const executionOptions: DefaultAccountEntrypointOptions = {
+      txNonce,
+      cancellable: this.cancellableTransactions,
+      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions,
+    };
+    return await fromAccount.createTxExecutionRequest(
+      feeExecutionPayload ?? ExecutionPayload.empty(),
+      feeOptions.gasSettings,
+      executionOptions,
+    );
+  }
+
+  async proveCancellationTx(
+    from: AztecAddress,
+    txNonce: Fr,
+    increasedFee: InteractionFeeOptions,
+  ): Promise<TxProvingResult> {
+    const cancellationTxRequest = await this.createCancellationTxExecutionRequest(from, txNonce, increasedFee);
+    return await this.pxe.proveTx(cancellationTxRequest);
+  }
+
+  override async getAccountFromAddress(address: AztecAddress) {
+    let account: Account | undefined;
+    if (address.equals(AztecAddress.ZERO)) {
+      const chainInfo = await this.getChainInfo();
+      account = new SignerlessAccount(chainInfo);
+    } else if (this.accountCache.has(address.toString())) {
+      return this.accountCache.get(address.toString())!;
+    } else {
+      const accountManager = await this.createOrRetrieveAccount(address);
+      account = await accountManager.getAccount();
+    }
+
+    if (!account) {
+      throw new Error(`Account not found in wallet for address: ${address}`);
+    }
+    return account;
+  }
+
+  private async createAccount(secret: Fr, salt: Fr, contract: AccountContract): Promise<AccountManager> {
+    const accountManager = await AccountManager.create(this, secret, contract, salt);
+
+    const instance = accountManager.getInstance();
+    const artifact = await contract.getContractArtifact();
+
+    await this.registerContract(instance, artifact, secret);
+    this.accountCache.set(accountManager.address.toString(), await accountManager.getAccount());
+    return accountManager;
+  }
+
+  async createOrRetrieveAccount(
+    address?: AztecAddress,
+    secretKey?: Fr,
+    type: AccountType = 'schnorr',
+    salt?: Fr,
+    publicKey?: string,
+  ): Promise<AccountManager> {
+    let account;
+
+    salt ??= Fr.ZERO;
+
+    if (this.db && address) {
+      ({ type, secretKey, salt } = await this.db.retrieveAccount(address));
+    }
+
+    if (!secretKey) {
+      throw new Error('Cannot retrieve/create wallet without secret key');
+    }
+
+    switch (type) {
+      case 'schnorr': {
+        account = await this.createAccount(secretKey, salt, new SchnorrAccountContract(deriveSigningKey(secretKey)));
+        break;
+      }
+      case 'ecdsasecp256r1': {
+        account = await this.createAccount(
+          secretKey,
+          salt,
+          new EcdsaRAccountContract(deriveSigningKey(secretKey).toBuffer()),
+        );
+        break;
+      }
+      case 'ecdsasecp256r1ssh': {
+        let publicSigningKey;
+        if (this.db && address) {
+          publicSigningKey = await this.db.retrieveAccountMetadata(address, 'publicSigningKey');
+        } else if (publicKey) {
+          const identities = await getIdentities();
+          const foundIdentity = identities.find(
+            identity => identity.type === 'ecdsa-sha2-nistp256' && identity.publicKey === publicKey,
+          );
+          if (!foundIdentity) {
+            throw new Error(`Identity for public key ${publicKey} not found in the SSH agent`);
+          }
+          publicSigningKey = extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
+        } else {
+          throw new Error('Public key must be provided for ECDSA SSH account');
+        }
+        account = await this.createAccount(secretKey, salt, new EcdsaRSSHAccountContract(publicSigningKey));
+        break;
+      }
+      default: {
+        throw new Error(`Unsupported account type: ${type}`);
+      }
+    }
+
+    return account;
+  }
+
+  private async getFakeAccountDataFor(address: AztecAddress) {
+    const chainInfo = await this.getChainInfo();
+    const originalAccount = await this.getAccountFromAddress(address);
+    const originalAddress = originalAccount.getCompleteAddress();
+    const { contractInstance } = await this.pxe.getContractMetadata(originalAddress.address);
+    if (!contractInstance) {
+      throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+    }
+    const stubAccount = createStubAccount(originalAddress, chainInfo);
+    const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
+      salt: Fr.random(),
+    });
+    return {
+      account: stubAccount,
+      instance,
+      artifact: StubAccountContractArtifact,
+    };
+  }
+
+  override async simulateTx(executionPayload: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
+    let simulationResults;
+    const feeOptions = opts.fee?.estimateGas
+      ? await this.getFeeOptionsForGasEstimation(opts.from, opts.fee)
+      : await this.getDefaultFeeOptions(opts.from, opts.fee);
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    const executionOptions: DefaultAccountEntrypointOptions = {
+      txNonce: Fr.random(),
+      cancellable: this.cancellableTransactions,
+      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions,
+    };
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, executionPayload])
+      : executionPayload;
+
+    // Kernelless simulations using the multicall entrypoints are not currently supported,
+    // since we only override proper account contracts.
+    // TODO: allow disabling kernels even when no overrides are necessary
+    if (opts.from.equals(AztecAddress.ZERO)) {
+      const fromAccount = await this.getAccountFromAddress(opts.from);
+      const txRequest = await fromAccount.createTxExecutionRequest(
+        finalExecutionPayload,
+        feeOptions.gasSettings,
+        executionOptions,
+      );
+      simulationResults = await this.pxe.simulateTx(
+        txRequest,
+        true /* simulatePublic */,
+        opts?.skipTxValidation,
+        opts?.skipFeeEnforcement ?? true,
+      );
+    } else {
+      const { account: fromAccount, instance, artifact } = await this.getFakeAccountDataFor(opts.from);
+      const txRequest = await fromAccount.createTxExecutionRequest(
+        finalExecutionPayload,
+        feeOptions.gasSettings,
+        executionOptions,
+      );
+      const contractOverrides = {
+        [opts.from.toString()]: { instance, artifact },
+      };
+      simulationResults = await this.pxe.simulateTx(txRequest, true /* simulatePublic */, true, true, {
+        contracts: contractOverrides,
+      });
+    }
+
+    if (opts.fee?.estimateGas) {
+      const limits = getGasLimits(simulationResults, opts.fee?.estimatedGasPadding);
+      printGasEstimates(feeOptions, limits, this.userLog);
+    }
+    return simulationResults;
+  }
+
+  // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+  // this is just a CLI wallet.
+  getContracts(): Promise<AztecAddress[]> {
+    return this.pxe.getContracts();
+  }
+
+  // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+  // this is just a CLI wallet.
+  getNotes(filter: NotesFilter): Promise<UniqueNote[]> {
+    return this.pxe.getNotes(filter);
+  }
+}

package/dest/cmds/add_authwit.d.ts

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

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

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

package/dest/cmds/cancel_tx.d.ts

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

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

@@ -1,38 +0,0 @@
-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/utils/accounts.d.ts

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

package/dest/utils/accounts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/utils/accounts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD,eAAO,MAAM,YAAY,6DAA8D,CAAC;AACxF,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,GAAG,EACR,OAAO,CAAC,EAAE,YAAY,EACtB,EAAE,CAAC,EAAE,QAAQ,EACb,SAAS,CAAC,EAAE,EAAE,EACd,IAAI,GAAE,WAAuB,EAC7B,IAAI,CAAC,EAAE,EAAE,EACT,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAAC,cAAc,CAAC,CAkDzB;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,0BAA0B,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,QAAQ,iBAU5G;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,EAAE,CAAC,EAAE,QAAQ,uCAgB/E"}

package/dest/utils/accounts.js

@@ -1,87 +0,0 @@
-import { getIdentities } from '@aztec/accounts/utils';
-import { Fr } from '@aztec/foundation/fields';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { deriveSigningKey } from '@aztec/stdlib/keys';
-import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
-export const AccountTypes = [
-    'schnorr',
-    'ecdsasecp256r1ssh',
-    'ecdsasecp256k1'
-];
-export async function createOrRetrieveAccount(pxe, address, db, secretKey, type = 'schnorr', salt, publicKey) {
-    let account;
-    salt ??= Fr.ZERO;
-    if (db && address) {
-        ({ type, secretKey, salt } = await db.retrieveAccount(address));
-    }
-    if (!salt) {
-        throw new Error('Cannot retrieve/create wallet without salt');
-    }
-    if (!secretKey) {
-        throw new Error('Cannot retrieve/create wallet without secret key');
-    }
-    switch(type){
-        case 'schnorr':
-            {
-                const { getSchnorrAccount } = await import('@aztec/accounts/schnorr');
-                account = getSchnorrAccount(pxe, secretKey, deriveSigningKey(secretKey), salt);
-                break;
-            }
-        case 'ecdsasecp256r1ssh':
-            {
-                let publicSigningKey;
-                if (db && address) {
-                    publicSigningKey = await db.retrieveAccountMetadata(address, 'publicSigningKey');
-                } else if (publicKey) {
-                    const identities = await getIdentities();
-                    const foundIdentity = identities.find((identity)=>identity.type === 'ecdsa-sha2-nistp256' && identity.publicKey === publicKey);
-                    if (!foundIdentity) {
-                        throw new Error(`Identity for public key ${publicKey} not found in the SSH agent`);
-                    }
-                    publicSigningKey = extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
-                } else {
-                    throw new Error('Public key must be provided for ECDSA SSH account');
-                }
-                const { getEcdsaRSSHAccount } = await import('@aztec/accounts/ecdsa');
-                account = getEcdsaRSSHAccount(pxe, secretKey, publicSigningKey, salt);
-                break;
-            }
-        default:
-            {
-                throw new Error(`Unsupported account type: ${type}`);
-            }
-    }
-    return account;
-}
-export async function addScopeToWallet(wallet, scope, db) {
-    const address = wallet.getAddress().toString();
-    const currentScopes = wallet.getScopes() ?? [];
-    const deduplicatedScopes = Array.from(new Set([
-        address,
-        ...currentScopes,
-        scope
-    ].map((scope)=>scope.toString())).values());
-    if (db) {
-        await db.storeAccountMetadata(wallet.getAddress(), 'scopes', Buffer.from(deduplicatedScopes.join(',')));
-    }
-    wallet.setScopes(deduplicatedScopes.map((scope)=>AztecAddress.fromString(scope)));
-}
-export async function getWalletWithScopes(account, db) {
-    const wallet = await account.getWallet();
-    if (db) {
-        const address = wallet.getAddress().toString();
-        let storedScopes = [];
-        try {
-            storedScopes = (await db.retrieveAccountMetadata(wallet.getAddress(), 'scopes') ?? '').toString().split(',');
-        // eslint-disable-next-line no-empty
-        } catch  {}
-        const currentScopes = wallet.getScopes()?.map((scopes)=>scopes.toString()) ?? [];
-        const deduplicatedScopes = Array.from(new Set([
-            address,
-            ...currentScopes,
-            ...storedScopes
-        ]).values()).map((scope)=>AztecAddress.fromString(scope));
-        wallet.setScopes(deduplicatedScopes);
-    }
-    return wallet;
-}

package/dest/utils/pxe_wrapper.d.ts

@@ -1,10 +0,0 @@
-import { type PXEServiceConfig } from '@aztec/pxe/server';
-import { type AztecNode, type PXE } from '@aztec/stdlib/interfaces/client';
-export declare class PXEWrapper {
-    private static pxe;
-    private static node;
-    getPXE(): PXE | undefined;
-    getNode(): AztecNode | undefined;
-    init(nodeUrl: string, dataDir: string, overridePXEServiceConfig?: Partial<PXEServiceConfig>): Promise<void>;
-}
-//# sourceMappingURL=pxe_wrapper.d.ts.map

package/dest/utils/pxe_wrapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pxe_wrapper.d.ts","sourceRoot":"","sources":["../../src/utils/pxe_wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAyC,MAAM,mBAAmB,CAAC;AACjG,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,GAAG,EAAyB,MAAM,iCAAiC,CAAC;AAMlG,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAC,GAAG,CAAkB;IACpC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAwB;IAE3C,MAAM,IAAI,GAAG,GAAG,SAAS;IAIzB,OAAO,IAAI,SAAS,GAAG,SAAS;IAI1B,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,wBAAwB,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC;CAMlG"}

package/dest/utils/pxe_wrapper.js

@@ -1,21 +0,0 @@
-import { createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
-import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
-/*
- * Wrapper class for PXE service, avoids initialization issues due to
- * closures when providing PXE service to injected commander.js commands
- */ export class PXEWrapper {
-    static pxe;
-    static node;
-    getPXE() {
-        return PXEWrapper.pxe;
-    }
-    getNode() {
-        return PXEWrapper.node;
-    }
-    async init(nodeUrl, dataDir, overridePXEServiceConfig) {
-        PXEWrapper.node = createAztecNodeClient(nodeUrl);
-        const pxeConfig = Object.assign(getPXEServiceConfig(), overridePXEServiceConfig);
-        pxeConfig.dataDirectory = dataDir;
-        PXEWrapper.pxe = await createPXEService(PXEWrapper.node, pxeConfig);
-    }
-}

package/src/cmds/add_authwit.ts

@@ -1,13 +0,0 @@
-import type { AccountWalletWithSecretKey, AuthWitness, AztecAddress } from '@aztec/aztec.js';
-import type { LogFn } from '@aztec/foundation/log';
-
-export async function addAuthwit(
-  wallet: AccountWalletWithSecretKey,
-  authwit: AuthWitness,
-  authorizer: AztecAddress,
-  log: LogFn,
-) {
-  await wallet.addAuthWitness(authwit);
-
-  log(`Added authorization witness from ${authorizer}`);
-}