@aztec/aztec.js 0.0.1-commit.03f7ef2 → 0.0.1-commit.04852196a

package/src/contract/wait_opts.ts

@@ -0,0 +1,21 @@
+import type { TxStatus } from '@aztec/stdlib/tx';
+
+/** 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;
+  /** The minimum inclusion status to wait for. If set, waits until the receipt reaches this status or higher. Defaults to CHECKPOINTED. */
+  waitForStatus?: TxStatus;
+};
+
+export const DefaultWaitOpts: WaitOpts = {
+  ignoreDroppedReceiptsFor: 5,
+  timeout: 300,
+  interval: 1,
+};

package/src/deployment/publish_class.ts

@@ -9,7 +9,7 @@ import { 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 { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
 import type { Wallet } from '../wallet/index.js';
 
 /** Sets up a call to publish a contract class given its artifact. */
@@ -19,7 +19,7 @@ export async function publishContractClass(
 ): Promise<ContractFunctionInteraction> {
   const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
     await getContractClassFromArtifact(artifact);
-  const classRegistry = await getClassRegistryContract(wallet);
+  const classRegistry = ContractClassRegistryContract.at(wallet);
 
   const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
   return classRegistry.methods.publish(artifactHash, privateFunctionsRoot, publicBytecodeCommitment).with({

package/src/deployment/publish_instance.ts

@@ -1,7 +1,7 @@
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { getInstanceRegistryContract } from '../contract/protocol_contracts.js';
+import { ContractInstanceRegistryContract } from '../contract/protocol_contracts/contract-instance-registry.js';
 import type { Wallet } from '../wallet/wallet.js';
 
 /**
@@ -9,11 +9,8 @@ import type { Wallet } from '../wallet/wallet.js';
  * @param wallet - The wallet to use for the publication (setup) tx.
  * @param instance - The instance to publish.
  */
-export async function publishInstance(
-  wallet: Wallet,
-  instance: ContractInstanceWithAddress,
-): Promise<ContractFunctionInteraction> {
-  const contractInstanceRegistry = await getInstanceRegistryContract(wallet);
+export function publishInstance(wallet: Wallet, instance: ContractInstanceWithAddress): ContractFunctionInteraction {
+  const contractInstanceRegistry = ContractInstanceRegistryContract.at(wallet);
   const { salt, currentContractClassId: contractClassId, publicKeys, deployer: instanceDeployer } = instance;
   const isUniversalDeploy = instanceDeployer.isZero();
   return contractInstanceRegistry.methods.publish_for_public_execution(

package/src/ethereum/portal_manager.ts

@@ -1,5 +1,6 @@
 import type { ExtendedViemWalletClient, ViemContract } from '@aztec/ethereum/types';
 import { extractEvent } from '@aztec/ethereum/utils';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
 import { sha256ToField } from '@aztec/foundation/crypto/sha256';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -132,7 +133,7 @@ export class L1FeeJuicePortalManager {
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
-    handlerAddress: EthAddress,
+    handlerAddress: EthAddress | undefined,
     private readonly extendedClient: ExtendedViemWalletClient,
     private readonly logger: Logger,
   ) {
@@ -157,9 +158,9 @@ export class L1FeeJuicePortalManager {
    */
   public async bridgeTokensPublic(to: AztecAddress, amount: bigint | undefined, mint = false): Promise<L2AmountClaim> {
     const [claimSecret, claimSecretHash] = await generateClaimSecret();
-    const mintableAmount = await this.tokenManager.getMintAmount();
-    const amountToBridge = amount ?? mintableAmount;
+    const amountToBridge = amount ?? (await this.tokenManager.getMintAmount());
     if (mint) {
+      const mintableAmount = await this.tokenManager.getMintAmount();
       if (amountToBridge !== mintableAmount) {
         throw new Error(`Minting amount must be ${mintableAmount}`);
       }
@@ -233,17 +234,12 @@ export class L1FeeJuicePortalManager {
     if (feeJuiceAddress.isZero() || feeJuicePortalAddress.isZero()) {
       throw new Error('Portal or token not deployed on L1');
     }
-    if (!feeAssetHandlerAddress || feeAssetHandlerAddress.isZero()) {
-      throw new Error('Handler not deployed on L1, or handler address is zero');
-    }
 
-    return new L1FeeJuicePortalManager(
-      feeJuicePortalAddress,
-      feeJuiceAddress,
-      feeAssetHandlerAddress,
-      extendedClient,
-      logger,
-    );
+    // Handler is optional - it's only needed for minting tokens during testing
+    const handlerAddress =
+      feeAssetHandlerAddress && !feeAssetHandlerAddress.isZero() ? feeAssetHandlerAddress : undefined;
+
+    return new L1FeeJuicePortalManager(feeJuicePortalAddress, feeJuiceAddress, handlerAddress, extendedClient, logger);
   }
 }
 
@@ -413,26 +409,26 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
    * Withdraws funds from the portal by consuming an L2 to L1 message. Returns once the tx is mined on L1.
    * @param amount - Amount to withdraw.
    * @param recipient - Who will receive the funds.
-   * @param blockNumber - L2 block number of the message.
+   * @param epochNumber - Epoch number of the message.
    * @param messageIndex - Index of the message.
    * @param siblingPath - Sibling path of the message.
    */
   public async withdrawFunds(
     amount: bigint,
     recipient: EthAddress,
-    blockNumber: bigint,
+    epochNumber: EpochNumber,
     messageIndex: bigint,
     siblingPath: SiblingPath<number>,
   ) {
     this.logger.info(
-      `Sending L1 tx to consume message at block ${blockNumber} index ${messageIndex} to withdraw ${amount}`,
+      `Sending L1 tx to consume message at epoch ${epochNumber} index ${messageIndex} to withdraw ${amount}`,
     );
 
     const messageLeafId = getL2ToL1MessageLeafId({ leafIndex: messageIndex, siblingPath });
-    const isConsumedBefore = await this.outbox.read.hasMessageBeenConsumedAtCheckpoint([blockNumber, messageLeafId]);
+    const isConsumedBefore = await this.outbox.read.hasMessageBeenConsumedAtEpoch([BigInt(epochNumber), messageLeafId]);
     if (isConsumedBefore) {
       throw new Error(
-        `L1 to L2 message at block ${blockNumber} index ${messageIndex} height ${siblingPath.pathSize} has already been consumed`,
+        `L2 to L1 message at epoch ${epochNumber} index ${messageIndex} height ${siblingPath.pathSize} has already been consumed`,
       );
     }
 
@@ -441,7 +437,7 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
       recipient.toString(),
       amount,
       false,
-      BigInt(blockNumber),
+      BigInt(epochNumber),
       messageIndex,
       siblingPath.toBufferArray().map((buf: Buffer): Hex => `0x${buf.toString('hex')}`),
     ]);
@@ -450,10 +446,10 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
       hash: await this.extendedClient.writeContract(withdrawRequest),
     });
 
-    const isConsumedAfter = await this.outbox.read.hasMessageBeenConsumedAtCheckpoint([blockNumber, messageLeafId]);
+    const isConsumedAfter = await this.outbox.read.hasMessageBeenConsumedAtEpoch([BigInt(epochNumber), messageLeafId]);
     if (!isConsumedAfter) {
       throw new Error(
-        `L1 to L2 message at block ${blockNumber} index ${messageIndex} height ${siblingPath.pathSize} not consumed after withdrawal`,
+        `L2 to L1 message at epoch ${epochNumber} index ${messageIndex} height ${siblingPath.pathSize} not consumed after withdrawal`,
       );
     }
   }

package/src/fee/fee_juice_payment_method_with_claim.ts

@@ -1,6 +1,6 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
 import { ExecutionPayload } from '@aztec/stdlib/tx';
@@ -27,10 +27,11 @@ export class FeeJuicePaymentMethodWithClaim implements FeePaymentMethod {
 
     return new ExecutionPayload(
       [
-        {
-          to: ProtocolContractAddress.FeeJuice,
+        FunctionCall.from({
           name: 'claim_and_end_setup',
+          to: ProtocolContractAddress.FeeJuice,
           selector,
+          type: FunctionType.PRIVATE,
           hideMsgSender: false,
           isStatic: false,
           args: [
@@ -40,8 +41,7 @@ export class FeeJuicePaymentMethodWithClaim implements FeePaymentMethod {
             new Fr(this.claim.messageLeafIndex),
           ],
           returnTypes: [],
-          type: FunctionType.PRIVATE,
-        },
+        }),
       ],
       [],
       [],

package/src/fee/private_fee_payment_method.ts

@@ -1,5 +1,5 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { type FunctionAbi, FunctionCall, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
 import { ExecutionPayload } from '@aztec/stdlib/tx';
@@ -10,6 +10,7 @@ import type { FeePaymentMethod } from './fee_payment_method.js';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
+ * @deprecated Is not supported on mainnet. Use {@link FeeJuicePaymentMethodWithClaim} or `SponsoredFeePaymentMethod` instead.
  */
 export class PrivateFeePaymentMethod implements FeePaymentMethod {
   private assetPromise: Promise<AztecAddress> | null = null;
@@ -102,21 +103,21 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
 
     const witness = await this.wallet.createAuthWit(this.sender, {
       caller: this.paymentContract,
-      call: {
+      call: FunctionCall.from({
         name: 'transfer_to_public',
-        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
+        to: await this.getAsset(),
         selector: await FunctionSelector.fromSignature('transfer_to_public((Field),(Field),u128,Field)'),
         type: FunctionType.PRIVATE,
         hideMsgSender: false,
         isStatic: false,
-        to: await this.getAsset(),
+        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
         returnTypes: [],
-      },
+      }),
     });
 
     return new ExecutionPayload(
       [
-        {
+        FunctionCall.from({
           name: 'fee_entrypoint_private',
           to: this.paymentContract,
           selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
@@ -125,7 +126,7 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
           isStatic: false,
           args: [maxFee, txNonce],
           returnTypes: [],
-        },
+        }),
       ],
       [witness],
       [],

package/src/fee/public_fee_payment_method.ts

@@ -1,5 +1,5 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { type FunctionAbi, FunctionCall, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasSettings } from '@aztec/stdlib/gas';
 import { ExecutionPayload } from '@aztec/stdlib/tx';
@@ -11,6 +11,7 @@ import type { FeePaymentMethod } from './fee_payment_method.js';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
+ * @deprecated Is not supported on mainnet. Use {@link FeeJuicePaymentMethodWithClaim} or `SponsoredFeePaymentMethod` instead.
  */
 export class PublicFeePaymentMethod implements FeePaymentMethod {
   private assetPromise: Promise<AztecAddress> | null = null;
@@ -94,16 +95,16 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
 
     const intent = {
       caller: this.paymentContract,
-      call: {
+      call: FunctionCall.from({
         name: 'transfer_in_public',
-        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
+        to: await this.getAsset(),
         selector: await FunctionSelector.fromSignature('transfer_in_public((Field),(Field),u128,Field)'),
         type: FunctionType.PUBLIC,
-        isStatic: false,
         hideMsgSender: false /** The target function performs an authwit check, so msg_sender is needed */,
-        to: await this.getAsset(),
+        isStatic: false,
+        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
         returnTypes: [],
-      },
+      }),
     };
 
     const setPublicAuthWitInteraction = await SetPublicAuthwitContractInteraction.create(
@@ -116,7 +117,7 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
     return new ExecutionPayload(
       [
         ...(await setPublicAuthWitInteraction.request()).calls,
-        {
+        FunctionCall.from({
           name: 'fee_entrypoint_public',
           to: this.paymentContract,
           selector: await FunctionSelector.fromSignature('fee_entrypoint_public(u128,Field)'),
@@ -125,7 +126,7 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
           isStatic: false,
           args: [maxFee, txNonce],
           returnTypes: [],
-        },
+        }),
       ],
       [],
       [],

package/src/fee/sponsored_fee_payment.ts

@@ -1,5 +1,5 @@
 import type { FeePaymentMethod } from '@aztec/aztec.js/fee';
-import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
 import { ExecutionPayload } from '@aztec/stdlib/tx';
@@ -22,7 +22,7 @@ export class SponsoredFeePaymentMethod implements FeePaymentMethod {
   async getExecutionPayload(): Promise<ExecutionPayload> {
     return new ExecutionPayload(
       [
-        {
+        FunctionCall.from({
           name: 'sponsor_unconditionally',
           to: this.paymentContract,
           selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'),
@@ -31,7 +31,7 @@ export class SponsoredFeePaymentMethod implements FeePaymentMethod {
           isStatic: false,
           args: [],
           returnTypes: [],
-        },
+        }),
       ],
       [],
       [],

package/src/scripts/generate_protocol_contract_types.ts

@@ -0,0 +1,150 @@
+/**
+ * Generates type-safe contract wrappers for protocol contracts.
+ * These wrappers use a minimal artifact (without bytecode) since PXE already has the full artifacts registered.
+ */
+import { generateTypescriptContractInterface } from '@aztec/builder/codegen';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  FunctionType,
+  getAllFunctionAbis,
+  loadContractArtifact,
+} from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const log = console.log;
+
+const noirContractsRoot = path.join(import.meta.dirname, '../../../../noir-projects/noir-contracts');
+const srcPath = path.join(noirContractsRoot, 'target');
+const outputDir = path.join(import.meta.dirname, '../contract/protocol_contracts');
+
+function toKebabCase(str: string): string {
+  return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+
+function functionTypeToEnum(type: FunctionType): string {
+  switch (type) {
+    case FunctionType.PRIVATE:
+      return 'FunctionType.PRIVATE';
+    case FunctionType.PUBLIC:
+      return 'FunctionType.PUBLIC';
+    case FunctionType.UTILITY:
+      return 'FunctionType.UTILITY';
+  }
+}
+
+function generateFunctionAbiJson(abi: FunctionAbi): string {
+  const baseObj = {
+    name: abi.name,
+    isOnlySelf: abi.isOnlySelf,
+    isStatic: abi.isStatic,
+    isInitializer: abi.isInitializer,
+    parameters: abi.parameters,
+    returnTypes: abi.returnTypes,
+    errorTypes: abi.errorTypes,
+  };
+  const jsonStr = JSON.stringify(baseObj);
+  return jsonStr.replace('{', `{ functionType: ${functionTypeToEnum(abi.functionType)},`);
+}
+
+function generateProtocolContractArtifact(input: ContractArtifact): string {
+  const allAbis = getAllFunctionAbis(input);
+  const functionAbis = input.functions.map(f => allAbis.find(abi => abi.name === f.name)!);
+  const nonDispatchAbis = input.nonDispatchPublicFunctions;
+
+  const functionsArray = functionAbis
+    .map(abi => `{ ...${generateFunctionAbiJson(abi)}, bytecode: Buffer.from([]), debugSymbols: '' }`)
+    .join(',\n    ');
+
+  const nonDispatchArray = nonDispatchAbis.map(abi => generateFunctionAbiJson(abi)).join(',\n    ');
+
+  return `{
+  name: '${input.name}',
+  functions: [
+    ${functionsArray}
+  ],
+  nonDispatchPublicFunctions: [
+    ${nonDispatchArray}
+  ],
+  outputs: { structs: {}, globals: {} },
+  storageLayout: {},
+  fileMap: {},
+}`;
+}
+
+async function generateProtocolContractInterface(
+  input: ContractArtifact,
+  protocolContractName: string,
+): Promise<string> {
+  const baseInterface = await generateTypescriptContractInterface(input);
+
+  // Match everything between "public declare methods: {" and the closing "};"
+  const methodsMatch = baseInterface.match(/public declare methods: \{([\s\S]*?)\n  \};/);
+  if (!methodsMatch) {
+    throw new Error('Could not extract methods from generated interface');
+  }
+
+  const artifactCode = generateProtocolContractArtifact(input);
+  const contractName = `${input.name}Contract`;
+
+  return `
+/* Autogenerated file, do not edit! */
+
+/* eslint-disable */
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FunctionType } from '@aztec/stdlib/abi';
+
+import type { ContractArtifact } from '../../api/abi.js';
+import { PublicKeys } from '../../api/keys.js';
+import type { AztecAddressLike, EthAddressLike, FieldLike, FunctionSelectorLike, WrappedFieldLike } from '../../utils/abi_types.js';
+import { ContractBase, type ContractMethod } from '../contract_base.js';
+import { ContractFunctionInteraction } from '../contract_function_interaction.js';
+import type { Wallet } from '../../wallet/wallet.js';
+
+const ${contractName}Artifact: ContractArtifact = ${artifactCode};
+
+export class ${contractName} extends ContractBase {
+  private constructor(wallet: Wallet) {
+    super(ProtocolContractAddress.${protocolContractName}, ${contractName}Artifact, wallet);
+  }
+
+  public static at(wallet: Wallet): ${contractName} {
+    return new ${contractName}(wallet);
+  }
+
+  public declare methods: {${methodsMatch[1]}
+  };
+}
+`;
+}
+
+async function main() {
+  await fs.rm(outputDir, { recursive: true, force: true });
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const srcNames = JSON.parse(
+    await fs.readFile(path.join(noirContractsRoot, 'protocol_contracts.json'), 'utf8'),
+  ) as string[];
+
+  for (const srcName of srcNames) {
+    // srcName is like "auth_registry_contract-AuthRegistry", split to get the contract name
+    const name = srcName.split('-')[1];
+    const artifactPath = path.join(srcPath, `${srcName}.json`);
+    const json = JSON.parse(await fs.readFile(artifactPath, 'utf8')) as NoirCompiledContract;
+    const contractArtifact = loadContractArtifact(json);
+
+    const content = await generateProtocolContractInterface(contractArtifact, name);
+    const fileName = `${toKebabCase(name)}.ts`;
+    await fs.writeFile(path.join(outputDir, fileName), content);
+
+    log(`Generated ${fileName}`);
+  }
+}
+
+main().catch(err => {
+  console.error('Error generating protocol contract types:', err);
+  process.exit(1);
+});

package/src/utils/abi_types.ts

@@ -23,3 +23,10 @@ export type U128Like = bigint | number;
 
 /** Any type that can be converted into a struct with a single `inner` field. */
 export type WrappedFieldLike = { /** Wrapped value */ inner: FieldLike } | FieldLike;
+
+/** Noir `Option<T>` lowered ABI shape, plus ergonomic direct `T | null | undefined` inputs. */
+export type OptionLike<T> =
+  | T
+  | null
+  | undefined
+  | { /** Whether the option is populated */ _is_some: boolean; /** Wrapped value */ _value: T };

package/src/utils/authwit.ts

@@ -9,12 +9,15 @@ import type { TxProfileResult } from '@aztec/stdlib/tx';
 
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
 import type {
+  InteractionWaitOptions,
   ProfileInteractionOptions,
   SendInteractionOptions,
+  SendInteractionOptionsWithoutWait,
+  SendReturn,
   SimulateInteractionOptions,
-  SimulationReturn,
+  SimulationResult,
+  TxSendResultMined,
 } from '../contract/interaction_options.js';
-import type { SentTx } from '../contract/sent_tx.js';
 import type { Wallet } from '../wallet/index.js';
 
 /** Intent with an inner hash */
@@ -42,7 +45,7 @@ export type ContractFunctionInteractionCallIntent = {
 };
 
 /** Identifies ContractFunctionInteractionCallIntents */
-function isContractFunctionIntractionCallIntent(
+export function isContractFunctionInteractionCallIntent(
   messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
 ): messageHashOrIntent is ContractFunctionInteractionCallIntent {
   return (
@@ -81,7 +84,7 @@ export const computeAuthWitMessageHash = async (
   const version = metadata.version;
 
   if ('caller' in intent) {
-    const call = isContractFunctionIntractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+    const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
     return computeOuterAuthWitHash(
       call.to,
       chainId,
@@ -154,7 +157,7 @@ export async function lookupValidity(
 }> {
   let innerHash, consumer;
   if ('caller' in intent) {
-    const call = isContractFunctionIntractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+    const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
     innerHash = await computeInnerAuthWitHashFromAction(intent.caller, call);
     consumer = call.to;
   } else {
@@ -187,10 +190,12 @@ export async function lookupValidity(
     errorTypes: {},
   } as FunctionAbi;
   try {
-    results.isValidInPrivate = (await new ContractFunctionInteraction(wallet, onBehalfOf, lookupValidityAbi, [
-      consumer,
-      innerHash,
-    ]).simulate({ from: onBehalfOf, authWitnesses: [witness] })) as boolean;
+    results.isValidInPrivate = (
+      await new ContractFunctionInteraction(wallet, onBehalfOf, lookupValidityAbi, [consumer, innerHash]).simulate({
+        from: onBehalfOf,
+        authWitnesses: [witness],
+      })
+    ).result as boolean;
     // TODO: Narrow down the error to make sure simulation failed due to an invalid authwit
     // eslint-disable-next-line no-empty
   } catch {}
@@ -217,12 +222,12 @@ export async function lookupValidity(
     returnTypes: [{ kind: 'boolean' }],
     errorTypes: {},
   } as FunctionAbi;
-  results.isValidInPublic = (await new ContractFunctionInteraction(
-    wallet,
-    ProtocolContractAddress.AuthRegistry,
-    isConsumableAbi,
-    [onBehalfOf, messageHash],
-  ).simulate({ from: onBehalfOf })) as boolean;
+  results.isValidInPublic = (
+    await new ContractFunctionInteraction(wallet, ProtocolContractAddress.AuthRegistry, isConsumableAbi, [
+      onBehalfOf,
+      messageHash,
+    ]).simulate({ from: onBehalfOf })
+  ).result as boolean;
 
   return results;
 }
@@ -260,14 +265,10 @@ export class SetPublicAuthwitContractInteraction extends ContractFunctionInterac
    * @param options - An optional object containing additional configuration for the transaction.
    * @returns The result of the transaction as returned by the contract function.
    */
-  public override simulate<T extends SimulateInteractionOptions>(
-    options: Omit<T, 'from'>,
-  ): Promise<SimulationReturn<T['includeMetadata']>>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
   public override simulate(
-    options: Omit<SimulateInteractionOptions, 'from'> = {},
-  ): Promise<SimulationReturn<typeof options.includeMetadata>> {
-    return super.simulate({ ...options, from: this.from });
+    options: Omit<SimulateInteractionOptions, 'from'> = {} as Omit<SimulateInteractionOptions, 'from'>,
+  ): Promise<SimulationResult> {
+    return super.simulate({ ...options, from: this.from } as SimulateInteractionOptions);
   }
 
   /**
@@ -286,9 +287,18 @@ export class SetPublicAuthwitContractInteraction extends ContractFunctionInterac
    * Overrides the send method, adding the sender of the authwit (authorizer) as from
    * and preventing misuse
    * @param options - An optional object containing 'fee' options information
-   * @returns A SentTx instance for tracking the transaction status and information.
+   * @returns A TxReceipt (if wait is true/undefined) or TxHash (if wait is false)
    */
-  public override send(options: Omit<SendInteractionOptions, 'from'> = {}): SentTx {
+  public override send(options?: Omit<SendInteractionOptionsWithoutWait, 'from'>): Promise<TxSendResultMined>;
+  // Generic overload for explicit wait values
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public override send<W extends InteractionWaitOptions>(
+    options?: Omit<SendInteractionOptions<W>, 'from'>,
+  ): Promise<SendReturn<W>>;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public override send(
+    options?: Omit<SendInteractionOptions<InteractionWaitOptions>, 'from'>,
+  ): Promise<SendReturn<InteractionWaitOptions>> {
     return super.send({ ...options, from: this.from });
   }
 

package/src/utils/cross_chain.ts

@@ -8,17 +8,15 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
  * @param l1ToL2MessageHash - Hash of the L1 to L2 message
  * @param opts - Options
  */
-export async function waitForL1ToL2MessageReady(
-  node: Pick<AztecNode, 'getBlockNumber' | 'getL1ToL2MessageBlock'>,
+export function waitForL1ToL2MessageReady(
+  node: Pick<AztecNode, 'getBlock' | 'getL1ToL2MessageCheckpoint'>,
   l1ToL2MessageHash: Fr,
   opts: {
     /** Timeout for the operation in seconds */ timeoutSeconds: number;
-    /** True if the message is meant to be consumed from a public function */ forPublicConsumption: boolean;
   },
 ) {
-  const messageBlockNumber = await node.getL1ToL2MessageBlock(l1ToL2MessageHash);
   return retryUntil(
-    () => isL1ToL2MessageReady(node, l1ToL2MessageHash, { ...opts, messageBlockNumber }),
+    () => isL1ToL2MessageReady(node, l1ToL2MessageHash),
     `L1 to L2 message ${l1ToL2MessageHash.toString()} ready`,
     opts.timeoutSeconds,
     1,
@@ -29,25 +27,18 @@ export async function waitForL1ToL2MessageReady(
  * Returns whether the L1 to L2 message is ready to be consumed.
  * @param node - Aztec node instance used to obtain the information about the message
  * @param l1ToL2MessageHash - Hash of the L1 to L2 message
- * @param opts - Options
  * @returns True if the message is ready to be consumed, false otherwise
  */
 export async function isL1ToL2MessageReady(
-  node: Pick<AztecNode, 'getBlockNumber' | 'getL1ToL2MessageBlock'>,
+  node: Pick<AztecNode, 'getBlock' | 'getL1ToL2MessageCheckpoint'>,
   l1ToL2MessageHash: Fr,
-  opts: {
-    /** True if the message is meant to be consumed from a public function */ forPublicConsumption: boolean;
-    /** Cached synced block number for the message (will be fetched from PXE otherwise) */ messageBlockNumber?: number;
-  },
 ): Promise<boolean> {
-  const blockNumber = await node.getBlockNumber();
-  const messageBlockNumber = opts.messageBlockNumber ?? (await node.getL1ToL2MessageBlock(l1ToL2MessageHash));
-  if (messageBlockNumber === undefined) {
+  const messageCheckpointNumber = await node.getL1ToL2MessageCheckpoint(l1ToL2MessageHash);
+  if (messageCheckpointNumber === undefined) {
     return false;
   }
 
-  // Note that public messages can be consumed 1 block earlier, since the sequencer will include the messages
-  // in the L1 to L2 message tree before executing the txs for the block. In private, however, we need to wait
-  // until the message is included so we can make use of the membership witness.
-  return opts.forPublicConsumption ? blockNumber + 1 >= messageBlockNumber : blockNumber >= messageBlockNumber;
+  // L1 to L2 messages are included in the first block of a checkpoint
+  const latestBlock = await node.getBlock('latest');
+  return latestBlock !== undefined && latestBlock.checkpointNumber >= messageCheckpointNumber;
 }