@aztec/aztec.js 3.0.3 → 4.0.0-devnet.1-patch.0

package/src/contract/sent_tx.ts

@@ -1,129 +0,0 @@
-import { promiseWithResolvers } from '@aztec/foundation/promise';
-import { retryUntil } from '@aztec/foundation/retry';
-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: 300,
-  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<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.address, artifact, wallet);
-  }
-}

package/src/deployment/broadcast_function.ts

@@ -1,148 +0,0 @@
-import {
-  ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
-  CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT,
-  MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-} from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { type ContractArtifact, FunctionSelector, FunctionType, bufferAsFields } from '@aztec/stdlib/abi';
-import {
-  computeVerificationKeyHash,
-  createPrivateFunctionMembershipProof,
-  createUtilityFunctionMembershipProof,
-  getContractClassFromArtifact,
-} from '@aztec/stdlib/contract';
-import { Capsule } from '@aztec/stdlib/tx';
-
-import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { getClassRegistryContract } from '../contract/protocol_contracts.js';
-import type { Wallet } from '../wallet/index.js';
-
-/**
- * Sets up a call to broadcast a private function's bytecode via the ClassRegistry contract.
- * Note that this is not required for users to call the function, but is rather a convenience to make
- * this code publicly available so dapps or wallets do not need to redistribute it.
- * @param wallet - Wallet to send the transaction.
- * @param artifact - Contract artifact that contains the function to be broadcast.
- * @param selector - Selector of the function to be broadcast.
- * @returns A ContractFunctionInteraction object that can be used to send the transaction.
- */
-export async function broadcastPrivateFunction(
-  wallet: Wallet,
-  artifact: ContractArtifact,
-  selector: FunctionSelector,
-): Promise<ContractFunctionInteraction> {
-  const contractClass = await getContractClassFromArtifact(artifact);
-  const privateFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.PRIVATE);
-  const functionsAndSelectors = await Promise.all(
-    privateFunctions.map(async fn => ({
-      f: fn,
-      selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
-    })),
-  );
-  const privateFunctionArtifact = functionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
-  if (!privateFunctionArtifact) {
-    throw new Error(`Private function with selector ${selector.toString()} not found`);
-  }
-
-  const {
-    artifactTreeSiblingPath,
-    artifactTreeLeafIndex,
-    artifactMetadataHash,
-    functionMetadataHash,
-    utilityFunctionsTreeRoot,
-    privateFunctionTreeSiblingPath,
-    privateFunctionTreeLeafIndex,
-  } = await createPrivateFunctionMembershipProof(selector, artifact);
-
-  const vkHash = await computeVerificationKeyHash(privateFunctionArtifact);
-
-  const classRegistry = await getClassRegistryContract(wallet);
-  const bytecode = bufferAsFields(
-    privateFunctionArtifact.bytecode,
-    MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-  );
-  return classRegistry.methods
-    .broadcast_private_function(
-      contractClass.id,
-      artifactMetadataHash,
-      utilityFunctionsTreeRoot,
-      privateFunctionTreeSiblingPath,
-      privateFunctionTreeLeafIndex,
-      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-      artifactTreeLeafIndex,
-      // eslint-disable-next-line camelcase
-      { selector, metadata_hash: functionMetadataHash, vk_hash: vkHash },
-    )
-    .with({
-      capsules: [
-        new Capsule(
-          ProtocolContractAddress.ContractClassRegistry,
-          new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT),
-          bytecode,
-        ),
-      ],
-    });
-}
-
-/**
- * Sets up a call to broadcast a utility function's bytecode via the ClassRegistry contract.
- * Note that this is not required for users to call the function, but is rather a convenience to make
- * this code publicly available so dapps or wallets do not need to redistribute it.
- * @param wallet - Wallet to send the transaction.
- * @param artifact - Contract artifact that contains the function to be broadcast.
- * @param selector - Selector of the function to be broadcast.
- * @returns A ContractFunctionInteraction object that can be used to send the transaction.
- */
-export async function broadcastUtilityFunction(
-  wallet: Wallet,
-  artifact: ContractArtifact,
-  selector: FunctionSelector,
-): Promise<ContractFunctionInteraction> {
-  const contractClass = await getContractClassFromArtifact(artifact);
-  const utilityFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UTILITY);
-  const utilityFunctionsAndSelectors = await Promise.all(
-    utilityFunctions.map(async fn => ({
-      f: fn,
-      selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
-    })),
-  );
-  const utilityFunctionArtifact = utilityFunctionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
-  if (!utilityFunctionArtifact) {
-    throw new Error(`Utility function with selector ${selector.toString()} not found`);
-  }
-
-  const {
-    artifactMetadataHash,
-    artifactTreeLeafIndex,
-    artifactTreeSiblingPath,
-    functionMetadataHash,
-    privateFunctionsArtifactTreeRoot,
-  } = await createUtilityFunctionMembershipProof(selector, artifact);
-
-  const classRegistry = await getClassRegistryContract(wallet);
-  const bytecode = bufferAsFields(
-    utilityFunctionArtifact.bytecode,
-    MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-  );
-  return classRegistry.methods
-    .broadcast_utility_function(
-      contractClass.id,
-      artifactMetadataHash,
-      privateFunctionsArtifactTreeRoot,
-      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-      artifactTreeLeafIndex,
-      // eslint-disable-next-line camelcase
-      { selector, metadata_hash: functionMetadataHash },
-    )
-    .with({
-      capsules: [
-        new Capsule(
-          ProtocolContractAddress.ContractClassRegistry,
-          new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT),
-          bytecode,
-        ),
-      ],
-    });
-}