@aztec/entrypoints 0.0.0-test.1 → 0.0.1-fake-ceab37513c

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":"AAEA,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;IA+C9B,OAAO,CAAC,gBAAgB;CAqGzB"}

package/dest/account_entrypoint.js

@@ -1,7 +1,8 @@
-import { EntrypointPayload, computeCombinedPayloadHash } from '@aztec/aztec.js/entrypoint';
+import { Fr } from '@aztec/foundation/fields';
 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,31 +17,47 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
         this.chainId = chainId;
         this.version = version;
     }
-    async createTxExecutionRequest(exec) {
-        const { calls, fee, nonce, cancellable, 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, 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.fromValues(encodeArguments(abi, [
-            appPayload,
-            feePayload,
+        const entrypointHashedArgs = await HashedValues.fromArgs(encodeArguments(abi, [
+            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
+            capsules,
+            salt: Fr.random()
         });
         return txRequest;
     }
@@ -122,7 +139,7 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
                                 }
                             },
                             {
-                                name: 'nonce',
+                                name: 'tx_nonce',
                                 type: {
                                     kind: 'field'
                                 }
@@ -201,7 +218,7 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
                                 }
                             },
                             {
-                                name: 'nonce',
+                                name: 'tx_nonce',
                                 type: {
                                     kind: 'field'
                                 }

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 rollupVersion;
+    constructor(chainId: number, rollupVersion: 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;IAEzD,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,aAAa;gBADb,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM;IAGzB,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;
+    rollupVersion;
+    constructor(chainId, rollupVersion){
+        this.chainId = chainId;
+        this.rollupVersion = rollupVersion;
+    }
+    async createTxExecutionRequest(exec, fee, options) {
+        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;
+        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.fromArgs(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.rollupVersion, fee.gasSettings), [
+            ...hashedArguments,
+            ...extraHashedArgs
+        ], authWitnesses, capsules);
+    }
+}

package/dest/default_multi_call_entrypoint.d.ts

@@ -0,0 +1,16 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { EntrypointInterface, FeeOptions } from './interfaces.js';
+import type { ExecutionPayload } from './payload.js';
+/**
+ * Implementation for an entrypoint interface that can execute multiple function calls in a single transaction
+ */
+export declare class DefaultMultiCallEntrypoint implements EntrypointInterface {
+    private chainId;
+    private version;
+    private address;
+    constructor(chainId: number, version: number, address?: AztecAddress);
+    createTxExecutionRequest(exec: ExecutionPayload, fee: FeeOptions): Promise<TxExecutionRequest>;
+    private getEntrypointAbi;
+}
+//# sourceMappingURL=default_multi_call_entrypoint.d.ts.map

package/dest/default_multi_call_entrypoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default_multi_call_entrypoint.d.ts","sourceRoot":"","sources":["../src/default_multi_call_entrypoint.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;GAEG;AACH,qBAAa,0BAA2B,YAAW,mBAAmB;IAElE,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;gBAFP,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,YAA0D;IAGvE,wBAAwB,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAkCpG,OAAO,CAAC,gBAAgB;CAwDzB"}

package/dest/{dapp_entrypoint.js → default_multi_call_entrypoint.js}

@@ -1,65 +1,52 @@
-import { Fr, computeAuthWitMessageHash, computeInnerAuthWitHash } from '@aztec/aztec.js';
-import { EntrypointPayload } from '@aztec/aztec.js/entrypoint';
+import { Fr } from '@aztec/foundation/fields';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 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 } 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
- */ export class DefaultDappEntrypoint {
-    userAddress;
-    userAuthWitnessProvider;
-    dappEntrypointAddress;
+ * Implementation for an entrypoint interface that can execute multiple function calls in a single transaction
+ */ export class DefaultMultiCallEntrypoint {
     chainId;
     version;
-    constructor(userAddress, userAuthWitnessProvider, dappEntrypointAddress, chainId = DEFAULT_CHAIN_ID, version = DEFAULT_VERSION){
-        this.userAddress = userAddress;
-        this.userAuthWitnessProvider = userAuthWitnessProvider;
-        this.dappEntrypointAddress = dappEntrypointAddress;
+    address;
+    constructor(chainId, version, address = ProtocolContractAddress.MultiCallEntrypoint){
         this.chainId = chainId;
         this.version = version;
+        this.address = address;
     }
-    async createTxExecutionRequest(exec) {
-        const { calls, fee, capsules = [] } = exec;
-        if (calls.length !== 1) {
-            throw new Error(`Expected exactly 1 function call, got ${calls.length}`);
-        }
-        const payload = await EntrypointPayload.fromFunctionCalls(calls);
+    async createTxExecutionRequest(exec, fee) {
+        // Initial request with calls, authWitnesses and capsules
+        const { calls, authWitnesses, capsules, extraHashedArgs } = 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.fromValues(encodeArguments(abi, [
-            payload,
-            this.userAddress
+        const entrypointHashedArgs = await HashedValues.fromArgs(encodeArguments(abi, [
+            encodedCalls
         ]));
-        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([
-            Fr.MAX_FIELD_VALUE,
-            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);
+        // Assemble the tx request
         const txRequest = TxExecutionRequest.from({
             firstCallArgsHash: entrypointHashedArgs.hash,
-            origin: this.dappEntrypointAddress,
-            functionSelector,
+            origin: this.address,
+            functionSelector: await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
             txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
             argsOfCalls: [
-                ...payload.hashedArguments,
-                entrypointHashedArgs
+                ...encodedCalls.hashedArguments,
+                entrypointHashedArgs,
+                ...extraHashedArgs,
+                ...feeExtraHashedArgs
             ],
             authWitnesses: [
-                authWitness
+                ...feeAuthwitnesses,
+                ...authWitnesses
             ],
-            capsules
+            capsules,
+            salt: Fr.random()
         });
-        return txRequest;
+        return Promise.resolve(txRequest);
     }
     getEntrypointAbi() {
         return {
@@ -70,16 +57,16 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
             isStatic: false,
             parameters: [
                 {
-                    name: 'payload',
+                    name: 'app_payload',
                     type: {
                         kind: 'struct',
-                        path: 'dapp_payload::DAppPayload',
+                        path: 'authwit::entrypoint::app::AppPayload',
                         fields: [
                             {
                                 name: 'function_calls',
                                 type: {
                                     kind: 'array',
-                                    length: 1,
+                                    length: 4,
                                     type: {
                                         kind: 'struct',
                                         path: 'authwit::entrypoint::function_call::FunctionCall',
@@ -111,7 +98,7 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
                                                 name: 'target_address',
                                                 type: {
                                                     kind: 'struct',
-                                                    path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+                                                    path: 'authwit::aztec::protocol_types::address::AztecAddress',
                                                     fields: [
                                                         {
                                                             name: 'inner',
@@ -139,23 +126,7 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
                                 }
                             },
                             {
-                                name: 'nonce',
-                                type: {
-                                    kind: 'field'
-                                }
-                            }
-                        ]
-                    },
-                    visibility: 'public'
-                },
-                {
-                    name: 'user_address',
-                    type: {
-                        kind: 'struct',
-                        path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
-                        fields: [
-                            {
-                                name: 'inner',
+                                name: 'tx_nonce',
                                 type: {
                                     kind: 'field'
                                 }

package/dest/encoding.d.ts

@@ -0,0 +1,121 @@
+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. */
+    /** This should be the calldata hash `hash([function_selector, ...args])` if `is_public` is true. */
+    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;
+    /**
+     * 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
+     * but higher fee. The nullifier ensures only one transaction can succeed.
+     */
+    tx_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, 
+    /**
+     * 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
+     * but higher fee. The nullifier ensures only one transaction can succeed.
+     */
+    tx_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 txNonce - A nonce used to enable transaction cancellation when cancellable=true. Transactions with the same
+     * nonce can be replaced by submitting a new one with a higher fee.
+     * @returns The encoded calls
+     */
+    static fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, typeof APP_MAX_CALLS>, txNonce?: 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, txNonce: Fr);
+    toFields(): Fr[];
+}
+/** Encoded calls for fee payment */
+export declare class EncodedFeeEntrypointCalls extends EncodedCallsForEntrypoint {
+    #private;
+    constructor(encodedFunctionCalls: EncodedFunctionCall[], hashedArguments: HashedValues[], generatorIndex: number, txNonce: 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;AAExB,oDAAoD;AACpD,MAAM,MAAM,mBAAmB,GAAG;IAChC,mCAAmC;IACnC,oGAAoG;IACpG,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;AAEF,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;;;;OAIG;IAEI,QAAQ,EAAE,EAAE;;IAZnB,gEAAgE;IACzD,oBAAoB,EAAE,mBAAmB,EAAE;IAClD,gFAAgF;IACzE,eAAe,EAAE,YAAY,EAAE;IACtC,oDAAoD;IAC7C,cAAc,EAAE,MAAM;IAC7B;;;;OAIG;IAEI,QAAQ,EAAE,EAAE;IAIrB;;;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;;;;;;OAMG;WACU,gBAAgB,CAC3B,aAAa,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC,YAAY,EAAE,OAAO,aAAa,CAAC,EACzE,OAAO,KAAc;IAevB;;;;;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,OAAO,EAAE,EAAE;IAKJ,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,OAAO,EAAE,EAAE,EACX,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,CAuBzE"}

package/dest/encoding.js

@@ -0,0 +1,145 @@
+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;
+    tx_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, /**
+     * 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
+     * but higher fee. The nullifier ensures only one transaction can succeed.
+     */ // eslint-disable-next-line camelcase
+    tx_nonce){
+        this.encodedFunctionCalls = encodedFunctionCalls;
+        this.hashedArguments = hashedArguments;
+        this.generatorIndex = generatorIndex;
+        this.tx_nonce = tx_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 txNonce - A nonce used to enable transaction cancellation when cancellable=true. Transactions with the same
+   * nonce can be replaced by submitting a new one with a higher fee.
+   * @returns The encoded calls
+   */ static async fromAppExecution(functionCalls, txNonce = 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, 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, 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, txNonce){
+        super(encodedFunctionCalls, hashedArguments, generatorIndex, txNonce);
+    }
+    toFields() {
+        return [
+            ...this.functionCallsToFields(),
+            this.tx_nonce
+        ];
+    }
+}
+/** Encoded calls for fee payment */ export class EncodedFeeEntrypointCalls extends EncodedCallsForEntrypoint {
+    #isFeePayer;
+    constructor(encodedFunctionCalls, hashedArguments, generatorIndex, txNonce, isFeePayer){
+        super(encodedFunctionCalls, hashedArguments, generatorIndex, txNonce);
+        this.#isFeePayer = isFeePayer;
+    }
+    toFields() {
+        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;
+    }
+}
+/**
+ * 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){
+        const hashed = call.type === FunctionType.PUBLIC ? await HashedValues.fromCalldata([
+            call.selector.toField(),
+            ...call.args
+        ]) : await HashedValues.fromArgs(call.args);
+        hashedArguments.push(hashed);
+    }
+    /* 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

@@ -6,5 +6,8 @@
  * @packageDocumentation
  */
 export * from './account_entrypoint.js';
-export * from './dapp_entrypoint.js';
+export * from './interfaces.js';
+export * from './default_entrypoint.js';
+export * from './encoding.js';
+export * from './default_multi_call_entrypoint.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,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,cAAc,oCAAoC,CAAC"}

package/dest/index.js

@@ -5,4 +5,7 @@
  *
  * @packageDocumentation
  */ export * from './account_entrypoint.js';
-export * from './dapp_entrypoint.js';
+export * from './interfaces.js';
+export * from './default_entrypoint.js';
+export * from './encoding.js';
+export * from './default_multi_call_entrypoint.js';