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

package/dest/encoding.d.ts

@@ -0,0 +1,88 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { FunctionCall } from '@aztec/stdlib/abi';
+import { HashedValues } from '@aztec/stdlib/tx';
+export 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 */
+    domainSeparator: 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 */
+    domainSeparator: 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>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2RpbmcuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9lbmNvZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDekQsT0FBTyxFQUFFLFlBQVksRUFBZ0IsTUFBTSxtQkFBbUIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFJaEQsZUFBTyxNQUFNLGFBQWEsSUFBSSxDQUFDO0FBRS9CLG9EQUFvRDtBQUNwRCxNQUFNLE1BQU0sbUJBQW1CLEdBQUc7SUFDaEMsbUNBQW1DO0lBQ25DLG9HQUFvRztJQUNwRyxTQUFTLEVBQUUsRUFBRSxDQUFDO0lBQ2QsdUNBQXVDO0lBQ3ZDLGlCQUFpQixFQUFFLEVBQUUsQ0FBQztJQUN0QixzQ0FBc0M7SUFDdEMsY0FBYyxFQUFFLEVBQUUsQ0FBQztJQUNuQixnREFBZ0Q7SUFDaEQsU0FBUyxFQUFFLE9BQU8sQ0FBQztJQUNuQix3R0FBd0c7SUFDeEcsZUFBZSxFQUFFLE9BQU8sQ0FBQztJQUN6QiwyQ0FBMkM7SUFDM0MsU0FBUyxFQUFFLE9BQU8sQ0FBQztDQUNwQixDQUFDO0FBRUYsc0ZBQXNGO0FBQ3RGLE1BQU0sTUFBTSxZQUFZLEdBQUc7SUFDekIsZ0VBQWdFO0lBQ2hFLG9CQUFvQixFQUFFLG1CQUFtQixFQUFFLENBQUM7SUFDNUMsZ0ZBQWdGO0lBQ2hGLGVBQWUsRUFBRSxZQUFZLEVBQUUsQ0FBQztDQUNqQyxDQUFDO0FBRUY7Ozs7S0FJSztBQUNMLHFCQUFhLHlCQUEwQixZQUFXLFlBQVk7SUFFMUQsZ0VBQWdFO0lBQ3pELG9CQUFvQixFQUFFLG1CQUFtQixFQUFFO0lBQ2xELGdGQUFnRjtJQUN6RSxlQUFlLEVBQUUsWUFBWSxFQUFFO0lBQ3RDLG9EQUFvRDtJQUM3QyxlQUFlLEVBQUUsTUFBTTtJQUM5Qjs7OztPQUlHO0lBRUksUUFBUSxFQUFFLEVBQUU7SUFickI7SUFDRSxnRUFBZ0U7SUFDekQsb0JBQW9CLEVBQUUsbUJBQW1CLEVBQUU7SUFDbEQsZ0ZBQWdGO0lBQ3pFLGVBQWUsRUFBRSxZQUFZLEVBQUU7SUFDdEMsb0RBQW9EO0lBQzdDLGVBQWUsRUFBRSxNQUFNO0lBQzlCOzs7O09BSUc7SUFFSSxRQUFRLEVBQUUsRUFBRSxFQUNqQjtJQUdKOzs7T0FHRztJQUNILElBQUksY0FBYywwQkFFakI7SUFHRDs7O09BR0c7SUFDSCxRQUFRLElBQUksRUFBRSxFQUFFLENBRWY7SUFFRDs7O09BR0c7SUFDSCxJQUFJLGdCQUVIO0lBRUQsMkRBQTJEO0lBQzNELFNBQVMsQ0FBQyxxQkFBcUIsU0FTOUI7SUFFRDs7Ozs7O09BTUc7SUFDSCxPQUFhLE1BQU0sQ0FDakIsYUFBYSxFQUFFLFlBQVksRUFBRSxHQUFHLEtBQUssQ0FBQyxZQUFZLEVBQUUsT0FBTyxhQUFhLENBQUMsRUFDekUsT0FBTyxLQUFjLHNDQWF0QjtDQUNGO0FBRUQsdUVBQXVFO0FBQ3ZFLHdCQUFzQixNQUFNLENBQUMsS0FBSyxFQUFFLFlBQVksRUFBRSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0F3QnpFIn0=

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,gCAAgC,CAAC;AACpD,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,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,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,eAAe,EAAE,MAAM;IAC9B;;;;OAIG;IAEI,QAAQ,EAAE,EAAE;IAbrB;IACE,gEAAgE;IACzD,oBAAoB,EAAE,mBAAmB,EAAE;IAClD,gFAAgF;IACzE,eAAe,EAAE,YAAY,EAAE;IACtC,oDAAoD;IAC7C,eAAe,EAAE,MAAM;IAC9B;;;;OAIG;IAEI,QAAQ,EAAE,EAAE,EACjB;IAGJ;;;OAGG;IACH,IAAI,cAAc,0BAEjB;IAGD;;;OAGG;IACH,QAAQ,IAAI,EAAE,EAAE,CAEf;IAED;;;OAGG;IACH,IAAI,gBAEH;IAED,2DAA2D;IAC3D,SAAS,CAAC,qBAAqB,SAS9B;IAED;;;;;;OAMG;IACH,OAAa,MAAM,CACjB,aAAa,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC,YAAY,EAAE,OAAO,aAAa,CAAC,EACzE,OAAO,KAAc,sCAatB;CACF;AAED,uEAAuE;AACvE,wBAAsB,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAwBzE"}

package/dest/encoding.js

@@ -0,0 +1,97 @@
+import { DomainSeparator } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
+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
+export const APP_MAX_CALLS = 5;
+/**
+ * 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 EncodedAppEntrypointCalls {
+    encodedFunctionCalls;
+    hashedArguments;
+    domainSeparator;
+    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 */ domainSeparator, /**
+     * 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.domainSeparator = domainSeparator;
+        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;
+    }
+    /* eslint-enable camelcase */ /**
+   * Serializes the payload to an array of fields
+   * @returns The fields of the payload
+   */ toFields() {
+        return [
+            ...this.functionCallsToFields(),
+            this.tx_nonce
+        ];
+    }
+    /**
+   * Hashes the payload
+   * @returns The hash of the payload
+   */ hash() {
+        return poseidon2HashWithSeparator(this.toFields(), this.domainSeparator);
+    }
+    /** 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.hide_msg_sender),
+                new Fr(call.is_static)
+            ]);
+    }
+    /**
+   * 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 create(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, DomainSeparator.SIGNATURE_PAYLOAD, txNonce);
+    }
+}
+/** 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,
+            hide_msg_sender: call.hideMsgSender,
+            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';
-//# sourceMappingURL=index.d.ts.map
+export * from './interfaces.js';
+export * from './default_entrypoint.js';
+export * from './encoding.js';
+export * from './default_multi_call_entrypoint.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLG9DQUFvQyxDQUFDIn0=

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';

package/dest/interfaces.d.ts

@@ -0,0 +1,66 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { ExecutionPayload, TxExecutionRequest } from '@aztec/stdlib/tx';
+import { z } from 'zod';
+/**
+ * Information on the connected chain. Used by wallets when constructing transactions to protect against replay
+ * attacks.
+ */
+export type ChainInfo = {
+    /** The L1 chain id */
+    chainId: Fr;
+    /** The version of the rollup  */
+    version: Fr;
+};
+/**
+ * Zod schema for ChainInfo
+ */
+export declare const ChainInfoSchema: z.ZodObject<{
+    chainId: z.ZodType<Fr, any, string>;
+    version: z.ZodType<Fr, any, string>;
+}, "strip", z.ZodTypeAny, {
+    chainId: Fr;
+    version: Fr;
+}, {
+    chainId: string;
+    version: string;
+}>;
+/**
+ * Creates transaction execution requests out of a set of function calls, a fee payment method and
+ * general options for the transaction
+ */
+export interface EntrypointInterface {
+    /**
+     * Generates an execution request out of set of function calls.
+     * @param exec - The execution intents to be run.
+     * @param gasSettings - The gas settings for the transaction.
+     * @param chainInfo - Chain information (chainId and version) for replay protection.
+     * @param options - Miscellaneous tx options that enable/disable features of the entrypoint
+     * @returns The authenticated transaction execution request.
+     */
+    createTxExecutionRequest(exec: ExecutionPayload, gasSettings: GasSettings, chainInfo: ChainInfo, options?: any): Promise<TxExecutionRequest>;
+    /**
+     * Wraps an execution payload such that it is executed *via* this entrypoint.
+     * This returns an ExecutionPayload with the entrypoint as the caller for the wrapped payload.
+     * Useful for account self-funding deployments and batching calls beyond the limit
+     * of a single entrypoint call.
+     *
+     * @param exec - The execution payload to wrap
+     * @param chainInfo - Chain information (chainId and version) for replay protection
+     * @param options - Implementation-specific options
+     * @returns A new execution payload with a single call to this entrypoint
+     * @throws Error if the payload cannot be wrapped (e.g., exceeds call limit)
+     */
+    wrapExecutionPayload(exec: ExecutionPayload, chainInfo: ChainInfo, options?: any): Promise<ExecutionPayload>;
+}
+/** Creates authorization witnesses. */
+export interface AuthWitnessProvider {
+    /**
+     * Computes an authentication witness from either a message hash
+     * @param messageHash - The message hash to approve
+     * @returns The authentication witness
+     */
+    createAuthWit(messageHash: Fr | Buffer): Promise<AuthWitness>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQzlELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3JELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLGtCQUFrQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFN0UsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4Qjs7O0dBR0c7QUFDSCxNQUFNLE1BQU0sU0FBUyxHQUFHO0lBQ3RCLHNCQUFzQjtJQUN0QixPQUFPLEVBQUUsRUFBRSxDQUFDO0lBQ1osaUNBQWlDO0lBQ2pDLE9BQU8sRUFBRSxFQUFFLENBQUM7Q0FDYixDQUFDO0FBRUY7O0dBRUc7QUFDSCxlQUFPLE1BQU0sZUFBZTs7Ozs7Ozs7O0VBRzFCLENBQUM7QUFFSDs7O0dBR0c7QUFDSCxNQUFNLFdBQVcsbUJBQW1CO0lBQ2xDOzs7Ozs7O09BT0c7SUFDSCx3QkFBd0IsQ0FDdEIsSUFBSSxFQUFFLGdCQUFnQixFQUN0QixXQUFXLEVBQUUsV0FBVyxFQUN4QixTQUFTLEVBQUUsU0FBUyxFQUNwQixPQUFPLENBQUMsRUFBRSxHQUFHLEdBQ1osT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFFL0I7Ozs7Ozs7Ozs7O09BV0c7SUFDSCxvQkFBb0IsQ0FBQyxJQUFJLEVBQUUsZ0JBQWdCLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxPQUFPLENBQUMsRUFBRSxHQUFHLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBQUM7Q0FDOUc7QUFFRCx1Q0FBdUM7QUFDdkMsTUFBTSxXQUFXLG1CQUFtQjtJQUNsQzs7OztPQUlHO0lBQ0gsYUFBYSxDQUFDLFdBQVcsRUFBRSxFQUFFLEdBQUcsTUFBTSxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztDQUMvRCJ9

package/dest/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE7E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,sBAAsB;IACtB,OAAO,EAAE,EAAE,CAAC;IACZ,iCAAiC;IACjC,OAAO,EAAE,EAAE,CAAC;CACb,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;EAG1B,CAAC;AAEH;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;OAOG;IACH,wBAAwB,CACtB,IAAI,EAAE,gBAAgB,EACtB,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,SAAS,EACpB,OAAO,CAAC,EAAE,GAAG,GACZ,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAE/B;;;;;;;;;;;OAWG;IACH,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC9G;AAED,uCAAuC;AACvC,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,aAAa,CAAC,WAAW,EAAE,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC/D"}

package/dest/interfaces.js

@@ -0,0 +1,8 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { z } from 'zod';
+/**
+ * Zod schema for ChainInfo
+ */ export const ChainInfoSchema = z.object({
+    chainId: Fr.schema,
+    version: Fr.schema
+});

package/package.json

@@ -2,11 +2,15 @@
   "name": "@aztec/entrypoints",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/entrypoints",
   "description": "Implementation of sample contract entrypoints for the Aztec Network",
-  "version": "0.0.0-test.1",
+  "version": "0.0.1-commit.001888fc",
   "type": "module",
   "exports": {
-    "./dapp": "./dest/dapp_entrypoint.js",
-    "./account": "./dest/account_entrypoint.js"
+    "./account": "./dest/account_entrypoint.js",
+    "./default": "./dest/default_entrypoint.js",
+    "./multicall": "./dest/default_multi_call_entrypoint.js",
+    "./interfaces": "./dest/interfaces.js",
+    "./payload": "./dest/payload.js",
+    "./encoding": "./dest/encoding.js"
   },
   "typedocOptions": {
     "entryPoints": [
@@ -16,12 +20,10 @@
     "tsconfig": "./tsconfig.json"
   },
   "scripts": {
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
-    "build:ts": "tsc -b",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "build:ts": "../scripts/tsc.sh",
     "clean": "rm -rf ./dest .tsbuildinfo",
-    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "inherits": [
@@ -58,21 +60,27 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/aztec.js": "0.0.0-test.1",
-    "@aztec/foundation": "0.0.0-test.1",
-    "@aztec/protocol-contracts": "0.0.0-test.1",
-    "@aztec/stdlib": "0.0.0-test.1",
-    "tslib": "^2.4.0"
+    "@aztec/constants": "0.0.1-commit.001888fc",
+    "@aztec/foundation": "0.0.1-commit.001888fc",
+    "@aztec/protocol-contracts": "0.0.1-commit.001888fc",
+    "@aztec/stdlib": "0.0.1-commit.001888fc",
+    "tslib": "^2.4.0",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
-    "jest": "^29.5.0",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "files": [
     "dest",
@@ -80,6 +88,6 @@
     "!*.test.*"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/account_entrypoint.ts

@@ -1,15 +1,54 @@
-import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
-import {
-  type EntrypointInterface,
-  EntrypointPayload,
-  type ExecutionRequestInit,
-  computeCombinedPayloadHash,
-} from '@aztec/aztec.js/entrypoint';
-import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type FunctionAbi, FunctionCall, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import { computeOuterAuthWitHash } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload, HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
+import { EncodedAppEntrypointCalls } from './encoding.js';
+import type { AuthWitnessProvider, ChainInfo, EntrypointInterface } from './interfaces.js';
+
+/**
+ * The mechanism via which an account contract will pay for a transaction in which it gets invoked.
+ */
+export 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
@@ -19,43 +58,103 @@ export class DefaultAccountEntrypoint implements EntrypointInterface {
   constructor(
     private address: AztecAddress,
     private auth: AuthWitnessProvider,
-    private chainId: number = DEFAULT_CHAIN_ID,
-    private version: number = DEFAULT_VERSION,
   ) {}
 
-  async createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    const { calls, fee, nonce, cancellable, capsules = [] } = exec;
-    const appPayload = await EntrypointPayload.fromAppExecution(calls, nonce);
-    const feePayload = await EntrypointPayload.fromFeeOptions(this.address, fee);
-
-    const abi = this.getEntrypointAbi();
-    const entrypointHashedArgs = await HashedValues.fromValues(
-      encodeArguments(abi, [appPayload, feePayload, !!cancellable]),
-    );
-
-    const combinedPayloadAuthWitness = await this.auth.createAuthWit(
-      await computeCombinedPayloadHash(appPayload, feePayload),
-    );
-
+  async createTxExecutionRequest(
+    exec: ExecutionPayload,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+    options: DefaultAccountEntrypointOptions,
+  ): Promise<TxExecutionRequest> {
+    const { authWitnesses, capsules, extraHashedArgs } = exec;
+    const callData = await this.#buildEntrypointCallData(exec, chainInfo, options);
+    const entrypointHashedArgs = await HashedValues.fromArgs(callData.encodedArgs);
     const txRequest = TxExecutionRequest.from({
       firstCallArgsHash: entrypointHashedArgs.hash,
       origin: this.address,
-      functionSelector: await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
-      txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
-      argsOfCalls: [...appPayload.hashedArguments, ...feePayload.hashedArguments, entrypointHashedArgs],
-      authWitnesses: [combinedPayloadAuthWitness],
+      functionSelector: callData.functionSelector,
+      txContext: new TxContext(chainInfo.chainId.toNumber(), chainInfo.version.toNumber(), gasSettings),
+      argsOfCalls: [...callData.encodedCalls.hashedArguments, entrypointHashedArgs, ...extraHashedArgs],
+      authWitnesses: [...authWitnesses, callData.payloadAuthWitness],
       capsules,
+      salt: Fr.random(),
     });
 
     return txRequest;
   }
 
+  async wrapExecutionPayload(
+    exec: ExecutionPayload,
+    chainInfo: ChainInfo,
+    options: DefaultAccountEntrypointOptions,
+  ): Promise<ExecutionPayload> {
+    const { authWitnesses, capsules, extraHashedArgs, feePayer } = exec;
+    const callData = await this.#buildEntrypointCallData(exec, chainInfo, options);
+
+    // Build the entrypoint function call
+    const entrypointCall = FunctionCall.from({
+      name: callData.abi.name,
+      to: this.address,
+      selector: callData.functionSelector,
+      type: callData.abi.functionType,
+      hideMsgSender: false,
+      isStatic: callData.abi.isStatic,
+      args: callData.encodedArgs,
+      returnTypes: callData.abi.returnTypes,
+    });
+
+    return new ExecutionPayload(
+      [entrypointCall],
+      [callData.payloadAuthWitness, ...authWitnesses],
+      capsules,
+      [...callData.encodedCalls.hashedArguments, ...extraHashedArgs],
+      feePayer ?? this.address,
+    );
+  }
+
+  /**
+   * Builds the shared data needed for both creating a tx execution request and wrapping an execution payload.
+   * This includes encoding calls, building entrypoint arguments, and creating the authwitness.
+   * @param exec - The execution payload containing calls to encode
+   * @param chainInfo - Chain information (chainId and version) for replay protection
+   * @param options - Account entrypoint options including tx nonce and fee payment method
+   * @returns Encoded call data, ABI, function selector, and auth witness
+   */
+  async #buildEntrypointCallData(
+    exec: ExecutionPayload,
+    chainInfo: ChainInfo,
+    options: DefaultAccountEntrypointOptions,
+  ) {
+    const { calls } = exec;
+    const { cancellable, txNonce, feePaymentMethodOptions } = options;
+
+    const encodedCalls = await EncodedAppEntrypointCalls.create(calls, txNonce);
+
+    const abi = this.getEntrypointAbi();
+    const args = [encodedCalls, feePaymentMethodOptions, !!cancellable];
+    const encodedArgs = encodeArguments(abi, args);
+
+    const functionSelector = await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters);
+
+    const payloadHash = await encodedCalls.hash();
+    const messageHash = await computeOuterAuthWitHash(this.address, chainInfo.chainId, chainInfo.version, payloadHash);
+    const payloadAuthWitness = await this.auth.createAuthWit(messageHash);
+
+    return {
+      encodedCalls,
+      abi,
+      encodedArgs,
+      functionSelector,
+      payloadAuthWitness,
+    };
+  }
+
   private getEntrypointAbi() {
     return {
       name: 'entrypoint',
       isInitializer: false,
       functionType: 'private',
-      isInternal: false,
+      isOnlySelf: false,
       isStatic: false,
       parameters: [
         {
@@ -68,50 +167,7 @@ export class DefaultAccountEntrypoint implements EntrypointInterface {
                 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',
-        },
-        {
-          name: 'fee_payload',
-          type: {
-            kind: 'struct',
-            path: 'authwit::entrypoint::fee::FeePayload',
-            fields: [
-              {
-                name: 'function_calls',
-                type: {
-                  kind: 'array',
-                  length: 2,
+                  length: 5,
                   type: {
                     kind: 'struct',
                     path: 'authwit::entrypoint::function_call::FunctionCall',
@@ -134,17 +190,18 @@ export class DefaultAccountEntrypoint implements EntrypointInterface {
                         },
                       },
                       { name: 'is_public', type: { kind: 'boolean' } },
+                      { name: 'hide_msg_sender', type: { kind: 'boolean' } },
                       { name: 'is_static', type: { kind: 'boolean' } },
                     ],
                   },
                 },
               },
-              { name: 'nonce', type: { kind: 'field' } },
-              { name: 'is_fee_payer', type: { kind: 'boolean' } },
+              { name: 'tx_nonce', type: { kind: 'field' } },
             ],
           },
           visibility: 'public',
         },
+        { name: 'fee_payment_method', type: { kind: 'integer', sign: 'unsigned', width: 8 } },
         { name: 'cancellable', type: { kind: 'boolean' } },
       ],
       returnTypes: [],