@aztec/aztec.js 0.0.1-commit.b655e406 → 0.0.1-commit.c31f2472

package/src/contract/protocol_contracts.ts

@@ -1,35 +0,0 @@
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-
-import type { Wallet } from '../wallet/wallet.js';
-import { UnsafeContract } from './unsafe_contract.js';
-
-/** Returns a Contract wrapper for the contract class registry. */
-export async function getClassRegistryContract(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractClassRegistry);
-  if (!contractInstance) {
-    throw new Error("ContractClassRegistry is not registered in this wallet's instance");
-  }
-  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-
-  return new UnsafeContract(contractInstance!, artifact!, wallet);
-}
-
-/** Returns a Contract wrapper for the contract instance registry. */
-export async function getInstanceRegistryContract(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractInstanceRegistry);
-  if (!contractInstance) {
-    throw new Error("ContractInstanceRegistry is not registered in this wallet's instance");
-  }
-  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-  return new UnsafeContract(contractInstance!, artifact!, wallet);
-}
-
-/** Returns a Contract wrapper for the fee juice contract */
-export async function getFeeJuice(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.FeeJuice);
-  if (!contractInstance) {
-    throw new Error("FeeJuice is not registered in this wallet's instance");
-  }
-  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-  return new UnsafeContract(contractInstance!, artifact!, wallet);
-}

package/src/contract/sent_tx.ts

@@ -1,130 +0,0 @@
-import { promiseWithResolvers } from '@aztec/foundation/promise';
-import { retryUntil } from '@aztec/foundation/retry';
-import type { FieldsOf } from '@aztec/foundation/types';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import { TxHash, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
-
-import type { Wallet } from '../wallet/wallet.js';
-
-/** Options related to waiting for a tx. */
-export type WaitOpts = {
-  /** The amount of time to ignore TxStatus.DROPPED receipts (in seconds) due to the presumption that it is being propagated by the p2p network. Defaults to 5. */
-  ignoreDroppedReceiptsFor?: number;
-  /** The maximum time (in seconds) to wait for the transaction to be mined. Defaults to 60. */
-  timeout?: number;
-  /** The time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
-  interval?: number;
-  /** Whether to accept a revert as a status code for the tx when waiting for it. If false, will throw if the tx reverts. */
-  dontThrowOnRevert?: boolean;
-};
-
-export const DefaultWaitOpts: WaitOpts = {
-  ignoreDroppedReceiptsFor: 5,
-  timeout: 60,
-  interval: 1,
-};
-
-/**
- * The SentTx class represents a sent transaction through the PXE (or directly to a node) providing methods to fetch
- * its hash, receipt, and mining status.
- */
-export class SentTx {
-  protected sendTxPromise: Promise<void>;
-  protected sendTxError?: Error;
-  protected txHash?: TxHash;
-
-  constructor(
-    protected walletOrNode: Wallet | AztecNode,
-    sendTx: () => Promise<TxHash>,
-  ) {
-    const { promise, resolve } = promiseWithResolvers<void>();
-    this.sendTxPromise = promise;
-    sendTx()
-      .then(txHash => {
-        this.txHash = txHash;
-        resolve();
-      })
-      .catch(err => {
-        this.sendTxError = err;
-        // Calling resolve instead of reject here because we want to throw the error when getTxHash is called.
-        resolve();
-      });
-  }
-
-  /**
-   * Retrieves the transaction hash of the SentTx instance.
-   * The function internally awaits for the 'txHashPromise' to resolve, and then returns the resolved transaction hash.
-   *
-   * @returns A promise that resolves to the transaction hash of the SentTx instance.
-   * TODO(#7717): Don't throw here.
-   */
-  public async getTxHash(): Promise<TxHash> {
-    // Make sure sendTx has been resolved, which can be triggered when it returns a txHash or when it throws an error.
-    await this.sendTxPromise;
-
-    // If sendTx threw an error, throw it.
-    if (this.sendTxError) {
-      throw this.sendTxError;
-    }
-
-    // sendTx returned a txHash if it's been resolved and no error was set.
-    return Promise.resolve(this.txHash!);
-  }
-
-  /**
-   * Retrieve the transaction receipt associated with the current SentTx instance.
-   * The function fetches the transaction hash using 'getTxHash' and then queries
-   * the PXE to get the corresponding transaction receipt.
-   *
-   * @returns A promise that resolves to a TxReceipt object representing the fetched transaction receipt.
-   */
-  public async getReceipt(): Promise<TxReceipt> {
-    const txHash = await this.getTxHash();
-    return await this.walletOrNode.getTxReceipt(txHash);
-  }
-
-  /**
-   * Awaits for a tx to be mined and returns the receipt. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The transaction receipt.
-   */
-  public async wait(opts?: WaitOpts): Promise<FieldsOf<TxReceipt>> {
-    const receipt = await this.waitForReceipt(opts);
-    if (receipt.status !== TxStatus.SUCCESS && !opts?.dontThrowOnRevert) {
-      throw new Error(
-        `Transaction ${(await this.getTxHash()).toString()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`,
-      );
-    }
-    return receipt;
-  }
-
-  protected async waitForReceipt(opts?: WaitOpts): Promise<TxReceipt> {
-    const txHash = await this.getTxHash();
-    const startTime = Date.now();
-    const ignoreDroppedReceiptsFor = opts?.ignoreDroppedReceiptsFor ?? DefaultWaitOpts.ignoreDroppedReceiptsFor;
-
-    return await retryUntil(
-      async () => {
-        const txReceipt = await this.walletOrNode.getTxReceipt(txHash);
-        // If receipt is not yet available, try again
-        if (txReceipt.status === TxStatus.PENDING) {
-          return undefined;
-        }
-        // If the tx was "dropped", either return it or ignore based on timing.
-        // We can ignore it at first because the transaction may have been sent to node 1, and now we're asking node 2 for the receipt.
-        // If we don't allow a short grace period, we could incorrectly return a TxReceipt with status DROPPED.
-        if (txReceipt.status === TxStatus.DROPPED) {
-          const elapsedSeconds = (Date.now() - startTime) / 1000;
-          if (!ignoreDroppedReceiptsFor || elapsedSeconds > ignoreDroppedReceiptsFor) {
-            return txReceipt;
-          }
-          return undefined;
-        }
-        return txReceipt;
-      },
-      'isMined',
-      opts?.timeout ?? DefaultWaitOpts.timeout,
-      opts?.interval ?? DefaultWaitOpts.interval,
-    );
-  }
-}

package/src/contract/unsafe_contract.ts

@@ -1,19 +0,0 @@
-import type { ContractArtifact } from '@aztec/stdlib/abi';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-
-import type { Wallet } from '../wallet/wallet.js';
-import { ContractBase } from './contract_base.js';
-
-/** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */
-export class UnsafeContract extends ContractBase {
-  constructor(
-    /** The deployed contract instance definition. */
-    instance: ContractInstanceWithAddress,
-    /** The Application Binary Interface for the contract. */
-    artifact: ContractArtifact,
-    /** The wallet used for interacting with this contract. */
-    wallet: Wallet,
-  ) {
-    super(instance, artifact, wallet);
-  }
-}

package/src/wallet/base_wallet.ts

@@ -1,350 +0,0 @@
-import {
-  GAS_ESTIMATION_DA_GAS_LIMIT,
-  GAS_ESTIMATION_L2_GAS_LIMIT,
-  GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT,
-  GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT,
-} from '@aztec/constants';
-import { AccountFeePaymentMethodOptions, type DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
-import type { ChainInfo } from '@aztec/entrypoints/interfaces';
-import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import type { ContractArtifact, EventMetadataDefinition } from '@aztec/stdlib/abi';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import {
-  type ContractClassMetadata,
-  type ContractInstanceWithAddress,
-  type ContractInstantiationData,
-  type ContractMetadata,
-  computePartialAddress,
-  getContractClassFromArtifact,
-  getContractInstanceFromInstantiationParams,
-} from '@aztec/stdlib/contract';
-import { SimulationError } from '@aztec/stdlib/errors';
-import { Gas, GasSettings } from '@aztec/stdlib/gas';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type {
-  TxExecutionRequest,
-  TxHash,
-  TxProfileResult,
-  TxReceipt,
-  TxSimulationResult,
-  UtilitySimulationResult,
-} from '@aztec/stdlib/tx';
-
-import { inspect } from 'util';
-
-import type { Account } from '../account/account.js';
-import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
-import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
-import type {
-  Aliased,
-  BatchResults,
-  BatchableMethods,
-  BatchedMethod,
-  ContractInstanceAndArtifact,
-  ProfileOptions,
-  SendOptions,
-  SimulateOptions,
-  UserFeeOptions,
-  Wallet,
-} from './wallet.js';
-
-/**
- * Options to configure fee payment for a transaction
- */
-export type FeeOptions = {
-  /**
-   * A wallet-provided fallback fee payment method that is used only if the transaction that is being constructed
-   * doesn't already include one
-   */
-  walletFeePaymentMethod?: FeePaymentMethod;
-  /** Configuration options for the account to properly handle the selected fee payment method */
-  accountFeePaymentMethodOptions: AccountFeePaymentMethodOptions;
-  /** The gas settings to use for the transaction */
-  gasSettings: GasSettings;
-};
-
-/**
- * A base class for Wallet implementations
- */
-export abstract class BaseWallet implements Wallet {
-  protected log = createLogger('aztecjs:base_wallet');
-
-  protected baseFeePadding = 0.5;
-  protected cancellableTransactions = false;
-
-  // Protected because we want to force wallets to instantiate their own PXE.
-  protected constructor(
-    // TODO: We cannot type here pxe because we cannot import that package as that would result in a circular
-    // dependency. This will eventually get resolved by the introduction of @aztec/wallet-sdk package.
-    protected readonly pxe: any,
-    protected readonly aztecNode: AztecNode,
-  ) {}
-
-  protected abstract getAccountFromAddress(address: AztecAddress): Promise<Account>;
-
-  abstract getAccounts(): Promise<Aliased<AztecAddress>[]>;
-
-  /**
-   * Returns the list of aliased contacts associated with the wallet.
-   * This base implementation directly returns PXE's senders, but note that in general contacts are a superset of senders.
-   *  - Senders: Addresses we check during synching in case they sent us notes,
-   *  - Contacts: more general concept akin to a phone's contact list.
-   * @returns The aliased collection of AztecAddresses that form this wallet's address book
-   */
-  async getAddressBook(): Promise<Aliased<AztecAddress>[]> {
-    const senders: AztecAddress[] = await this.pxe.getSenders();
-    return senders.map(sender => ({ item: sender, alias: '' }));
-  }
-
-  async getChainInfo(): Promise<ChainInfo> {
-    const { l1ChainId, rollupVersion } = await this.aztecNode.getNodeInfo();
-    return { chainId: new Fr(l1ChainId), version: new Fr(rollupVersion) };
-  }
-
-  protected async createTxExecutionRequestFromPayloadAndFee(
-    executionPayload: ExecutionPayload,
-    from: AztecAddress,
-    feeOptions: FeeOptions,
-  ): Promise<TxExecutionRequest> {
-    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;
-    const fromAccount = await this.getAccountFromAddress(from);
-    return fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, executionOptions);
-  }
-
-  public async createAuthWit(
-    from: AztecAddress,
-    messageHashOrIntent: Fr | Buffer | IntentInnerHash | CallIntent,
-  ): Promise<AuthWitness> {
-    const account = await this.getAccountFromAddress(from);
-    return account.createAuthWit(messageHashOrIntent);
-  }
-
-  public async batch<const T extends readonly BatchedMethod<keyof BatchableMethods>[]>(
-    methods: T,
-  ): Promise<BatchResults<T>> {
-    const results: any[] = [];
-    for (const method of methods) {
-      const { name, args } = method;
-      // Type safety is guaranteed by the BatchedMethod type, which ensures that:
-      // 1. `name` is a valid batchable method name
-      // 2. `args` matches the parameter types of that specific method
-      // 3. The return type is correctly mapped in BatchResults<T>
-      // We use dynamic dispatch here for simplicity, but the types are enforced at the call site.
-
-      const fn = this[name] as (...args: any[]) => Promise<any>;
-      const result = await fn.apply(this, args);
-      // Wrap result with method name for discriminated union deserialization
-      results.push({ name, result });
-    }
-    return results as BatchResults<T>;
-  }
-
-  /**
-   * Returns default values for the transaction fee options
-   * if they were omitted by the user.
-   * @param from - The address where the transaction is being sent from
-   * @param userFeeOptions - User-provided fee options, which might be incomplete
-   * @returns - Populated fee options that can be used to create a transaction execution request
-   */
-  protected async getDefaultFeeOptions(from: AztecAddress, userFeeOptions?: UserFeeOptions): Promise<FeeOptions> {
-    const maxFeesPerGas =
-      userFeeOptions?.gasSettings?.maxFeesPerGas ??
-      (await this.aztecNode.getCurrentBaseFees()).mul(1 + this.baseFeePadding);
-    let accountFeePaymentMethodOptions;
-    // The transaction does not include a fee payment method, so we set the flag
-    // for the account to use its fee juice balance
-    if (!userFeeOptions?.embeddedPaymentMethodFeePayer) {
-      accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE;
-    } else {
-      // The transaction includes fee payment method, so we check if we are the fee payer for it
-      // (this can only happen if the embedded payment method is FeeJuiceWithClaim)
-      accountFeePaymentMethodOptions = from.equals(userFeeOptions.embeddedPaymentMethodFeePayer)
-        ? AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM
-        : AccountFeePaymentMethodOptions.EXTERNAL;
-    }
-    const gasSettings: GasSettings = GasSettings.default({ ...userFeeOptions?.gasSettings, maxFeesPerGas });
-    this.log.debug(`Using L2 gas settings`, gasSettings);
-    return {
-      gasSettings,
-      walletFeePaymentMethod: undefined,
-      accountFeePaymentMethodOptions,
-    };
-  }
-
-  /**
-   * Returns unreasonably high gas limits in order to execute a simulation
-   * with the goal of estimating its gas cost. It will otherwise try to respect
-   * the user-specified fee options, filling the gaps with default values as needed.
-   * @param from - The address where the transaction is being sent from
-   * @param userFeeOptions - User-provided fee options to use as a basis for the fully populated `FeeOptions` type.
-   */
-  protected async getFeeOptionsForGasEstimation(from: AztecAddress, userFeeOptions?: UserFeeOptions) {
-    const defaultFeeOptions = await this.getDefaultFeeOptions(from, userFeeOptions);
-    const {
-      gasSettings: { maxFeesPerGas, maxPriorityFeesPerGas },
-    } = defaultFeeOptions;
-    // Use unrealistically high gas limits for estimation to avoid running out of gas.
-    // They will be tuned down after the simulation.
-    const gasSettingsForEstimation = new GasSettings(
-      new Gas(GAS_ESTIMATION_DA_GAS_LIMIT, GAS_ESTIMATION_L2_GAS_LIMIT),
-      new Gas(GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT),
-      maxFeesPerGas,
-      maxPriorityFeesPerGas,
-    );
-    return {
-      ...defaultFeeOptions,
-      gasSettings: gasSettingsForEstimation,
-    };
-  }
-
-  registerSender(address: AztecAddress, _alias: string = ''): Promise<AztecAddress> {
-    return this.pxe.registerSender(address);
-  }
-
-  async registerContract(
-    instanceData: AztecAddress | ContractInstanceWithAddress | ContractInstantiationData | ContractInstanceAndArtifact,
-    artifact?: ContractArtifact,
-    secretKey?: Fr,
-  ): Promise<ContractInstanceWithAddress> {
-    /** Determines if the provided instance data is already a contract instance with an address. */
-    function isInstanceWithAddress(instanceData: any): instanceData is ContractInstanceWithAddress {
-      return (instanceData as ContractInstanceWithAddress).address !== undefined;
-    }
-    /** Determines if the provided instance data is contract instantiation data */
-    function isContractInstantiationData(instanceData: any): instanceData is ContractInstantiationData {
-      return (instanceData as ContractInstantiationData).salt !== undefined;
-    }
-    /** Determines if the provided instance data is already a contract */
-    function isContractInstanceAndArtifact(instanceData: any): instanceData is ContractInstanceAndArtifact {
-      return (
-        (instanceData as ContractInstanceAndArtifact).instance !== undefined &&
-        (instanceData as ContractInstanceAndArtifact).artifact !== undefined
-      );
-    }
-    let instance: ContractInstanceWithAddress;
-    if (isContractInstanceAndArtifact(instanceData)) {
-      instance = instanceData.instance;
-      await this.pxe.registerContract(instanceData);
-    } else if (isInstanceWithAddress(instanceData)) {
-      instance = instanceData;
-      await this.pxe.registerContract({ artifact, instance });
-    } else if (isContractInstantiationData(instanceData)) {
-      if (!artifact) {
-        throw new Error(`Contract artifact must be provided when registering a contract using instantiation data`);
-      }
-      instance = await getContractInstanceFromInstantiationParams(artifact, instanceData);
-      await this.pxe.registerContract({ artifact, instance });
-    } else {
-      if (!artifact) {
-        throw new Error(`Contract artifact must be provided when registering a contract using an address`);
-      }
-      const { contractInstance: maybeContractInstance } = await this.pxe.getContractMetadata(instanceData);
-      if (!maybeContractInstance) {
-        throw new Error(`Contract instance at ${instanceData.toString()} has not been registered in the wallet's PXE`);
-      }
-      instance = maybeContractInstance;
-      const thisContractClass = await getContractClassFromArtifact(artifact);
-      if (!thisContractClass.id.equals(instance.currentContractClassId)) {
-        // wallet holds an outdated version of this contract
-        await this.pxe.updateContract(instance.address, artifact);
-        instance.currentContractClassId = thisContractClass.id;
-      }
-    }
-    if (secretKey) {
-      await this.pxe.registerAccount(secretKey, await computePartialAddress(instance));
-    }
-    return instance;
-  }
-
-  async simulateTx(executionPayload: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
-    const feeOptions = opts.fee?.estimateGas
-      ? await this.getFeeOptionsForGasEstimation(opts.from, opts.fee)
-      : await this.getDefaultFeeOptions(opts.from, opts.fee);
-    const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
-    return this.pxe.simulateTx(
-      txRequest,
-      true /* simulatePublic */,
-      opts?.skipTxValidation,
-      opts?.skipFeeEnforcement ?? true,
-    );
-  }
-
-  async profileTx(executionPayload: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult> {
-    const fee = await this.getDefaultFeeOptions(opts.from, opts.fee);
-    const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, fee);
-    return this.pxe.profileTx(txRequest, opts.profileMode, opts.skipProofGeneration ?? true);
-  }
-
-  async sendTx(executionPayload: ExecutionPayload, opts: SendOptions): Promise<TxHash> {
-    const fee = await this.getDefaultFeeOptions(opts.from, opts.fee);
-    const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, fee);
-    const provenTx = await this.pxe.proveTx(txRequest);
-    const tx = await provenTx.toTx();
-    const txHash = tx.getTxHash();
-    if (await this.aztecNode.getTxEffect(txHash)) {
-      throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
-    }
-    this.log.debug(`Sending transaction ${txHash}`);
-    await this.aztecNode.sendTx(tx).catch(err => {
-      throw this.contextualizeError(err, inspect(tx));
-    });
-    this.log.info(`Sent transaction ${txHash}`);
-    return txHash;
-  }
-
-  protected contextualizeError(err: Error, ...context: string[]): Error {
-    let contextStr = '';
-    if (context.length > 0) {
-      contextStr = `\nContext:\n${context.join('\n')}`;
-    }
-    if (err instanceof SimulationError) {
-      err.setAztecContext(contextStr);
-    } else {
-      this.log.error(err.name, err);
-      this.log.debug(contextStr);
-    }
-    return err;
-  }
-
-  simulateUtility(
-    functionName: string,
-    args: any[],
-    to: AztecAddress,
-    authwits?: AuthWitness[],
-    from?: AztecAddress,
-  ): Promise<UtilitySimulationResult> {
-    return this.pxe.simulateUtility(functionName, args, to, authwits, from);
-  }
-
-  getContractClassMetadata(id: Fr, includeArtifact: boolean = false): Promise<ContractClassMetadata> {
-    return this.pxe.getContractClassMetadata(id, includeArtifact);
-  }
-  getContractMetadata(address: AztecAddress): Promise<ContractMetadata> {
-    return this.pxe.getContractMetadata(address);
-  }
-
-  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    return this.aztecNode.getTxReceipt(txHash);
-  }
-
-  getPrivateEvents<T>(
-    contractAddress: AztecAddress,
-    event: EventMetadataDefinition,
-    from: number,
-    limit: number,
-    recipients: AztecAddress[] = [],
-  ): Promise<T[]> {
-    return this.pxe.getPrivateEvents(contractAddress, event, from, limit, recipients);
-  }
-}