@aztec/entrypoints 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/account_entrypoint.d.ts

@@ -1,7 +1,49 @@
-import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
-import { type EntrypointInterface, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
+import { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
 import { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { AuthWitnessProvider, EntrypointInterface } from './interfaces.js';
+import { ExecutionPayload } from './payload.js';
+/**
+ * The mechanism via which an account contract will pay for a transaction in which it gets invoked.
+ */
+export declare enum AccountFeePaymentMethodOptions {
+    /**
+     * Signals that some other contract is in charge of paying the fee, nothing needs to be done.
+     */
+    EXTERNAL = 0,
+    /**
+     * Used to make the account contract publicly pay for the transaction with its own fee juice balance,
+     * **which it must already have prior to this transaction**.
+     *
+     * The contract will set itself as the fee payer and end the setup phase.
+     */
+    PREEXISTING_FEE_JUICE = 1,
+    /**
+     * Used to make the account contract publicly pay for the transaction with its own fee juice balance
+     * **which is being claimed in the same transaction**.
+     *
+     * The contract will set itself as the fee payer but not end setup phase - this is done by the Fee Juice
+     * contract after enqueuing a public call, which unlike most public calls is whitelisted by the nodes
+     * to be executable during the setup phase.
+     */
+    FEE_JUICE_WITH_CLAIM = 2
+}
+/**
+ * General options for the tx execution.
+ */
+export type DefaultAccountEntrypointOptions = {
+    /** Whether the transaction can be cancelled. */
+    cancellable?: boolean;
+    /**
+     * A nonce to inject into the app payload of the transaction. When used with cancellable=true, this nonce will be
+     * used to compute a nullifier that allows cancelling this transaction by submitting a new one with the same nonce
+     * but higher fee. The nullifier ensures only one transaction can succeed.
+     */
+    txNonce?: Fr;
+    /** Options that configure how the account contract behaves depending on the fee payment method of the tx */
+    feePaymentMethodOptions: AccountFeePaymentMethodOptions;
+};
 /**
  * Implementation for an entrypoint interface that follows the default entrypoint signature
  * for an account, which accepts an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
@@ -12,7 +54,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, gasSettings: GasSettings, options: DefaultAccountEntrypointOptions): 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":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAI/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD;;GAEG;AACH,oBAAY,8BAA8B;IACxC;;OAEG;IACH,QAAQ,IAAI;IACZ;;;;;OAKG;IACH,qBAAqB,IAAI;IACzB;;;;;;;OAOG;IACH,oBAAoB,IAAI;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG;IAC5C,gDAAgD;IAChD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,OAAO,CAAC,EAAE,EAAE,CAAC;IACb,4GAA4G;IAC5G,uBAAuB,EAAE,8BAA8B,CAAC;CACzD,CAAC;AAEF;;;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,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,kBAAkB,CAAC;IAgC9B,OAAO,CAAC,gBAAgB;CA2DzB"}

package/dest/account_entrypoint.js

@@ -1,7 +1,30 @@
-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 { EncodedAppEntrypointCalls } from './encoding.js';
+/**
+ * The mechanism via which an account contract will pay for a transaction in which it gets invoked.
+ */ export var AccountFeePaymentMethodOptions = /*#__PURE__*/ function(AccountFeePaymentMethodOptions) {
+    /**
+   * Signals that some other contract is in charge of paying the fee, nothing needs to be done.
+   */ AccountFeePaymentMethodOptions[AccountFeePaymentMethodOptions["EXTERNAL"] = 0] = "EXTERNAL";
+    /**
+   * Used to make the account contract publicly pay for the transaction with its own fee juice balance,
+   * **which it must already have prior to this transaction**.
+   *
+   * The contract will set itself as the fee payer and end the setup phase.
+   */ AccountFeePaymentMethodOptions[AccountFeePaymentMethodOptions["PREEXISTING_FEE_JUICE"] = 1] = "PREEXISTING_FEE_JUICE";
+    /**
+   * Used to make the account contract publicly pay for the transaction with its own fee juice balance
+   * **which is being claimed in the same transaction**.
+   *
+   * The contract will set itself as the fee payer but not end setup phase - this is done by the Fee Juice
+   * contract after enqueuing a public call, which unlike most public calls is whitelisted by the nodes
+   * to be executable during the setup phase.
+   */ AccountFeePaymentMethodOptions[AccountFeePaymentMethodOptions["FEE_JUICE_WITH_CLAIM"] = 2] = "FEE_JUICE_WITH_CLAIM";
+    return AccountFeePaymentMethodOptions;
+}({});
 /**
  * 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 +39,39 @@ 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, gasSettings, options) {
+        // Initial request with calls, authWitnesses and capsules
+        const { calls, authWitnesses, capsules, extraHashedArgs } = exec;
+        // Global tx options
+        const { cancellable, txNonce, feePaymentMethodOptions } = options;
+        // Encode the calls for the app
+        const encodedCalls = await EncodedAppEntrypointCalls.create(calls, txNonce);
+        // Obtain the entrypoint hashed args, built from the app encoded calls and global options
         const abi = this.getEntrypointAbi();
-        const entrypointHashedArgs = await HashedValues.fromValues(encodeArguments(abi, [
-            appPayload,
-            feePayload,
+        const entrypointHashedArgs = await HashedValues.fromArgs(encodeArguments(abi, [
+            encodedCalls,
+            feePaymentMethodOptions,
             !!cancellable
         ]));
-        const combinedPayloadAuthWitness = await this.auth.createAuthWit(await computeCombinedPayloadHash(appPayload, feePayload));
+        // Generate the payload auth witness, by signing the hash of the payload
+        const appPayloadAuthwitness = await this.auth.createAuthWit(await encodedCalls.hash());
+        // 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),
+            txContext: new TxContext(this.chainId, this.version, gasSettings),
             argsOfCalls: [
-                ...appPayload.hashedArguments,
-                ...feePayload.hashedArguments,
-                entrypointHashedArgs
+                ...encodedCalls.hashedArguments,
+                entrypointHashedArgs,
+                ...extraHashedArgs
             ],
             authWitnesses: [
-                combinedPayloadAuthWitness
+                ...authWitnesses,
+                appPayloadAuthwitness
             ],
-            capsules
+            capsules,
+            salt: Fr.random()
         });
         return txRequest;
     }
@@ -62,7 +93,7 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
                                 name: 'function_calls',
                                 type: {
                                     kind: 'array',
-                                    length: 4,
+                                    length: 5,
                                     type: {
                                         kind: 'struct',
                                         path: 'authwit::entrypoint::function_call::FunctionCall',
@@ -112,80 +143,7 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
                                                 }
                                             },
                                             {
-                                                name: 'is_static',
-                                                type: {
-                                                    kind: 'boolean'
-                                                }
-                                            }
-                                        ]
-                                    }
-                                }
-                            },
-                            {
-                                name: 'nonce',
-                                type: {
-                                    kind: 'field'
-                                }
-                            }
-                        ]
-                    },
-                    visibility: 'public'
-                },
-                {
-                    name: 'fee_payload',
-                    type: {
-                        kind: 'struct',
-                        path: 'authwit::entrypoint::fee::FeePayload',
-                        fields: [
-                            {
-                                name: 'function_calls',
-                                type: {
-                                    kind: 'array',
-                                    length: 2,
-                                    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',
+                                                name: 'hide_msg_sender',
                                                 type: {
                                                     kind: 'boolean'
                                                 }
@@ -201,21 +159,23 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
                                 }
                             },
                             {
-                                name: 'nonce',
+                                name: 'tx_nonce',
                                 type: {
                                     kind: 'field'
                                 }
-                            },
-                            {
-                                name: 'is_fee_payer',
-                                type: {
-                                    kind: 'boolean'
-                                }
                             }
                         ]
                     },
                     visibility: 'public'
                 },
+                {
+                    name: 'fee_payment_method',
+                    type: {
+                        kind: 'integer',
+                        sign: 'unsigned',
+                        width: 8
+                    }
+                },
                 {
                     name: 'cancellable',
                     type: {

package/dest/default_entrypoint.d.ts

@@ -0,0 +1,14 @@
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { EntrypointInterface } 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, gasSettings: GasSettings): 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,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,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,CAAC,IAAI,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;CA4B9G"}

package/dest/default_entrypoint.js

@@ -0,0 +1,32 @@
+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, gasSettings) {
+        // 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, gasSettings), [
+            ...hashedArguments,
+            ...extraHashedArgs
+        ], authWitnesses, capsules);
+    }
+}

package/dest/default_multi_call_entrypoint.d.ts

@@ -0,0 +1,17 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { EntrypointInterface } 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, gasSettings: GasSettings): 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,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,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,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA0B7G,OAAO,CAAC,gBAAgB;CAyDzB"}

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

@@ -1,65 +1,45 @@
-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 { EncodedAppEntrypointCalls } 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, gasSettings) {
+        // Initial request with calls, authWitnesses and capsules
+        const { calls, authWitnesses, capsules, extraHashedArgs } = exec;
+        // Encode the calls for the app
+        const encodedCalls = await EncodedAppEntrypointCalls.create(calls);
+        // 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,
-            txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
+            origin: this.address,
+            functionSelector: await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
+            txContext: new TxContext(this.chainId, this.version, gasSettings),
             argsOfCalls: [
-                ...payload.hashedArguments,
-                entrypointHashedArgs
-            ],
-            authWitnesses: [
-                authWitness
+                ...encodedCalls.hashedArguments,
+                entrypointHashedArgs,
+                ...extraHashedArgs
             ],
-            capsules
+            authWitnesses,
+            capsules,
+            salt: Fr.random()
         });
-        return txRequest;
+        return Promise.resolve(txRequest);
     }
     getEntrypointAbi() {
         return {
@@ -70,16 +50,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: 5,
                                     type: {
                                         kind: 'struct',
                                         path: 'authwit::entrypoint::function_call::FunctionCall',
@@ -111,7 +91,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',
@@ -128,6 +108,12 @@ import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
                                                     kind: 'boolean'
                                                 }
                                             },
+                                            {
+                                                name: 'hide_msg_sender',
+                                                type: {
+                                                    kind: 'boolean'
+                                                }
+                                            },
                                             {
                                                 name: 'is_static',
                                                 type: {
@@ -139,23 +125,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,89 @@
+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 = 5;
+/** 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;
+    /** Only applicable for enqueued public function calls. Whether the msg_sender will be set to "null". */
+    hide_msg_sender: boolean;
+    /** Whether the function can alter state */
+    is_static: boolean;
+};
+/** 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 class EncodedAppEntrypointCalls 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
+     */
+    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 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 create(functionCalls: FunctionCall[] | Tuple<FunctionCall, typeof APP_MAX_CALLS>, txNonce?: Fr): Promise<EncodedAppEntrypointCalls>;
+}
+/** 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,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,wGAAwG;IACxG,eAAe,EAAE,OAAO,CAAC;IACzB,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,qBAAa,yBAA0B,YAAW,YAAY;IAE1D,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,IAAI,EAAE,EAAE;IAIhB;;;OAGG;IACH,IAAI;IAIJ,2DAA2D;IAC3D,SAAS,CAAC,qBAAqB;IAW/B;;;;;;OAMG;WACU,MAAM,CACjB,aAAa,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC,YAAY,EAAE,OAAO,aAAa,CAAC,EACzE,OAAO,KAAc;CAcxB;AAED,uEAAuE;AACvE,wBAAsB,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAwBzE"}