@aztec/aztec.js 0.78.1 → 0.80.0

package/src/{utils/index.ts → api/utils.ts}

@@ -1,4 +1,4 @@
-export { generatePublicKey } from './pub_key.js';
+export { generatePublicKey } from '../utils/pub_key.js';
 export {
   type AztecAddressLike,
   type EthAddressLike,
@@ -7,15 +7,15 @@ export {
   type FunctionSelectorLike,
   type U128Like,
   type WrappedFieldLike,
-} from './abi_types.js';
+} from '../utils/abi_types.js';
 export {
   computeAuthWitMessageHash,
   computeInnerAuthWitHash,
   computeInnerAuthWitHashFromAction,
   type IntentAction,
   type IntentInnerHash,
-} from './authwit.js';
-export { waitForPXE } from './pxe.js';
-export { waitForNode, createAztecNodeClient, type AztecNode } from './node.js';
-export { getFeeJuiceBalance } from './fee_juice.js';
-export { readFieldCompressedString } from './field_compressed_string.js';
+} from '../utils/authwit.js';
+export { waitForPXE } from '../utils/pxe.js';
+export { waitForNode, createAztecNodeClient, type AztecNode } from '../utils/node.js';
+export { getFeeJuiceBalance } from '../utils/fee_juice.js';
+export { readFieldCompressedString } from '../utils/field_compressed_string.js';

package/src/api/wallet.ts

@@ -1,7 +1 @@
-export {
-  AccountWallet,
-  AccountWalletWithSecretKey as AccountWalletWithSecretKey,
-  SignerlessWallet,
-  type Wallet,
-  getWallet,
-} from '../wallet/index.js';
+export { AccountWallet, AccountWalletWithSecretKey, SignerlessWallet, getWallet } from '../wallet/index.js';

package/src/contract/base_contract_interaction.ts

@@ -1,7 +1,8 @@
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { GasSettings } from '@aztec/stdlib/gas';
-import type { Capsule, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
+import type { Capsule, HashedValues, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../account/wallet.js';
 import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
@@ -33,7 +34,9 @@ export type SendMethodOptions = {
 export abstract class BaseContractInteraction {
   protected log = createLogger('aztecjs:contract_interaction');
 
-  private capsules: Capsule[] = [];
+  protected authWitnesses: AuthWitness[] = [];
+  protected hashedArguments: HashedValues[] = [];
+  protected capsules: Capsule[] = [];
 
   constructor(protected wallet: Wallet) {}
 
@@ -44,6 +47,14 @@ export abstract class BaseContractInteraction {
    */
   public abstract create(options?: SendMethodOptions): Promise<TxExecutionRequest>;
 
+  /**
+   * Returns an execution request that represents this operation.
+   * Can be used as a building block for constructing batch requests.
+   * @param options - An optional object containing additional configuration for the transaction.
+   * @returns An execution request wrapped in promise.
+   */
+  public abstract request(options?: SendMethodOptions): Promise<Omit<ExecutionRequestInit, 'fee'>>;
+
   /**
    * Creates a transaction execution request, simulates and proves it. Differs from .prove in
    * that its result does not include the wallet nor the composed tx object, but only the proving result.
@@ -167,6 +178,52 @@ export abstract class BaseContractInteraction {
     return { gasSettings, paymentMethod };
   }
 
+  /**
+   * Add authWitness used in this contract interaction.
+   * @param authWitness - authWitness used in the contract interaction.
+   */
+  public addAuthWitness(authWitness: AuthWitness) {
+    this.authWitnesses.push(authWitness);
+  }
+
+  /**
+   * Add authWitness used in this contract interaction.
+   * @param authWitnesses - authWitnesses used in the contract interaction.
+   */
+  public addAuthWitnesses(authWitnesses: AuthWitness[]) {
+    this.authWitnesses.push(...authWitnesses);
+  }
+
+  /**
+   * Return all authWitnesses added for this interaction.
+   */
+  public getAuthWitnesses() {
+    return this.authWitnesses;
+  }
+
+  /**
+   * Add hashedArgument used in this contract interaction.
+   * @param hashedArgument - hashedArgument used in the contract interaction.
+   */
+  public addHashedArgument(hashedArgument: HashedValues) {
+    this.hashedArguments.push(hashedArgument);
+  }
+
+  /**
+   * Add hashedArguments used in this contract interaction.
+   * @param hashedArguments - hashedArguments used in the contract interaction.
+   */
+  public addHashedArguments(hashedArguments: HashedValues[]) {
+    this.hashedArguments.push(...hashedArguments);
+  }
+
+  /**
+   * Return all hashedArguments added for this interaction.
+   */
+  public getHashedArguments() {
+    return this.hashedArguments;
+  }
+
   /**
    * Add data passed to the oracle calls during this contract interaction.
    * @param capsule - Data passed to oracle calls.
@@ -184,7 +241,7 @@ export abstract class BaseContractInteraction {
   }
 
   /**
-   * Return all capsules added for this function interaction.
+   * Return all capsules added for this contract interaction.
    */
   public getCapsules() {
     return this.capsules;

package/src/contract/batch_call.ts

@@ -1,27 +1,41 @@
 import { type FunctionCall, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
 import type { TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../account/wallet.js';
+import { type ExecutionRequestInit, mergeExecutionRequestInits } from '../entrypoint/entrypoint.js';
 import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
 import type { SimulateMethodOptions } from './contract_function_interaction.js';
 
 /** A batch of function calls to be sent as a single transaction through a wallet. */
 export class BatchCall extends BaseContractInteraction {
-  constructor(wallet: Wallet, protected calls: FunctionCall[]) {
+  constructor(wallet: Wallet, protected calls: BaseContractInteraction[]) {
     super(wallet);
   }
 
   /**
    * Create a transaction execution request that represents this batch, encoded and authenticated by the
    * user's wallet, ready to be simulated.
-   * @param opts - An optional object containing additional configuration for the transaction.
+   * @param options - An optional object containing additional configuration for the transaction.
    * @returns A Promise that resolves to a transaction instance.
    */
-  public async create(opts?: SendMethodOptions): Promise<TxExecutionRequest> {
-    const calls = this.calls;
-    const capsules = this.getCapsules();
-    const fee = await this.getFeeOptions({ calls, capsules, ...opts });
-    return await this.wallet.createTxExecutionRequest({ calls, capsules, ...opts, fee });
+  public async create(options: SendMethodOptions = {}): Promise<TxExecutionRequest> {
+    const requestWithoutFee = await this.request(options);
+
+    const { fee: userFee } = options;
+    const fee = await this.getFeeOptions({ ...requestWithoutFee, fee: userFee });
+
+    return await this.wallet.createTxExecutionRequest({ ...requestWithoutFee, fee });
+  }
+
+  /**
+   * Returns an execution request that represents this operation.
+   * @param options - An optional object containing additional configuration for the transaction.
+   * @returns An execution request wrapped in promise.
+   */
+  public async request(options: SendMethodOptions = {}): Promise<Omit<ExecutionRequestInit, 'fee'>> {
+    const requests = await this.getRequests();
+    const { nonce, cancellable } = options;
+    return mergeExecutionRequestInits(requests, { nonce, cancellable });
   }
 
   /**
@@ -34,35 +48,37 @@ export class BatchCall extends BaseContractInteraction {
    * @returns The result of the transaction as returned by the contract function.
    */
   public async simulate(options: SimulateMethodOptions = {}): Promise<any> {
-    const { indexedCalls, unconstrained } = this.calls.reduce<{
+    const { indexedRequests, unconstrained } = (await this.getRequests()).reduce<{
       /** Keep track of the number of private calls to retrieve the return values */
       privateIndex: 0;
       /** Keep track of the number of public calls to retrieve the return values */
       publicIndex: 0;
-      /** The public and private function calls in the batch */
-      indexedCalls: [FunctionCall, number, number][];
+      /** The public and private function execution requests in the batch */
+      indexedRequests: [Omit<ExecutionRequestInit, 'fee'>, number, number][];
       /** The unconstrained function calls in the batch. */
       unconstrained: [FunctionCall, number][];
     }>(
       (acc, current, index) => {
-        if (current.type === FunctionType.UNCONSTRAINED) {
-          acc.unconstrained.push([current, index]);
+        const call = current.calls[0];
+        if (call.type === FunctionType.UNCONSTRAINED) {
+          acc.unconstrained.push([call, index]);
         } else {
-          acc.indexedCalls.push([
+          acc.indexedRequests.push([
             current,
             index,
-            current.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++,
+            call.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++,
           ]);
         }
         return acc;
       },
-      { indexedCalls: [], unconstrained: [], publicIndex: 0, privateIndex: 0 },
+      { indexedRequests: [], unconstrained: [], publicIndex: 0, privateIndex: 0 },
     );
 
-    const calls = indexedCalls.map(([call]) => call);
-    const capsules = this.getCapsules();
-    const fee = await this.getFeeOptions({ calls, capsules, ...options });
-    const txRequest = await this.wallet.createTxExecutionRequest({ calls, capsules, ...options, fee });
+    const requests = indexedRequests.map(([request]) => request);
+    const requestWithoutFee = mergeExecutionRequestInits(requests);
+    const { fee: userFee } = options;
+    const fee = await this.getFeeOptions({ ...requestWithoutFee, fee: userFee });
+    const txRequest = await this.wallet.createTxExecutionRequest({ ...requestWithoutFee, fee });
 
     const unconstrainedCalls = unconstrained.map(
       async ([call, index]) =>
@@ -79,7 +95,8 @@ export class BatchCall extends BaseContractInteraction {
     unconstrainedResults.forEach(([result, index]) => {
       results[index] = result;
     });
-    indexedCalls.forEach(([call, callIndex, resultIndex]) => {
+    indexedRequests.forEach(([request, callIndex, resultIndex]) => {
+      const call = request.calls[0];
       // As account entrypoints are private, for private functions we retrieve the return values from the first nested call
       // since we're interested in the first set of values AFTER the account entrypoint
       // For public functions we retrieve the first values directly from the public output.
@@ -92,4 +109,29 @@ export class BatchCall extends BaseContractInteraction {
     });
     return results;
   }
+
+  /**
+   * Return all authWitnesses added for this interaction.
+   */
+  public override getAuthWitnesses() {
+    return [this.authWitnesses, ...this.calls.map(c => c.getAuthWitnesses())].flat();
+  }
+
+  /**
+   * Return all hashedArguments added for this interaction.
+   */
+  public override getHashedArguments() {
+    return [this.hashedArguments, ...this.calls.map(c => c.getHashedArguments())].flat();
+  }
+
+  /**
+   * Return all capsules added for this interaction.
+   */
+  public override getCapsules() {
+    return [this.capsules, ...this.calls.map(c => c.getCapsules())].flat();
+  }
+
+  private async getRequests() {
+    return await Promise.all(this.calls.map(c => c.request()));
+  }
 }

package/src/contract/checker.ts

@@ -1,4 +1,10 @@
-import type { AbiType, BasicType, ContractArtifact, StructType } from '@aztec/stdlib/abi';
+import {
+  type AbiType,
+  type BasicType,
+  type ContractArtifact,
+  type StructType,
+  getDefaultInitializer,
+} from '@aztec/stdlib/abi';
 
 /**
  * Represents a type derived from input type T with the 'kind' property removed.
@@ -38,8 +44,7 @@ export function abiChecker(artifact: ContractArtifact) {
     });
   });
 
-  // TODO: implement a better check for constructor (right now only checks if it has it or not)
-  if (!artifact.functions.find(func => func.name === 'constructor')) {
+  if (!getDefaultInitializer(artifact)) {
     throw new Error('ABI has no constructor');
   }
 

package/src/contract/contract.ts

@@ -3,7 +3,7 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../account/wallet.js';
 import { ContractBase } from './contract_base.js';
 import { DeployMethod } from './deploy_method.js';
 

package/src/contract/contract_base.ts

@@ -2,12 +2,13 @@ import {
   type ContractArtifact,
   type ContractNote,
   type FieldLayout,
-  type FunctionArtifact,
+  type FunctionAbi,
   FunctionSelector,
+  getAllFunctionAbis,
 } from '@aztec/stdlib/abi';
 import { type ContractInstanceWithAddress, computePartialAddress } from '@aztec/stdlib/contract';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../account/wallet.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
 
 /**
@@ -52,7 +53,7 @@ export class ContractBase {
     /** The wallet used for interacting with this contract. */
     public wallet: Wallet,
   ) {
-    artifact.functions.forEach((f: FunctionArtifact) => {
+    getAllFunctionAbis(artifact).forEach((f: FunctionAbi) => {
       const interactionFunction = (...args: any[]) => {
         return new ContractFunctionInteraction(this.wallet, this.instance.address, f, args);
       };

package/src/contract/contract_function_interaction.ts

@@ -1,16 +1,10 @@
-import {
-  type FunctionAbi,
-  FunctionCall,
-  FunctionSelector,
-  FunctionType,
-  decodeFromAbi,
-  encodeArguments,
-} from '@aztec/stdlib/abi';
+import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi, encodeArguments } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { PrivateKernelProverProfileResult } from '@aztec/stdlib/kernel';
 import type { TxExecutionRequest } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../account/wallet.js';
+import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
 import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
 import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
 
@@ -59,38 +53,54 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
   /**
    * Create a transaction execution request that represents this call, encoded and authenticated by the
    * user's wallet, ready to be simulated.
-   * @param opts - An optional object containing additional configuration for the transaction.
+   * @param options - An optional object containing additional configuration for the transaction.
    * @returns A Promise that resolves to a transaction instance.
    */
-  public async create(opts: SendMethodOptions = {}): Promise<TxExecutionRequest> {
+  public async create(options: SendMethodOptions = {}): Promise<TxExecutionRequest> {
     // docs:end:create
     if (this.functionDao.functionType === FunctionType.UNCONSTRAINED) {
       throw new Error("Can't call `create` on an unconstrained function.");
     }
-    const calls = [await this.request()];
-    const capsules = this.getCapsules();
-    const fee = await this.getFeeOptions({ calls, capsules, ...opts });
-    const { nonce, cancellable } = opts;
-    return await this.wallet.createTxExecutionRequest({ calls, fee, nonce, cancellable, capsules });
+    const requestWithoutFee = await this.request(options);
+
+    const { fee: userFee } = options;
+    const fee = await this.getFeeOptions({ ...requestWithoutFee, fee: userFee });
+
+    return await this.wallet.createTxExecutionRequest({ ...requestWithoutFee, fee });
   }
 
   // docs:start:request
   /**
-   * Returns an execution request that represents this operation. Useful as a building
-   * block for constructing batch requests.
+   * Returns an execution request that represents this operation.
+   * Can be used as a building block for constructing batch requests.
+   * @param options - An optional object containing additional configuration for the transaction.
    * @returns An execution request wrapped in promise.
    */
-  public async request(): Promise<FunctionCall> {
+  public async request(options: SendMethodOptions = {}): Promise<Omit<ExecutionRequestInit, 'fee'>> {
     // docs:end:request
     const args = encodeArguments(this.functionDao, this.args);
+    const calls = [
+      {
+        name: this.functionDao.name,
+        args,
+        selector: await FunctionSelector.fromNameAndParameters(this.functionDao.name, this.functionDao.parameters),
+        type: this.functionDao.functionType,
+        to: this.contractAddress,
+        isStatic: this.functionDao.isStatic,
+        returnTypes: this.functionDao.returnTypes,
+      },
+    ];
+    const authWitnesses = this.getAuthWitnesses();
+    const hashedArguments = this.getHashedArguments();
+    const capsules = this.getCapsules();
+    const { nonce, cancellable } = options;
     return {
-      name: this.functionDao.name,
-      args,
-      selector: await FunctionSelector.fromNameAndParameters(this.functionDao.name, this.functionDao.parameters),
-      type: this.functionDao.functionType,
-      to: this.contractAddress,
-      isStatic: this.functionDao.isStatic,
-      returnTypes: this.functionDao.returnTypes,
+      calls,
+      authWitnesses,
+      hashedArguments,
+      capsules,
+      nonce,
+      cancellable,
     };
   }
 

package/src/contract/deploy_method.ts

@@ -1,5 +1,5 @@
 import type { Fr } from '@aztec/foundation/fields';
-import { type ContractArtifact, type FunctionArtifact, type FunctionCall, getInitializer } from '@aztec/stdlib/abi';
+import { type ContractArtifact, type FunctionAbi, type FunctionArtifact, getInitializer } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
   type ContractInstanceWithAddress,
@@ -9,12 +9,12 @@ import {
 } 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 { TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../account/wallet.js';
 import { deployInstance } from '../deployment/deploy_instance.js';
 import { registerContractClass } from '../deployment/register_class.js';
-import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
+import { type ExecutionRequestInit, mergeExecutionRequestInits } from '../entrypoint/entrypoint.js';
 import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
 import type { Contract } from './contract.js';
 import type { ContractBase } from './contract_base.js';
@@ -51,7 +51,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   private instance?: ContractInstanceWithAddress = undefined;
 
   /** Constructor function to call. */
-  private constructorArtifact: FunctionArtifact | undefined;
+  private constructorArtifact: FunctionAbi | undefined;
 
   constructor(
     private publicKeys: PublicKeys,
@@ -75,7 +75,9 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @returns A Promise resolving to an object containing the signed transaction data and other relevant information.
    */
   public async create(options: DeployOptions = {}): Promise<TxExecutionRequest> {
-    return this.wallet.createTxExecutionRequest(await this.request(options));
+    const requestWithoutFee = await this.request(options);
+    const fee = await this.getFeeOptions({ ...requestWithoutFee, fee: options.fee });
+    return this.wallet.createTxExecutionRequest({ ...requestWithoutFee, fee });
   }
 
   // REFACTOR: Having a `request` method with different semantics than the ones in the other
@@ -89,7 +91,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @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> {
+  public async request(options: DeployOptions = {}): Promise<Omit<ExecutionRequestInit, 'fee'>> {
     const deployment = await this.getDeploymentFunctionCalls(options);
 
     // NOTE: MEGA HACK. Remove with #10007
@@ -105,20 +107,13 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
 
     const bootstrap = await this.getInitializeFunctionCalls(options);
 
-    if (deployment.calls.length + bootstrap.calls.length === 0) {
+    const requests = await Promise.all([...deployment, ...bootstrap].map(c => c.request()));
+    if (!requests.length) {
       throw new Error(`No function calls needed to deploy 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 };
-
-    const fee = await this.getFeeOptions(request);
-    return { ...request, fee };
+    const { nonce, cancellable } = options;
+    return mergeExecutionRequestInits(requests, { nonce, cancellable });
   }
 
   /**
@@ -136,11 +131,8 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - Deployment options.
    * @returns A function call array with potentially requests to the class registerer and instance deployer.
    */
-  protected async getDeploymentFunctionCalls(
-    options: DeployOptions = {},
-  ): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments' | 'capsules'>> {
-    const calls: FunctionCall[] = [];
-    const capsules: Capsule[] = [];
+  protected async getDeploymentFunctionCalls(options: DeployOptions = {}): Promise<ContractFunctionInteraction[]> {
+    const calls: ContractFunctionInteraction[] = [];
 
     // Set contract instance object so it's available for populating the DeploySendTx object
     const instance = await this.getInstance(options);
@@ -165,19 +157,17 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
           `Creating request for registering contract class ${contractClass.id.toString()} as part of deployment for ${instance.address.toString()}`,
         );
         const registerContractClassInteraction = await registerContractClass(this.wallet, this.artifact);
-        calls.push(await registerContractClassInteraction.request());
-        capsules.push(...registerContractClassInteraction.getCapsules());
+        calls.push(registerContractClassInteraction);
       }
     }
 
     // Deploy the contract via the instance deployer.
     if (!options.skipPublicDeployment) {
       const deploymentInteraction = await deployInstance(this.wallet, instance);
-      calls.push(await deploymentInteraction.request());
-      capsules.push(...deploymentInteraction.getCapsules());
+      calls.push(deploymentInteraction);
     }
 
-    return { calls, capsules };
+    return calls;
   }
 
   /**
@@ -185,23 +175,19 @@ 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[] = [];
+  protected async getInitializeFunctionCalls(options: DeployOptions): Promise<ContractFunctionInteraction[]> {
+    const calls: ContractFunctionInteraction[] = [];
     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());
+      calls.push(constructorCall);
     }
-    return { calls, capsules };
+    return calls;
   }
 
   /**

package/src/contract/deploy_proven_tx.ts

@@ -3,7 +3,7 @@ import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import type { PXE } from '@aztec/stdlib/interfaces/client';
 import type { Tx } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../account/wallet.js';
 import type { Contract } from './contract.js';
 import { DeploySentTx } from './deploy_sent_tx.js';
 import { ProvenTx } from './proven_tx.js';

package/src/contract/deploy_sent_tx.ts

@@ -5,7 +5,7 @@ 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 '../account/wallet.js';
 import type { Contract } from './contract.js';
 import type { ContractBase } from './contract_base.js';
 import { SentTx, type WaitOpts } from './sent_tx.js';

package/src/contract/protocol_contracts.ts

@@ -1,6 +1,6 @@
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 
-import type { Wallet } from '../wallet/index.js';
+import type { Wallet } from '../account/wallet.js';
 import { UnsafeContract } from './unsafe_contract.js';
 
 /** Returns a Contract wrapper for the class registerer. */

package/src/contract/proven_tx.ts

@@ -1,7 +1,7 @@
 import type { PXE } from '@aztec/stdlib/interfaces/client';
 import { Tx } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../account/wallet.js';
 import { SentTx } from './sent_tx.js';
 
 /**

package/src/contract/unsafe_contract.ts

@@ -1,7 +1,7 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
-import type { Wallet } from '../wallet/index.js';
+import type { Wallet } from '../account/wallet.js';
 import { ContractBase } from './contract_base.js';
 
 /** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */

package/src/entrypoint/entrypoint.ts

@@ -28,6 +28,27 @@ export type ExecutionRequestInit = {
   cancellable?: boolean;
 };
 
+/**
+ * Merges an array of ExecutionRequestInits.
+ */
+export function mergeExecutionRequestInits(
+  requests: Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments' | 'capsules'>[],
+  { nonce, cancellable }: Pick<ExecutionRequestInit, 'nonce' | 'cancellable'> = {},
+): Omit<ExecutionRequestInit, 'fee'> {
+  const calls = requests.map(r => r.calls).flat();
+  const authWitnesses = requests.map(r => r.authWitnesses ?? []).flat();
+  const hashedArguments = requests.map(r => r.hashedArguments ?? []).flat();
+  const capsules = requests.map(r => r.capsules ?? []).flat();
+  return {
+    calls,
+    authWitnesses,
+    hashedArguments,
+    capsules,
+    nonce,
+    cancellable,
+  };
+}
+
 /** Creates transaction execution requests out of a set of function calls. */
 export interface EntrypointInterface {
   /**

package/src/{api/ethereum → ethereum}/l1_contracts.ts

@@ -1,7 +1,7 @@
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { retryUntil } from '@aztec/foundation/retry';
 
-import { createPXEClient } from '../../rpc_clients/index.js';
+import { createPXEClient } from '../rpc_clients/pxe_client.js';
 
 export const getL1ContractAddresses = async (url: string): Promise<L1ContractAddresses> => {
   const pxeClient = createPXEClient(url, {});