@aztec/aztec.js 0.0.1-commit.29c6b1a3 → 0.0.1-commit.2c85e299c

package/src/contract/batch_call.ts

@@ -1,16 +1,13 @@
 import { type FunctionCall, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
-import {
-  ExecutionPayload,
-  TxSimulationResult,
-  UtilitySimulationResult,
-  mergeExecutionPayloads,
-} from '@aztec/stdlib/tx';
+import { ExecutionPayload, TxSimulationResult, UtilityExecutionResult, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import type { BatchedMethod, Wallet } from '../wallet/wallet.js';
 import { BaseContractInteraction } from './base_contract_interaction.js';
 import {
   type RequestInteractionOptions,
   type SimulateInteractionOptions,
+  emptyOffchainOutput,
+  extractOffchainOutput,
   toSimulateOptions,
 } from './interaction_options.js';
 
@@ -42,9 +39,9 @@ export class BatchCall extends BaseContractInteraction {
   }
 
   /**
-   * Simulates the batch, supporting private, public and utility functions. Although this is a single
+   * Simulates/executes the batch, supporting private, public and utility functions. Although this is a single
    * interaction with the wallet, private and public functions will be grouped into a single ExecutionPayload
-   * that the wallet will simulate as a single transaction. Utility function calls will simply be executed
+   * that the wallet will simulate as a single transaction. Utility function calls will be executed
    * one by one.
    * @param options - An optional object containing additional configuration for the interaction.
    * @returns The results of all the interactions that make up the batch
@@ -81,8 +78,8 @@ export class BatchCall extends BaseContractInteraction {
     // Add utility calls to batch
     for (const [call] of utility) {
       batchRequests.push({
-        name: 'simulateUtility' as const,
-        args: [call, options?.authWitnesses],
+        name: 'executeUtility' as const,
+        args: [call, { scope: options.from, authWitnesses: options.authWitnesses }],
       });
     }
 
@@ -111,9 +108,12 @@ export class BatchCall extends BaseContractInteraction {
     for (let i = 0; i < utility.length; i++) {
       const [call, resultIndex] = utility[i];
       const wrappedResult = batchResults[i];
-      if (wrappedResult.name === 'simulateUtility') {
-        const rawReturnValues = (wrappedResult.result as UtilitySimulationResult).result;
-        results[resultIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+      if (wrappedResult.name === 'executeUtility') {
+        const rawReturnValues = (wrappedResult.result as UtilityExecutionResult).result;
+        results[resultIndex] = {
+          result: rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [],
+          ...emptyOffchainOutput(),
+        };
       }
     }
 
@@ -132,7 +132,10 @@ export class BatchCall extends BaseContractInteraction {
               ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values
               : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
 
-          results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+          results[callIndex] = {
+            result: rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [],
+            ...extractOffchainOutput(simulatedTx.offchainEffects),
+          };
         });
       }
     }

package/src/contract/contract_function_interaction.ts

@@ -1,7 +1,18 @@
-import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi, encodeArguments } from '@aztec/stdlib/abi';
+import {
+  type ABIParameter,
+  type AbiType,
+  type FunctionAbi,
+  FunctionCall,
+  FunctionSelector,
+  FunctionType,
+  canBeMappedFromNullOrUndefined,
+  decodeFromAbi,
+  encodeArguments,
+  isOptionStruct,
+} from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type Capsule, type HashedValues, type TxProfileResult, collectOffchainEffects } from '@aztec/stdlib/tx';
+import type { Capsule, HashedValues, TxProfileResult } from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../wallet/wallet.js';
@@ -11,7 +22,9 @@ import {
   type ProfileInteractionOptions,
   type RequestInteractionOptions,
   type SimulateInteractionOptions,
-  type SimulationReturn,
+  type SimulationResult,
+  emptyOffchainOutput,
+  extractOffchainOutput,
   toProfileOptions,
   toSimulateOptions,
 } from './interaction_options.js';
@@ -31,11 +44,32 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     private extraHashedArgs: HashedValues[] = [],
   ) {
     super(wallet, authWitnesses, capsules);
-    if (args.some(arg => arg === undefined || arg === null)) {
-      throw new Error(`All function interaction arguments must be defined and not null. Received: ${args}`);
+    // This may feel a bit ad-hoc here, so it warrants a comment. We accept Noir Option<T> parameters, and it's natural
+    // to map JS's null/undefined to Noir Option's None. One possible way to deal with null/undefined arguments at this
+    // point in the codebase is to conclude that they are accepted since at least one Noir type (ie: Option) can be
+    // encoded from them. Then we would let `encode` deal with potential mismatches. I chose not to do that because of
+    // the pervasiveness of null/undefined in JS, and how easy it is to inadvertently pass it around. Having this check
+    // here allows us to fail at a point where the boundaries and intent are clear.
+    if (this.hasInvalidNullOrUndefinedArguments(args)) {
+      const signature = formatFunctionSignature(this.functionDao.name, this.functionDao.parameters);
+      const received = args.map(formatArg).join(', ');
+      throw new Error(
+        `Null or undefined arguments are only allowed for Option<T> parameters in ${signature}. Received: (${received}).`,
+      );
     }
   }
 
+  private hasInvalidNullOrUndefinedArguments(args: any[]) {
+    return args.some((arg, index) => {
+      if (arg !== undefined && arg !== null) {
+        return false;
+      }
+
+      const parameterType = this.functionDao.parameters[index]?.type;
+      return !parameterType || !canBeMappedFromNullOrUndefined(parameterType);
+    });
+  }
+
   /**
    * Returns the encoded function call wrapped by this interaction
    * Useful when generating authwits
@@ -43,16 +77,16 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    */
   public async getFunctionCall() {
     const args = encodeArguments(this.functionDao, this.args);
-    return {
+    return FunctionCall.from({
       name: this.functionDao.name,
-      args,
+      to: this.contractAddress,
       selector: await FunctionSelector.fromNameAndParameters(this.functionDao.name, this.functionDao.parameters),
       type: this.functionDao.functionType,
-      to: this.contractAddress,
-      isStatic: this.functionDao.isStatic,
       hideMsgSender: false /** Only set to `true` for enqueued public function calls */,
+      isStatic: this.functionDao.isStatic,
+      args,
       returnTypes: this.functionDao.returnTypes,
-    };
+    });
   }
 
   /**
@@ -90,21 +124,16 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    * function or a rich object containing extra metadata, such as estimated gas costs (if requested via options),
    * execution statistics and emitted offchain effects
    */
-  public async simulate<T extends SimulateInteractionOptions>(
-    options: T,
-  ): Promise<SimulationReturn<Exclude<T['fee'], undefined>['estimateGas']>>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  public async simulate<T extends SimulateInteractionOptions>(
-    options: T,
-  ): Promise<SimulationReturn<T['includeMetadata']>>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
   public async simulate(
-    options: SimulateInteractionOptions,
-  ): Promise<SimulationReturn<typeof options.includeMetadata>> {
+    options: SimulateInteractionOptions = {} as SimulateInteractionOptions,
+  ): Promise<SimulationResult> {
     // docs:end:simulate
     if (this.functionDao.functionType == FunctionType.UTILITY) {
       const call = await this.getFunctionCall();
-      const utilityResult = await this.wallet.simulateUtility(call, options.authWitnesses ?? []);
+      const utilityResult = await this.wallet.executeUtility(call, {
+        scope: options.from,
+        authWitnesses: options.authWitnesses,
+      });
 
       // Decode the raw field elements to the actual return type
       const returnValue = utilityResult.result ? decodeFromAbi(this.functionDao.returnTypes, utilityResult.result) : [];
@@ -112,11 +141,11 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       if (options.includeMetadata) {
         return {
           stats: utilityResult.stats,
+          ...emptyOffchainOutput(),
           result: returnValue,
         };
-      } else {
-        return returnValue;
       }
+      return { result: returnValue, ...emptyOffchainOutput() };
     }
 
     const executionPayload = await this.request(options);
@@ -138,6 +167,7 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     }
 
     const returnValue = rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
+    const offchainOutput = extractOffchainOutput(simulatedTx.offchainEffects);
 
     if (options.includeMetadata || options.fee?.estimateGas) {
       const { gasLimits, teardownGasLimits } = getGasLimits(simulatedTx, options.fee?.estimatedGasPadding);
@@ -146,13 +176,12 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       );
       return {
         stats: simulatedTx.stats,
-        offchainEffects: collectOffchainEffects(simulatedTx.privateExecutionResult),
+        ...offchainOutput,
         result: returnValue,
         estimatedGas: { gasLimits, teardownGasLimits },
       };
-    } else {
-      return returnValue;
     }
+    return { result: returnValue, ...offchainOutput };
   }
 
   /**
@@ -200,3 +229,62 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     );
   }
 }
+
+/**
+ *  Render an AbiType as a human readable string
+ * */
+function formatAbiType(abiType: AbiType): string {
+  switch (abiType.kind) {
+    case 'field':
+      return 'Field';
+    case 'boolean':
+      return 'bool';
+    case 'integer':
+      return `${abiType.sign === 'signed' ? 'i' : 'u'}${abiType.width}`;
+    case 'string':
+      return `str<${abiType.length}>`;
+    case 'array':
+      return `[${formatAbiType(abiType.type)}; ${abiType.length}]`;
+    case 'struct': {
+      if (isOptionStruct(abiType)) {
+        const innerType = abiType.fields.find(f => f.name === '_value')!.type;
+        return `Option<${formatAbiType(innerType)}>`;
+      }
+      return `(${abiType.fields.map(f => `${f.name}: ${formatAbiType(f.type)}`).join(', ')})`;
+    }
+    case 'tuple':
+      return `(${abiType.fields.map(formatAbiType).join(', ')})`;
+  }
+}
+
+/**
+ * Pretty print a function signature
+ */
+function formatFunctionSignature(name: string, parameters: ABIParameter[]): string {
+  const params = parameters.map(p => `${p.name}: ${formatAbiType(p.type)}`).join(', ');
+  return `${name}(${params})`;
+}
+
+/**
+ * Non-exhaustive pretty print of JS args to display in error messages in this module
+ */
+function formatArg(arg: unknown): string {
+  if (arg === undefined) {
+    return 'undefined';
+  }
+  if (arg === null) {
+    return 'null';
+  }
+  if (typeof arg === 'bigint') {
+    return `${arg}n`;
+  }
+  if (Array.isArray(arg)) {
+    return `[${arg.map(formatArg).join(', ')}]`;
+  }
+  if (typeof arg === 'object') {
+    const entries = Object.entries(arg).map(([k, v]) => `${k}: ${formatArg(v)}`);
+    return `{ ${entries.join(', ')} }`;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-base-to-string
+  return String(arg);
+}

package/src/contract/deploy_method.ts

@@ -9,12 +9,12 @@ import {
   getContractInstanceFromInstantiationParams,
 } from '@aztec/stdlib/contract';
 import type { PublicKeys } from '@aztec/stdlib/keys';
-import { type Capsule, TxHash, type TxProfileResult, type TxReceipt, collectOffchainEffects } from '@aztec/stdlib/tx';
+import { type Capsule, HashedValues, type TxProfileResult, type TxReceipt } from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import { publishContractClass } from '../deployment/publish_class.js';
 import { publishInstance } from '../deployment/publish_instance.js';
-import type { SendOptions, Wallet } from '../wallet/wallet.js';
+import type { ProfileOptions, SendOptions, SimulateOptions, Wallet } from '../wallet/wallet.js';
 import { BaseContractInteraction } from './base_contract_interaction.js';
 import type { ContractBase } from './contract_base.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
@@ -22,11 +22,15 @@ import { getGasLimits } from './get_gas_limits.js';
 import {
   NO_WAIT,
   type NoWait,
+  type OffchainOutput,
   type ProfileInteractionOptions,
   type RequestInteractionOptions,
   type SendInteractionOptionsWithoutWait,
   type SimulationInteractionFeeOptions,
-  type SimulationReturn,
+  type SimulationResult,
+  type TxSendResultImmediate,
+  type TxSendResultMined,
+  extractOffchainOutput,
   toProfileOptions,
   toSendOptions,
   toSimulateOptions,
@@ -82,7 +86,7 @@ export type DeployOptionsWithoutWait = Omit<RequestDeployOptions, 'deployer'> &
    * is mutually exclusive with "deployer"
    */
   universalDeploy?: boolean;
-} & Pick<SendInteractionOptionsWithoutWait, 'from' | 'fee'>;
+} & Pick<SendInteractionOptionsWithoutWait, 'from' | 'fee' | 'additionalScopes'>;
 
 /**
  * Extends the deployment options with the required parameters to send the transaction.
@@ -123,20 +127,32 @@ export type DeployTxReceipt<TContract extends ContractBase = ContractBase> = TxR
   instance: ContractInstanceWithAddress;
 };
 
+/** Wait options that request a full receipt instead of just the contract instance. */
+type WaitWithReturnReceipt = {
+  /** Request the full receipt instead of just the contract instance. */
+  returnReceipt: true;
+};
+
 /**
  * Represents the result type of deploying a contract.
  * - If wait is NO_WAIT, returns TxHash immediately.
  * - If wait has returnReceipt: true, returns DeployTxReceipt after waiting.
  * - Otherwise (undefined or DeployWaitOptions without returnReceipt), returns TContract after waiting.
  */
+/** Result of deploying a contract when waiting for mining (default case). */
+export type DeployResultMined<TContract extends ContractBase> = {
+  /** The deployed contract instance. */
+  contract: TContract;
+  /** The deploy transaction receipt. */
+  receipt: DeployTxReceipt<TContract>;
+} & OffchainOutput;
+
+/** Conditional return type for deploy based on wait options. */
 export type DeployReturn<TContract extends ContractBase, W extends DeployInteractionWaitOptions> = W extends NoWait
-  ? TxHash
-  : W extends {
-        // eslint-disable-next-line jsdoc/require-jsdoc
-        returnReceipt: true;
-      }
-    ? DeployTxReceipt<TContract>
-    : TContract;
+  ? TxSendResultImmediate
+  : W extends WaitWithReturnReceipt
+    ? TxSendResultMined<DeployTxReceipt<TContract>>
+    : DeployResultMined<TContract>;
 
 /**
  * Contract interaction for deployment.
@@ -164,6 +180,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
     constructorNameOrArtifact?: string | FunctionArtifact,
     authWitnesses: AuthWitness[] = [],
     capsules: Capsule[] = [],
+    private extraHashedArgs: HashedValues[] = [],
   ) {
     super(wallet, authWitnesses, capsules);
     this.constructorArtifact = getInitializer(artifact, constructorNameOrArtifact);
@@ -174,20 +191,29 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    * @param options - Configuration options.
    * @returns The execution payload for this operation
    */
-  public async request(options?: RequestDeployOptions): Promise<ExecutionPayload> {
+  public async request(options: RequestDeployOptions = {}): Promise<ExecutionPayload> {
     const publication = await this.getPublicationExecutionPayload(options);
 
     if (!options?.skipRegistration) {
       await this.wallet.registerContract(await this.getInstance(options), this.artifact);
     }
-
+    const { authWitnesses, capsules } = options;
+
+    // Propagates the included authwitnesses, capsules, and extraHashedArgs
+    // potentially baked into the interaction
+    const initialExecutionPayload = new ExecutionPayload(
+      [],
+      this.authWitnesses.concat(authWitnesses ?? []),
+      this.capsules.concat(capsules ?? []),
+      this.extraHashedArgs,
+    );
     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]);
+      ? mergeExecutionPayloads([initialExecutionPayload, feeExecutionPayload, publication, initialization])
+      : mergeExecutionPayloads([initialExecutionPayload, publication, initialization]);
     if (!finalExecutionPayload.calls.length) {
       throw new Error(`No transactions are needed to publish or initialize contract ${this.artifact.name}`);
     }
@@ -207,7 +233,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    * @param options - Deploy options with wait parameter
    * @returns Send options with wait parameter
    */
-  private convertDeployOptionsToSendOptions<W extends DeployInteractionWaitOptions>(
+  protected convertDeployOptionsToSendOptions<W extends DeployInteractionWaitOptions>(
     options: DeployOptions<W>,
     // eslint-disable-next-line jsdoc/require-jsdoc
   ): SendOptions<W extends { returnReceipt: true } ? WaitOpts : W> {
@@ -219,6 +245,24 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
     } as any;
   }
 
+  /**
+   * Converts deploy simulation options into wallet-level simulate options.
+   * @param options - The deploy simulation options to convert.
+   */
+  protected convertDeployOptionsToSimulateOptions(options: SimulateDeployOptions): SimulateOptions {
+    return toSimulateOptions(options);
+  }
+
+  /**
+   * Converts deploy profile options into wallet-level profile options.
+   * @param options - The deploy profile options to convert.
+   */
+  protected convertDeployOptionsToProfileOptions(
+    options: DeployOptionsWithoutWait & ProfileInteractionOptions,
+  ): ProfileOptions {
+    return toProfileOptions(options);
+  }
+
   /**
    * Adds this contract to the wallet and returns the Contract object.
    * @param options - Deployment options.
@@ -308,8 +352,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    * @returns TxHash (if wait is NO_WAIT), TContract (if wait is undefined or doesn't have returnReceipt), or DeployTxReceipt (if wait.returnReceipt is true)
    */
   // Overload for when wait is not specified at all - returns the contract
-  public override send(options: DeployOptionsWithoutWait): Promise<TContract>;
-  // Generic overload for explicit wait values
+  public override send(options: DeployOptionsWithoutWait): Promise<DeployResultMined<TContract>>;
   // eslint-disable-next-line jsdoc/require-jsdoc
   public override send<W extends DeployInteractionWaitOptions>(
     options: DeployOptions<W>,
@@ -320,12 +363,15 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
     const sendOptions = this.convertDeployOptionsToSendOptions(options);
 
     if (options.wait === NO_WAIT) {
-      const txHash = await this.wallet.sendTx(executionPayload, sendOptions as SendOptions<NoWait>);
-      this.log.debug(`Sent deployment tx ${txHash.hash} of ${this.artifact.name} contract`);
-      return txHash;
+      const result = await this.wallet.sendTx(executionPayload, sendOptions as SendOptions<NoWait>);
+      this.log.debug(`Sent deployment tx ${result.txHash.hash} of ${this.artifact.name} contract`);
+      return result;
     }
 
-    const receipt = await this.wallet.sendTx(executionPayload, sendOptions as SendOptions<WaitOpts | undefined>);
+    const { receipt, ...offchainOutput } = await this.wallet.sendTx(
+      executionPayload,
+      sendOptions as SendOptions<WaitOpts | undefined>,
+    );
     this.log.debug(`Deployed ${this.artifact.name} contract in tx ${receipt.txHash}`);
 
     // Attach contract instance
@@ -334,10 +380,10 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
 
     // Return full receipt if requested, otherwise just the contract
     if (options.wait && typeof options.wait === 'object' && options.wait.returnReceipt) {
-      return { ...receipt, contract, instance };
+      return { receipt: { ...receipt, contract, instance }, ...offchainOutput };
     }
 
-    return contract;
+    return { contract, receipt, ...offchainOutput };
   }
 
   /**
@@ -366,9 +412,12 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    * @returns A simulation result object containing metadata of the execution, including gas
    * estimations (if requested via options), execution statistics and emitted offchain effects
    */
-  public async simulate(options: SimulateDeployOptions): Promise<SimulationReturn<true>> {
+  public async simulate(options: SimulateDeployOptions): Promise<SimulationResult> {
     const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
-    const simulatedTx = await this.wallet.simulateTx(executionPayload, toSimulateOptions(options));
+    const simulatedTx = await this.wallet.simulateTx(
+      executionPayload,
+      this.convertDeployOptionsToSimulateOptions(options),
+    );
 
     const { gasLimits, teardownGasLimits } = getGasLimits(simulatedTx, options.fee?.estimatedGasPadding);
     this.log.verbose(
@@ -376,7 +425,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
     );
     return {
       stats: simulatedTx.stats!,
-      offchainEffects: collectOffchainEffects(simulatedTx.privateExecutionResult),
+      ...extractOffchainOutput(simulatedTx.offchainEffects),
       result: undefined,
       estimatedGas: { gasLimits, teardownGasLimits },
     };
@@ -390,11 +439,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    */
   public async profile(options: DeployOptionsWithoutWait & ProfileInteractionOptions): Promise<TxProfileResult> {
     const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
-    return await this.wallet.profileTx(executionPayload, {
-      ...toProfileOptions(options),
-      profileMode: options.profileMode,
-      skipProofGeneration: options.skipProofGeneration,
-    });
+    return await this.wallet.profileTx(executionPayload, this.convertDeployOptionsToProfileOptions(options));
   }
 
   /** Return this deployment address. */

package/src/contract/get_gas_limits.ts

@@ -1,4 +1,4 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
+import { MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
 import { Gas } from '@aztec/stdlib/gas';
 import type { TxSimulationResult } from '@aztec/stdlib/tx';
 
@@ -23,8 +23,8 @@ export function getGasLimits(
   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');
+  if (gasLimits.l2Gas > MAX_PROCESSABLE_L2_GAS) {
+    throw new Error('Transaction consumes more l2 gas than the maximum processable gas');
   }
   return {
     gasLimits,