@aztec/entrypoints 0.80.0 → 0.82.0

package/dest/account_entrypoint.d.ts

@@ -1,7 +1,7 @@
-import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
-import { type EntrypointInterface, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { TxExecutionRequest } from '@aztec/stdlib/tx';
+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
  * for an account, which accepts an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
@@ -12,7 +12,7 @@ export declare class DefaultAccountEntrypoint implements EntrypointInterface {
     private chainId;
     private version;
     constructor(address: AztecAddress, auth: AuthWitnessProvider, chainId?: number, version?: number);
-    createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest>;
+    createTxExecutionRequest(exec: ExecutionPayload, fee: FeeOptions, options: TxExecutionOptions): Promise<TxExecutionRequest>;
     private getEntrypointAbi;
 }
 //# sourceMappingURL=account_entrypoint.d.ts.map

package/dest/account_entrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"account_entrypoint.d.ts","sourceRoot":"","sources":["../src/account_entrypoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EACL,KAAK,mBAAmB,EAExB,KAAK,oBAAoB,EAE1B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAI/E;;;GAGG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAEhE,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;gBAHP,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,mBAAmB,EACzB,OAAO,GAAE,MAAyB,EAClC,OAAO,GAAE,MAAwB;IAGrC,wBAAwB,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA2BvF,OAAO,CAAC,gBAAgB;CAqGzB"}
+{"version":3,"file":"account_entrypoint.d.ts","sourceRoot":"","sources":["../src/account_entrypoint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAI/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAChH,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD;;;GAGG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAEhE,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;gBAHP,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,mBAAmB,EACzB,OAAO,GAAE,MAAyB,EAClC,OAAO,GAAE,MAAwB;IAGrC,wBAAwB,CAC5B,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,kBAAkB,CAAC;IA8C9B,OAAO,CAAC,gBAAgB;CAqGzB"}

package/dest/account_entrypoint.js

@@ -1,7 +1,7 @@
-import { EntrypointPayload, computeCombinedPayloadHash } from '@aztec/aztec.js/entrypoint';
 import { FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
 import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
 import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
+import { EncodedCallsForEntrypoint, computeCombinedPayloadHash } from './encoding.js';
 /**
  * Implementation for an entrypoint interface that follows the default entrypoint signature
  * for an account, which accepts an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
@@ -16,29 +16,43 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
         this.chainId = chainId;
         this.version = version;
     }
-    async createTxExecutionRequest(exec) {
-        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, fee, options) {
+        // 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,
+            appEncodedCalls,
+            feeEncodedCalls,
             !!cancellable
         ]));
-        const combinedPayloadAuthWitness = await this.auth.createAuthWit(await computeCombinedPayloadHash(appPayload, feePayload));
+        // 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 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
+                ...appEncodedCalls.hashedArguments,
+                ...feeEncodedCalls.hashedArguments,
+                entrypointHashedArgs,
+                ...extraHashedArgs
             ],
             authWitnesses: [
                 ...authWitnesses,
+                ...feeAuthwitnesses,
                 combinedPayloadAuthWitness
             ],
             capsules

package/dest/dapp_entrypoint.d.ts

@@ -1,7 +1,7 @@
-import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
-import { type EntrypointInterface, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { TxExecutionRequest } from '@aztec/stdlib/tx';
+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
  * for an account, which accepts an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
@@ -13,7 +13,7 @@ export declare class DefaultDappEntrypoint implements EntrypointInterface {
     private chainId;
     private version;
     constructor(userAddress: AztecAddress, userAuthWitnessProvider: AuthWitnessProvider, dappEntrypointAddress: AztecAddress, chainId?: number, version?: number);
-    createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest>;
+    createTxExecutionRequest(exec: ExecutionPayload, fee: FeeOptions, options: TxExecutionOptions): Promise<TxExecutionRequest>;
     private getEntrypointAbi;
 }
 //# sourceMappingURL=dapp_entrypoint.d.ts.map

package/dest/dapp_entrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dapp_entrypoint.d.ts","sourceRoot":"","sources":["../src/dapp_entrypoint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,KAAK,mBAAmB,EAAqB,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEpH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAI/E;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,mBAAmB;IAE7D,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,uBAAuB;IAC/B,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;gBAJP,WAAW,EAAE,YAAY,EACzB,uBAAuB,EAAE,mBAAmB,EAC5C,qBAAqB,EAAE,YAAY,EACnC,OAAO,GAAE,MAAyB,EAClC,OAAO,GAAE,MAAwB;IAGrC,wBAAwB,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAqCvF,OAAO,CAAC,gBAAgB;CAiEzB"}
+{"version":3,"file":"dapp_entrypoint.d.ts","sourceRoot":"","sources":["../src/dapp_entrypoint.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAI/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAChH,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,mBAAmB;IAE7D,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,uBAAuB;IAC/B,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;gBAJP,WAAW,EAAE,YAAY,EACzB,uBAAuB,EAAE,mBAAmB,EAC5C,qBAAqB,EAAE,YAAY,EACnC,OAAO,GAAE,MAAyB,EAClC,OAAO,GAAE,MAAwB;IAGrC,wBAAwB,CAC5B,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,kBAAkB,CAAC;IAiD9B,OAAO,CAAC,gBAAgB;CAiEzB"}

package/dest/dapp_entrypoint.js

@@ -1,8 +1,9 @@
-import { Fr, computeAuthWitMessageHash, computeInnerAuthWitHash } from '@aztec/aztec.js';
-import { EntrypointPayload } from '@aztec/aztec.js/entrypoint';
-import { FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import { Fr } from '@aztec/foundation/fields';
+import { FunctionSelector, FunctionType, encodeArguments } from '@aztec/stdlib/abi';
+import { computeInnerAuthWitHash, computeOuterAuthWitHash } from '@aztec/stdlib/auth-witness';
 import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
 import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
+import { EncodedCallsForEntrypoint } from './encoding.js';
 /**
  * Implementation for an entrypoint interface that follows the default entrypoint signature
  * for an account, which accepts an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
@@ -19,17 +20,25 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
         this.chainId = chainId;
         this.version = version;
     }
-    async createTxExecutionRequest(exec) {
-        const { calls, fee, authWitnesses = [], capsules = [] } = exec;
+    async createTxExecutionRequest(exec, fee, options) {
+        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,
+            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,26 +46,22 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
             functionSelector.toField(),
             entrypointHashedArgs.hash
         ]);
-        const outerHash = await computeAuthWitMessageHash({
-            consumer: this.dappEntrypointAddress,
-            innerHash
-        }, {
-            chainId: new Fr(this.chainId),
-            version: new Fr(this.version)
-        });
-        const authWitness = await this.userAuthWitnessProvider.createAuthWit(outerHash);
+        const outerHash = await computeOuterAuthWitHash(this.dappEntrypointAddress, new Fr(this.chainId), new Fr(this.version), innerHash);
+        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
+                ...encodedCalls.hashedArguments,
+                entrypointHashedArgs,
+                ...extraHashedArgs
             ],
             authWitnesses: [
-                ...authWitnesses,
-                authWitness
+                entypointAuthwitness,
+                ...authWitnesses
             ],
             capsules
         });
@@ -66,7 +71,7 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
         return {
             name: 'entrypoint',
             isInitializer: false,
-            functionType: 'private',
+            functionType: FunctionType.PRIVATE,
             isInternal: false,
             isStatic: false,
             parameters: [

package/dest/default_entrypoint.d.ts

@@ -0,0 +1,13 @@
+import { 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 declare class DefaultEntrypoint implements EntrypointInterface {
+    private chainId;
+    private protocolVersion;
+    constructor(chainId: number, protocolVersion: number);
+    createTxExecutionRequest(exec: ExecutionPayload, fee: FeeOptions, options: TxExecutionOptions): Promise<TxExecutionRequest>;
+}
+//# sourceMappingURL=default_entrypoint.d.ts.map

package/dest/default_entrypoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default_entrypoint.d.ts","sourceRoot":"","sources":["../src/default_entrypoint.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC3F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;GAEG;AACH,qBAAa,iBAAkB,YAAW,mBAAmB;IAC/C,OAAO,CAAC,OAAO;IAAU,OAAO,CAAC,eAAe;gBAAxC,OAAO,EAAE,MAAM,EAAU,eAAe,EAAE,MAAM;IAE9D,wBAAwB,CAC5B,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,kBAAkB,CAAC;CA+B/B"}

package/dest/default_entrypoint.js

@@ -0,0 +1,35 @@
+import { FunctionType } from '@aztec/stdlib/abi';
+import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+/**
+ * Default implementation of the entrypoint interface. It calls a function on a contract directly
+ */ export class DefaultEntrypoint {
+    chainId;
+    protocolVersion;
+    constructor(chainId, protocolVersion){
+        this.chainId = chainId;
+        this.protocolVersion = protocolVersion;
+    }
+    async createTxExecutionRequest(exec, fee, options) {
+        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/dest/encoding.d.ts

@@ -0,0 +1,111 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { FunctionCall } from '@aztec/stdlib/abi';
+import { HashedValues } from '@aztec/stdlib/tx';
+declare const APP_MAX_CALLS = 4;
+declare const FEE_MAX_CALLS = 2;
+/** 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;
+};
+/** 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 declare abstract class EncodedCallsForEntrypoint implements 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[];
+    /** The index of the generator to use for hashing */
+    generatorIndex: number;
+    /** The nonce for the payload, used to emit a nullifier identifying the call */
+    nonce: Fr;
+    constructor(
+    /** 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[], 
+    /** The index of the generator to use for hashing */
+    generatorIndex: number, 
+    /** The nonce for the payload, used to emit a nullifier identifying the call */
+    nonce: Fr);
+    /**
+     * The function calls to execute. This uses snake_case naming so that it is compatible with Noir encoding
+     * @internal
+     */
+    get function_calls(): EncodedFunctionCall[];
+    /**
+     * 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(): Promise<Fr>;
+    /** Serializes the function calls to an array of fields. */
+    protected functionCallsToFields(): Fr[];
+    /**
+     * Encodes a set of function calls for a dapp entrypoint
+     * @param functionCalls - The function calls to execute
+     * @returns The encoded calls
+     */
+    static fromFunctionCalls(functionCalls: FunctionCall[]): Promise<EncodedAppEntrypointCalls>;
+    /**
+     * 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 fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, typeof APP_MAX_CALLS>, nonce?: Fr): Promise<EncodedAppEntrypointCalls>;
+    /**
+     * 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 fromFeeCalls(functionCalls: FunctionCall[] | Tuple<FunctionCall, typeof FEE_MAX_CALLS>, isFeePayer: boolean): Promise<EncodedFeeEntrypointCalls>;
+}
+/** Encoded calls for app phase execution. */
+export declare class EncodedAppEntrypointCalls extends EncodedCallsForEntrypoint {
+    constructor(encodedFunctionCalls: EncodedFunctionCall[], hashedArguments: HashedValues[], generatorIndex: number, nonce: Fr);
+    toFields(): Fr[];
+}
+/** Encoded calls for fee payment */
+export declare class EncodedFeeEntrypointCalls extends EncodedCallsForEntrypoint {
+    #private;
+    constructor(encodedFunctionCalls: EncodedFunctionCall[], hashedArguments: HashedValues[], generatorIndex: number, nonce: Fr, isFeePayer: boolean);
+    toFields(): Fr[];
+    /** Whether the sender should be appointed as fee payer. */
+    get is_fee_payer(): boolean;
+}
+/**
+ * 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 declare function computeCombinedPayloadHash(appPayload: EncodedAppEntrypointCalls, feePayload: EncodedFeeEntrypointCalls): Promise<Fr>;
+/** Encodes FunctionCalls for execution, following Noir's convention */
+export declare function encode(calls: FunctionCall[]): Promise<EncodedCalls>;
+export {};
+//# sourceMappingURL=encoding.d.ts.map

package/dest/encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../src/encoding.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAgB,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIhD,QAAA,MAAM,aAAa,IAAI,CAAC;AAExB,QAAA,MAAM,aAAa,IAAI,CAAC;AAGxB,oDAAoD;AACpD,MAAM,MAAM,mBAAmB,GAAG;IAChC,kCAAkC;IAClC,SAAS,EAAE,EAAE,CAAC;IACd,uCAAuC;IACvC,iBAAiB,EAAE,EAAE,CAAC;IACtB,sCAAsC;IACtC,cAAc,EAAE,EAAE,CAAC;IACnB,gDAAgD;IAChD,SAAS,EAAE,OAAO,CAAC;IACnB,2CAA2C;IAC3C,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAGF,sFAAsF;AACtF,MAAM,MAAM,YAAY,GAAG;IACzB,gEAAgE;IAChE,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;IAC5C,gFAAgF;IAChF,eAAe,EAAE,YAAY,EAAE,CAAC;CACjC,CAAC;AAEF;;;;KAIK;AACL,8BAAsB,yBAA0B,YAAW,YAAY;IAEnE,gEAAgE;IACzD,oBAAoB,EAAE,mBAAmB,EAAE;IAClD,gFAAgF;IACzE,eAAe,EAAE,YAAY,EAAE;IACtC,oDAAoD;IAC7C,cAAc,EAAE,MAAM;IAC7B,+EAA+E;IACxE,KAAK,EAAE,EAAE;;IAPhB,gEAAgE;IACzD,oBAAoB,EAAE,mBAAmB,EAAE;IAClD,gFAAgF;IACzE,eAAe,EAAE,YAAY,EAAE;IACtC,oDAAoD;IAC7C,cAAc,EAAE,MAAM;IAC7B,+EAA+E;IACxE,KAAK,EAAE,EAAE;IAIlB;;;OAGG;IACH,IAAI,cAAc,0BAEjB;IAGD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,IAAI,EAAE,EAAE;IAEzB;;;OAGG;IACH,IAAI;IAIJ,2DAA2D;IAC3D,SAAS,CAAC,qBAAqB;IAU/B;;;;OAIG;WACU,iBAAiB,CAAC,aAAa,EAAE,YAAY,EAAE;IAK5D;;;;;OAKG;WACU,gBAAgB,CAC3B,aAAa,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC,YAAY,EAAE,OAAO,aAAa,CAAC,EACzE,KAAK,KAAc;IAerB;;;;;OAKG;WACU,YAAY,CACvB,aAAa,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC,YAAY,EAAE,OAAO,aAAa,CAAC,EACzE,UAAU,EAAE,OAAO;CAYtB;AAED,6CAA6C;AAC7C,qBAAa,yBAA0B,SAAQ,yBAAyB;gBAEpE,oBAAoB,EAAE,mBAAmB,EAAE,EAC3C,eAAe,EAAE,YAAY,EAAE,EAC/B,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,EAAE;IAKF,QAAQ,IAAI,EAAE,EAAE;CAG1B;AAED,oCAAoC;AACpC,qBAAa,yBAA0B,SAAQ,yBAAyB;;gBAIpE,oBAAoB,EAAE,mBAAmB,EAAE,EAC3C,eAAe,EAAE,YAAY,EAAE,EAC/B,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,EAAE,EACT,UAAU,EAAE,OAAO;IAMZ,QAAQ,IAAI,EAAE,EAAE;IAKzB,2DAA2D;IAC3D,IAAI,YAAY,YAEf;CAEF;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,yBAAyB,EACrC,UAAU,EAAE,yBAAyB,GACpC,OAAO,CAAC,EAAE,CAAC,CAKb;AAED,uEAAuE;AACvE,wBAAsB,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAmBzE"}

package/dest/encoding.js

@@ -0,0 +1,135 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+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;
+/**
+ * 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 class EncodedCallsForEntrypoint {
+    encodedFunctionCalls;
+    hashedArguments;
+    generatorIndex;
+    nonce;
+    constructor(/** Function calls in the expected format (Noir's convention) */ encodedFunctionCalls, /** The hashed args for the call, ready to be injected in the execution cache */ hashedArguments, /** The index of the generator to use for hashing */ generatorIndex, /** The nonce for the payload, used to emit a nullifier identifying the call */ nonce){
+        this.encodedFunctionCalls = encodedFunctionCalls;
+        this.hashedArguments = hashedArguments;
+        this.generatorIndex = generatorIndex;
+        this.nonce = nonce;
+    }
+    /* 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;
+    }
+    /**
+   * 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. */ 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) {
+        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, 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, isFeePayer) {
+        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, hashedArguments, generatorIndex, nonce){
+        super(encodedFunctionCalls, hashedArguments, generatorIndex, nonce);
+    }
+    toFields() {
+        return [
+            ...this.functionCallsToFields(),
+            this.nonce
+        ];
+    }
+}
+/** Encoded calls for fee payment */ export class EncodedFeeEntrypointCalls extends EncodedCallsForEntrypoint {
+    #isFeePayer;
+    constructor(encodedFunctionCalls, hashedArguments, generatorIndex, nonce, isFeePayer){
+        super(encodedFunctionCalls, hashedArguments, generatorIndex, nonce);
+        this.#isFeePayer = isFeePayer;
+    }
+    toFields() {
+        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;
+    }
+}
+/**
+ * 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, feePayload) {
+    return poseidon2HashWithSeparator([
+        await appPayload.hash(),
+        await feePayload.hash()
+    ], GeneratorIndex.COMBINED_PAYLOAD);
+}
+/** Encodes FunctionCalls for execution, following Noir's convention */ export async function encode(calls) {
+    const hashedArguments = [];
+    for (const call of calls){
+        hashedArguments.push(await HashedValues.fromValues(call.args));
+    }
+    /* eslint-disable camelcase */ const encodedFunctionCalls = 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/dest/index.d.ts

@@ -7,4 +7,7 @@
  */
 export * from './account_entrypoint.js';
 export * from './dapp_entrypoint.js';
+export * from './interfaces.js';
+export * from './default_entrypoint.js';
+export * from './encoding.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC"}

package/dest/index.js

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

package/dest/interfaces.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+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;
+};
+/** 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;
+};
+//# sourceMappingURL=interfaces.d.ts.map

package/dest/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gDAAgD;IAChD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,EAAE,CAAC;CACZ,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,wBAAwB,CACtB,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAChC;AAED,uCAAuC;AACvC,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,aAAa,CAAC,WAAW,EAAE,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC/D;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IAClC;;;;;OAKG;IACH,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACzE;;;OAGG;IACH,WAAW,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CAC9D;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,oCAAoC;IACpC,aAAa,EAAE,gBAAgB,CAAC;IAChC,uBAAuB;IACvB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAGF,oCAAoC;AACpC,MAAM,MAAM,cAAc,GAAG;IAC3B,oCAAoC;IACpC,aAAa,CAAC,EAAE,gBAAgB,CAAC;IACjC,uBAAuB;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;IAC7C,mEAAmE;IACnE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4GAA4G;IAC5G,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,qHAAqH;IACrH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC"}

package/dest/interfaces.js

@@ -0,0 +1,2 @@
+// docs:start:user_fee_options
+/** Fee options as set by a user. */ export { }; // docs:end:user_fee_options