@aztec/entrypoints 0.80.0 → 0.82.0

package/dest/payload.d.ts

@@ -0,0 +1,32 @@
+import { FunctionCall } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { Capsule, HashedValues } from '@aztec/stdlib/tx';
+/**
+ * Represents data necessary to perform an action in the network successfully.
+ * This class can be considered Aztec's "minimal execution unit".
+ * */
+export declare class ExecutionPayload {
+    /** The function calls to be executed. */
+    calls: FunctionCall[];
+    /** Any transient auth witnesses needed for this execution */
+    authWitnesses: AuthWitness[];
+    /** Data passed through an oracle for this execution. */
+    capsules: Capsule[];
+    /** Extra hashed values to be injected in the execution cache */
+    extraHashedArgs: HashedValues[];
+    constructor(
+    /** The function calls to be executed. */
+    calls: FunctionCall[], 
+    /** Any transient auth witnesses needed for this execution */
+    authWitnesses: AuthWitness[], 
+    /** Data passed through an oracle for this execution. */
+    capsules: Capsule[], 
+    /** Extra hashed values to be injected in the execution cache */
+    extraHashedArgs?: HashedValues[]);
+    static empty(): ExecutionPayload;
+}
+/**
+ * Merges an array ExecutionPayloads combining their calls, authWitnesses, capsules and extraArgHashes.
+ */
+export declare function mergeExecutionPayloads(requests: ExecutionPayload[]): ExecutionPayload;
+//# sourceMappingURL=payload.d.ts.map

package/dest/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../src/payload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;;KAGK;AACL,qBAAa,gBAAgB;IAEzB,yCAAyC;IAClC,KAAK,EAAE,YAAY,EAAE;IAC5B,6DAA6D;IACtD,aAAa,EAAE,WAAW,EAAE;IACnC,wDAAwD;IACjD,QAAQ,EAAE,OAAO,EAAE;IAC1B,gEAAgE;IACzD,eAAe,EAAE,YAAY,EAAE;;IAPtC,yCAAyC;IAClC,KAAK,EAAE,YAAY,EAAE;IAC5B,6DAA6D;IACtD,aAAa,EAAE,WAAW,EAAE;IACnC,wDAAwD;IACjD,QAAQ,EAAE,OAAO,EAAE;IAC1B,gEAAgE;IACzD,eAAe,GAAE,YAAY,EAAO;IAG7C,MAAM,CAAC,KAAK;CAGb;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,CAMrF"}

package/dest/payload.js

@@ -0,0 +1,27 @@
+/**
+ * Represents data necessary to perform an action in the network successfully.
+ * This class can be considered Aztec's "minimal execution unit".
+ * */ export class ExecutionPayload {
+    calls;
+    authWitnesses;
+    capsules;
+    extraHashedArgs;
+    constructor(/** The function calls to be executed. */ calls, /** Any transient auth witnesses needed for this execution */ authWitnesses, /** Data passed through an oracle for this execution. */ capsules, /** Extra hashed values to be injected in the execution cache */ extraHashedArgs = []){
+        this.calls = calls;
+        this.authWitnesses = authWitnesses;
+        this.capsules = capsules;
+        this.extraHashedArgs = extraHashedArgs;
+    }
+    static empty() {
+        return new ExecutionPayload([], [], []);
+    }
+}
+/**
+ * Merges an array ExecutionPayloads combining their calls, authWitnesses, capsules and extraArgHashes.
+ */ export function mergeExecutionPayloads(requests) {
+    const calls = requests.map((r)=>r.calls).flat();
+    const combinedAuthWitnesses = requests.map((r)=>r.authWitnesses ?? []).flat();
+    const combinedCapsules = requests.map((r)=>r.capsules ?? []).flat();
+    const combinedextraHashedArgs = requests.map((r)=>r.extraHashedArgs ?? []).flat();
+    return new ExecutionPayload(calls, combinedAuthWitnesses, combinedCapsules, combinedextraHashedArgs);
+}

package/package.json

@@ -2,11 +2,15 @@
   "name": "@aztec/entrypoints",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/entrypoints",
   "description": "Implementation of sample contract entrypoints for the Aztec Network",
-  "version": "0.80.0",
+  "version": "0.82.0",
   "type": "module",
   "exports": {
     "./dapp": "./dest/dapp_entrypoint.js",
-    "./account": "./dest/account_entrypoint.js"
+    "./account": "./dest/account_entrypoint.js",
+    "./default": "./dest/default_entrypoint.js",
+    "./interfaces": "./dest/interfaces.js",
+    "./payload": "./dest/payload.js",
+    "./encoding": "./dest/encoding.js"
   },
   "typedocOptions": {
     "entryPoints": [
@@ -61,10 +65,10 @@
     ]
   },
   "dependencies": {
-    "@aztec/aztec.js": "0.80.0",
-    "@aztec/foundation": "0.80.0",
-    "@aztec/protocol-contracts": "0.80.0",
-    "@aztec/stdlib": "0.80.0",
+    "@aztec/constants": "0.82.0",
+    "@aztec/foundation": "0.82.0",
+    "@aztec/protocol-contracts": "0.82.0",
+    "@aztec/stdlib": "0.82.0",
     "tslib": "^2.4.0"
   },
   "devDependencies": {

package/src/account_entrypoint.ts

@@ -1,15 +1,11 @@
-import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
-import {
-  type EntrypointInterface,
-  EntrypointPayload,
-  type ExecutionRequestInit,
-  computeCombinedPayloadHash,
-} from '@aztec/aztec.js/entrypoint';
 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 { 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';
 
 /**
  * Implementation for an entrypoint interface that follows the default entrypoint signature
@@ -23,27 +19,50 @@ export class DefaultAccountEntrypoint implements EntrypointInterface {
     private version: number = DEFAULT_VERSION,
   ) {}
 
-  async createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    const { calls, fee, nonce, cancellable, authWitnesses = [], capsules = [] } = exec;
-    const appPayload = await EntrypointPayload.fromAppExecution(calls, nonce);
-    const feePayload = await EntrypointPayload.fromFeeOptions(this.address, fee);
+  async createTxExecutionRequest(
+    exec: ExecutionPayload,
+    fee: FeeOptions,
+    options: TxExecutionOptions,
+  ): Promise<TxExecutionRequest> {
+    // Initial request with calls, authWitnesses and capsules
+    const { calls, authWitnesses, capsules, extraHashedArgs } = exec;
+    // Global tx options
+    const { cancellable, nonce } = options;
+    // Encode the calls for the app
+    const appEncodedCalls = await EncodedCallsForEntrypoint.fromAppExecution(calls, nonce);
+    // 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.fromValues(
-      encodeArguments(abi, [appPayload, feePayload, !!cancellable]),
+      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(appPayload, feePayload),
+      await computeCombinedPayloadHash(appEncodedCalls, feeEncodedCalls),
     );
 
+    // 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: [...appPayload.hashedArguments, ...feePayload.hashedArguments, entrypointHashedArgs],
-      authWitnesses: [...authWitnesses, combinedPayloadAuthWitness],
+      argsOfCalls: [
+        ...appEncodedCalls.hashedArguments,
+        ...feeEncodedCalls.hashedArguments,
+        entrypointHashedArgs,
+        ...extraHashedArgs,
+      ],
+      authWitnesses: [...authWitnesses, ...feeAuthwitnesses, combinedPayloadAuthWitness],
       capsules,
     });
 

package/src/dapp_entrypoint.ts

@@ -1,11 +1,13 @@
-import { Fr, computeAuthWitMessageHash, computeInnerAuthWitHash } from '@aztec/aztec.js';
-import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
-import { type EntrypointInterface, EntrypointPayload, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
-import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import { Fr } from '@aztec/foundation/fields';
+import { type FunctionAbi, FunctionSelector, FunctionType, encodeArguments } from '@aztec/stdlib/abi';
+import { computeInnerAuthWitHash, computeOuterAuthWitHash } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
 
 import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
+import { EncodedCallsForEntrypoint } from './encoding.js';
+import type { AuthWitnessProvider, EntrypointInterface, FeeOptions, TxExecutionOptions } from './interfaces.js';
+import { ExecutionPayload } from './payload.js';
 
 /**
  * Implementation for an entrypoint interface that follows the default entrypoint signature
@@ -20,16 +22,29 @@ export class DefaultDappEntrypoint implements EntrypointInterface {
     private version: number = DEFAULT_VERSION,
   ) {}
 
-  async createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    const { calls, fee, authWitnesses = [], capsules = [] } = exec;
+  async createTxExecutionRequest(
+    exec: ExecutionPayload,
+    fee: FeeOptions,
+    options: TxExecutionOptions,
+  ): Promise<TxExecutionRequest> {
+    if (options.nonce || options.cancellable !== undefined) {
+      throw new Error('TxExecutionOptions are not supported in DappEntrypoint');
+    }
+    // Initial request with calls, authWitnesses and capsules
+    const { calls, authWitnesses, capsules, extraHashedArgs } = exec;
     if (calls.length !== 1) {
       throw new Error(`Expected exactly 1 function call, got ${calls.length}`);
     }
 
-    const payload = await EntrypointPayload.fromFunctionCalls(calls);
+    // Encode the function call the dapp is ultimately going to invoke
+    const encodedCalls = await EncodedCallsForEntrypoint.fromFunctionCalls(calls);
 
+    // Obtain the entrypoint hashed args, built from the function call and the user's address
     const abi = this.getEntrypointAbi();
-    const entrypointHashedArgs = await HashedValues.fromValues(encodeArguments(abi, [payload, this.userAddress]));
+    const entrypointHashedArgs = await HashedValues.fromValues(encodeArguments(abi, [encodedCalls, this.userAddress]));
+
+    // Construct an auth witness for the entrypoint, by signing the hash of the action to perform
+    // (the dapp calls a function on the user's behalf)
     const functionSelector = await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters);
     // Default msg_sender for entrypoints is now Fr.max_value rather than 0 addr (see #7190 & #7404)
     const innerHash = await computeInnerAuthWitHash([
@@ -37,31 +52,34 @@ export class DefaultDappEntrypoint implements EntrypointInterface {
       functionSelector.toField(),
       entrypointHashedArgs.hash,
     ]);
-    const outerHash = await computeAuthWitMessageHash(
-      { consumer: this.dappEntrypointAddress, innerHash },
-      { chainId: new Fr(this.chainId), version: new Fr(this.version) },
+    const outerHash = await computeOuterAuthWitHash(
+      this.dappEntrypointAddress,
+      new Fr(this.chainId),
+      new Fr(this.version),
+      innerHash,
     );
 
-    const authWitness = await this.userAuthWitnessProvider.createAuthWit(outerHash);
+    const entypointAuthwitness = await this.userAuthWitnessProvider.createAuthWit(outerHash);
 
+    // Assemble the tx request
     const txRequest = TxExecutionRequest.from({
       firstCallArgsHash: entrypointHashedArgs.hash,
       origin: this.dappEntrypointAddress,
       functionSelector,
       txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
-      argsOfCalls: [...payload.hashedArguments, entrypointHashedArgs],
-      authWitnesses: [...authWitnesses, authWitness],
+      argsOfCalls: [...encodedCalls.hashedArguments, entrypointHashedArgs, ...extraHashedArgs],
+      authWitnesses: [entypointAuthwitness, ...authWitnesses],
       capsules,
     });
 
     return txRequest;
   }
 
-  private getEntrypointAbi() {
+  private getEntrypointAbi(): FunctionAbi {
     return {
       name: 'entrypoint',
       isInitializer: false,
-      functionType: 'private',
+      functionType: FunctionType.PRIVATE,
       isInternal: false,
       isStatic: false,
       parameters: [
@@ -120,6 +138,6 @@ export class DefaultDappEntrypoint implements EntrypointInterface {
       ],
       returnTypes: [],
       errorTypes: {},
-    } as FunctionAbi;
+    } as const;
   }
 }

package/src/default_entrypoint.ts

@@ -0,0 +1,48 @@
+import { FunctionType } from '@aztec/stdlib/abi';
+import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import type { EntrypointInterface, FeeOptions, TxExecutionOptions } from './interfaces.js';
+import type { ExecutionPayload } from './payload.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 protocolVersion: number) {}
+
+  async createTxExecutionRequest(
+    exec: ExecutionPayload,
+    fee: FeeOptions,
+    options: TxExecutionOptions,
+  ): Promise<TxExecutionRequest> {
+    if (options.nonce || 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;
+
+    if (calls.length > 1) {
+      throw new Error(`Expected a single call, got ${calls.length}`);
+    }
+
+    const call = calls[0];
+
+    // Hash the arguments for the function call
+    const hashedArguments = [await HashedValues.fromValues(call.args)];
+
+    if (call.type !== FunctionType.PRIVATE) {
+      throw new Error('Public entrypoints are not allowed');
+    }
+
+    // Assemble the tx request
+    return new TxExecutionRequest(
+      call.to,
+      call.selector,
+      hashedArguments[0].hash,
+      new TxContext(this.chainId, this.protocolVersion, fee.gasSettings),
+      [...hashedArguments, ...extraHashedArgs],
+      authWitnesses,
+      capsules,
+    );
+  }
+}

package/src/encoding.ts

@@ -0,0 +1,225 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+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;
+
+/* eslint-disable camelcase */
+/** Encoded function call for an Aztec entrypoint */
+export 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;
+  /** Whether the function can alter state */
+  is_static: boolean;
+};
+/* eslint-enable camelcase */
+
+/** Type that represents function calls ready to be sent to a circuit for execution */
+export type EncodedCalls = {
+  /** Function calls in the expected format (Noir's convention) */
+  encodedFunctionCalls: EncodedFunctionCall[];
+  /** The hashed args for the call, ready to be injected in the execution cache */
+  hashedArguments: HashedValues[];
+};
+
+/**
+ * Entrypoints derive their arguments from the calls that they'll ultimate make.
+ * 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 {
+  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,
+    /** The nonce for the payload, used to emit a nullifier identifying the call */
+    public nonce: Fr,
+  ) {}
+
+  /* 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.encodedFunctionCalls;
+  }
+  /* eslint-enable camelcase */
+
+  /**
+   * Serializes the payload to an array of fields
+   * @returns The fields of the payload
+   */
+  abstract toFields(): Fr[];
+
+  /**
+   * Hashes the payload
+   * @returns The hash of the payload
+   */
+  hash() {
+    return poseidon2HashWithSeparator(this.toFields(), this.generatorIndex);
+  }
+
+  /** Serializes the function calls to an array of fields. */
+  protected functionCallsToFields() {
+    return this.encodedFunctionCalls.flatMap(call => [
+      call.args_hash,
+      call.function_selector,
+      call.target_address,
+      new Fr(call.is_public),
+      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
+   * @param nonce - The nonce for the payload, used to emit a nullifier identifying the call
+   * @returns The encoded calls
+   */
+  static async fromAppExecution(
+    functionCalls: FunctionCall[] | Tuple<FunctionCall, typeof APP_MAX_CALLS>,
+    nonce = Fr.random(),
+  ) {
+    if (functionCalls.length > APP_MAX_CALLS) {
+      throw new Error(`Expected at most ${APP_MAX_CALLS} function calls, got ${functionCalls.length}`);
+    }
+    const paddedCalls = padArrayEnd(functionCalls, FunctionCall.empty(), APP_MAX_CALLS);
+    const encoded = await encode(paddedCalls);
+    return new EncodedAppEntrypointCalls(
+      encoded.encodedFunctionCalls,
+      encoded.hashedArguments,
+      GeneratorIndex.SIGNATURE_PAYLOAD,
+      nonce,
+    );
+  }
+
+  /**
+   * 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,
+    nonce: Fr,
+  ) {
+    super(encodedFunctionCalls, hashedArguments, generatorIndex, nonce);
+  }
+
+  override toFields(): Fr[] {
+    return [...this.functionCallsToFields(), this.nonce];
+  }
+}
+
+/** Encoded calls for fee payment */
+export class EncodedFeeEntrypointCalls extends EncodedCallsForEntrypoint {
+  #isFeePayer: boolean;
+
+  constructor(
+    encodedFunctionCalls: EncodedFunctionCall[],
+    hashedArguments: HashedValues[],
+    generatorIndex: number,
+    nonce: Fr,
+    isFeePayer: boolean,
+  ) {
+    super(encodedFunctionCalls, hashedArguments, generatorIndex, nonce);
+    this.#isFeePayer = isFeePayer;
+  }
+
+  override toFields(): Fr[] {
+    return [...this.functionCallsToFields(), this.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 */
+export async function encode(calls: FunctionCall[]): Promise<EncodedCalls> {
+  const hashedArguments: HashedValues[] = [];
+  for (const call of calls) {
+    hashedArguments.push(await HashedValues.fromValues(call.args));
+  }
+
+  /* eslint-disable camelcase */
+  const encodedFunctionCalls: EncodedFunctionCall[] = calls.map((call, index) => ({
+    args_hash: hashedArguments[index].hash,
+    function_selector: call.selector.toField(),
+    target_address: call.to.toField(),
+    is_public: call.type == FunctionType.PUBLIC,
+    is_static: call.isStatic,
+  }));
+
+  return {
+    encodedFunctionCalls,
+    hashedArguments,
+  };
+}

package/src/index.ts

@@ -8,3 +8,6 @@
 
 export * from './account_entrypoint.js';
 export * from './dapp_entrypoint.js';
+export * from './interfaces.js';
+export * from './default_entrypoint.js';
+export * from './encoding.js';

package/src/interfaces.ts

@@ -0,0 +1,93 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FieldsOf } from '@aztec/foundation/types';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import type { ExecutionPayload } from './payload.js';
+
+/**
+ * General options for the tx execution.
+ */
+export type TxExecutionOptions = {
+  /** Whether the transaction can be cancelled. */
+  cancellable?: boolean;
+  /** The nonce to use for the transaction. */
+  nonce?: Fr;
+};
+
+/**
+ * Creates transaction execution requests out of a set of function calls, a fee payment method and
+ * general options for the transaction
+ */
+export interface EntrypointInterface {
+  /**
+   * Generates an execution request out of set of function calls.
+   * @param exec - The execution intents to be run.
+   * @param fee - The fee options for the transaction.
+   * @param options - Nonce and whether the transaction is cancellable.
+   * @returns The authenticated transaction execution request.
+   */
+  createTxExecutionRequest(
+    exec: ExecutionPayload,
+    fee: FeeOptions,
+    options: TxExecutionOptions,
+  ): Promise<TxExecutionRequest>;
+}
+
+/** Creates authorization witnesses. */
+export interface AuthWitnessProvider {
+  /**
+   * Computes an authentication witness from either a message hash
+   * @param messageHash - The message hash to approve
+   * @returns The authentication witness
+   */
+  createAuthWit(messageHash: Fr | Buffer): Promise<AuthWitness>;
+}
+
+/**
+ * Holds information about how the fee for a transaction is to be paid.
+ */
+export interface FeePaymentMethod {
+  /** The asset used to pay the fee. */
+  getAsset(): Promise<AztecAddress>;
+  /**
+   * Returns the data to be added to the final execution request
+   * to pay the fee in the given asset
+   * @param gasSettings - The gas limits and max fees.
+   * @returns The function calls to pay the fee.
+   */
+  getExecutionPayload(gasSettings: GasSettings): Promise<ExecutionPayload>;
+  /**
+   * The expected fee payer for this tx.
+   * @param gasSettings - The gas limits and max fees.
+   */
+  getFeePayer(gasSettings: GasSettings): Promise<AztecAddress>;
+}
+
+/**
+ * Fee payment options for a transaction.
+ */
+export type FeeOptions = {
+  /** The fee payment method to use */
+  paymentMethod: FeePaymentMethod;
+  /** The gas settings */
+  gasSettings: GasSettings;
+};
+
+// docs:start:user_fee_options
+/** Fee options as set by a user. */
+export type UserFeeOptions = {
+  /** The fee payment method to use */
+  paymentMethod?: FeePaymentMethod;
+  /** The gas settings */
+  gasSettings?: Partial<FieldsOf<GasSettings>>;
+  /** Percentage to pad the base fee by, if empty, defaults to 0.5 */
+  baseFeePadding?: number;
+  /** Whether to run an initial simulation of the tx with high gas limit to figure out actual gas settings. */
+  estimateGas?: boolean;
+  /** Percentage to pad the estimated gas limits by, if empty, defaults to 0.1. Only relevant if estimateGas is set. */
+  estimatedGasPadding?: number;
+};
+// docs:end:user_fee_options