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

package/src/contract/deploy_method.ts

@@ -1,146 +1,173 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { type ContractArtifact, type FunctionArtifact, type FunctionCall, getInitializer } from '@aztec/stdlib/abi';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
+import { Fr } from '@aztec/foundation/fields';
+import { type ContractArtifact, type FunctionAbi, type FunctionArtifact, getInitializer } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
   type ContractInstanceWithAddress,
   computePartialAddress,
   getContractClassFromArtifact,
-  getContractInstanceFromDeployParams,
+  getContractInstanceFromInstantiationParams,
 } from '@aztec/stdlib/contract';
-import type { GasSettings } from '@aztec/stdlib/gas';
 import type { PublicKeys } from '@aztec/stdlib/keys';
-import type { Capsule, TxExecutionRequest } from '@aztec/stdlib/tx';
+import { type Capsule, type TxProfileResult, collectOffchainEffects } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/index.js';
-import { deployInstance } from '../deployment/deploy_instance.js';
-import { registerContractClass } from '../deployment/register_class.js';
-import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
-import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
+import { publishContractClass } from '../deployment/publish_class.js';
+import { publishInstance } from '../deployment/publish_instance.js';
+import type { Wallet } from '../wallet/wallet.js';
+import { BaseContractInteraction } from './base_contract_interaction.js';
 import type { Contract } from './contract.js';
 import type { ContractBase } from './contract_base.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
-import { DeployProvenTx } from './deploy_proven_tx.js';
 import { DeploySentTx } from './deploy_sent_tx.js';
+import { getGasLimits } from './get_gas_limits.js';
+import {
+  type ProfileInteractionOptions,
+  type RequestInteractionOptions,
+  type SendInteractionOptions,
+  type SimulationInteractionFeeOptions,
+  type SimulationReturn,
+  toProfileOptions,
+  toSendOptions,
+  toSimulateOptions,
+} from './interaction_options.js';
 
 /**
  * Options for deploying a contract on the Aztec network.
- * Allows specifying a contract address salt, and additional send method options.
+ * Allows specifying a contract address salt and different options to tweak contract publication
+ * and initialization
  */
-// docs:start:deploy_options
-export type DeployOptions = {
+export type RequestDeployOptions = RequestInteractionOptions & {
   /** An optional salt value used to deterministically calculate the contract address. */
   contractAddressSalt?: Fr;
-  /** Set to true to *not* include the sender in the address computation. */
-  universalDeploy?: boolean;
-  /** Skip contract class registration. */
-  skipClassRegistration?: boolean;
-  /** Skip public deployment, instead just privately initialize the contract. */
-  skipPublicDeployment?: boolean;
+  /**
+   * Deployer address that will be used for the deployed contract's address computation.
+   * If set to 0, the sender's address won't be mixed in
+   */
+  deployer?: AztecAddress;
+  /** Skip contract class publication. */
+  skipClassPublication?: boolean;
+  /** Skip publication, instead just privately initialize the contract. */
+  skipInstancePublication?: boolean;
   /** Skip contract initialization. */
   skipInitialization?: boolean;
-} & SendMethodOptions;
+};
+
+/**
+ * Extends the deployment options with the required parameters to send the transaction
+ */
+export type DeployOptions = Omit<RequestDeployOptions, 'deployer'> & {
+  /**
+   * Set to true to *not* include the sender in the address computation. This option
+   * is mutually exclusive with "deployer"
+   */
+  universalDeploy?: boolean;
+} & Pick<SendInteractionOptions, 'from' | 'fee'>;
 // docs:end:deploy_options
 // TODO(@spalladino): Add unit tests for this class!
 
 /**
- * Contract interaction for deployment. Handles class registration, public instance deployment,
- * and initialization of the contract. Extends the BaseContractInteraction class.
+ * Options for simulating the deployment of a contract
+ * Allows skipping certain validations and computing gas estimations
+ */
+export type SimulateDeployOptions = Omit<DeployOptions, 'fee'> & {
+  /** The fee options for the transaction. */
+  fee?: SimulationInteractionFeeOptions;
+  /** Simulate without checking for the validity of the resulting transaction,
+   * e.g. whether it emits any existing nullifiers. */
+  skipTxValidation?: boolean;
+  /** Whether to ensure the fee payer is not empty and has enough balance to pay for the fee. */
+  skipFeeEnforcement?: boolean;
+  /** Whether to include metadata such as offchain effects and performance statistics
+   * (e.g. timing information of the different circuits and oracles) in
+   * the simulation result, instead of just the return value of the function */
+  includeMetadata?: boolean;
+};
+
+/**
+ * Contract interaction for deployment.
+ * Handles class publication, instance publication, and initialization of the contract.
+ *
+ * Note that for some contracts, a tx is not required as part of its "creation":
+ * If there are no public functions, and if there are no initialization functions,
+ * then technically the contract has already been "created", and all of the contract's
+ * functions (private and utility) can be interacted-with immediately, without any
+ * "deployment tx".
+ *
+ * Extends the BaseContractInteraction class.
  */
 export class DeployMethod<TContract extends ContractBase = Contract> extends BaseContractInteraction {
   /** The contract instance to be deployed. */
   private instance?: ContractInstanceWithAddress = undefined;
 
   /** Constructor function to call. */
-  private constructorArtifact: FunctionArtifact | undefined;
+  private constructorArtifact: FunctionAbi | undefined;
 
   constructor(
     private publicKeys: PublicKeys,
     wallet: Wallet,
-    private artifact: ContractArtifact,
-    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
+    protected artifact: ContractArtifact,
+    protected postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
     private args: any[] = [],
     constructorNameOrArtifact?: string | FunctionArtifact,
+    authWitnesses: AuthWitness[] = [],
+    capsules: Capsule[] = [],
   ) {
-    super(wallet);
+    super(wallet, authWitnesses, capsules);
     this.constructorArtifact = getInitializer(artifact, constructorNameOrArtifact);
   }
 
   /**
-   * Create a contract deployment transaction, given the deployment options.
-   * This function internally calls `request()` and `sign()` methods to prepare
-   * the transaction for deployment. The resulting signed transaction can be
-   * later sent using the `send()` method.
-   *
-   * @param options - An object containing optional deployment settings, contractAddressSalt, and from.
-   * @returns A Promise resolving to an object containing the signed transaction data and other relevant information.
+   * Returns the execution payload that allows this operation to happen on chain.
+   * @param options - Configuration options.
+   * @returns The execution payload for this operation
    */
-  public async create(options: DeployOptions = {}): Promise<TxExecutionRequest> {
-    return this.wallet.createTxExecutionRequest(await this.request(options));
-  }
+  public async request(options?: RequestDeployOptions): Promise<ExecutionPayload> {
+    const publication = await this.getPublicationExecutionPayload(options);
 
-  // REFACTOR: Having a `request` method with different semantics than the ones in the other
-  // derived ContractInteractions is confusing. We should unify the flow of all ContractInteractions.
+    await this.wallet.registerContract(await this.getInstance(options), this.artifact);
 
-  /**
-   * Returns an array of function calls that represent this operation. Useful as a building
-   * block for constructing batch requests.
-   * @param options - Deployment options.
-   * @returns An array of function calls.
-   * @remarks This method does not have the same return type as the `request` in the ContractInteraction object,
-   * it returns a promise for an array instead of a function call directly.
-   */
-  public async request(options: DeployOptions = {}): Promise<ExecutionRequestInit> {
-    const deployment = await this.getDeploymentFunctionCalls(options);
-
-    // NOTE: MEGA HACK. Remove with #10007
-    // register the contract after generating deployment function calls in order to publicly register the class and (optioanlly) emit its bytecode
-    //
-    // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
-    // Note that we need to run this registerContract here so it's available when computeFeeOptionsFromEstimatedGas
-    // runs, since it needs the contract to have been registered in order to estimate gas for its initialization,
-    // in case the initializer is public. This hints at the need of having "transient" contracts scoped to a
-    // simulation, so we can run the simulation with a set of contracts, but only "commit" them to the wallet
-    // once this tx has gone through.
-    await this.wallet.registerContract({ artifact: this.artifact, instance: await this.getInstance(options) });
-
-    const bootstrap = await this.getInitializeFunctionCalls(options);
-
-    if (deployment.calls.length + bootstrap.calls.length === 0) {
-      throw new Error(`No function calls needed to deploy contract ${this.artifact.name}`);
+    const initialization = await this.getInitializationExecutionPayload(options);
+    const feeExecutionPayload = options?.fee?.paymentMethod
+      ? await options.fee.paymentMethod.getExecutionPayload()
+      : undefined;
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, publication, initialization])
+      : mergeExecutionPayloads([publication, initialization]);
+    if (!finalExecutionPayload.calls.length) {
+      throw new Error(`No transactions are needed to publish or initialize contract ${this.artifact.name}`);
     }
 
-    const calls = [...deployment.calls, ...bootstrap.calls];
-    const authWitnesses = [...(deployment.authWitnesses ?? []), ...(bootstrap.authWitnesses ?? [])];
-    const hashedArguments = [...(deployment.hashedArguments ?? []), ...(bootstrap.hashedArguments ?? [])];
-    const capsules = [...(deployment.capsules ?? []), ...(bootstrap.capsules ?? [])];
-    const { cancellable, nonce, fee: userFee } = options;
-
-    const request = { calls, authWitnesses, hashedArguments, capsules, cancellable, fee: userFee, nonce };
+    return finalExecutionPayload;
+  }
 
-    const fee = await this.getFeeOptions(request);
-    return { ...request, fee };
+  convertDeployOptionsToRequestOptions(options: DeployOptions): RequestDeployOptions {
+    return {
+      ...options,
+      deployer: !options?.universalDeploy ? options.from : undefined,
+    };
   }
 
   /**
-   * Register this contract in the PXE and returns the Contract object.
+   * Adds this contract to the wallet and returns the Contract object.
    * @param options - Deployment options.
    */
-  public async register(options: DeployOptions = {}): Promise<TContract> {
+  public async register(options?: RequestDeployOptions): Promise<TContract> {
     const instance = await this.getInstance(options);
-    await this.wallet.registerContract({ artifact: this.artifact, instance });
+    await this.wallet.registerContract(instance, this.artifact);
     return this.postDeployCtor(instance.address, this.wallet);
   }
 
   /**
-   * Returns calls for registration of the class and deployment of the instance, depending on the provided options.
-   * @param options - Deployment options.
-   * @returns A function call array with potentially requests to the class registerer and instance deployer.
+   * Returns an execution payload for:
+   * - publication of the contract class and
+   * - publication of the contract instance to enable public execution
+   * depending on the provided options.
+   * @param options - Contract creation options.
+   * @returns An execution payload with potentially calls (and bytecode capsule) to the class registry and instance registry.
    */
-  protected async getDeploymentFunctionCalls(
-    options: DeployOptions = {},
-  ): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments' | 'capsules'>> {
-    const calls: FunctionCall[] = [];
-    const capsules: Capsule[] = [];
+  protected async getPublicationExecutionPayload(options?: RequestDeployOptions): Promise<ExecutionPayload> {
+    const calls: ExecutionPayload[] = [];
 
     // Set contract instance object so it's available for populating the DeploySendTx object
     const instance = await this.getInstance(options);
@@ -154,30 +181,31 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
       );
     }
 
-    // Register the contract class if it hasn't been published already.
-    if (!options.skipClassRegistration) {
+    // Publish the contract class if it hasn't been published already.
+    if (!options?.skipClassPublication) {
       if ((await this.wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
         this.log.debug(
-          `Skipping registration of already registered contract class ${contractClass.id.toString()} for ${instance.address.toString()}`,
+          `Skipping publication of already-registered contract class ${contractClass.id.toString()} for ${instance.address.toString()}`,
         );
       } else {
         this.log.info(
-          `Creating request for registering contract class ${contractClass.id.toString()} as part of deployment for ${instance.address.toString()}`,
+          `Creating request for publishing contract class ${contractClass.id.toString()} as part of deployment for ${instance.address.toString()}`,
         );
-        const registerContractClassInteraction = await registerContractClass(this.wallet, this.artifact);
+        const registerContractClassInteraction = await publishContractClass(this.wallet, this.artifact);
         calls.push(await registerContractClassInteraction.request());
-        capsules.push(...registerContractClassInteraction.getCapsules());
       }
     }
 
-    // Deploy the contract via the instance deployer.
-    if (!options.skipPublicDeployment) {
-      const deploymentInteraction = await deployInstance(this.wallet, instance);
+    // Publish the contract instance:
+    if (!options?.skipInstancePublication) {
+      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/15596):
+      // Read the artifact, and if there are no public functions, warn the caller that publication of the
+      // contract instance is not necessary (until such time as they wish to update the instance (i.e. change its class_id)).
+      const deploymentInteraction = await publishInstance(this.wallet, instance);
       calls.push(await deploymentInteraction.request());
-      capsules.push(...deploymentInteraction.getCapsules());
     }
 
-    return { calls, capsules };
+    return mergeExecutionPayloads(calls);
   }
 
   /**
@@ -185,78 +213,94 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - Deployment options.
    * @returns - An array of function calls.
    */
-  protected async getInitializeFunctionCalls(
-    options: DeployOptions,
-  ): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments' | 'capsules'>> {
-    const { address } = await this.getInstance(options);
-    const calls: FunctionCall[] = [];
-    const capsules: Capsule[] = [];
-    if (this.constructorArtifact && !options.skipInitialization) {
+  protected async getInitializationExecutionPayload(options?: RequestDeployOptions): Promise<ExecutionPayload> {
+    const executionsPayloads: ExecutionPayload[] = [];
+    if (this.constructorArtifact && !options?.skipInitialization) {
+      const { address } = await this.getInstance(options);
       const constructorCall = new ContractFunctionInteraction(
         this.wallet,
         address,
         this.constructorArtifact,
         this.args,
       );
-      calls.push(await constructorCall.request());
-      capsules.push(...constructorCall.getCapsules());
+      executionsPayloads.push(await constructorCall.request());
     }
-    return { calls, capsules };
+    return mergeExecutionPayloads(executionsPayloads);
   }
 
   /**
-   * Send the contract deployment transaction using the provided options.
+   * Send a contract deployment transaction (initialize and/or publish) using the provided options.
    * This function extends the 'send' method from the ContractFunctionInteraction class,
    * allowing us to send a transaction specifically for contract deployment.
    *
    * @param options - An object containing various deployment options such as contractAddressSalt and from.
    * @returns A SentTx object that returns the receipt and the deployed contract instance.
    */
-  public override send(options: DeployOptions = {}): DeploySentTx<TContract> {
-    const txHashPromise = super.send(options).getTxHash();
+  public override send(options: DeployOptions): DeploySentTx<TContract> {
+    const sendTx = async () => {
+      const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
+      const sendOptions = await toSendOptions(options);
+      return this.wallet.sendTx(executionPayload, sendOptions);
+    };
     this.log.debug(`Sent deployment tx of ${this.artifact.name} contract`);
-    return new DeploySentTx(this.wallet, txHashPromise, this.postDeployCtor, () => this.getInstance(options));
+    return new DeploySentTx(this.wallet, sendTx, this.postDeployCtor, () => this.getInstance(options));
   }
 
   /**
-   * Builds the contract instance to be deployed and returns it.
+   * Builds the contract instance and returns it.
    *
-   * @param options - An object containing various deployment options.
+   * @param options - An object containing various initialization and publication options.
    * @returns An instance object.
    */
-  public async getInstance(options: DeployOptions = {}): Promise<ContractInstanceWithAddress> {
+  public async getInstance(options?: RequestDeployOptions): Promise<ContractInstanceWithAddress> {
     if (!this.instance) {
-      this.instance = await getContractInstanceFromDeployParams(this.artifact, {
+      this.instance = await getContractInstanceFromInstantiationParams(this.artifact, {
         constructorArgs: this.args,
-        salt: options.contractAddressSalt,
+        salt: options?.contractAddressSalt ?? Fr.random(),
         publicKeys: this.publicKeys,
         constructorArtifact: this.constructorArtifact,
-        deployer: options.universalDeploy ? AztecAddress.ZERO : this.wallet.getAddress(),
+        deployer: options?.deployer ? options.deployer : AztecAddress.ZERO,
       });
     }
     return this.instance;
   }
 
   /**
-   * Prove the request.
-   * @param options - Deployment options.
-   * @returns The proven tx.
+   * Simulate the deployment
+   *
+   * @param options - An optional object containing additional configuration for the simulation.
+   * @returns A simulation result object containing metadata of the execution, including gas
+   * estimations (if requested via options), execution statistics and emitted offchain effects
    */
-  public override async prove(options: DeployOptions): Promise<DeployProvenTx<TContract>> {
-    const txProvingResult = await this.proveInternal(options);
-    return new DeployProvenTx(this.wallet, txProvingResult.toTx(), this.postDeployCtor, () =>
-      this.getInstance(options),
+  public async simulate(options: SimulateDeployOptions): Promise<SimulationReturn<true>> {
+    const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
+    const simulatedTx = await this.wallet.simulateTx(executionPayload, await toSimulateOptions(options));
+
+    const { gasLimits, teardownGasLimits } = getGasLimits(simulatedTx, options.fee?.estimatedGasPadding);
+    this.log.verbose(
+      `Estimated gas limits for tx: DA=${gasLimits.daGas} L2=${gasLimits.l2Gas} teardownDA=${teardownGasLimits.daGas} teardownL2=${teardownGasLimits.l2Gas}`,
     );
+    return {
+      stats: simulatedTx.stats!,
+      offchainEffects: collectOffchainEffects(simulatedTx.privateExecutionResult),
+      result: undefined,
+      estimatedGas: { gasLimits, teardownGasLimits },
+    };
   }
 
   /**
-   * Estimates gas cost for this deployment operation.
-   * @param options - Options.
+   * Simulate a deployment and profile the gate count for each function in the transaction.
+   * @param options - Same options as `send`, plus extra profiling options.
+   *
+   * @returns An object containing the function return value and profile result.
    */
-  public override estimateGas(
-    options?: Omit<DeployOptions, 'estimateGas' | 'skipPublicSimulation'>,
-  ): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>> {
-    return super.estimateGas(options);
+  public async profile(options: DeployOptions & ProfileInteractionOptions): Promise<TxProfileResult> {
+    const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
+    return await this.wallet.profileTx(executionPayload, {
+      ...(await toProfileOptions(options)),
+      profileMode: options.profileMode,
+      skipProofGeneration: options.skipProofGeneration,
+    });
   }
 
   /** Return this deployment address. */
@@ -268,4 +312,30 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   public get partialAddress() {
     return this.instance && computePartialAddress(this.instance);
   }
+
+  /**
+   * Augments this DeployMethod with additional metadata, such as authWitnesses and capsules.
+   * @param options - An object containing the metadata to add to the interaction
+   * @returns A new DeployMethod with the added metadata, but calling the same original function in the same manner
+   */
+  public with({
+    authWitnesses = [],
+    capsules = [],
+  }: {
+    /** The authWitnesses to add to the deployment */
+    authWitnesses?: AuthWitness[];
+    /** The capsules to add to the deployment */
+    capsules?: Capsule[];
+  }): DeployMethod {
+    return new DeployMethod(
+      this.publicKeys,
+      this.wallet,
+      this.artifact,
+      this.postDeployCtor,
+      this.args,
+      this.constructorArtifact?.name,
+      this.authWitnesses.concat(authWitnesses),
+      this.capsules.concat(capsules),
+    );
+  }
 }

package/src/contract/deploy_sent_tx.ts

@@ -2,10 +2,9 @@ import { createLogger } from '@aztec/foundation/log';
 import type { FieldsOf } from '@aztec/foundation/types';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
 import type { TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 import type { Contract } from './contract.js';
 import type { ContractBase } from './contract_base.js';
 import { SentTx, type WaitOpts } from './sent_tx.js';
@@ -23,19 +22,19 @@ export type DeployTxReceipt<TContract extends ContractBase = Contract> = FieldsO
 };
 
 /**
- * A contract deployment transaction sent to the network, extending SentTx with methods to create a contract instance.
+ * A contract deployment transaction sent to the network, extending SentTx with methods to publish a contract instance.
  */
 export class DeploySentTx<TContract extends Contract = Contract> extends SentTx {
   private log = createLogger('aztecjs:deploy_sent_tx');
 
   constructor(
-    pxeOrWallet: PXE | Wallet,
-    txHashPromise: Promise<TxHash>,
+    wallet: Wallet,
+    sendTx: () => Promise<TxHash>,
     private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
     /** A getter for the deployed contract instance */
     public instanceGetter: () => Promise<ContractInstanceWithAddress>,
   ) {
-    super(pxeOrWallet, txHashPromise);
+    super(wallet, sendTx);
   }
 
   /**
@@ -57,18 +56,13 @@ export class DeploySentTx<TContract extends Contract = Contract> extends SentTx
    */
   public override async wait(opts?: DeployedWaitOpts): Promise<DeployTxReceipt<TContract>> {
     const receipt = await super.wait(opts);
-    const contract = await this.getContractObject(opts?.wallet);
-    return { ...receipt, contract };
-  }
-
-  protected async getContractObject(wallet?: Wallet): Promise<TContract> {
-    const isWallet = (pxeOrWallet: PXE | Wallet | AztecNode): pxeOrWallet is Wallet =>
-      !!(pxeOrWallet as Wallet).createTxExecutionRequest;
-    const contractWallet = wallet ?? (isWallet(this.pxeOrNode) && this.pxeOrNode);
+    // In the case of DeploySentTx we have a guarantee that this.walletOrNode is a Wallet so we can cast it to Wallet.
+    const contractWallet = opts?.wallet ?? (this.walletOrNode as Wallet);
     if (!contractWallet) {
       throw new Error(`A wallet is required for creating a contract instance`);
     }
     const instance = await this.instanceGetter();
-    return this.postDeployCtor(instance.address, contractWallet) as Promise<TContract>;
+    const contract = (await this.postDeployCtor(instance.address, contractWallet)) as TContract;
+    return { ...receipt, contract };
   }
 }

package/src/contract/get_gas_limits.ts

@@ -1,9 +1,9 @@
-import type { Gas } from '@aztec/stdlib/gas';
+import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
+import { Gas } from '@aztec/stdlib/gas';
 import type { TxSimulationResult } from '@aztec/stdlib/tx';
 
 /**
  * Returns suggested total and teardown gas limits for a simulated tx.
- * Note that public gas usage is only accounted for if the publicOutput is present.
  * @param pad - Percentage to pad the suggested gas limits by, (as decimal, e.g., 0.10 for 10%).
  */
 export function getGasLimits(
@@ -11,16 +11,23 @@ export function getGasLimits(
   pad = 0.1,
 ): {
   /**
-   * Total gas used across private and public
+   * Gas limit for the tx, excluding teardown gas
    */
-  totalGas: Gas;
+  gasLimits: Gas;
   /**
-   * Teardown gas used
+   * Gas limit for the teardown phase
    */
-  teardownGas: Gas;
+  teardownGasLimits: Gas;
 } {
+  // Total gas does not use the teardown gas limit, but the actual total gas used by the tx.
+  const gasLimits = simulationResult.gasUsed.totalGas.mul(1 + pad);
+  const teardownGasLimits = simulationResult.gasUsed.teardownGas.mul(1 + pad);
+
+  if (gasLimits.l2Gas > AVM_MAX_PROCESSABLE_L2_GAS) {
+    throw new Error('Transaction consumes more gas than the AVM maximum processable gas');
+  }
   return {
-    totalGas: simulationResult.gasUsed.totalGas.mul(1 + pad),
-    teardownGas: simulationResult.gasUsed.teardownGas.mul(1 + pad),
+    gasLimits,
+    teardownGasLimits,
   };
 }