@aztec/aztec.js 0.80.0 → 0.82.0

package/src/contract/deploy_method.ts

@@ -1,3 +1,5 @@
+import type { ExecutionPayload } from '@aztec/entrypoints/payload';
+import { mergeExecutionPayloads } from '@aztec/entrypoints/payload';
 import type { Fr } from '@aztec/foundation/fields';
 import { type ContractArtifact, type FunctionAbi, type FunctionArtifact, getInitializer } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -11,10 +13,9 @@ import type { GasSettings } from '@aztec/stdlib/gas';
 import type { PublicKeys } from '@aztec/stdlib/keys';
 import type { TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/wallet.js';
 import { deployInstance } from '../deployment/deploy_instance.js';
 import { registerContractClass } from '../deployment/register_class.js';
-import { type ExecutionRequestInit, mergeExecutionRequestInits } from '../entrypoint/entrypoint.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
 import type { Contract } from './contract.js';
 import type { ContractBase } from './contract_base.js';
@@ -76,8 +77,9 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    */
   public async create(options: DeployOptions = {}): Promise<TxExecutionRequest> {
     const requestWithoutFee = await this.request(options);
-    const fee = await this.getFeeOptions({ ...requestWithoutFee, fee: options.fee });
-    return this.wallet.createTxExecutionRequest({ ...requestWithoutFee, fee });
+    const { fee: userFee, nonce, cancellable } = options;
+    const fee = await this.getFeeOptions(requestWithoutFee, userFee, { nonce, cancellable });
+    return this.wallet.createTxExecutionRequest(requestWithoutFee, fee, { nonce, cancellable });
   }
 
   // REFACTOR: Having a `request` method with different semantics than the ones in the other
@@ -91,12 +93,9 @@ 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<Omit<ExecutionRequestInit, 'fee'>> {
-    const deployment = await this.getDeploymentFunctionCalls(options);
+  public async request(options: DeployOptions = {}): Promise<ExecutionPayload> {
+    const deployment = await this.getDeploymentExecutionPayload(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,
@@ -105,15 +104,14 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     // once this tx has gone through.
     await this.wallet.registerContract({ artifact: this.artifact, instance: await this.getInstance(options) });
 
-    const bootstrap = await this.getInitializeFunctionCalls(options);
-
-    const requests = await Promise.all([...deployment, ...bootstrap].map(c => c.request()));
-    if (!requests.length) {
+    const bootstrap = await this.getInitializeExecutionPayload(options);
+    const exec = [deployment, bootstrap];
+    const fnCalls = exec.map(exec => exec.calls).flat();
+    if (!fnCalls.length) {
       throw new Error(`No function calls needed to deploy contract ${this.artifact.name}`);
     }
 
-    const { nonce, cancellable } = options;
-    return mergeExecutionRequestInits(requests, { nonce, cancellable });
+    return mergeExecutionPayloads(exec);
   }
 
   /**
@@ -127,12 +125,12 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   }
 
   /**
-   * Returns calls for registration of the class and deployment of the instance, depending on the provided options.
+   * Returns the execution payload 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 with potentially calls (and bytecode capsule) to the class registerer  and instance deployer.
    */
-  protected async getDeploymentFunctionCalls(options: DeployOptions = {}): Promise<ContractFunctionInteraction[]> {
-    const calls: ContractFunctionInteraction[] = [];
+  protected async getDeploymentExecutionPayload(options: DeployOptions = {}): Promise<ExecutionPayload> {
+    const calls: ExecutionPayload[] = [];
 
     // Set contract instance object so it's available for populating the DeploySendTx object
     const instance = await this.getInstance(options);
@@ -157,17 +155,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(registerContractClassInteraction);
+        calls.push(await registerContractClassInteraction.request());
       }
     }
 
     // Deploy the contract via the instance deployer.
     if (!options.skipPublicDeployment) {
       const deploymentInteraction = await deployInstance(this.wallet, instance);
-      calls.push(deploymentInteraction);
+      calls.push(await deploymentInteraction.request());
     }
 
-    return calls;
+    return mergeExecutionPayloads(calls);
   }
 
   /**
@@ -175,8 +173,8 @@ 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<ContractFunctionInteraction[]> {
-    const calls: ContractFunctionInteraction[] = [];
+  protected async getInitializeExecutionPayload(options: DeployOptions): Promise<ExecutionPayload> {
+    const executionsPayloads: ExecutionPayload[] = [];
     if (this.constructorArtifact && !options.skipInitialization) {
       const { address } = await this.getInstance(options);
       const constructorCall = new ContractFunctionInteraction(
@@ -185,9 +183,9 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
         this.constructorArtifact,
         this.args,
       );
-      calls.push(constructorCall);
+      executionsPayloads.push(await constructorCall.request());
     }
-    return calls;
+    return mergeExecutionPayloads(executionsPayloads);
   }
 
   /**

package/src/contract/deploy_proven_tx.ts

@@ -1,9 +1,8 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 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/wallet.js';
+import type { Wallet } from '../wallet/wallet.js';
 import type { Contract } from './contract.js';
 import { DeploySentTx } from './deploy_sent_tx.js';
 import { ProvenTx } from './proven_tx.js';
@@ -13,7 +12,7 @@ import { ProvenTx } from './proven_tx.js';
  */
 export class DeployProvenTx<TContract extends Contract = Contract> extends ProvenTx {
   constructor(
-    wallet: PXE | Wallet,
+    wallet: Wallet,
     tx: Tx,
     private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
     private instanceGetter: () => Promise<ContractInstanceWithAddress>,

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/wallet.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';
@@ -29,13 +29,13 @@ export class DeploySentTx<TContract extends Contract = Contract> extends SentTx
   private log = createLogger('aztecjs:deploy_sent_tx');
 
   constructor(
-    pxeOrWallet: PXE | Wallet,
+    wallet: Wallet,
     txHashPromise: 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, txHashPromise);
   }
 
   /**
@@ -62,9 +62,9 @@ export class DeploySentTx<TContract extends Contract = Contract> extends SentTx
   }
 
   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);
+    const isWallet = (pxeWalletOrNode: Wallet | AztecNode | PXE): pxeWalletOrNode is Wallet =>
+      !!(pxeWalletOrNode as Wallet).createTxExecutionRequest;
+    const contractWallet = wallet ?? (isWallet(this.pxeWalletOrNode) && this.pxeWalletOrNode);
     if (!contractWallet) {
       throw new Error(`A wallet is required for creating a contract instance`);
     }

package/src/contract/protocol_contracts.ts

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

package/src/contract/proven_tx.ts

@@ -1,14 +1,13 @@
-import type { PXE } from '@aztec/stdlib/interfaces/client';
 import { Tx } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/wallet.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { SentTx } from './sent_tx.js';
 
 /**
  * A proven transaction that can be sent to the network. Returned by the `prove` method of a contract interaction.
  */
 export class ProvenTx extends Tx {
-  constructor(protected wallet: PXE | Wallet, tx: Tx) {
+  constructor(protected wallet: Wallet, tx: Tx) {
     super(
       tx.data,
       tx.clientIvcProof,

package/src/contract/sent_tx.ts

@@ -1,22 +1,18 @@
 import { retryUntil } from '@aztec/foundation/retry';
 import type { FieldsOf } from '@aztec/foundation/types';
-import type { AztecNode, GetPublicLogsResponse, PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
 import { type TxHash, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
 
+import type { Wallet } from '../wallet/wallet.js';
+
 /** Options related to waiting for a tx. */
 export type WaitOpts = {
   /** The amount of time to ignore TxStatus.DROPPED receipts (in seconds) due to the presumption that it is being propagated by the p2p network. Defaults to 5. */
   ignoreDroppedReceiptsFor?: number;
   /** The maximum time (in seconds) to wait for the transaction to be mined. Defaults to 60. */
   timeout?: number;
-  /** The maximum time (in seconds) to wait for the transaction to be proven. Defaults to 600. */
-  provenTimeout?: number;
   /** The time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
   interval?: number;
-  /** Whether to wait for the tx to be proven. */
-  proven?: boolean;
-  /** Whether to include information useful for debugging/testing in the receipt. */
-  debug?: boolean;
   /** 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;
 };
@@ -24,9 +20,7 @@ export type WaitOpts = {
 export const DefaultWaitOpts: WaitOpts = {
   ignoreDroppedReceiptsFor: 5,
   timeout: 60,
-  provenTimeout: 600,
   interval: 1,
-  debug: false,
 };
 
 /**
@@ -34,7 +28,7 @@ export const DefaultWaitOpts: WaitOpts = {
  * its hash, receipt, and mining status.
  */
 export class SentTx {
-  constructor(protected pxeOrNode: PXE | AztecNode, protected txHashPromise: Promise<TxHash>) {}
+  constructor(protected pxeWalletOrNode: Wallet | AztecNode | PXE, protected txHashPromise: Promise<TxHash>) {}
 
   /**
    * Retrieves the transaction hash of the SentTx instance.
@@ -56,7 +50,7 @@ export class SentTx {
    */
   public async getReceipt(): Promise<TxReceipt> {
     const txHash = await this.getTxHash();
-    return await this.pxeOrNode.getTxReceipt(txHash);
+    return await this.pxeWalletOrNode.getTxReceipt(txHash);
   }
 
   /**
@@ -71,32 +65,9 @@ export class SentTx {
         `Transaction ${await this.getTxHash()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`,
       );
     }
-    if (opts?.proven && receipt.blockNumber !== undefined) {
-      await this.waitForProven(receipt.blockNumber, opts);
-    }
-    if (opts?.debug) {
-      const txHash = await this.getTxHash();
-      const { data: tx } = (await this.pxeOrNode.getTxEffect(txHash))!;
-      receipt.debugInfo = {
-        noteHashes: tx.noteHashes,
-        nullifiers: tx.nullifiers,
-        publicDataWrites: tx.publicDataWrites,
-        l2ToL1Msgs: tx.l2ToL1Msgs,
-      };
-    }
     return receipt;
   }
 
-  /**
-   * Gets public logs emitted by this tx.
-   * @remarks This function will wait for the tx to be mined if it hasn't been already.
-   * @returns The requested logs.
-   */
-  public async getPublicLogs(): Promise<GetPublicLogsResponse> {
-    await this.wait();
-    return this.pxeOrNode.getPublicLogs({ txHash: await this.getTxHash() });
-  }
-
   protected async waitForReceipt(opts?: WaitOpts): Promise<TxReceipt> {
     const txHash = await this.getTxHash();
     const startTime = Date.now();
@@ -104,7 +75,7 @@ export class SentTx {
 
     return await retryUntil(
       async () => {
-        const txReceipt = await this.pxeOrNode.getTxReceipt(txHash);
+        const txReceipt = await this.pxeWalletOrNode.getTxReceipt(txHash);
         // If receipt is not yet available, try again
         if (txReceipt.status === TxStatus.PENDING) {
           return undefined;
@@ -126,16 +97,4 @@ export class SentTx {
       opts?.interval ?? DefaultWaitOpts.interval,
     );
   }
-
-  protected async waitForProven(minedBlock: number, opts?: WaitOpts) {
-    return await retryUntil(
-      async () => {
-        const provenBlock = await this.pxeOrNode.getProvenBlockNumber();
-        return provenBlock >= minedBlock ? provenBlock : undefined;
-      },
-      'isProven',
-      opts?.provenTimeout ?? DefaultWaitOpts.provenTimeout,
-      opts?.interval ?? DefaultWaitOpts.interval,
-    );
-  }
 }

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 '../account/wallet.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractBase } from './contract_base.js';
 
 /** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */

package/src/contract/wait_for_proven.ts

@@ -0,0 +1,38 @@
+import { retryUntil } from '@aztec/foundation/retry';
+import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+
+import type { TxReceipt } from '../index.js';
+import { DefaultWaitOpts } from './sent_tx.js';
+
+/**
+ * Options for waiting for a transaction to be proven.
+ */
+export type WaitForProvenOpts = {
+  /** Time to wait for the tx to be proven before timing out */
+  provenTimeout?: number;
+  /** Ellapsed time between polls to the node */
+  interval?: number;
+};
+
+export const DefaultWaitForProvenOpts: WaitForProvenOpts = {
+  provenTimeout: 600,
+  interval: DefaultWaitOpts.interval,
+};
+
+/**
+ * Wait for a transaction to be proven by polling the node
+ */
+export async function waitForProven(pxeOrNode: PXE | AztecNode, receipt: TxReceipt, opts?: WaitForProvenOpts) {
+  if (!receipt.blockNumber) {
+    throw new Error(`Cannot wait for proven: receipt of tx ${receipt.txHash} does not have a block number`);
+  }
+  return await retryUntil(
+    async () => {
+      const provenBlock = await pxeOrNode.getProvenBlockNumber();
+      return provenBlock >= receipt.blockNumber! ? provenBlock : undefined;
+    },
+    'isProven',
+    opts?.provenTimeout ?? DefaultWaitForProvenOpts.provenTimeout,
+    opts?.interval ?? DefaultWaitForProvenOpts.interval,
+  );
+}

package/src/deployment/broadcast_function.ts

@@ -59,31 +59,31 @@ export async function broadcastPrivateFunction(
   const vkHash = await computeVerificationKeyHash(privateFunctionArtifact);
 
   const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.broadcast_private_function(
-    contractClass.id,
-    artifactMetadataHash,
-    unconstrainedFunctionsArtifactTreeRoot,
-    privateFunctionTreeSiblingPath,
-    privateFunctionTreeLeafIndex,
-    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-    artifactTreeLeafIndex,
-    // eslint-disable-next-line camelcase
-    { selector, metadata_hash: functionMetadataHash, vk_hash: vkHash },
-  );
-
   const bytecode = bufferAsFields(
     privateFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
   );
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      bytecode,
-    ),
-  );
-
-  return fn;
+  return registerer.methods
+    .broadcast_private_function(
+      contractClass.id,
+      artifactMetadataHash,
+      unconstrainedFunctionsArtifactTreeRoot,
+      privateFunctionTreeSiblingPath,
+      privateFunctionTreeLeafIndex,
+      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+      artifactTreeLeafIndex,
+      // eslint-disable-next-line camelcase
+      { selector, metadata_hash: functionMetadataHash, vk_hash: vkHash },
+    )
+    .with({
+      capsules: [
+        new Capsule(
+          ProtocolContractAddress.ContractClassRegisterer,
+          new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
+          bytecode,
+        ),
+      ],
+    });
 }
 
 /**
@@ -122,27 +122,27 @@ export async function broadcastUnconstrainedFunction(
   } = await createUnconstrainedFunctionMembershipProof(selector, artifact);
 
   const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.broadcast_unconstrained_function(
-    contractClass.id,
-    artifactMetadataHash,
-    privateFunctionsArtifactTreeRoot,
-    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-    artifactTreeLeafIndex,
-    // eslint-disable-next-line camelcase
-    { selector, metadata_hash: functionMetadataHash },
-  );
-
   const bytecode = bufferAsFields(
     unconstrainedFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
   );
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      bytecode,
-    ),
-  );
-
-  return fn;
+  return registerer.methods
+    .broadcast_unconstrained_function(
+      contractClass.id,
+      artifactMetadataHash,
+      privateFunctionsArtifactTreeRoot,
+      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+      artifactTreeLeafIndex,
+      // eslint-disable-next-line camelcase
+      { selector, metadata_hash: functionMetadataHash },
+    )
+    .with({
+      capsules: [
+        new Capsule(
+          ProtocolContractAddress.ContractClassRegisterer,
+          new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
+          bytecode,
+        ),
+      ],
+    });
 }

package/src/deployment/contract_deployer.ts

@@ -2,9 +2,9 @@ import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
-import type { Wallet } from '../account/wallet.js';
 import { Contract } from '../contract/contract.js';
 import { DeployMethod } from '../contract/deploy_method.js';
+import type { Wallet } from '../wallet/wallet.js';
 
 /**
  * A class for deploying contract.

package/src/deployment/register_class.ts

@@ -9,36 +9,23 @@ import type { ContractFunctionInteraction } from '../contract/contract_function_
 import { getRegistererContract } from '../contract/protocol_contracts.js';
 import type { Wallet } from '../wallet/index.js';
 
-const defaultEmitPublicBytecode =
-  // guard against `process` not being defined (e.g. in the browser)
-  typeof process === 'object' && typeof process.env === 'object'
-    ? ['1', 'true', 'yes', ''].includes(process.env.AZTEC_EMIT_PUBLIC_BYTECODE ?? '')
-    : true;
-
 /** Sets up a call to register a contract class given its artifact. */
 export async function registerContractClass(
   wallet: Wallet,
   artifact: ContractArtifact,
-  emitPublicBytecode = defaultEmitPublicBytecode,
 ): Promise<ContractFunctionInteraction> {
   const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
     await getContractClassFromArtifact(artifact);
   const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.register(
-    artifactHash,
-    privateFunctionsRoot,
-    publicBytecodeCommitment,
-    emitPublicBytecode,
-  );
 
   const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      encodedBytecode,
-    ),
-  );
-
-  return fn;
+  return registerer.methods.register(artifactHash, privateFunctionsRoot, publicBytecodeCommitment).with({
+    capsules: [
+      new Capsule(
+        ProtocolContractAddress.ContractClassRegisterer,
+        new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
+        encodedBytecode,
+      ),
+    ],
+  });
 }

package/src/entrypoint/default_multi_call_entrypoint.ts

@@ -1,10 +1,11 @@
+import { EncodedCallsForEntrypoint } from '@aztec/entrypoints/encoding';
+import type { EntrypointInterface, FeeOptions } from '@aztec/entrypoints/interfaces';
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import { type EntrypointInterface, EntrypointPayload, type ExecutionRequestInit } from './entrypoint.js';
-
 /**
  * Implementation for an entrypoint interface that can execute multiple function calls in a single transaction
  */
@@ -15,18 +16,24 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
     private address: AztecAddress = ProtocolContractAddress.MultiCallEntrypoint,
   ) {}
 
-  async createTxExecutionRequest(executions: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    const { fee, calls, authWitnesses = [], hashedArguments = [], capsules = [] } = executions;
-    const payload = await EntrypointPayload.fromAppExecution(calls);
+  async createTxExecutionRequest(exec: ExecutionPayload, fee: FeeOptions): Promise<TxExecutionRequest> {
+    // Initial request with calls, authWitnesses and capsules
+    const { calls, authWitnesses, capsules, extraHashedArgs } = exec;
+
+    // Encode the calls
+    const encodedCalls = await EncodedCallsForEntrypoint.fromAppExecution(calls);
+
+    // Obtain the entrypoint hashed args, built from the encoded calls
     const abi = this.getEntrypointAbi();
-    const entrypointHashedArgs = await HashedValues.fromValues(encodeArguments(abi, [payload]));
+    const entrypointHashedArgs = await HashedValues.fromValues(encodeArguments(abi, [encodedCalls]));
 
+    // Assemble the tx request
     const txRequest = TxExecutionRequest.from({
       firstCallArgsHash: entrypointHashedArgs.hash,
       origin: this.address,
       functionSelector: await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
       txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
-      argsOfCalls: [...payload.hashedArguments, ...hashedArguments, entrypointHashedArgs],
+      argsOfCalls: [...encodedCalls.hashedArguments, entrypointHashedArgs, ...extraHashedArgs],
       authWitnesses,
       capsules,
     });