@aztec-labs/entrypoints 6.0.0-nightly.20260829

package/dest/encoding.d.ts

@@ -0,0 +1,88 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Tuple } from '@aztec-labs/foundation/serialize';
+import { FunctionCall } from '@aztec-labs/stdlib/abi';
+import { HashedValues } from '@aztec-labs/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2RpbmcuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9lbmNvZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDOUQsT0FBTyxFQUFFLFlBQVksRUFBZ0IsTUFBTSx3QkFBd0IsQ0FBQztBQUNwRSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFJckQsZUFBTyxNQUFNLGFBQWEsSUFBSSxDQUFDO0FBRS9CLG9EQUFvRDtBQUNwRCxNQUFNLE1BQU0sbUJBQW1CLEdBQUc7SUFDaEMsbUNBQW1DO0lBQ25DLG9HQUFvRztJQUNwRyxTQUFTLEVBQUUsRUFBRSxDQUFDO0lBQ2QsdUNBQXVDO0lBQ3ZDLGlCQUFpQixFQUFFLEVBQUUsQ0FBQztJQUN0QixzQ0FBc0M7SUFDdEMsY0FBYyxFQUFFLEVBQUUsQ0FBQztJQUNuQixnREFBZ0Q7SUFDaEQsU0FBUyxFQUFFLE9BQU8sQ0FBQztJQUNuQix3R0FBd0c7SUFDeEcsZUFBZSxFQUFFLE9BQU8sQ0FBQztJQUN6QiwyQ0FBMkM7SUFDM0MsU0FBUyxFQUFFLE9BQU8sQ0FBQztDQUNwQixDQUFDO0FBRUYsc0ZBQXNGO0FBQ3RGLE1BQU0sTUFBTSxZQUFZLEdBQUc7SUFDekIsZ0VBQWdFO0lBQ2hFLG9CQUFvQixFQUFFLG1CQUFtQixFQUFFLENBQUM7SUFDNUMsZ0ZBQWdGO0lBQ2hGLGVBQWUsRUFBRSxZQUFZLEVBQUUsQ0FBQztDQUNqQyxDQUFDO0FBRUY7Ozs7S0FJSztBQUNMLHFCQUFhLHlCQUEwQixZQUFXLFlBQVk7SUFFMUQsZ0VBQWdFO0lBQ3pELG9CQUFvQixFQUFFLG1CQUFtQixFQUFFO0lBQ2xELGdGQUFnRjtJQUN6RSxlQUFlLEVBQUUsWUFBWSxFQUFFO0lBQ3RDLG9EQUFvRDtJQUM3QyxlQUFlLEVBQUUsTUFBTTtJQUM5Qjs7OztPQUlHO0lBRUksUUFBUSxFQUFFLEVBQUU7SUFickI7SUFDRSxnRUFBZ0U7SUFDekQsb0JBQW9CLEVBQUUsbUJBQW1CLEVBQUU7SUFDbEQsZ0ZBQWdGO0lBQ3pFLGVBQWUsRUFBRSxZQUFZLEVBQUU7SUFDdEMsb0RBQW9EO0lBQzdDLGVBQWUsRUFBRSxNQUFNO0lBQzlCOzs7O09BSUc7SUFFSSxRQUFRLEVBQUUsRUFBRSxFQUNqQjtJQUdKOzs7T0FHRztJQUNILElBQUksY0FBYywwQkFFakI7SUFHRDs7O09BR0c7SUFDSCxRQUFRLElBQUksRUFBRSxFQUFFLENBRWY7SUFFRDs7O09BR0c7SUFDSCxJQUFJLGdCQUVIO0lBRUQsMkRBQTJEO0lBQzNELFNBQVMsQ0FBQyxxQkFBcUIsU0FTOUI7SUFFRDs7Ozs7O09BTUc7SUFDSCxPQUFhLE1BQU0sQ0FDakIsYUFBYSxFQUFFLFlBQVksRUFBRSxHQUFHLEtBQUssQ0FBQyxZQUFZLEVBQUUsT0FBTyxhQUFhLENBQUMsRUFDekUsT0FBTyxLQUFjLHNDQWF0QjtDQUNGO0FBRUQsdUVBQXVFO0FBQ3ZFLHdCQUFzQixNQUFNLENBQUMsS0FBSyxFQUFFLFlBQVksRUFBRSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0F3QnpFIn0=

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,qCAAqC,CAAC;AACzD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAgB,MAAM,wBAAwB,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAIrD,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-labs/constants';
+import { padArrayEnd } from '@aztec-labs/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec-labs/foundation/crypto/poseidon';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { FunctionCall, FunctionType } from '@aztec-labs/stdlib/abi';
+import { HashedValues } from '@aztec-labs/stdlib/tx';
+// These must match the values defined in:
+// - noir-projects/aztec-nr/aztec/src/authwit/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

@@ -0,0 +1,13 @@
+/**
+ * The `@aztec-labs/accounts/defaults` export provides the base class {@link DefaultAccountContract} for implementing account contracts that use the default entrypoint payload module.
+ *
+ * Read more in {@link https://docs.aztec.network/developers/tutorials/codealong/contract_tutorials/write_accounts_contract | Writing an account contract}.
+ *
+ * @packageDocumentation
+ */
+export * from './account_entrypoint.js';
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,11 @@
+/**
+ * The `@aztec-labs/accounts/defaults` export provides the base class {@link DefaultAccountContract} for implementing account contracts that use the default entrypoint payload module.
+ *
+ * Read more in {@link https://docs.aztec.network/developers/tutorials/codealong/contract_tutorials/write_accounts_contract | Writing an account contract}.
+ *
+ * @packageDocumentation
+ */ export * from './account_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,60 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { AuthWitness } from '@aztec-labs/stdlib/auth-witness';
+import type { GasSettings } from '@aztec-labs/stdlib/gas';
+import type { ExecutionPayload, TxExecutionRequest } from '@aztec-labs/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, string, z.core.$ZodTypeInternals<Fr, string>>;
+    version: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+}, z.core.$strip>;
+/**
+ * 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzFELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLGtCQUFrQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDbEYsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4Qjs7O0dBR0c7QUFDSCxNQUFNLE1BQU0sU0FBUyxHQUFHO0lBQ3RCLHNCQUFzQjtJQUN0QixPQUFPLEVBQUUsRUFBRSxDQUFDO0lBQ1osaUNBQWlDO0lBQ2pDLE9BQU8sRUFBRSxFQUFFLENBQUM7Q0FDYixDQUFDO0FBRUY7O0dBRUc7QUFDSCxlQUFPLE1BQU0sZUFBZTs7O2lCQUcxQixDQUFDO0FBRUg7OztHQUdHO0FBQ0gsTUFBTSxXQUFXLG1CQUFtQjtJQUNsQzs7Ozs7OztPQU9HO0lBQ0gsd0JBQXdCLENBQ3RCLElBQUksRUFBRSxnQkFBZ0IsRUFDdEIsV0FBVyxFQUFFLFdBQVcsRUFDeEIsU0FBUyxFQUFFLFNBQVMsRUFDcEIsT0FBTyxDQUFDLEVBQUUsR0FBRyxHQUNaLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0lBRS9COzs7Ozs7Ozs7OztPQVdHO0lBQ0gsb0JBQW9CLENBQUMsSUFBSSxFQUFFLGdCQUFnQixFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsT0FBTyxDQUFDLEVBQUUsR0FBRyxHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0NBQzlHO0FBRUQsdUNBQXVDO0FBQ3ZDLE1BQU0sV0FBVyxtQkFBbUI7SUFDbEM7Ozs7T0FJRztJQUNILGFBQWEsQ0FBQyxXQUFXLEVBQUUsRUFBRSxHQUFHLE1BQU0sR0FBRyxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUM7Q0FDL0QifQ==

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,qCAAqC,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAClF,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;;;iBAG1B,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-labs/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

@@ -0,0 +1,93 @@
+{
+  "name": "@aztec-labs/entrypoints",
+  "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/entrypoints",
+  "description": "Implementation of sample contract entrypoints for the Aztec Network",
+  "version": "6.0.0-nightly.20260829",
+  "type": "module",
+  "exports": {
+    "./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": [
+      "./src/index.ts"
+    ],
+    "name": "Entrypoints",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "build:ts": "../scripts/tsc.sh",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec-labs/constants": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/standard-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "tslib": "^2.4.0",
+    "zod": "^4"
+  },
+  "devDependencies": {
+    "@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.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/account_entrypoint.ts

@@ -0,0 +1,216 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import {
+  type FunctionAbi,
+  FunctionCall,
+  FunctionSelector,
+  encodeArguments,
+  getFunctionReturnType,
+} from '@aztec-labs/stdlib/abi';
+import { computeOuterAuthWitHash } from '@aztec-labs/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { GasSettings } from '@aztec-labs/stdlib/gas';
+import { ExecutionPayload, HashedValues, TxContext, TxExecutionRequest } from '@aztec-labs/stdlib/tx';
+
+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
+ * for an account, which accepts an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
+ */
+export class DefaultAccountEntrypoint implements EntrypointInterface {
+  constructor(
+    private address: AztecAddress,
+    private auth: AuthWitnessProvider,
+  ) {}
+
+  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: 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,
+      returnType: getFunctionReturnType(callData.abi),
+    });
+
+    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',
+      isOnlySelf: false,
+      isStatic: false,
+      parameters: [
+        {
+          name: 'app_payload',
+          type: {
+            kind: 'struct',
+            path: 'authwit::entrypoint::app::AppPayload',
+            fields: [
+              {
+                name: 'function_calls',
+                type: {
+                  kind: 'array',
+                  length: 5,
+                  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: 'hide_msg_sender', type: { kind: 'boolean' } },
+                      { name: 'is_static', 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' } },
+      ],
+      errorTypes: {},
+    } as FunctionAbi;
+  }
+}

package/src/constants.ts

@@ -0,0 +1,4 @@
+/** Default L1 chain ID to use when constructing txs (matches hardhat and anvil's default). */
+export const DEFAULT_CHAIN_ID = 31337;
+/** Default protocol version to use. */
+export const DEFAULT_VERSION = 1;