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

package/src/utils/profiling.ts

@@ -0,0 +1,172 @@
+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.perMethod)) {
+      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),
+        ),
+      );
+    }
+
+    const { roundTrips } = stats.nodeRPCCalls;
+    log(format('\nRound trips (actual blocking waits):\n'));
+    log(format('Round trips:'.padEnd(25), `${roundTrips.roundTrips}`.padStart(COLUMN_MAX_WIDTH)));
+    log(
+      format(
+        'Total blocking time:'.padEnd(25),
+        `${roundTrips.totalBlockingTime.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH),
+      ),
+    );
+    if (roundTrips.roundTrips > 0) {
+      const avgRoundTrip = roundTrips.totalBlockingTime / roundTrips.roundTrips;
+      log(format('Avg round trip:'.padEnd(25), `${avgRoundTrip.toFixed(2)}ms`.padStart(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,330 @@
+import { EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { StubEcdsaAccountContractArtifact, createStubEcdsaAccount } from '@aztec/accounts/stub/ecdsa';
+import { StubSchnorrAccountContractArtifact, createStubSchnorrAccount } from '@aztec/accounts/stub/schnorr';
+import { getIdentities } from '@aztec/accounts/utils';
+import { type Account, type AccountContract, NO_FROM } from '@aztec/aztec.js/account';
+import { type InteractionFeeOptions, getContractClassFromArtifact, getGasLimits } from '@aztec/aztec.js/contracts';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { AccountManager, type Aliased, type SimulateOptions } from '@aztec/aztec.js/wallet';
+import { TxSimulationResultWithAppOffset } from '@aztec/aztec.js/wallet';
+import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
+import { DefaultEntrypoint } from '@aztec/entrypoints/default';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { LogFn } from '@aztec/foundation/log';
+import type { NotesFilter } from '@aztec/pxe/client/lazy';
+import type { PXEConfig } from '@aztec/pxe/config';
+import type { PXE } from '@aztec/pxe/server';
+import { createPXE, getPXEConfig } from '@aztec/pxe/server';
+import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { NoteDao } from '@aztec/stdlib/note';
+import type { SimulationOverrides, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { BaseWallet, type SimulateViaEntrypointOptions } from '@aztec/wallet-sdk/base-wallet';
+
+import type { WalletDB } from '../storage/wallet_db.js';
+import type { AccountType } from './constants.js';
+import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
+import { printGasEstimates } from './options/fees.js';
+
+export class CLIWallet extends BaseWallet {
+  private accountCache = new Map<string, Account>();
+  // Stub class ids, populated on wallet startup
+  // to avoid redundant work per simulation
+  private stubClassIds = new Map<AccountType, Fr>();
+
+  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);
+    const wallet = new CLIWallet(pxe, node, log, db);
+    await wallet.initStubClasses();
+    await wallet.registerAuthRegistry();
+    return wallet;
+  }
+
+  private async registerAuthRegistry(): Promise<void> {
+    const { instance, artifact } = await getStandardAuthRegistry();
+    await this.pxe.registerContract({ instance, artifact });
+  }
+
+  /**
+   * Hashes and registers the stub class for every supported account type with PXE, populating
+   * stubClassIds. Called on wallet initialization.
+   */
+  private async initStubClasses(): Promise<void> {
+    const { id: schnorrClassId } = await getContractClassFromArtifact(StubSchnorrAccountContractArtifact);
+    await this.pxe.registerContractClass(StubSchnorrAccountContractArtifact);
+
+    // ecdsa stubs share the same class id
+    const { id: ecdsaClassId } = await getContractClassFromArtifact(StubEcdsaAccountContractArtifact);
+    await this.pxe.registerContractClass(StubEcdsaAccountContractArtifact);
+
+    this.stubClassIds.set('schnorr', schnorrClassId);
+    this.stubClassIds.set('ecdsasecp256k1', ecdsaClassId);
+    this.stubClassIds.set('ecdsasecp256r1', ecdsaClassId);
+    this.stubClassIds.set('ecdsasecp256r1ssh', ecdsaClassId);
+  }
+
+  override async getAccounts(): Promise<Aliased<AztecAddress>[]> {
+    const accounts = (await this.db?.listAliases('accounts')) ?? [];
+    return Promise.resolve(
+      accounts.map(({ key, value }) => {
+        const alias = key.includes(':') ? key.slice(key.indexOf(':') + 1) : key;
+        return { alias, item: AztecAddress.fromString(value) };
+      }),
+    );
+  }
+
+  private async createCancellationTxExecutionRequest(
+    from: AztecAddress,
+    txNonce: Fr,
+    increasedFee: InteractionFeeOptions,
+  ) {
+    const executionPayload = ExecutionPayload.empty();
+    const feeOptions = await this.completeFeeOptions({
+      from,
+      feePayer: executionPayload.feePayer,
+      gasSettings: increasedFee.gasSettings,
+    });
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    const fromAccount = await this.getAccountFromAddress(from);
+    const chainInfo = await this.getChainInfo();
+    const executionOptions: DefaultAccountEntrypointOptions = {
+      txNonce,
+      cancellable: this.cancellableTransactions,
+      // If from is an address, feeOptions include the way the account contract should handle the fee payment
+      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions!,
+    };
+    return await fromAccount.createTxExecutionRequest(
+      feeExecutionPayload ?? executionPayload,
+      feeOptions.gasSettings,
+      chainInfo,
+      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, { scopes: this.scopesFrom(from), senderForTags: from });
+  }
+
+  override async getAccountFromAddress(address: AztecAddress) {
+    let account: Account | undefined;
+    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;
+  }
+
+  /**
+   * Creates a stub account that impersonates the given address, allowing kernelless simulations
+   * to bypass the account's authorization mechanisms via contract overrides.
+   * @param address - The address of the account to impersonate
+   * @returns The stub account, contract instance, and artifact for simulation
+   */
+  private async getFakeAccountDataFor(address: AztecAddress) {
+    const originalAccount = await this.getAccountFromAddress(address);
+    const originalAddress = originalAccount.getCompleteAddress();
+    const contractInstance = await this.pxe.getContractInstance(originalAddress.address);
+    if (!contractInstance) {
+      throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+    }
+    const { type } = await this.db!.retrieveAccount(address);
+    const stubAccount =
+      type === 'schnorr' ? createStubSchnorrAccount(originalAddress) : createStubEcdsaAccount(originalAddress);
+    const stubClassId = this.stubClassIds.get(type);
+    if (!stubClassId) {
+      throw new Error(
+        `Stub class for account type '${type}' was not registered at wallet init. This is a bug — initStubClasses should cover every supported AccountType.`,
+      );
+    }
+    const instance = { ...contractInstance, currentContractClassId: stubClassId };
+    return { account: stubAccount, instance };
+  }
+
+  override async simulateTx(
+    executionPayload: ExecutionPayload,
+    opts: SimulateOptions,
+  ): Promise<TxSimulationResultWithAppOffset> {
+    const simulationResults = await super.simulateTx(executionPayload, opts);
+
+    if (opts.fee?.estimateGas) {
+      const feeOptions = await this.completeFeeOptions({
+        from: opts.from,
+        feePayer: executionPayload.feePayer,
+        gasSettings: opts.fee?.gasSettings,
+      });
+      const limits = getGasLimits(simulationResults, opts.fee?.estimatedGasPadding);
+      printGasEstimates(feeOptions, limits, this.userLog);
+    }
+    return simulationResults;
+  }
+
+  /**
+   * Uses a stub account for kernelless simulation, bypassing real account authorization.
+   * Uses DefaultEntrypoint directly for NO_FROM transactions.
+   */
+  protected override async simulateViaEntrypoint(
+    executionPayload: ExecutionPayload,
+    opts: SimulateViaEntrypointOptions,
+  ): Promise<TxSimulationResultWithAppOffset> {
+    const { from, feeOptions, additionalScopes, sendMessagesAs } = opts;
+    const scopes = this.scopesFrom(from, additionalScopes);
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, executionPayload])
+      : executionPayload;
+    const chainInfo = await this.getChainInfo();
+
+    let overrides: SimulationOverrides | undefined;
+    let txRequest: TxExecutionRequest;
+    if (from === NO_FROM) {
+      const entrypoint = new DefaultEntrypoint();
+      txRequest = await entrypoint.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo);
+    } else {
+      const { account, instance } = await this.getFakeAccountDataFor(from);
+      overrides = {
+        contracts: { [from.toString()]: { instance } },
+      };
+      const executionOptions: DefaultAccountEntrypointOptions = {
+        txNonce: Fr.random(),
+        cancellable: this.cancellableTransactions,
+        // If from is an address, feeOptions include the way the account contract should handle the fee payment
+        feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions!,
+      };
+      txRequest = await account.createTxExecutionRequest(
+        finalExecutionPayload,
+        feeOptions.gasSettings,
+        chainInfo,
+        executionOptions,
+      );
+    }
+
+    const result = await this.pxe.simulateTx(txRequest, {
+      simulatePublic: true,
+      skipFeeEnforcement: true,
+      skipTxValidation: true,
+      overrides,
+      scopes,
+      senderForTags: this.senderForTagsFrom(from, sendMessagesAs),
+    });
+    const appCallOffset = await this.computeAppCallOffset(from, feeOptions);
+    return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
+  }
+
+  // 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<NoteDao[]> {
+    return this.pxe.debug.getNotes(filter);
+  }
+
+  // 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.
+  getContractArtifact(id: Fr) {
+    return this.pxe.getContractArtifact(id);
+  }
+}

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;
-}