@aztec/entrypoints 0.81.0 → 0.82.1-alpha-testnet.1

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,
+        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

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,
+        const entrypointHashedArgs = await HashedValues.fromArgs(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,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.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.protocolVersion, 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":"AAEA,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;IAiCpG,OAAO,CAAC,gBAAgB;CAwDzB"}

package/dest/default_multi_call_entrypoint.js

@@ -0,0 +1,141 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+import { EncodedCallsForEntrypoint } from './encoding.js';
+/**
+ * Implementation for an entrypoint interface that can execute multiple function calls in a single transaction
+ */ export class DefaultMultiCallEntrypoint {
+    chainId;
+    version;
+    address;
+    constructor(chainId, version, address = ProtocolContractAddress.MultiCallEntrypoint){
+        this.chainId = chainId;
+        this.version = version;
+        this.address = address;
+    }
+    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.fromArgs(encodeArguments(abi, [
+            encodedCalls
+        ]));
+        // 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: [
+                ...encodedCalls.hashedArguments,
+                entrypointHashedArgs,
+                ...extraHashedArgs,
+                ...feeExtraHashedArgs
+            ],
+            authWitnesses: [
+                ...feeAuthwitnesses,
+                ...authWitnesses
+            ],
+            capsules
+        });
+        return Promise.resolve(txRequest);
+    }
+    getEntrypointAbi() {
+        return {
+            name: 'entrypoint',
+            isInitializer: false,
+            functionType: 'private',
+            isInternal: false,
+            isStatic: false,
+            parameters: [
+                {
+                    name: 'app_payload',
+                    type: {
+                        kind: 'struct',
+                        path: 'authwit::entrypoint::app::AppPayload',
+                        fields: [
+                            {
+                                name: 'function_calls',
+                                type: {
+                                    kind: 'array',
+                                    length: 4,
+                                    type: {
+                                        kind: 'struct',
+                                        path: 'authwit::entrypoint::function_call::FunctionCall',
+                                        fields: [
+                                            {
+                                                name: 'args_hash',
+                                                type: {
+                                                    kind: 'field'
+                                                }
+                                            },
+                                            {
+                                                name: 'function_selector',
+                                                type: {
+                                                    kind: 'struct',
+                                                    path: 'authwit::aztec::protocol_types::abis::function_selector::FunctionSelector',
+                                                    fields: [
+                                                        {
+                                                            name: 'inner',
+                                                            type: {
+                                                                kind: 'integer',
+                                                                sign: 'unsigned',
+                                                                width: 32
+                                                            }
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                name: 'target_address',
+                                                type: {
+                                                    kind: 'struct',
+                                                    path: 'authwit::aztec::protocol_types::address::AztecAddress',
+                                                    fields: [
+                                                        {
+                                                            name: 'inner',
+                                                            type: {
+                                                                kind: 'field'
+                                                            }
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            {
+                                                name: 'is_public',
+                                                type: {
+                                                    kind: 'boolean'
+                                                }
+                                            },
+                                            {
+                                                name: 'is_static',
+                                                type: {
+                                                    kind: 'boolean'
+                                                }
+                                            }
+                                        ]
+                                    }
+                                }
+                            },
+                            {
+                                name: 'nonce',
+                                type: {
+                                    kind: 'field'
+                                }
+                            }
+                        ]
+                    },
+                    visibility: 'public'
+                }
+            ],
+            returnTypes: [],
+            errorTypes: {}
+        };
+    }
+}

package/dest/encoding.d.ts

@@ -0,0 +1,112 @@
+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;
+    /** 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,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;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,CAuBzE"}