@aztec/entrypoints 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/account_entrypoint.ts

@@ -1,12 +1,53 @@
-import { Fr } from '@aztec/foundation/fields';
-import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type FunctionAbi, FunctionCall, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload, HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
-import { EncodedCallsForEntrypoint, computeCombinedPayloadHash } from './encoding.js';
-import type { AuthWitnessProvider, EntrypointInterface, FeeOptions, TxExecutionOptions } from './interfaces.js';
-import { ExecutionPayload } from './payload.js';
+import { EncodedAppEntrypointCalls } from './encoding.js';
+import type { AuthWitnessProvider, ChainInfo, EntrypointInterface } from './interfaces.js';
+
+/**
+ * The mechanism via which an account contract will pay for a transaction in which it gets invoked.
+ */
+export enum AccountFeePaymentMethodOptions {
+  /**
+   * Signals that some other contract is in charge of paying the fee, nothing needs to be done.
+   */
+  EXTERNAL = 0,
+  /**
+   * Used to make the account contract publicly pay for the transaction with its own fee juice balance,
+   * **which it must already have prior to this transaction**.
+   *
+   * The contract will set itself as the fee payer and end the setup phase.
+   */
+  PREEXISTING_FEE_JUICE = 1,
+  /**
+   * Used to make the account contract publicly pay for the transaction with its own fee juice balance
+   * **which is being claimed in the same transaction**.
+   *
+   * The contract will set itself as the fee payer but not end setup phase - this is done by the Fee Juice
+   * contract after enqueuing a public call, which unlike most public calls is whitelisted by the nodes
+   * to be executable during the setup phase.
+   */
+  FEE_JUICE_WITH_CLAIM = 2,
+}
+
+/**
+ * General options for the tx execution.
+ */
+export type DefaultAccountEntrypointOptions = {
+  /** Whether the transaction can be cancelled. */
+  cancellable?: boolean;
+  /**
+   * A nonce to inject into the app payload of the transaction. When used with cancellable=true, this nonce will be
+   * used to compute a nullifier that allows cancelling this transaction by submitting a new one with the same nonce
+   * but higher fee. The nullifier ensures only one transaction can succeed.
+   */
+  txNonce?: Fr;
+  /** Options that configure how the account contract behaves depending on the fee payment method of the tx */
+  feePaymentMethodOptions: AccountFeePaymentMethodOptions;
+};
 
 /**
  * Implementation for an entrypoint interface that follows the default entrypoint signature
@@ -16,54 +57,24 @@ export class DefaultAccountEntrypoint implements EntrypointInterface {
   constructor(
     private address: AztecAddress,
     private auth: AuthWitnessProvider,
-    private chainId: number = DEFAULT_CHAIN_ID,
-    private version: number = DEFAULT_VERSION,
   ) {}
 
   async createTxExecutionRequest(
     exec: ExecutionPayload,
-    fee: FeeOptions,
-    options: TxExecutionOptions,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+    options: DefaultAccountEntrypointOptions,
   ): Promise<TxExecutionRequest> {
-    // Initial request with calls, authWitnesses and capsules
-    const { calls, authWitnesses, capsules, extraHashedArgs } = exec;
-    // Global tx options
-    const { cancellable, txNonce } = options;
-    // Encode the calls for the app
-    const appEncodedCalls = await EncodedCallsForEntrypoint.fromAppExecution(calls, txNonce);
-    // Get the execution payload for the fee, it includes the calls and potentially authWitnesses
-    const { calls: feeCalls, authWitnesses: feeAuthwitnesses } = await fee.paymentMethod.getExecutionPayload(
-      fee.gasSettings,
-    );
-    // Encode the calls for the fee
-    const feePayer = await fee.paymentMethod.getFeePayer(fee.gasSettings);
-    const isFeePayer = feePayer.equals(this.address);
-    const feeEncodedCalls = await EncodedCallsForEntrypoint.fromFeeCalls(feeCalls, isFeePayer);
-
-    // Obtain the entrypoint hashed args, built from the app and fee encoded calls
-    const abi = this.getEntrypointAbi();
-    const entrypointHashedArgs = await HashedValues.fromArgs(
-      encodeArguments(abi, [appEncodedCalls, feeEncodedCalls, !!cancellable]),
-    );
-
-    // Generate the combined payload auth witness, by signing the hash of the combined payload
-    const combinedPayloadAuthWitness = await this.auth.createAuthWit(
-      await computeCombinedPayloadHash(appEncodedCalls, feeEncodedCalls),
-    );
-
-    // Assemble the tx request
+    const { authWitnesses, capsules, extraHashedArgs } = exec;
+    const callData = await this.#buildEntrypointCallData(exec, options);
+    const entrypointHashedArgs = await HashedValues.fromArgs(callData.encodedArgs);
     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: [
-        ...appEncodedCalls.hashedArguments,
-        ...feeEncodedCalls.hashedArguments,
-        entrypointHashedArgs,
-        ...extraHashedArgs,
-      ],
-      authWitnesses: [...authWitnesses, ...feeAuthwitnesses, combinedPayloadAuthWitness],
+      functionSelector: callData.functionSelector,
+      txContext: new TxContext(chainInfo.chainId.toNumber(), chainInfo.version.toNumber(), gasSettings),
+      argsOfCalls: [...callData.encodedCalls.hashedArguments, entrypointHashedArgs, ...extraHashedArgs],
+      authWitnesses: [...authWitnesses, callData.payloadAuthWitness],
       capsules,
       salt: Fr.random(),
     });
@@ -71,12 +82,70 @@ export class DefaultAccountEntrypoint implements EntrypointInterface {
     return txRequest;
   }
 
+  async wrapExecutionPayload(
+    exec: ExecutionPayload,
+    options: DefaultAccountEntrypointOptions,
+  ): Promise<ExecutionPayload> {
+    const { authWitnesses, capsules, extraHashedArgs, feePayer } = exec;
+    const callData = await this.#buildEntrypointCallData(exec, options);
+
+    // Build the entrypoint function call
+    const entrypointCall = FunctionCall.from({
+      name: callData.abi.name,
+      to: this.address,
+      selector: callData.functionSelector,
+      type: callData.abi.functionType,
+      hideMsgSender: false,
+      isStatic: callData.abi.isStatic,
+      args: callData.encodedArgs,
+      returnTypes: callData.abi.returnTypes,
+    });
+
+    return new ExecutionPayload(
+      [entrypointCall],
+      [callData.payloadAuthWitness, ...authWitnesses],
+      capsules,
+      [...callData.encodedCalls.hashedArguments, ...extraHashedArgs],
+      feePayer ?? this.address,
+    );
+  }
+
+  /**
+   * Builds the shared data needed for both creating a tx execution request and wrapping an execution payload.
+   * This includes encoding calls, building entrypoint arguments, and creating the authwitness.
+   * @param exec - The execution payload containing calls to encode
+   * @param options - Account entrypoint options including tx nonce and fee payment method
+   * @returns Encoded call data, ABI, function selector, and auth witness
+   */
+  async #buildEntrypointCallData(exec: ExecutionPayload, options: DefaultAccountEntrypointOptions) {
+    const { calls } = exec;
+    const { cancellable, txNonce, feePaymentMethodOptions } = options;
+
+    const encodedCalls = await EncodedAppEntrypointCalls.create(calls, txNonce);
+
+    const abi = this.getEntrypointAbi();
+    const args = [encodedCalls, feePaymentMethodOptions, !!cancellable];
+    const encodedArgs = encodeArguments(abi, args);
+
+    const functionSelector = await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters);
+
+    const payloadAuthWitness = await this.auth.createAuthWit(await encodedCalls.hash());
+
+    return {
+      encodedCalls,
+      abi,
+      encodedArgs,
+      functionSelector,
+      payloadAuthWitness,
+    };
+  }
+
   private getEntrypointAbi() {
     return {
       name: 'entrypoint',
       isInitializer: false,
       functionType: 'private',
-      isInternal: false,
+      isOnlySelf: false,
       isStatic: false,
       parameters: [
         {
@@ -89,50 +158,7 @@ export class DefaultAccountEntrypoint implements EntrypointInterface {
                 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: 'is_static', type: { kind: 'boolean' } },
-                    ],
-                  },
-                },
-              },
-              { name: 'tx_nonce', type: { kind: 'field' } },
-            ],
-          },
-          visibility: 'public',
-        },
-        {
-          name: 'fee_payload',
-          type: {
-            kind: 'struct',
-            path: 'authwit::entrypoint::fee::FeePayload',
-            fields: [
-              {
-                name: 'function_calls',
-                type: {
-                  kind: 'array',
-                  length: 2,
+                  length: 5,
                   type: {
                     kind: 'struct',
                     path: 'authwit::entrypoint::function_call::FunctionCall',
@@ -155,17 +181,18 @@ export class DefaultAccountEntrypoint implements EntrypointInterface {
                         },
                       },
                       { name: 'is_public', type: { kind: 'boolean' } },
+                      { name: 'hide_msg_sender', type: { kind: 'boolean' } },
                       { name: 'is_static', type: { kind: 'boolean' } },
                     ],
                   },
                 },
               },
               { name: 'tx_nonce', type: { kind: 'field' } },
-              { name: 'is_fee_payer', type: { kind: 'boolean' } },
             ],
           },
           visibility: 'public',
         },
+        { name: 'fee_payment_method', type: { kind: 'integer', sign: 'unsigned', width: 8 } },
         { name: 'cancellable', type: { kind: 'boolean' } },
       ],
       returnTypes: [],

package/src/default_entrypoint.ts

@@ -1,26 +1,18 @@
 import { FunctionType } from '@aztec/stdlib/abi';
-import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload, HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import type { EntrypointInterface, FeeOptions, TxExecutionOptions } from './interfaces.js';
-import type { ExecutionPayload } from './payload.js';
+import type { ChainInfo, EntrypointInterface } from './interfaces.js';
 
 /**
  * Default implementation of the entrypoint interface. It calls a function on a contract directly
  */
 export class DefaultEntrypoint implements EntrypointInterface {
-  constructor(
-    private chainId: number,
-    private rollupVersion: number,
-  ) {}
-
   async createTxExecutionRequest(
     exec: ExecutionPayload,
-    fee: FeeOptions,
-    options: TxExecutionOptions,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
   ): Promise<TxExecutionRequest> {
-    if (options.txNonce || options.cancellable !== undefined) {
-      throw new Error('TxExecutionOptions are not supported in DefaultEntrypoint');
-    }
     // Initial request with calls, authWitnesses and capsules
     const { calls, authWitnesses, capsules, extraHashedArgs } = exec;
 
@@ -42,10 +34,28 @@ export class DefaultEntrypoint implements EntrypointInterface {
       call.to,
       call.selector,
       hashedArguments[0].hash,
-      new TxContext(this.chainId, this.rollupVersion, fee.gasSettings),
+      new TxContext(chainInfo.chainId.toNumber(), chainInfo.version.toNumber(), gasSettings),
       [...hashedArguments, ...extraHashedArgs],
       authWitnesses,
       capsules,
     );
   }
+
+  async wrapExecutionPayload(exec: ExecutionPayload, _options?: any): Promise<ExecutionPayload> {
+    if (exec.calls.length !== 1) {
+      throw new Error(`DefaultEntrypoint can only wrap a single call, got ${exec.calls.length}`);
+    }
+
+    const call = exec.calls[0];
+
+    const hashedArguments = await HashedValues.fromArgs(call.args);
+
+    return new ExecutionPayload(
+      [call],
+      exec.authWitnesses,
+      exec.capsules,
+      [hashedArguments, ...exec.extraHashedArgs],
+      exec.feePayer,
+    );
+  }
 }

package/src/default_multi_call_entrypoint.ts

@@ -1,50 +1,35 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import { type FunctionAbi, FunctionCall, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload, HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import { EncodedCallsForEntrypoint } from './encoding.js';
-import type { EntrypointInterface, FeeOptions } from './interfaces.js';
-import type { ExecutionPayload } from './payload.js';
+import { EncodedAppEntrypointCalls } from './encoding.js';
+import type { ChainInfo, EntrypointInterface } from './interfaces.js';
 
 /**
  * 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 = ProtocolContractAddress.MultiCallEntrypoint,
-  ) {}
+  constructor(private address: AztecAddress = ProtocolContractAddress.MultiCallEntrypoint) {}
 
-  async createTxExecutionRequest(exec: ExecutionPayload, fee: FeeOptions): Promise<TxExecutionRequest> {
-    // Initial request with calls, authWitnesses and capsules
-    const { calls, authWitnesses, capsules, extraHashedArgs } = exec;
+  async createTxExecutionRequest(
+    exec: ExecutionPayload,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+  ): Promise<TxExecutionRequest> {
+    const { authWitnesses, capsules, extraHashedArgs } = exec;
+    const callData = await this.#buildEntrypointCallData(exec);
 
-    // Get the execution payload for the fee, it includes the calls and potentially authWitnesses
-    const {
-      calls: feeCalls,
-      authWitnesses: feeAuthwitnesses,
-      extraHashedArgs: feeExtraHashedArgs,
-    } = await fee.paymentMethod.getExecutionPayload(fee.gasSettings);
-
-    // Encode the calls, including the fee calls
-    // (since this entrypoint does not distinguish between app and fee calls)
-    const encodedCalls = await EncodedCallsForEntrypoint.fromAppExecution(calls.concat(feeCalls));
-
-    // Obtain the entrypoint hashed args, built from the encoded calls
-    const abi = this.getEntrypointAbi();
-    const entrypointHashedArgs = await HashedValues.fromArgs(encodeArguments(abi, [encodedCalls]));
-
-    // Assemble the tx request
+    const entrypointHashedArgs = await HashedValues.fromArgs(callData.encodedArgs);
     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: [...encodedCalls.hashedArguments, entrypointHashedArgs, ...extraHashedArgs, ...feeExtraHashedArgs],
-      authWitnesses: [...feeAuthwitnesses, ...authWitnesses],
+      functionSelector: callData.functionSelector,
+      txContext: new TxContext(chainInfo.chainId.toNumber(), chainInfo.version.toNumber(), gasSettings),
+      argsOfCalls: [...callData.encodedCalls.hashedArguments, entrypointHashedArgs, ...extraHashedArgs],
+      authWitnesses,
       capsules,
       salt: Fr.random(),
     });
@@ -52,12 +37,59 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
     return Promise.resolve(txRequest);
   }
 
+  async wrapExecutionPayload(exec: ExecutionPayload, _options?: any): Promise<ExecutionPayload> {
+    const { authWitnesses, capsules, extraHashedArgs } = exec;
+    const callData = await this.#buildEntrypointCallData(exec);
+    const entrypointCall = FunctionCall.from({
+      name: callData.abi.name,
+      to: this.address,
+      selector: callData.functionSelector,
+      type: callData.abi.functionType,
+      hideMsgSender: false,
+      isStatic: callData.abi.isStatic,
+      args: callData.encodedArgs,
+      returnTypes: callData.abi.returnTypes,
+    });
+
+    return new ExecutionPayload(
+      [entrypointCall],
+      authWitnesses,
+      capsules,
+      [...callData.encodedCalls.hashedArguments, ...extraHashedArgs],
+      exec.feePayer,
+    );
+  }
+
+  /**
+   * Builds the shared data needed for both creating a tx execution request and wrapping an execution payload.
+   * This includes encoding calls and building entrypoint arguments.
+   * @param exec - The execution payload containing calls to encode
+   * @returns Encoded call data, ABI, encoded arguments, and function selector
+   */
+  async #buildEntrypointCallData(exec: ExecutionPayload) {
+    const { calls } = exec;
+
+    const encodedCalls = await EncodedAppEntrypointCalls.create(calls);
+
+    const abi = this.getEntrypointAbi();
+    const encodedArgs = encodeArguments(abi, [encodedCalls]);
+
+    const functionSelector = await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters);
+
+    return {
+      encodedCalls,
+      abi,
+      encodedArgs,
+      functionSelector,
+    };
+  }
+
   private getEntrypointAbi() {
     return {
       name: 'entrypoint',
       isInitializer: false,
       functionType: 'private',
-      isInternal: false,
+      isOnlySelf: false,
       isStatic: false,
       parameters: [
         {
@@ -70,7 +102,7 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
                 name: 'function_calls',
                 type: {
                   kind: 'array',
-                  length: 4,
+                  length: 5,
                   type: {
                     kind: 'struct',
                     path: 'authwit::entrypoint::function_call::FunctionCall',
@@ -93,6 +125,7 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
                         },
                       },
                       { name: 'is_public', type: { kind: 'boolean' } },
+                      { name: 'hide_msg_sender', type: { kind: 'boolean' } },
                       { name: 'is_static', type: { kind: 'boolean' } },
                     ],
                   },

package/src/encoding.ts

@@ -1,16 +1,14 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { FunctionCall, FunctionType } from '@aztec/stdlib/abi';
 import { HashedValues } from '@aztec/stdlib/tx';
 
 // 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;
+export const APP_MAX_CALLS = 5;
 
 /** Encoded function call for an Aztec entrypoint */
 export type EncodedFunctionCall = {
@@ -23,6 +21,8 @@ export type EncodedFunctionCall = {
   target_address: Fr;
   /** Whether the function is public or private */
   is_public: boolean;
+  /** Only applicable for enqueued public function calls. Whether the msg_sender will be set to "null". */
+  hide_msg_sender: boolean;
   /** Whether the function can alter state */
   is_static: boolean;
 };
@@ -40,14 +40,14 @@ export type EncodedCalls = {
  * This utility class helps in creating the payload for the entrypoint by taking into
  * account how the calls are encoded and hashed.
  * */
-export abstract class EncodedCallsForEntrypoint implements EncodedCalls {
+export class EncodedAppEntrypointCalls implements EncodedCalls {
   constructor(
     /** Function calls in the expected format (Noir's convention) */
     public encodedFunctionCalls: EncodedFunctionCall[],
     /** The hashed args for the call, ready to be injected in the execution cache */
     public hashedArguments: HashedValues[],
     /** The index of the generator to use for hashing */
-    public generatorIndex: number,
+    public domainSeparator: number,
     /**
      * A nonce to inject into the payload of the transaction. When used with cancellable=true, this nonce will be
      * used to compute a nullifier that allows cancelling this transaction by submitting a new one with the same nonce
@@ -71,14 +71,16 @@ export abstract class EncodedCallsForEntrypoint implements EncodedCalls {
    * Serializes the payload to an array of fields
    * @returns The fields of the payload
    */
-  abstract toFields(): Fr[];
+  toFields(): Fr[] {
+    return [...this.functionCallsToFields(), this.tx_nonce];
+  }
 
   /**
    * Hashes the payload
    * @returns The hash of the payload
    */
   hash() {
-    return poseidon2HashWithSeparator(this.toFields(), this.generatorIndex);
+    return poseidon2HashWithSeparator(this.toFields(), this.domainSeparator);
   }
 
   /** Serializes the function calls to an array of fields. */
@@ -88,20 +90,11 @@ export abstract class EncodedCallsForEntrypoint implements EncodedCalls {
       call.function_selector,
       call.target_address,
       new Fr(call.is_public),
+      new Fr(call.hide_msg_sender),
       new Fr(call.is_static),
     ]);
   }
 
-  /**
-   * Encodes a set of function calls for a dapp entrypoint
-   * @param functionCalls - The function calls to execute
-   * @returns The encoded calls
-   */
-  static async fromFunctionCalls(functionCalls: FunctionCall[]) {
-    const encoded = await encode(functionCalls);
-    return new EncodedAppEntrypointCalls(encoded.encodedFunctionCalls, encoded.hashedArguments, 0, Fr.random());
-  }
-
   /**
    * Encodes the functions for the app-portion of a transaction from a set of function calls and a nonce
    * @param functionCalls - The function calls to execute
@@ -109,7 +102,7 @@ export abstract class EncodedCallsForEntrypoint implements EncodedCalls {
    * nonce can be replaced by submitting a new one with a higher fee.
    * @returns The encoded calls
    */
-  static async fromAppExecution(
+  static async create(
     functionCalls: FunctionCall[] | Tuple<FunctionCall, typeof APP_MAX_CALLS>,
     txNonce = Fr.random(),
   ) {
@@ -121,90 +114,10 @@ export abstract class EncodedCallsForEntrypoint implements EncodedCalls {
     return new EncodedAppEntrypointCalls(
       encoded.encodedFunctionCalls,
       encoded.hashedArguments,
-      GeneratorIndex.SIGNATURE_PAYLOAD,
+      DomainSeparator.SIGNATURE_PAYLOAD,
       txNonce,
     );
   }
-
-  /**
-   * Creates an encoded set of functions to pay the fee for a transaction
-   * @param functionCalls - The calls generated by the payment method
-   * @param isFeePayer - Whether the sender should be appointed as fee payer
-   * @returns The encoded calls
-   */
-  static async fromFeeCalls(
-    functionCalls: FunctionCall[] | Tuple<FunctionCall, typeof FEE_MAX_CALLS>,
-    isFeePayer: boolean,
-  ) {
-    const paddedCalls = padArrayEnd(functionCalls, FunctionCall.empty(), FEE_MAX_CALLS);
-    const encoded = await encode(paddedCalls);
-    return new EncodedFeeEntrypointCalls(
-      encoded.encodedFunctionCalls,
-      encoded.hashedArguments,
-      GeneratorIndex.FEE_PAYLOAD,
-      Fr.random(),
-      isFeePayer,
-    );
-  }
-}
-
-/** Encoded calls for app phase execution. */
-export class EncodedAppEntrypointCalls extends EncodedCallsForEntrypoint {
-  constructor(
-    encodedFunctionCalls: EncodedFunctionCall[],
-    hashedArguments: HashedValues[],
-    generatorIndex: number,
-    txNonce: Fr,
-  ) {
-    super(encodedFunctionCalls, hashedArguments, generatorIndex, txNonce);
-  }
-
-  override toFields(): Fr[] {
-    return [...this.functionCallsToFields(), this.tx_nonce];
-  }
-}
-
-/** Encoded calls for fee payment */
-export class EncodedFeeEntrypointCalls extends EncodedCallsForEntrypoint {
-  #isFeePayer: boolean;
-
-  constructor(
-    encodedFunctionCalls: EncodedFunctionCall[],
-    hashedArguments: HashedValues[],
-    generatorIndex: number,
-    txNonce: Fr,
-    isFeePayer: boolean,
-  ) {
-    super(encodedFunctionCalls, hashedArguments, generatorIndex, txNonce);
-    this.#isFeePayer = isFeePayer;
-  }
-
-  override toFields(): Fr[] {
-    return [...this.functionCallsToFields(), this.tx_nonce, new Fr(this.#isFeePayer)];
-  }
-
-  /* eslint-disable camelcase */
-  /** Whether the sender should be appointed as fee payer. */
-  get is_fee_payer() {
-    return this.#isFeePayer;
-  }
-  /* eslint-enable camelcase */
-}
-
-/**
- * Computes a hash of a combined set of app and fee calls.
- * @param appCalls - A set of app calls.
- * @param feeCalls - A set of calls used to pay fees.
- * @returns A hash of a combined call set.
- */
-export async function computeCombinedPayloadHash(
-  appPayload: EncodedAppEntrypointCalls,
-  feePayload: EncodedFeeEntrypointCalls,
-): Promise<Fr> {
-  return poseidon2HashWithSeparator(
-    [await appPayload.hash(), await feePayload.hash()],
-    GeneratorIndex.COMBINED_PAYLOAD,
-  );
 }
 
 /** Encodes FunctionCalls for execution, following Noir's convention */
@@ -224,6 +137,7 @@ export async function encode(calls: FunctionCall[]): Promise<EncodedCalls> {
     function_selector: call.selector.toField(),
     target_address: call.to.toField(),
     is_public: call.type == FunctionType.PUBLIC,
+    hide_msg_sender: call.hideMsgSender,
     is_static: call.isStatic,
   }));