@aztec/entrypoints 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/default_entrypoint.ts

@@ -0,0 +1,61 @@
+import { FunctionType } from '@aztec/stdlib/abi';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload, HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import type { ChainInfo, EntrypointInterface } from './interfaces.js';
+
+/**
+ * Default implementation of the entrypoint interface. It calls a function on a contract directly
+ */
+export class DefaultEntrypoint implements EntrypointInterface {
+  async createTxExecutionRequest(
+    exec: ExecutionPayload,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+  ): Promise<TxExecutionRequest> {
+    // 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(chainInfo.chainId.toNumber(), chainInfo.version.toNumber(), gasSettings),
+      [...hashedArguments, ...extraHashedArgs],
+      authWitnesses,
+      capsules,
+    );
+  }
+
+  async wrapExecutionPayload(exec: ExecutionPayload, _options?: any): Promise<ExecutionPayload> {
+    if (exec.calls.length !== 1) {
+      throw new Error(`DefaultEntrypoint can only wrap a single call, got ${exec.calls.length}`);
+    }
+
+    const call = exec.calls[0];
+
+    const hashedArguments = await HashedValues.fromArgs(call.args);
+
+    return new ExecutionPayload(
+      [call],
+      exec.authWitnesses,
+      exec.capsules,
+      [hashedArguments, ...exec.extraHashedArgs],
+      exec.feePayer,
+    );
+  }
+}

package/src/default_multi_call_entrypoint.ts

@@ -0,0 +1,144 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { type FunctionAbi, FunctionCall, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload, HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import { EncodedAppEntrypointCalls } from './encoding.js';
+import type { ChainInfo, EntrypointInterface } from './interfaces.js';
+
+/**
+ * Implementation for an entrypoint interface that can execute multiple function calls in a single transaction
+ */
+export class DefaultMultiCallEntrypoint implements EntrypointInterface {
+  constructor(private address: AztecAddress = ProtocolContractAddress.MultiCallEntrypoint) {}
+
+  async createTxExecutionRequest(
+    exec: ExecutionPayload,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+  ): Promise<TxExecutionRequest> {
+    const { authWitnesses, capsules, extraHashedArgs } = exec;
+    const callData = await this.#buildEntrypointCallData(exec);
+
+    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,
+      capsules,
+      salt: Fr.random(),
+    });
+
+    return Promise.resolve(txRequest);
+  }
+
+  async wrapExecutionPayload(exec: ExecutionPayload, _options?: any): Promise<ExecutionPayload> {
+    const { authWitnesses, capsules, extraHashedArgs } = exec;
+    const callData = await this.#buildEntrypointCallData(exec);
+    const entrypointCall = new FunctionCall(
+      callData.abi.name,
+      this.address,
+      callData.functionSelector,
+      callData.abi.functionType,
+      false,
+      callData.abi.isStatic,
+      callData.encodedArgs,
+      callData.abi.returnTypes,
+    );
+
+    return new ExecutionPayload(
+      [entrypointCall],
+      authWitnesses,
+      capsules,
+      [...callData.encodedCalls.hashedArguments, ...extraHashedArgs],
+      exec.feePayer,
+    );
+  }
+
+  /**
+   * Builds the shared data needed for both creating a tx execution request and wrapping an execution payload.
+   * This includes encoding calls and building entrypoint arguments.
+   * @param exec - The execution payload containing calls to encode
+   * @returns Encoded call data, ABI, encoded arguments, and function selector
+   */
+  async #buildEntrypointCallData(exec: ExecutionPayload) {
+    const { calls } = exec;
+
+    const encodedCalls = await EncodedAppEntrypointCalls.create(calls);
+
+    const abi = this.getEntrypointAbi();
+    const encodedArgs = encodeArguments(abi, [encodedCalls]);
+
+    const functionSelector = await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters);
+
+    return {
+      encodedCalls,
+      abi,
+      encodedArgs,
+      functionSelector,
+    };
+  }
+
+  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',
+        },
+      ],
+      returnTypes: [],
+      errorTypes: {},
+    } as FunctionAbi;
+  }
+}

package/src/encoding.ts

@@ -0,0 +1,148 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Tuple } from '@aztec/foundation/serialize';
+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;
+
+/** 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 class EncodedAppEntrypointCalls implements EncodedCalls {
+  constructor(
+    /** Function calls in the expected format (Noir's convention) */
+    public encodedFunctionCalls: EncodedFunctionCall[],
+    /** The hashed args for the call, ready to be injected in the execution cache */
+    public hashedArguments: HashedValues[],
+    /** The index of the generator to use for hashing */
+    public 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.
+     */
+    // eslint-disable-next-line camelcase
+    public tx_nonce: Fr,
+  ) {}
+
+  /* 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(): Fr[] {
+    return [...this.functionCallsToFields(), this.tx_nonce];
+  }
+
+  /**
+   * Hashes the payload
+   * @returns The hash of the payload
+   */
+  hash() {
+    return poseidon2HashWithSeparator(this.toFields(), this.generatorIndex);
+  }
+
+  /** Serializes the function calls to an array of fields. */
+  protected 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: FunctionCall[] | Tuple<FunctionCall, typeof APP_MAX_CALLS>,
+    txNonce = Fr.random(),
+  ) {
+    if (functionCalls.length > APP_MAX_CALLS) {
+      throw new Error(`Expected at most ${APP_MAX_CALLS} function calls, got ${functionCalls.length}`);
+    }
+    const paddedCalls = padArrayEnd(functionCalls, FunctionCall.empty(), APP_MAX_CALLS);
+    const encoded = await encode(paddedCalls);
+    return new EncodedAppEntrypointCalls(
+      encoded.encodedFunctionCalls,
+      encoded.hashedArguments,
+      GeneratorIndex.SIGNATURE_PAYLOAD,
+      txNonce,
+    );
+  }
+}
+
+/** Encodes FunctionCalls for execution, following Noir's convention */
+export async function encode(calls: FunctionCall[]): Promise<EncodedCalls> {
+  const hashedArguments: HashedValues[] = [];
+  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: EncodedFunctionCall[] = 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/src/index.ts

@@ -7,4 +7,7 @@
  */
 
 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/src/interfaces.ts

@@ -0,0 +1,69 @@
+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 const ChainInfoSchema = z.object({
+  chainId: Fr.schema,
+  version: Fr.schema,
+});
+
+/**
+ * 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 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, 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>;
+}

package/dest/dapp_entrypoint.d.ts

@@ -1,19 +0,0 @@
-import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
-import { type EntrypointInterface, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { TxExecutionRequest } from '@aztec/stdlib/tx';
-/**
- * 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 declare class DefaultDappEntrypoint implements EntrypointInterface {
-    private userAddress;
-    private userAuthWitnessProvider;
-    private dappEntrypointAddress;
-    private chainId;
-    private version;
-    constructor(userAddress: AztecAddress, userAuthWitnessProvider: AuthWitnessProvider, dappEntrypointAddress: AztecAddress, chainId?: number, version?: number);
-    createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest>;
-    private getEntrypointAbi;
-}
-//# sourceMappingURL=dapp_entrypoint.d.ts.map

package/dest/dapp_entrypoint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dapp_entrypoint.d.ts","sourceRoot":"","sources":["../src/dapp_entrypoint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,KAAK,mBAAmB,EAAqB,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEpH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAA2B,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAI/E;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,mBAAmB;IAE7D,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,uBAAuB;IAC/B,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;gBAJP,WAAW,EAAE,YAAY,EACzB,uBAAuB,EAAE,mBAAmB,EAC5C,qBAAqB,EAAE,YAAY,EACnC,OAAO,GAAE,MAAyB,EAClC,OAAO,GAAE,MAAwB;IAGrC,wBAAwB,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAqCvF,OAAO,CAAC,gBAAgB;CAiEzB"}

package/src/dapp_entrypoint.ts

@@ -1,125 +0,0 @@
-import { Fr, computeAuthWitMessageHash, computeInnerAuthWitHash } from '@aztec/aztec.js';
-import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
-import { type EntrypointInterface, EntrypointPayload, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
-import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
-
-import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.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 implements EntrypointInterface {
-  constructor(
-    private userAddress: AztecAddress,
-    private userAuthWitnessProvider: AuthWitnessProvider,
-    private dappEntrypointAddress: AztecAddress,
-    private chainId: number = DEFAULT_CHAIN_ID,
-    private version: number = DEFAULT_VERSION,
-  ) {}
-
-  async createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    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);
-
-    const abi = this.getEntrypointAbi();
-    const entrypointHashedArgs = await HashedValues.fromValues(encodeArguments(abi, [payload, this.userAddress]));
-    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);
-
-    const txRequest = TxExecutionRequest.from({
-      firstCallArgsHash: entrypointHashedArgs.hash,
-      origin: this.dappEntrypointAddress,
-      functionSelector,
-      txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
-      argsOfCalls: [...payload.hashedArguments, entrypointHashedArgs],
-      authWitnesses: [authWitness],
-      capsules,
-    });
-
-    return txRequest;
-  }
-
-  private getEntrypointAbi() {
-    return {
-      name: 'entrypoint',
-      isInitializer: false,
-      functionType: 'private',
-      isInternal: false,
-      isStatic: false,
-      parameters: [
-        {
-          name: 'payload',
-          type: {
-            kind: 'struct',
-            path: 'dapp_payload::DAppPayload',
-            fields: [
-              {
-                name: 'function_calls',
-                type: {
-                  kind: 'array',
-                  length: 1,
-                  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::aztec_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: 'user_address',
-          type: {
-            kind: 'struct',
-            path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
-            fields: [{ name: 'inner', type: { kind: 'field' } }],
-          },
-          visibility: 'public',
-        },
-      ],
-      returnTypes: [],
-      errorTypes: {},
-    } as FunctionAbi;
-  }
-}