@aztec/aztec.js 0.0.1-commit.24de95ac → 0.0.1-commit.2e2504e2

package/src/account/account_contract.ts

@@ -1,11 +1,11 @@
-import type { AuthWitnessProvider, ChainInfo } from '@aztec/entrypoints/interfaces';
-import { Fr } from '@aztec/foundation/fields';
+import type { AuthWitnessProvider } from '@aztec/entrypoints/interfaces';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import type { CompleteAddress } from '@aztec/stdlib/contract';
 import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
 import { deriveKeys } from '@aztec/stdlib/keys';
 
-import type { AccountInterface } from './interface.js';
+import type { Account } from './account.js';
 
 /**
  * An account contract instance. Knows its artifact, deployment arguments, how to create
@@ -31,14 +31,13 @@ export interface AccountContract {
   >;
 
   /**
-   * Returns the account interface for this account contract given an instance at the provided address.
-   * The account interface is responsible for assembling tx requests given requested function calls, and
+   * Returns the account implementation for this account contract given an instance at the provided address.
+   * The account is responsible for assembling tx requests given requested function calls, and
    * for creating signed auth witnesses given action identifiers (message hashes).
    * @param address - Address of this account contract.
-   * @param chainInfo - Chain id and version of the rollup where the account contract is initialized / published.
-   * @returns An account interface instance for creating tx requests and authorizing actions.
+   * @returns An account instance for creating tx requests and authorizing actions.
    */
-  getInterface(address: CompleteAddress, chainInfo: ChainInfo): AccountInterface;
+  getAccount(address: CompleteAddress): Account;
 
   /**
    * Returns the auth witness provider for the given address.

package/src/account/account_with_secret_key.ts

@@ -1,23 +1,48 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { CompleteAddress } from '@aztec/stdlib/contract';
+import type { GasSettings } from '@aztec/stdlib/gas';
 import { computeAddressSecret, deriveMasterIncomingViewingSecretKey } from '@aztec/stdlib/keys';
+import type { ExecutionPayload, TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import { BaseAccount } from './account.js';
-import type { Salt } from './index.js';
-import type { AccountInterface } from './interface.js';
+import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
+import type { Account, Salt } from './index.js';
 
 /**
- * Extends {@link Account} with the encryption private key. Not required for
+ * Extends {@link BaseAccount} with the encryption private key. Not required for
  * implementing the wallet interface but useful for testing purposes or exporting
  * an account to another pxe.
  */
-export class AccountWithSecretKey extends BaseAccount {
+export class AccountWithSecretKey implements Account {
   constructor(
-    account: AccountInterface,
+    private account: Account,
     private secretKey: Fr,
     /** Deployment salt for this account contract. */
     public readonly salt: Salt,
-  ) {
-    super(account);
+  ) {}
+
+  createTxExecutionRequest(
+    exec: ExecutionPayload,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+    options?: any,
+  ): Promise<TxExecutionRequest> {
+    return this.account.createTxExecutionRequest(exec, gasSettings, chainInfo, options);
+  }
+
+  wrapExecutionPayload(exec: ExecutionPayload, options?: any): Promise<ExecutionPayload> {
+    return this.account.wrapExecutionPayload(exec, options);
+  }
+  createAuthWit(intent: IntentInnerHash | CallIntent, chainInfo: ChainInfo): Promise<AuthWitness> {
+    return this.account.createAuthWit(intent, chainInfo);
+  }
+  getCompleteAddress(): CompleteAddress {
+    return this.account.getCompleteAddress();
+  }
+  getAddress(): AztecAddress {
+    return this.account.getAddress();
   }
 
   /** Returns the encryption private key associated with this account. */

package/src/account/index.ts

@@ -3,10 +3,11 @@
  *
  * @packageDocumentation
  */
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 export { type AccountContract, getAccountContractAddress } from './account_contract.js';
-export { type AccountInterface } from './interface.js';
+export { type Account, BaseAccount, type AuthorizationProvider } from './account.js';
+export { AccountWithSecretKey } from './account_with_secret_key.js';
 
 /** A contract deployment salt. */
 export type Salt = Fr | number | bigint;

package/src/account/signerless_account.ts

@@ -1,12 +1,11 @@
 import type { ChainInfo, EntrypointInterface } from '@aztec/entrypoints/interfaces';
 import { DefaultMultiCallEntrypoint } from '@aztec/entrypoints/multicall';
-import type { ExecutionPayload } from '@aztec/entrypoints/payload';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { CompleteAddress } from '@aztec/stdlib/contract';
 import type { GasSettings } from '@aztec/stdlib/gas';
-import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { ExecutionPayload, TxExecutionRequest } from '@aztec/stdlib/tx';
 
 import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
 import type { Account } from './account.js';
@@ -16,20 +15,25 @@ import type { Account } from './account.js';
  */
 export class SignerlessAccount implements Account {
   private entrypoint: EntrypointInterface;
-  constructor(chainInfo: ChainInfo) {
-    this.entrypoint = new DefaultMultiCallEntrypoint(chainInfo.chainId.toNumber(), chainInfo.version.toNumber());
+
+  constructor() {
+    this.entrypoint = new DefaultMultiCallEntrypoint();
   }
 
-  createTxExecutionRequest(exec: ExecutionPayload, gasSettings: GasSettings): Promise<TxExecutionRequest> {
-    return this.entrypoint.createTxExecutionRequest(exec, gasSettings);
+  createTxExecutionRequest(
+    exec: ExecutionPayload,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+  ): Promise<TxExecutionRequest> {
+    return this.entrypoint.createTxExecutionRequest(exec, gasSettings, chainInfo);
   }
 
-  getChainId(): Fr {
-    throw new Error('SignerlessAccount: Method getChainId not implemented.');
+  wrapExecutionPayload(exec: ExecutionPayload, options?: any): Promise<ExecutionPayload> {
+    return this.entrypoint.wrapExecutionPayload(exec, options);
   }
 
-  getVersion(): Fr {
-    throw new Error('SignerlessAccount: Method getVersion not implemented.');
+  createAuthWit(_intent: Fr | Buffer | IntentInnerHash | CallIntent): Promise<AuthWitness> {
+    throw new Error('SignerlessAccount: Method createAuthWit not implemented.');
   }
 
   getCompleteAddress(): CompleteAddress {
@@ -39,8 +43,4 @@ export class SignerlessAccount implements Account {
   getAddress(): AztecAddress {
     throw new Error('SignerlessAccount: Method getAddress not implemented.');
   }
-
-  createAuthWit(_intent: Fr | Buffer | IntentInnerHash | CallIntent): Promise<AuthWitness> {
-    throw new Error('SignerlessAccount: Method createAuthWit not implemented.');
-  }
 }

package/src/api/account.ts

@@ -1,6 +1,13 @@
-export { type AccountContract, type AccountInterface, type Salt, getAccountContractAddress } from '../account/index.js';
+export {
+  type Account,
+  type AccountContract,
+  AccountWithSecretKey,
+  BaseAccount,
+  type AuthorizationProvider,
+  getAccountContractAddress,
+  type Salt,
+} from '../account/index.js';
 export type { AuthWitnessProvider, ChainInfo } from '@aztec/entrypoints/interfaces';
+export { ChainInfoSchema } from '@aztec/entrypoints/interfaces';
 
-export { AccountWithSecretKey } from '../account/account_with_secret_key.js';
-export { type Account, BaseAccount } from '../account/account.js';
 export { SignerlessAccount } from '../account/signerless_account.js';

package/src/api/authorization.ts

@@ -2,6 +2,7 @@ export { AuthWitness } from '@aztec/stdlib/auth-witness';
 export {
   SetPublicAuthwitContractInteraction,
   type ContractFunctionInteractionCallIntent,
+  isContractFunctionInteractionCallIntent,
   getMessageHashFromIntent,
   computeAuthWitMessageHash,
   computeInnerAuthWitHashFromAction,

package/src/api/contract.ts

@@ -10,13 +10,21 @@
  * or can be queried via `simulate()`.
  *
  * ```ts
- * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send().deployed();
+ * // Deploy and get the contract instance directly (default behavior)
+ * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send({ from: accountAddress });
  * console.log(`Contract deployed at ${contract.address}`);
+ *
+ * // Or get the full receipt with contract and instance
+ * const receipt = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send({
+ *   from: accountAddress,
+ *   wait: { returnReceipt: true }
+ * });
+ * console.log(`Contract deployed at ${receipt.contract.address}`);
  * ```
  *
  * ```ts
- * const contract = await Contract.at(address, MyContractArtifact, wallet);
- * await contract.methods.mint(1000, owner).send().wait();
+ * const contract = Contract.at(address, MyContractArtifact, wallet);
+ * await contract.methods.mint(1000, owner).send({ from: accountAddress });
  * console.log(`Total supply is now ${await contract.methods.totalSupply().simulate()}`);
  * ```
  *
@@ -25,9 +33,8 @@
  * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
  * or obtaining the `request` for aggregating into a {@link BatchCall}.
  *
- * The result of `send`ing a transaction is a {@link SentTx} object, from which you can get the
- * transaction hash, or simply `wait` until the transaction is mined and the local PXE
- * has synchronized its changes.
+ * The `send` method returns a {@link TxReceipt} by default (waits for the transaction to be mined).
+ * If you pass `wait: NO_WAIT` in the options, it will return a {@link TxHash} immediately without waiting.
  *
  * @remarks If you are using typescript, consider using the
  * {@link https://docs.aztec.network/developers/aztec-nr/how_to_compile_contract#use-generated-interfaces | autogenerated type-safe interfaces}
@@ -39,26 +46,35 @@ export { Contract } from '../contract/contract.js';
 export { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
 
 export {
+  NO_WAIT,
+  type NoWait,
   type RequestInteractionOptions,
   type SendInteractionOptions,
   type ProfileInteractionOptions,
   type SimulateInteractionOptions,
   type InteractionFeeOptions,
+  type InteractionWaitOptions,
+  type GasSettingsOption,
+  type SendReturn,
+  type SimulationReturn,
   toProfileOptions,
   toSendOptions,
   toSimulateOptions,
 } from '../contract/interaction_options.js';
 
-export { DefaultWaitOpts, SentTx, type WaitOpts } from '../contract/sent_tx.js';
+export { DefaultWaitOpts, type WaitOpts } from '../contract/wait_opts.js';
 export { ContractBase, type ContractMethod, type ContractStorageLayout } from '../contract/contract_base.js';
 export { BatchCall } from '../contract/batch_call.js';
 export {
   type DeployOptions,
+  type DeployReturn,
+  type DeployTxReceipt,
+  type DeployWaitOptions,
+  type DeployInteractionWaitOptions,
   DeployMethod,
   type RequestDeployOptions,
   type SimulateDeployOptions,
 } from '../contract/deploy_method.js';
-export { DeploySentTx } from '../contract/deploy_sent_tx.js';
 export { waitForProven, type WaitForProvenOpts, DefaultWaitForProvenOpts } from '../contract/wait_for_proven.js';
 export { getGasLimits } from '../contract/get_gas_limits.js';
 

package/src/api/fields.ts

@@ -1 +1,2 @@
-export { Point, Fr, Fq, GrumpkinScalar } from '@aztec/foundation/fields';
+export { Fr, Fq } from '@aztec/foundation/curves/bn254';
+export { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';

package/src/api/keys.ts

@@ -1,8 +1,8 @@
 export { type PublicKey, PublicKeys } from '@aztec/stdlib/keys';
 export {
-  computeAppNullifierSecretKey,
+  computeAppNullifierHidingKey,
   deriveKeys,
   deriveMasterIncomingViewingSecretKey,
-  deriveMasterNullifierSecretKey,
+  deriveMasterNullifierHidingKey,
 } from '@aztec/stdlib/keys';
 export { generatePublicKey } from '../utils/pub_key.js';

package/src/api/node.ts

@@ -3,18 +3,22 @@
  *
  * The primary function is {@link createAztecNodeClient}, which creates a JSON-RPC client
  * that connects to a running Aztec node instance. Use {@link waitForNode} to wait for
- * the node to be ready before proceeding.
+ * the node to be ready before proceeding, and {@link waitForTx} to wait for a transaction
+ * to be mined.
  *
  * @example
  * ```ts
- * import { createAztecNodeClient, waitForNode } from '@aztec/aztec.js/node';
+ * import { createAztecNodeClient, waitForNode, waitForTx } from '@aztec/aztec.js/node';
  *
  * const node = createAztecNodeClient('http://localhost:8080');
  * await waitForNode(node);
  * const blockNumber = await node.getBlockNumber();
+ *
+ * // Wait for a transaction
+ * const receipt = await waitForTx(node, txHash);
  * ```
  *
  * @packageDocumentation
  */
-export { createAztecNodeClient, waitForNode, type AztecNode } from '../utils/node.js';
+export { createAztecNodeClient, waitForNode, waitForTx, type AztecNode } from '../utils/node.js';
 export { type NodeInfo } from '@aztec/stdlib/contract';

package/src/api/note.ts

@@ -1 +1 @@
-export { UniqueNote, Comparator, Note } from '@aztec/stdlib/note';
+export { Comparator, Note } from '@aztec/stdlib/note';

package/src/api/protocol.ts

@@ -1,2 +1,9 @@
 export { ProtocolContractAddress } from '@aztec/protocol-contracts';
 export { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+
+export { AuthRegistryContract } from '../contract/protocol_contracts/auth-registry.js';
+export { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
+export { ContractInstanceRegistryContract } from '../contract/protocol_contracts/contract-instance-registry.js';
+export { FeeJuiceContract } from '../contract/protocol_contracts/fee-juice.js';
+export { MultiCallEntrypointContract } from '../contract/protocol_contracts/multi-call-entrypoint.js';
+export { PublicChecksContract } from '../contract/protocol_contracts/public-checks.js';

package/src/api/tx.ts

@@ -1,11 +1,15 @@
 export {
   Tx,
   TxExecutionRequest,
+  TxExecutionResult,
   TxHash,
   TxReceipt,
   TxStatus,
+  SortedTxStatuses,
   Capsule,
   HashedValues,
   GlobalVariables,
   TxProfileResult,
+  ExecutionPayload,
+  mergeExecutionPayloads,
 } from '@aztec/stdlib/tx';

package/src/api/wallet.ts

@@ -1,7 +1,5 @@
 export {
   type Aliased,
-  type ContractInstanceAndArtifact,
-  type UserFeeOptions,
   type SimulateOptions,
   type ProfileOptions,
   type SendOptions,
@@ -11,24 +9,65 @@ export {
   type BatchedMethodResultWrapper,
   type BatchResults,
   type Wallet,
-  ContractInstantiationDataSchema,
+  type PrivateEvent,
+  type PrivateEventFilter,
+  type ContractMetadata,
+  type ContractClassMetadata,
+  AppCapabilitiesSchema,
+  WalletCapabilitiesSchema,
   FunctionCallSchema,
   ExecutionPayloadSchema,
-  UserFeeOptionsSchema,
+  GasSettingsOptionSchema,
   WalletSimulationFeeOptionSchema,
+  WaitOptsSchema,
   SendOptionsSchema,
   SimulateOptionsSchema,
   ProfileOptionsSchema,
-  InstanceDataSchema,
   MessageHashOrIntentSchema,
   BatchedMethodSchema,
-  ContractMetadataSchema,
-  ContractClassMetadataSchema,
   EventMetadataDefinitionSchema,
+  PrivateEventSchema,
+  PrivateEventFilterSchema,
+  ContractClassMetadataSchema,
+  ContractMetadataSchema,
   WalletSchema,
+  ContractFunctionPatternSchema,
+  AccountsCapabilitySchema,
+  GrantedAccountsCapabilitySchema,
+  ContractsCapabilitySchema,
+  GrantedContractsCapabilitySchema,
+  ContractClassesCapabilitySchema,
+  GrantedContractClassesCapabilitySchema,
+  SimulationCapabilitySchema,
+  GrantedSimulationCapabilitySchema,
+  TransactionCapabilitySchema,
+  GrantedTransactionCapabilitySchema,
+  DataCapabilitySchema,
+  GrantedDataCapabilitySchema,
+  CapabilitySchema,
+  GrantedCapabilitySchema,
 } from '../wallet/wallet.js';
 
-export { type FeeOptions, BaseWallet } from '../wallet/base_wallet.js';
+export {
+  type AppCapabilities,
+  type WalletCapabilities,
+  CAPABILITY_VERSION,
+  type Capability,
+  type GrantedCapability,
+  type ContractFunctionPattern,
+  type AccountsCapability,
+  type GrantedAccountsCapability,
+  type ContractsCapability,
+  type GrantedContractsCapability,
+  type ContractClassesCapability,
+  type GrantedContractClassesCapability,
+  type SimulationCapability,
+  type GrantedSimulationCapability,
+  type TransactionCapability,
+  type GrantedTransactionCapability,
+  type DataCapability,
+  type GrantedDataCapability,
+} from '../wallet/capabilities.js';
 
 export { AccountManager } from '../wallet/account_manager.js';
 

package/src/authorization/call_authorization_request.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { AuthorizationSelector, FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';

package/src/contract/base_contract_interaction.ts

@@ -1,11 +1,16 @@
-import type { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { createLogger } from '@aztec/foundation/log';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { Capsule } from '@aztec/stdlib/tx';
+import type { Capsule, ExecutionPayload, TxReceipt } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../wallet/wallet.js';
-import { type RequestInteractionOptions, type SendInteractionOptions, toSendOptions } from './interaction_options.js';
-import { SentTx } from './sent_tx.js';
+import {
+  type InteractionWaitOptions,
+  type RequestInteractionOptions,
+  type SendInteractionOptions,
+  type SendInteractionOptionsWithoutWait,
+  type SendReturn,
+  toSendOptions,
+} from './interaction_options.js';
 
 /**
  * Base class for an interaction with a contract, be it a deployment, a function call, or a batch.
@@ -31,20 +36,26 @@ export abstract class BaseContractInteraction {
   // docs:start:send
   /**
    * Sends a transaction to the contract function with the specified options.
-   * This function throws an error if called on a utility function.
-   * It creates and signs the transaction if necessary, and returns a SentTx instance,
-   * which can be used to track the transaction status, receipt, and events.
+   * By default, waits for the transaction to be mined and returns the receipt (or custom type).
    * @param options - An object containing 'from' property representing
-   * the AztecAddress of the sender and optional fee configuration
-   * @returns A SentTx instance for tracking the transaction status and information.
+   * the AztecAddress of the sender, optional fee configuration, and optional wait settings
+   * @returns TReturn (if wait is undefined/WaitOpts) or TxHash (if wait is NO_WAIT)
    */
-  public send(options: SendInteractionOptions): SentTx {
+  // Overload for when wait is not specified at all - returns TReturn
+  public send<TReturn = TxReceipt>(options: SendInteractionOptionsWithoutWait): Promise<TReturn>;
+  // Generic overload for explicit wait values
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public send<TReturn = TxReceipt, W extends InteractionWaitOptions = undefined>(
+    options: SendInteractionOptions<W>,
+  ): Promise<SendReturn<W, TReturn>>;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public async send<TReturn = TxReceipt>(
+    options: SendInteractionOptions<InteractionWaitOptions>,
+  ): Promise<SendReturn<typeof options.wait, TReturn>> {
     // docs:end:send
-    const sendTx = async () => {
-      const executionPayload = await this.request(options);
-      const sendOptions = await toSendOptions(options);
-      return this.wallet.sendTx(executionPayload, sendOptions);
-    };
-    return new SentTx(this.wallet, sendTx);
+    const executionPayload = await this.request(options);
+    const sendOptions = toSendOptions(options);
+
+    return (await this.wallet.sendTx(executionPayload, sendOptions as any)) as SendReturn<typeof options.wait, TReturn>;
   }
 }

package/src/contract/batch_call.ts

@@ -1,7 +1,12 @@
-import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
 import { type FunctionCall, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import {
+  ExecutionPayload,
+  TxSimulationResult,
+  UtilitySimulationResult,
+  mergeExecutionPayloads,
+} from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../wallet/wallet.js';
+import type { BatchedMethod, Wallet } from '../wallet/wallet.js';
 import { BaseContractInteraction } from './base_contract_interaction.js';
 import {
   type RequestInteractionOptions,
@@ -10,6 +15,7 @@ import {
 } from './interaction_options.js';
 
 /** A batch of function calls to be sent as a single transaction through a wallet. */
+// docs:start:batch_call_class
 export class BatchCall extends BaseContractInteraction {
   constructor(
     wallet: Wallet,
@@ -17,6 +23,7 @@ export class BatchCall extends BaseContractInteraction {
   ) {
     super(wallet);
   }
+  // docs:end:batch_call_class
 
   /**
    * Returns an execution request that represents this operation.
@@ -35,13 +42,12 @@ export class BatchCall extends BaseContractInteraction {
   }
 
   /**
-   * Simulate a transaction and get its return values
-   * Differs from prove in a few important ways:
-   * 1. It returns the values of the function execution
-   * 2. It supports `utility`, `private` and `public` functions
-   *
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns The result of the transaction as returned by the contract function.
+   * Simulates 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
+   * 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
    */
   public async simulate(options: SimulateInteractionOptions): Promise<any> {
     const { indexedExecutionPayloads, utility } = (await this.getExecutionPayloads()).reduce<{
@@ -70,52 +76,65 @@ export class BatchCall extends BaseContractInteraction {
       { indexedExecutionPayloads: [], utility: [], publicIndex: 0, privateIndex: 0 },
     );
 
-    const payloads = indexedExecutionPayloads.map(([request]) => request);
-    const combinedPayload = mergeExecutionPayloads(payloads);
-    const executionPayload = new ExecutionPayload(
-      combinedPayload.calls,
-      combinedPayload.authWitnesses.concat(options.authWitnesses ?? []),
-      combinedPayload.capsules.concat(options.capsules ?? []),
-      combinedPayload.extraHashedArgs,
-    );
+    const batchRequests: BatchedMethod[] = [];
+
+    // Add utility calls to batch
+    for (const [call] of utility) {
+      batchRequests.push({
+        name: 'simulateUtility' as const,
+        args: [call, options?.authWitnesses],
+      });
+    }
 
-    const utilityBatchPromise =
-      utility.length > 0
-        ? this.wallet.batch(
-            utility.map(([call]) => ({
-              name: 'simulateUtility' as const,
-              args: [call.name, call.args, call.to, options?.authWitnesses] as const,
-            })),
-          )
-        : Promise.resolve([]);
+    // Add tx simulation to batch if there are any private/public calls
+    if (indexedExecutionPayloads.length > 0) {
+      const payloads = indexedExecutionPayloads.map(([request]) => request);
+      const combinedPayload = mergeExecutionPayloads(payloads);
+      const executionPayload = new ExecutionPayload(
+        combinedPayload.calls,
+        combinedPayload.authWitnesses.concat(options.authWitnesses ?? []),
+        combinedPayload.capsules.concat(options.capsules ?? []),
+        combinedPayload.extraHashedArgs,
+      );
 
-    const [utilityBatchResults, simulatedTx] = await Promise.all([
-      utilityBatchPromise,
-      indexedExecutionPayloads.length > 0
-        ? this.wallet.simulateTx(executionPayload, await toSimulateOptions(options))
-        : Promise.resolve(),
-    ]);
+      batchRequests.push({
+        name: 'simulateTx' as const,
+        args: [executionPayload, toSimulateOptions(options)],
+      });
+    }
+
+    const batchResults = batchRequests.length > 0 ? await this.wallet.batch(batchRequests) : [];
 
     const results: any[] = [];
 
-    utilityBatchResults.forEach((wrappedResult, utilityIndex) => {
-      const [, originalIndex] = utility[utilityIndex];
-      results[originalIndex] = wrappedResult.result.result;
-    });
+    // Process utility results (they come first in batch results)
+    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 (simulatedTx) {
-      indexedExecutionPayloads.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.
-        const rawReturnValues =
-          call.type == FunctionType.PRIVATE
-            ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values
-            : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
+    // Process tx simulation result (it comes last if present)
+    if (indexedExecutionPayloads.length > 0) {
+      const txResultWrapper = batchResults[utility.length];
+      if (txResultWrapper.name === 'simulateTx') {
+        const simulatedTx = txResultWrapper.result as TxSimulationResult;
+        indexedExecutionPayloads.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.
+          const rawReturnValues =
+            call.type == FunctionType.PRIVATE
+              ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values
+              : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
 
-        results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
-      });
+          results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+        });
+      }
     }
 
     return results;