@aztec/aztec.js 0.33.0 → 0.35.0

package/src/account_manager/deploy_account_sent_tx.ts

@@ -1,4 +1,4 @@
-import { type TxHash, type TxReceipt } from '@aztec/circuit-types';
+import { type PXE, type TxHash, type TxReceipt } from '@aztec/circuit-types';
 import { type FieldsOf } from '@aztec/foundation/types';
 
 import { type Wallet } from '../account/index.js';
@@ -15,8 +15,8 @@ export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {
  * A deployment transaction for an account contract sent to the network, extending SentTx with methods to get the resulting wallet.
  */
 export class DeployAccountSentTx extends SentTx {
-  constructor(private wallet: Wallet, txHashPromise: Promise<TxHash>) {
-    super(wallet, txHashPromise);
+  constructor(pxe: PXE, txHashPromise: Promise<TxHash>, private getWalletPromise: Promise<Wallet>) {
+    super(pxe, txHashPromise);
   }
 
   /**
@@ -36,7 +36,8 @@ export class DeployAccountSentTx extends SentTx {
    */
   public async wait(opts: WaitOpts = DefaultWaitOpts): Promise<DeployAccountTxReceipt> {
     const receipt = await super.wait(opts);
-    await waitForAccountSynch(this.pxe, this.wallet.getCompleteAddress(), opts);
-    return { ...receipt, wallet: this.wallet };
+    const wallet = await this.getWalletPromise;
+    await waitForAccountSynch(this.pxe, wallet.getCompleteAddress(), opts);
+    return { ...receipt, wallet };
   }
 }

package/src/account_manager/index.ts

@@ -6,14 +6,20 @@ import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { type AccountContract } from '../account/contract.js';
 import { type Salt } from '../account/index.js';
 import { type AccountInterface } from '../account/interface.js';
-import { type DeployMethod } from '../contract/deploy_method.js';
+import { type DeployOptions } from '../contract/deploy_method.js';
 import { DefaultWaitOpts, type WaitOpts } from '../contract/sent_tx.js';
-import { ContractDeployer } from '../deployment/contract_deployer.js';
+import { DefaultMultiCallEntrypoint } from '../entrypoint/default_multi_call_entrypoint.js';
 import { waitForAccountSynch } from '../utils/account.js';
 import { generatePublicKey } from '../utils/index.js';
 import { AccountWalletWithPrivateKey, SignerlessWallet } from '../wallet/index.js';
+import { DeployAccountMethod } from './deploy_account_method.js';
 import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
 
+/**
+ * Options to deploy an account contract.
+ */
+export type DeployAccountOptions = Pick<DeployOptions, 'fee' | 'skipClassRegistration' | 'skipPublicDeployment'>;
+
 /**
  * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
  * and creating and registering the user wallet in the PXE Service.
@@ -26,7 +32,7 @@ export class AccountManager {
   private completeAddress?: CompleteAddress;
   private instance?: ContractInstanceWithAddress;
   private encryptionPublicKey?: PublicKey;
-  private deployMethod?: DeployMethod;
+  private deployMethod?: DeployAccountMethod;
 
   constructor(
     private pxe: PXE,
@@ -34,7 +40,7 @@ export class AccountManager {
     private accountContract: AccountContract,
     salt?: Salt,
   ) {
-    this.salt = salt ? new Fr(salt) : Fr.random();
+    this.salt = salt !== undefined ? new Fr(salt) : Fr.random();
   }
 
   protected getEncryptionPublicKey() {
@@ -128,17 +134,22 @@ export class AccountManager {
       }
       await this.#register();
       const encryptionPublicKey = this.getEncryptionPublicKey();
-      // We use a signerless wallet so we hit the account contract directly and it deploys itself.
+      const { chainId, protocolVersion } = await this.pxe.getNodeInfo();
+      const deployWallet = new SignerlessWallet(this.pxe, new DefaultMultiCallEntrypoint(chainId, protocolVersion));
+
+      // We use a signerless wallet with the multi call entrypoint in order to make multiple calls in one go
       // If we used getWallet, the deployment would get routed via the account contract entrypoint
-      // instead of directly hitting the initializer.
-      const deployWallet = new SignerlessWallet(this.pxe);
-      const deployer = new ContractDeployer(
-        this.accountContract.getContractArtifact(),
-        deployWallet,
+      // and it can't be used unless the contract is initialized
+      const args = this.accountContract.getDeploymentArgs() ?? [];
+      this.deployMethod = new DeployAccountMethod(
+        this.accountContract.getAuthWitnessProvider(this.getCompleteAddress()),
         encryptionPublicKey,
+        deployWallet,
+        this.accountContract.getContractArtifact(),
+        args,
+        'constructor',
+        'entrypoint',
       );
-      const args = this.accountContract.getDeploymentArgs() ?? [];
-      this.deployMethod = deployer.deploy(...args);
     }
     return this.deployMethod;
   }
@@ -148,18 +159,23 @@ export class AccountManager {
    * Does not register the associated class nor publicly deploy the instance by default.
    * Uses the salt provided in the constructor or a randomly generated one.
    * Registers the account in the PXE Service before deploying the contract.
+   * @param opts - Fee options to be used for the deployment.
    * @returns A SentTx object that can be waited to get the associated Wallet.
    */
-  public async deploy(): Promise<DeployAccountSentTx> {
-    const deployMethod = await this.getDeployMethod();
-    const wallet = await this.getWallet();
-    const sentTx = deployMethod.send({
-      contractAddressSalt: this.salt,
-      skipClassRegistration: true,
-      skipPublicDeployment: true,
-      universalDeploy: true,
-    });
-    return new DeployAccountSentTx(wallet, sentTx.getTxHash());
+  public deploy(opts?: DeployAccountOptions): DeployAccountSentTx {
+    const sentTx = this.getDeployMethod()
+      .then(deployMethod =>
+        deployMethod.send({
+          contractAddressSalt: this.salt,
+          skipClassRegistration: opts?.skipClassRegistration ?? true,
+          skipPublicDeployment: opts?.skipPublicDeployment ?? true,
+          skipInitialization: false,
+          universalDeploy: true,
+          fee: opts?.fee,
+        }),
+      )
+      .then(tx => tx.getTxHash());
+    return new DeployAccountSentTx(this.pxe, sentTx, this.getWallet());
   }
 
   /**
@@ -170,7 +186,7 @@ export class AccountManager {
    * @returns A Wallet instance.
    */
   public async waitSetup(opts: WaitOpts = DefaultWaitOpts): Promise<AccountWalletWithPrivateKey> {
-    await (this.isDeployable() ? this.deploy().then(tx => tx.wait(opts)) : this.register());
+    await (this.isDeployable() ? this.deploy().wait(opts) : this.register());
     return this.getWallet();
   }
 

package/src/contract/batch_call.ts

@@ -17,7 +17,10 @@ export class BatchCall extends BaseContractInteraction {
    */
   public async create(opts?: SendMethodOptions): Promise<TxExecutionRequest> {
     if (!this.txRequest) {
-      this.txRequest = await this.wallet.createTxExecutionRequest(this.calls, opts?.fee);
+      this.txRequest = await this.wallet.createTxExecutionRequest({
+        calls: this.calls,
+        fee: opts?.fee,
+      });
     }
     return this.txRequest;
   }

package/src/contract/contract_function_interaction.ts

@@ -1,5 +1,5 @@
-import { type FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/circuit-types';
-import { type AztecAddress, FunctionData, TxContext } from '@aztec/circuits.js';
+import { type FunctionCall, PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
+import { type AztecAddress, FunctionData, GasSettings, TxContext } from '@aztec/circuits.js';
 import { type FunctionAbi, FunctionType, encodeArguments } from '@aztec/foundation/abi';
 
 import { type Wallet } from '../account/wallet.js';
@@ -13,10 +13,10 @@ export { SendMethodOptions };
  * Disregarded for simulation of public functions
  */
 export type SimulateMethodOptions = {
-  /**
-   * The sender's Aztec address.
-   */
+  /** The sender's Aztec address. */
   from?: AztecAddress;
+  /** Gas settings for the simulation. */
+  gasSettings?: GasSettings;
 };
 
 /**
@@ -47,7 +47,10 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       throw new Error("Can't call `create` on an unconstrained function.");
     }
     if (!this.txRequest) {
-      this.txRequest = await this.wallet.createTxExecutionRequest([this.request()], opts?.fee);
+      this.txRequest = await this.wallet.createTxExecutionRequest({
+        calls: [this.request()],
+        fee: opts?.fee,
+      });
     }
     return this.txRequest;
   }
@@ -89,7 +92,7 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
 
     if (this.functionDao.functionType == FunctionType.SECRET) {
       const nodeInfo = await this.wallet.getNodeInfo();
-      const packedArgs = PackedArguments.fromArgs(encodeArguments(this.functionDao, this.args));
+      const packedArgs = PackedValues.fromValues(encodeArguments(this.functionDao, this.args));
 
       const txRequest = TxExecutionRequest.from({
         argsHash: packedArgs.hash,
@@ -98,6 +101,7 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
         txContext: TxContext.empty(nodeInfo.chainId, nodeInfo.protocolVersion),
         packedArguments: [packedArgs],
         authWitnesses: [],
+        gasSettings: options.gasSettings ?? GasSettings.simulation(),
       });
       const simulatedTx = await this.pxe.simulateTx(txRequest, false, options.from ?? this.wallet.getAddress());
       return simulatedTx.privateReturnValues?.[0];

package/src/contract/deploy_method.ts

@@ -14,6 +14,7 @@ import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { type Wallet } from '../account/index.js';
 import { deployInstance } from '../deployment/deploy_instance.js';
 import { registerContractClass } from '../deployment/register_class.js';
+import { type ExecutionRequestInit } from '../entrypoint/entrypoint.js';
 import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
 import { type Contract } from './contract.js';
 import { type ContractBase } from './contract_base.js';
@@ -53,7 +54,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   private constructorArtifact: FunctionArtifact | undefined;
 
   /** Cached call to request() */
-  private functionCalls: FunctionCall[] | undefined;
+  private functionCalls?: ExecutionRequestInit;
 
   private log = createDebugLogger('aztec:js:deploy_method');
 
@@ -80,10 +81,6 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    */
   public async create(options: DeployOptions = {}): Promise<TxExecutionRequest> {
     if (!this.txRequest) {
-      const calls = await this.request(options);
-      if (calls.length === 0) {
-        throw new Error(`No function calls needed to deploy contract ${this.artifact.name}`);
-      }
       this.txRequest = await this.wallet.createTxExecutionRequest(await this.request(options));
       // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
       await this.pxe.registerContract({ artifact: this.artifact, instance: this.instance! });
@@ -99,20 +96,21 @@ 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<FunctionCall[]> {
+  public async request(options: DeployOptions = {}): Promise<ExecutionRequestInit> {
     if (!this.functionCalls) {
-      const { address } = this.getInstance(options);
-      const calls = await this.getDeploymentFunctionCalls(options);
-      if (this.constructorArtifact && !options.skipInitialization) {
-        const constructorCall = new ContractFunctionInteraction(
-          this.wallet,
-          address,
-          this.constructorArtifact,
-          this.args,
-        );
-        calls.push(constructorCall.request());
+      const deployment = await this.getDeploymentFunctionCalls(options);
+      const bootstrap = await this.getInitializeFunctionCalls(options);
+
+      if (deployment.calls.length + bootstrap.calls.length === 0) {
+        throw new Error(`No function calls needed to deploy contract ${this.artifact.name}`);
       }
-      this.functionCalls = calls;
+
+      this.functionCalls = {
+        calls: [...deployment.calls, ...bootstrap.calls],
+        authWitnesses: [...(deployment.authWitnesses ?? []), ...(bootstrap.authWitnesses ?? [])],
+        packedArguments: [...(deployment.packedArguments ?? []), ...(bootstrap.packedArguments ?? [])],
+        fee: options.fee,
+      };
     }
     return this.functionCalls;
   }
@@ -122,7 +120,7 @@ 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<FunctionCall[]> {
+  protected async getDeploymentFunctionCalls(options: DeployOptions = {}): Promise<ExecutionRequestInit> {
     const calls: FunctionCall[] = [];
 
     // Set contract instance object so it's available for populating the DeploySendTx object
@@ -140,11 +138,11 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     // Register the contract class if it hasn't been published already.
     if (!options.skipClassRegistration) {
       if (await this.pxe.isContractClassPubliclyRegistered(contractClass.id)) {
-        this.log(
+        this.log.debug(
           `Skipping registration of already registered contract class ${contractClass.id.toString()} for ${instance.address.toString()}`,
         );
       } else {
-        this.log(
+        this.log.info(
           `Creating request for registering contract class ${contractClass.id.toString()} as part of deployment for ${instance.address.toString()}`,
         );
         calls.push((await registerContractClass(this.wallet, this.artifact)).request());
@@ -156,7 +154,31 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
       calls.push(deployInstance(this.wallet, instance).request());
     }
 
-    return calls;
+    return {
+      calls,
+    };
+  }
+
+  /**
+   * Returns the calls necessary to initialize the contract.
+   * @param options - Deployment options.
+   * @returns - An array of function calls.
+   */
+  protected getInitializeFunctionCalls(options: DeployOptions): Promise<ExecutionRequestInit> {
+    const { address } = this.getInstance(options);
+    const calls: FunctionCall[] = [];
+    if (this.constructorArtifact && !options.skipInitialization) {
+      const constructorCall = new ContractFunctionInteraction(
+        this.wallet,
+        address,
+        this.constructorArtifact,
+        this.args,
+      );
+      calls.push(constructorCall.request());
+    }
+    return Promise.resolve({
+      calls,
+    });
   }
 
   /**
@@ -170,7 +192,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   public send(options: DeployOptions = {}): DeploySentTx<TContract> {
     const txHashPromise = super.send(options).getTxHash();
     const instance = this.getInstance(options);
-    this.log(
+    this.log.debug(
       `Sent deployment tx of ${this.artifact.name} contract with deployment address ${instance.address.toString()}`,
     );
     return new DeploySentTx(this.pxe, txHashPromise, this.postDeployCtor, instance);

package/src/contract/deploy_sent_tx.ts

@@ -44,7 +44,7 @@ export class DeploySentTx<TContract extends Contract = Contract> extends SentTx
    */
   public async deployed(opts?: DeployedWaitOpts): Promise<TContract> {
     const receipt = await this.wait(opts);
-    this.log(`Contract ${this.instance.address.toString()} successfully deployed.`);
+    this.log.info(`Contract ${this.instance.address.toString()} successfully deployed.`);
     return receipt.contract;
   }
 

package/src/entrypoint/default_entrypoint.ts

@@ -1,7 +1,7 @@
-import { type FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/circuit-types';
-import { TxContext } from '@aztec/circuits.js';
+import { PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
+import { GasSettings, TxContext } from '@aztec/circuits.js';
 
-import { type EntrypointInterface } from './entrypoint.js';
+import { type EntrypointInterface, type ExecutionRequestInit } from './entrypoint.js';
 
 /**
  * Default implementation of the entrypoint interface. It calls a function on a contract directly
@@ -9,18 +9,25 @@ import { type EntrypointInterface } from './entrypoint.js';
 export class DefaultEntrypoint implements EntrypointInterface {
   constructor(private chainId: number, private protocolVersion: number) {}
 
-  createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
-    const [execution] = executions;
-    const packedArguments = PackedArguments.fromArgs(execution.args);
+  createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
+    const { calls, authWitnesses = [], packedArguments = [] } = exec;
+
+    if (calls.length > 1) {
+      throw new Error(`Expected a single call, got ${calls.length}`);
+    }
+
+    const call = calls[0];
+    const entrypointPackedValues = PackedValues.fromValues(call.args);
     const txContext = TxContext.empty(this.chainId, this.protocolVersion);
     return Promise.resolve(
       new TxExecutionRequest(
-        execution.to,
-        execution.functionData,
-        packedArguments.hash,
+        call.to,
+        call.functionData,
+        entrypointPackedValues.hash,
         txContext,
-        [packedArguments],
-        [],
+        [...packedArguments, entrypointPackedValues],
+        authWitnesses,
+        exec.fee?.gasSettings ?? GasSettings.default(),
       ),
     );
   }

package/src/entrypoint/default_multi_call_entrypoint.ts

@@ -0,0 +1,89 @@
+import { type EntrypointInterface, EntrypointPayload, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
+import { PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
+import { type AztecAddress, FunctionData, GasSettings, TxContext } from '@aztec/circuits.js';
+import { type FunctionAbi, encodeArguments } from '@aztec/foundation/abi';
+import { getCanonicalMultiCallEntrypointAddress } from '@aztec/protocol-contracts/multi-call-entrypoint';
+
+/**
+ * Implementation for an entrypoint interface that can execute multiple function calls in a single transaction
+ */
+export class DefaultMultiCallEntrypoint implements EntrypointInterface {
+  constructor(
+    private chainId: number,
+    private version: number,
+    private address: AztecAddress = getCanonicalMultiCallEntrypointAddress(),
+  ) {}
+
+  createTxExecutionRequest(executions: ExecutionRequestInit): Promise<TxExecutionRequest> {
+    const { calls, authWitnesses = [], packedArguments = [] } = executions;
+    const payload = EntrypointPayload.fromAppExecution(calls);
+    const abi = this.getEntrypointAbi();
+    const entrypointPackedArgs = PackedValues.fromValues(encodeArguments(abi, [payload]));
+
+    const txRequest = TxExecutionRequest.from({
+      argsHash: entrypointPackedArgs.hash,
+      origin: this.address,
+      functionData: FunctionData.fromAbi(abi),
+      txContext: TxContext.empty(this.chainId, this.version),
+      packedArguments: [...payload.packedArguments, ...packedArguments, entrypointPackedArgs],
+      authWitnesses,
+      gasSettings: executions.fee?.gasSettings ?? GasSettings.default(),
+    });
+
+    return Promise.resolve(txRequest);
+  }
+
+  private getEntrypointAbi() {
+    return {
+      name: 'entrypoint',
+      isInitializer: false,
+      functionType: 'secret',
+      isInternal: false,
+      parameters: [
+        {
+          name: 'app_payload',
+          type: {
+            kind: 'struct',
+            path: 'authwit::entrypoint::app::AppPayload',
+            fields: [
+              {
+                name: 'function_calls',
+                type: {
+                  kind: 'array',
+                  length: 4,
+                  type: {
+                    kind: 'struct',
+                    path: 'authwit::entrypoint::function_call::FunctionCall',
+                    fields: [
+                      { name: 'args_hash', type: { kind: 'field' } },
+                      {
+                        name: 'function_selector',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::abis::function_selector::FunctionSelector',
+                          fields: [{ name: 'inner', type: { kind: 'integer', sign: 'unsigned', width: 32 } }],
+                        },
+                      },
+                      {
+                        name: 'target_address',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::address::AztecAddress',
+                          fields: [{ name: 'inner', type: { kind: 'field' } }],
+                        },
+                      },
+                      { name: 'is_public', type: { kind: 'boolean' } },
+                    ],
+                  },
+                },
+              },
+              { name: 'nonce', type: { kind: 'field' } },
+            ],
+          },
+          visibility: 'public',
+        },
+      ],
+      returnTypes: [],
+    } as FunctionAbi;
+  }
+}

package/src/entrypoint/entrypoint.ts

@@ -1,25 +1,30 @@
-import { type FunctionCall, type TxExecutionRequest } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/foundation/fields';
+import { type AuthWitness, type FunctionCall, type PackedValues, type TxExecutionRequest } from '@aztec/circuit-types';
 
-import { type FeePaymentMethod } from '../fee/fee_payment_method.js';
+import { EntrypointPayload, type FeeOptions } from './payload.js';
 
-/**
- * Fee payment options for a transaction.
- */
-export type FeeOptions = {
-  /** The fee payment method to use */
-  paymentMethod: FeePaymentMethod;
-  /** The fee limit to pay */
-  maxFee: bigint | number | Fr;
+export { EntrypointPayload, FeeOptions };
+
+export { DefaultEntrypoint } from './default_entrypoint.js';
+export { DefaultMultiCallEntrypoint } from './default_multi_call_entrypoint.js';
+
+/** Encodes the calls to be done in a transaction. */
+export type ExecutionRequestInit = {
+  /** The function calls to be executed. */
+  calls: FunctionCall[];
+  /** Any transient auth witnesses needed for this execution */
+  authWitnesses?: AuthWitness[];
+  /** Any transient packed arguments for this execution */
+  packedArguments?: PackedValues[];
+  /** How the fee is going to be payed */
+  fee?: FeeOptions;
 };
 
 /** Creates transaction execution requests out of a set of function calls. */
 export interface EntrypointInterface {
   /**
    * Generates an execution request out of set of function calls.
-   * @param executions - The execution intents to be run.
-   * @param feeOpts - The fee to be paid for the transaction.
+   * @param execution - The execution intents to be run.
    * @returns The authenticated transaction execution request.
    */
-  createTxExecutionRequest(executions: FunctionCall[], feeOpts?: FeeOptions): Promise<TxExecutionRequest>;
+  createTxExecutionRequest(execution: ExecutionRequestInit): Promise<TxExecutionRequest>;
 }

package/src/entrypoint/payload.ts

@@ -0,0 +1,144 @@
+import { type FunctionCall, PackedValues, emptyFunctionCall } from '@aztec/circuit-types';
+import { Fr, type GasSettings, GeneratorIndex } from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { pedersenHash } from '@aztec/foundation/crypto';
+import { type Tuple } from '@aztec/foundation/serialize';
+
+import { type FeePaymentMethod } from '../fee/fee_payment_method.js';
+
+/**
+ * Fee payment options for a transaction.
+ */
+export type FeeOptions = {
+  /** The fee payment method to use */
+  paymentMethod: FeePaymentMethod;
+  /** The gas settings */
+  gasSettings: GasSettings;
+};
+
+// These must match the values defined in:
+// - noir-projects/aztec-nr/aztec/src/entrypoint/app.nr
+const APP_MAX_CALLS = 4;
+// - and noir-projects/aztec-nr/aztec/src/entrypoint/fee.nr
+const FEE_MAX_CALLS = 2;
+
+/* eslint-disable camelcase */
+/** Encoded function call for account contract entrypoint */
+type EncodedFunctionCall = {
+  /** Arguments hash for the call */
+  args_hash: Fr;
+  /** Selector of the function to call */
+  function_selector: Fr;
+  /** Address of the contract to call */
+  target_address: Fr;
+  /** Whether the function is public or private */
+  is_public: boolean;
+};
+/* eslint-enable camelcase */
+
+/** Assembles an entrypoint payload */
+export class EntrypointPayload {
+  #packedArguments: PackedValues[] = [];
+  #functionCalls: EncodedFunctionCall[] = [];
+  #nonce = Fr.random();
+  #generatorIndex: number;
+
+  private constructor(functionCalls: FunctionCall[], generatorIndex: number) {
+    for (const call of functionCalls) {
+      this.#packedArguments.push(PackedValues.fromValues(call.args));
+    }
+
+    /* eslint-disable camelcase */
+    this.#functionCalls = functionCalls.map((call, index) => ({
+      args_hash: this.#packedArguments[index].hash,
+      function_selector: call.functionData.selector.toField(),
+      target_address: call.to.toField(),
+      is_public: !call.functionData.isPrivate,
+    }));
+    /* eslint-enable camelcase */
+
+    this.#generatorIndex = generatorIndex;
+  }
+
+  /* eslint-disable camelcase */
+  /**
+   * The function calls to execute. This uses snake_case naming so that it is compatible with Noir encoding
+   * @internal
+   */
+  get function_calls() {
+    return this.#functionCalls;
+  }
+  /* eslint-enable camelcase */
+
+  /**
+   * The nonce
+   * @internal
+   */
+  get nonce() {
+    return this.#nonce;
+  }
+
+  /**
+   * The packed arguments for the function calls
+   */
+  get packedArguments() {
+    return this.#packedArguments;
+  }
+
+  /**
+   * Serializes the payload to an array of fields
+   * @returns The fields of the payload
+   */
+  toFields(): Fr[] {
+    return [
+      ...this.#functionCalls.flatMap(call => [
+        call.args_hash,
+        call.function_selector,
+        call.target_address,
+        new Fr(call.is_public),
+      ]),
+      this.#nonce,
+    ];
+  }
+
+  /**
+   * Hashes the payload
+   * @returns The hash of the payload
+   */
+  hash() {
+    return pedersenHash(this.toFields(), this.#generatorIndex);
+  }
+
+  /**
+   * Creates an execution payload from a set of function calls
+   * @param functionCalls - The function calls to execute
+   * @returns The execution payload
+   */
+  static fromFunctionCalls(functionCalls: FunctionCall[]) {
+    return new EntrypointPayload(functionCalls, 0);
+  }
+
+  /**
+   * Creates an execution payload for the app-portion of a transaction from a set of function calls
+   * @param functionCalls - The function calls to execute
+   * @returns The execution payload
+   */
+  static fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, 4>) {
+    if (functionCalls.length > APP_MAX_CALLS) {
+      throw new Error(`Expected at most ${APP_MAX_CALLS} function calls, got ${functionCalls.length}`);
+    }
+    const paddedCalls = padArrayEnd(functionCalls, emptyFunctionCall(), APP_MAX_CALLS);
+    return new EntrypointPayload(paddedCalls, GeneratorIndex.SIGNATURE_PAYLOAD);
+  }
+
+  /**
+   * Creates an execution payload to pay the fee for a transaction
+   * @param feeOpts - The fee payment options
+   * @returns The execution payload
+   */
+  static async fromFeeOptions(feeOpts?: FeeOptions) {
+    const calls = feeOpts ? await feeOpts.paymentMethod.getFunctionCalls(feeOpts?.gasSettings) : [];
+    const paddedCalls = padArrayEnd(calls, emptyFunctionCall(), FEE_MAX_CALLS);
+    return new EntrypointPayload(paddedCalls, GeneratorIndex.FEE_PAYLOAD);
+  }
+}