@aztec/aztec.js 0.23.0 → 0.26.1

package/src/deployment/contract_deployer.ts

@@ -0,0 +1,42 @@
+import { PublicKey } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { Point } from '@aztec/foundation/fields';
+
+import { Wallet } from '../account/wallet.js';
+import { DeployMethod } from '../contract/deploy_method.js';
+import { Contract } from '../contract/index.js';
+
+/**
+ * A class for deploying contract.
+ * @remarks Keeping this around even though we have Aztec.nr contract types because it can be useful for non-TS users.
+ */
+export class ContractDeployer {
+  constructor(
+    private artifact: ContractArtifact,
+    private wallet: Wallet,
+    private publicKey?: PublicKey,
+    private constructorName?: string,
+  ) {}
+
+  /**
+   * Deploy a contract using the provided ABI and constructor arguments.
+   * This function creates a new DeployMethod instance that can be used to send deployment transactions
+   * and query deployment status. The method accepts any number of constructor arguments, which will
+   * be passed to the contract's constructor during deployment.
+   *
+   * @param args - The constructor arguments for the contract being deployed.
+   * @returns A DeployMethod instance configured with the ABI, PXE, and constructor arguments.
+   */
+  public deploy(...args: any[]) {
+    const postDeployCtor = (address: AztecAddress, wallet: Wallet) => Contract.at(address, this.artifact, wallet);
+    return new DeployMethod(
+      this.publicKey ?? Point.ZERO,
+      this.wallet,
+      this.artifact,
+      postDeployCtor,
+      args,
+      this.constructorName,
+    );
+  }
+}

package/src/deployment/deploy_instance.ts

@@ -0,0 +1,28 @@
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { Wallet } from '../wallet/index.js';
+import { getDeployerContract } from './protocol_contracts.js';
+
+/**
+ * Sets up a call to the canonical deployer contract to publicly deploy a contract instance.
+ * @param wallet - The wallet to use for the deployment.
+ * @param instance - The instance to deploy.
+ * @param opts - Additional options.
+ */
+export function deployInstance(
+  wallet: Wallet,
+  instance: ContractInstanceWithAddress,
+  opts: { /** Set to true to *not* mix in the deployer into the address. */ universalDeploy?: boolean } = {},
+): ContractFunctionInteraction {
+  const deployer = getDeployerContract(wallet);
+  const { salt, contractClassId, portalContractAddress, publicKeysHash } = instance;
+  return deployer.methods.deploy(
+    salt,
+    contractClassId,
+    instance.initializationHash,
+    portalContractAddress,
+    publicKeysHash,
+    !!opts.universalDeploy,
+  );
+}

package/src/deployment/index.ts

@@ -0,0 +1 @@
+export * from './contract_deployer.js';

package/src/deployment/protocol_contracts.ts

@@ -0,0 +1,17 @@
+import { getCanonicalClassRegisterer } from '@aztec/protocol-contracts/class-registerer';
+import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
+
+import { UnsafeContract } from '../contract/unsafe_contract.js';
+import { Wallet } from '../wallet/index.js';
+
+/** Returns a Contract wrapper for the class registerer. */
+export function getRegistererContract(wallet: Wallet) {
+  const { artifact, instance } = getCanonicalClassRegisterer();
+  return new UnsafeContract(instance, artifact, wallet);
+}
+
+/** Returns a Contract wrapper for the instance deployer. */
+export function getDeployerContract(wallet: Wallet) {
+  const { artifact, instance } = getCanonicalInstanceDeployer();
+  return new UnsafeContract(instance, artifact, wallet);
+}

package/src/deployment/register_class.ts

@@ -0,0 +1,19 @@
+import { MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS, getContractClassFromArtifact } from '@aztec/circuits.js';
+import { ContractArtifact, bufferAsFields } from '@aztec/foundation/abi';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { Wallet } from '../wallet/index.js';
+import { getRegistererContract } from './protocol_contracts.js';
+
+/** Sets up a call to register a contract class given its artifact. */
+export async function registerContractClass(
+  wallet: Wallet,
+  artifact: ContractArtifact,
+): Promise<ContractFunctionInteraction> {
+  const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
+    getContractClassFromArtifact(artifact);
+  const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
+  const registerer = getRegistererContract(wallet);
+  await wallet.addCapsule(encodedBytecode);
+  return registerer.methods.register(artifactHash, privateFunctionsRoot, publicBytecodeCommitment);
+}

package/src/fee/fee_payment_method.ts

@@ -0,0 +1,25 @@
+import { FunctionCall } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+
+/**
+ * Holds information about how the fee for a transaction is to be paid.
+ */
+export interface FeePaymentMethod {
+  /**
+   * The asset used to pay the fee.
+   */
+  getAsset(): AztecAddress;
+  /**
+   * Address which will hold the fee payment.
+   */
+  getPaymentContract(): AztecAddress;
+
+  /**
+   * Creates a function call to pay the fee in the given asset.
+   * TODO(fees) replace maxFee with gas limits
+   * @param maxFee - The maximum fee to be paid in the given asset.
+   * @returns The function call to pay the fee.
+   */
+  getFunctionCalls(maxFee: Fr): Promise<FunctionCall[]>;
+}

package/src/fee/native_fee_payment_method.ts

@@ -0,0 +1,60 @@
+import { FunctionCall } from '@aztec/circuit-types';
+import { FunctionData } from '@aztec/circuits.js';
+import { FunctionSelector } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+import { GasTokenAddress } from '@aztec/protocol-contracts/gas-token';
+
+import { FeePaymentMethod } from './fee_payment_method.js';
+
+/**
+ * Pay fee directly in the native gas token.
+ */
+export class NativeFeePaymentMethod implements FeePaymentMethod {
+  static #GAS_TOKEN = GasTokenAddress;
+
+  constructor() {}
+
+  /**
+   * Gets the native gas asset used to pay the fee.
+   * @returns The asset used to pay the fee.
+   */
+  getAsset() {
+    return NativeFeePaymentMethod.#GAS_TOKEN;
+  }
+
+  /**
+   * The contract responsible for fee payment. This will be the same as the asset.
+   * @returns The contract address responsible for holding the fee payment.
+   */
+  getPaymentContract() {
+    return NativeFeePaymentMethod.#GAS_TOKEN;
+  }
+
+  /**
+   * Fee payments in the native gas token are always public.
+   * @returns false
+   */
+  isPrivateFeePayment(): boolean {
+    return false;
+  }
+
+  /**
+   * Creates a function call to pay the fee in gas token..
+   * @param feeLimit - The maximum fee to be paid in gas token.
+   * @returns A function call
+   */
+  getFunctionCalls(feeLimit: Fr): Promise<FunctionCall[]> {
+    return Promise.resolve([
+      {
+        to: NativeFeePaymentMethod.#GAS_TOKEN,
+        functionData: new FunctionData(FunctionSelector.fromSignature('check_balance(Field)'), false, false, false),
+        args: [feeLimit],
+      },
+      {
+        to: NativeFeePaymentMethod.#GAS_TOKEN,
+        functionData: new FunctionData(FunctionSelector.fromSignature('pay_fee(Field)'), false, false, false),
+        args: [feeLimit],
+      },
+    ]);
+  }
+}

package/src/fee/private_fee_payment_method.ts

@@ -0,0 +1,79 @@
+import { FunctionCall } from '@aztec/circuit-types';
+import { FunctionData } from '@aztec/circuits.js';
+import { FunctionSelector } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+
+import { computeAuthWitMessageHash } from '../utils/authwit.js';
+import { AccountWalletWithPrivateKey } from '../wallet/account_wallet_with_private_key.js';
+import { FeePaymentMethod } from './fee_payment_method.js';
+
+/**
+ * Holds information about how the fee for a transaction is to be paid.
+ */
+export class PrivateFeePaymentMethod implements FeePaymentMethod {
+  constructor(
+    /**
+     * The asset used to pay the fee.
+     */
+    private asset: AztecAddress,
+    /**
+     * Address which will hold the fee payment.
+     */
+    private paymentContract: AztecAddress,
+
+    /**
+     * An auth witness provider to authorize fee payments
+     */
+    private wallet: AccountWalletWithPrivateKey,
+  ) {}
+
+  /**
+   * The asset used to pay the fee.
+   * @returns The asset used to pay the fee.
+   */
+  getAsset() {
+    return this.asset;
+  }
+
+  /**
+   * The address which will facilitate the fee payment.
+   * @returns The contract address responsible for holding the fee payment.
+   */
+  getPaymentContract() {
+    return this.paymentContract;
+  }
+
+  /**
+   * Creates a function call to pay the fee in the given asset.
+   * @param maxFee - The maximum fee to be paid in the given asset.
+   * @returns The function call to pay the fee.
+   */
+  async getFunctionCalls(maxFee: Fr): Promise<FunctionCall[]> {
+    const nonce = Fr.random();
+    const messageHash = computeAuthWitMessageHash(this.paymentContract, {
+      args: [this.wallet.getAddress(), this.paymentContract, maxFee, nonce],
+      functionData: new FunctionData(
+        FunctionSelector.fromSignature('unshield((Field),(Field),Field,Field)'),
+        false,
+        true,
+        false,
+      ),
+      to: this.asset,
+    });
+    await this.wallet.createAuthWitness(messageHash);
+
+    return [
+      {
+        to: this.getPaymentContract(),
+        functionData: new FunctionData(
+          FunctionSelector.fromSignature('fee_entrypoint_private(Field,(Field),Field)'),
+          false,
+          true,
+          false,
+        ),
+        args: [maxFee, this.asset, nonce],
+      },
+    ];
+  }
+}

package/src/fee/public_fee_payment_method.ts

@@ -0,0 +1,79 @@
+import { FunctionCall } from '@aztec/circuit-types';
+import { FunctionData } from '@aztec/circuits.js';
+import { FunctionSelector } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+
+import { computeAuthWitMessageHash } from '../utils/authwit.js';
+import { AccountWallet } from '../wallet/account_wallet.js';
+import { FeePaymentMethod } from './fee_payment_method.js';
+
+/**
+ * Holds information about how the fee for a transaction is to be paid.
+ */
+export class PublicFeePaymentMethod implements FeePaymentMethod {
+  constructor(
+    /**
+     * The asset used to pay the fee.
+     */
+    private asset: AztecAddress,
+    /**
+     * Address which will hold the fee payment.
+     */
+    private paymentContract: AztecAddress,
+
+    /**
+     * An auth witness provider to authorize fee payments
+     */
+    private wallet: AccountWallet,
+  ) {}
+
+  /**
+   * The asset used to pay the fee.
+   * @returns The asset used to pay the fee.
+   */
+  getAsset() {
+    return this.asset;
+  }
+
+  /**
+   * The address which will facilitate the fee payment.
+   * @returns The contract address responsible for holding the fee payment.
+   */
+  getPaymentContract() {
+    return this.paymentContract;
+  }
+
+  /**
+   * Creates a function call to pay the fee in the given asset.
+   * @param maxFee - The maximum fee to be paid in the given asset.
+   * @returns The function call to pay the fee.
+   */
+  getFunctionCalls(maxFee: Fr): Promise<FunctionCall[]> {
+    const nonce = Fr.random();
+    const messageHash = computeAuthWitMessageHash(this.paymentContract, {
+      args: [this.wallet.getAddress(), this.paymentContract, maxFee, nonce],
+      functionData: new FunctionData(
+        FunctionSelector.fromSignature('transfer_public((Field),(Field),Field,Field)'),
+        false,
+        false,
+        false,
+      ),
+      to: this.asset,
+    });
+
+    return Promise.resolve([
+      this.wallet.setPublicAuth(messageHash, true).request(),
+      {
+        to: this.getPaymentContract(),
+        functionData: new FunctionData(
+          FunctionSelector.fromSignature('fee_entrypoint_public(Field,(Field),Field)'),
+          false,
+          true,
+          false,
+        ),
+        args: [maxFee, this.asset, nonce],
+      },
+    ]);
+  }
+}

package/src/index.ts

@@ -0,0 +1,150 @@
+/**
+ * This is our public api.
+ * Do NOT "export * from ..." here.
+ * Everything here should be explicit, to ensure we can clearly see everything we're exposing to the world.
+ * If it's exposed, people will use it, and then we can't remove/change the api without breaking client code.
+ * At the time of writing we overexpose things that should only be internal.
+ *
+ * TODO: Review and narrow scope of public api.
+ * We should also consider exposing subsections of the api via package.json exports, like we do with foundation.
+ * This can allow consumers to import much smaller parts of the library to incur less overhead.
+ * It will also allow web bundlers do perform intelligent chunking of bundles etc.
+ * Some work as been done on this within the api folder, providing the alternative import style of e.g.:
+ * ```typescript
+ *   import { TxHash } from '@aztec.js/tx_hash'
+ *   import { type ContractArtifact, type FunctionArtifact, FunctionSelector } from '@aztec/aztec.js/abi';
+ *   import { AztecAddress } from '@aztec/aztec.js/aztec_address';
+ *   import { EthAddress } from '@aztec/aztec.js/eth_address';
+ * ```
+ *
+ * TODO: Ultimately reimplement this mega exporter by mega exporting a granular api (then deprecate it).
+ */
+export {
+  WaitOpts,
+  ContractFunctionInteraction,
+  Contract,
+  ContractBase,
+  ContractMethod,
+  SentTx,
+  BatchCall,
+  DeployMethod,
+  DeploySentTx,
+} from './contract/index.js';
+
+export { ContractDeployer } from './deployment/index.js';
+
+export {
+  generatePublicKey,
+  FieldLike,
+  EthAddressLike,
+  CheatCodes,
+  AztecAddressLike,
+  FunctionSelectorLike,
+  WrappedFieldLike,
+  isContractDeployed,
+  EthCheatCodes,
+  computeAuthWitMessageHash,
+  computeInnerAuthWitHash,
+  computeOuterAuthWitHash,
+  waitForPXE,
+  waitForAccountSynch,
+} from './utils/index.js';
+
+export { createPXEClient } from './rpc_clients/index.js';
+
+export { AuthWitnessProvider } from './account/index.js';
+
+export { AccountContract } from './account/index.js';
+export { AccountManager } from './account_manager/index.js';
+
+export { AccountWalletWithPrivateKey, AccountWallet, Wallet, SignerlessWallet } from './wallet/index.js';
+
+// // TODO https://github.com/AztecProtocol/aztec-packages/issues/2632 --> FunctionSelector might not need to be exposed
+// // here once the issue is resolved.
+export {
+  AztecAddress,
+  EthAddress,
+  Fr,
+  Fq,
+  GlobalVariables,
+  GrumpkinScalar,
+  Point,
+  getContractInstanceFromDeployParams,
+  getContractClassFromArtifact,
+  INITIAL_L2_BLOCK_NUM,
+} from '@aztec/circuits.js';
+
+export { computeMessageSecretHash } from '@aztec/circuits.js/hash';
+
+export { Grumpkin, Schnorr } from '@aztec/circuits.js/barretenberg';
+
+export {
+  AuthWitness,
+  AztecNode,
+  Body,
+  CompleteAddress,
+  ContractData,
+  DeployedContract,
+  ExtendedContractData,
+  ExtendedNote,
+  FunctionCall,
+  GrumpkinPrivateKey,
+  L1ToL2Message,
+  L1Actor,
+  L2Actor,
+  L2Block,
+  L2BlockL2Logs,
+  LogFilter,
+  LogId,
+  LogType,
+  MerkleTreeId,
+  Note,
+  PXE,
+  PackedArguments,
+  PartialAddress,
+  PublicKey,
+  SyncStatus,
+  Tx,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+  TxStatus,
+  UnencryptedL2Log,
+  createAztecNodeClient,
+  emptyFunctionCall,
+  merkleTreeIds,
+  mockTx,
+  Comparator,
+} from '@aztec/circuit-types';
+export { NodeInfo } from '@aztec/types/interfaces';
+
+export { ContractInstanceWithAddress, ContractClassWithId } from '@aztec/types/contracts';
+
+// TODO: These kinds of things have no place on our public api.
+// External devs will almost certainly have their own methods of doing these things.
+// If we want to use them in our own "aztec.js consuming code", import them from foundation as needed.
+export { encodeArguments } from '@aztec/foundation/abi';
+export { sha256 } from '@aztec/foundation/crypto';
+export { DebugLogger, createDebugLogger, onLog } from '@aztec/foundation/log';
+export { retry, retryUntil } from '@aztec/foundation/retry';
+export { sleep } from '@aztec/foundation/sleep';
+export { elapsed } from '@aztec/foundation/timer';
+export { fileURLToPath } from '@aztec/foundation/url';
+export { to2Fields, toBigInt } from '@aztec/foundation/serialize';
+export { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+export { makeFetch } from '@aztec/foundation/json-rpc/client';
+export { FieldsOf } from '@aztec/foundation/types';
+
+export {
+  DeployL1Contracts,
+  L1ContractArtifactsForDeployment,
+  deployL1Contract,
+  deployL1Contracts,
+} from '@aztec/ethereum';
+
+// Start of section that exports public api via granular api.
+// Here you *can* do `export *` as the granular api defacto exports things explicitly.
+// This entire index file will be deprecated at some point after we're satisfied.
+export * from './api/init.js';
+export * from './api/abi.js';
+export * from './api/fee.js';

package/src/rpc_clients/index.ts

@@ -0,0 +1 @@
+export * from './pxe_client.js';

package/src/rpc_clients/pxe_client.ts

@@ -0,0 +1,63 @@
+import {
+  AuthWitness,
+  ContractData,
+  ExtendedContractData,
+  ExtendedNote,
+  ExtendedUnencryptedL2Log,
+  L2Block,
+  L2BlockL2Logs,
+  LogId,
+  Note,
+  NullifierMembershipWitness,
+  PXE,
+  Tx,
+  TxEffect,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+} from '@aztec/circuit-types';
+import {
+  AztecAddress,
+  CompleteAddress,
+  EthAddress,
+  Fr,
+  FunctionSelector,
+  GrumpkinScalar,
+  Point,
+} from '@aztec/circuits.js';
+import { createJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+
+/**
+ * Creates a JSON-RPC client to remotely talk to PXE.
+ * @param url - The URL of the PXE.
+ * @param fetch - The fetch implementation to use.
+ * @returns A JSON-RPC client of PXE.
+ */
+export const createPXEClient = (url: string, fetch = makeFetch([1, 2, 3], false)): PXE =>
+  createJsonRpcClient<PXE>(
+    url,
+    {
+      AuthWitness,
+      AztecAddress,
+      CompleteAddress,
+      ContractData,
+      FunctionSelector,
+      EthAddress,
+      ExtendedContractData,
+      ExtendedNote,
+      ExtendedUnencryptedL2Log,
+      Fr,
+      GrumpkinScalar,
+      L2Block,
+      TxEffect,
+      LogId,
+      Note,
+      Point,
+      TxExecutionRequest,
+      TxHash,
+    },
+    { Tx, TxReceipt, L2BlockL2Logs, NullifierMembershipWitness },
+    false,
+    'pxe',
+    fetch,
+  );

package/src/utils/abi_types.ts

@@ -0,0 +1,16 @@
+import { AztecAddress, EthAddress, Fr, FunctionSelector } from '@aztec/circuits.js';
+
+/** Any type that can be converted into a field for a contract call. */
+export type FieldLike = Fr | Buffer | bigint | number | { /** Converts to field */ toField: () => Fr };
+
+/** Any type that can be converted into an EthAddress Aztec.nr struct. */
+export type EthAddressLike = { /** Wrapped address */ address: FieldLike } | EthAddress;
+
+/** Any type that can be converted into an AztecAddress Aztec.nr struct. */
+export type AztecAddressLike = { /** Wrapped address */ address: FieldLike } | AztecAddress;
+
+/** Any type that can be converted into an FunctionSelector Aztec.nr struct. */
+export type FunctionSelectorLike = FieldLike | FunctionSelector;
+
+/** Any type that can be converted into a struct with a single `inner` field. */
+export type WrappedFieldLike = { /** Wrapped value */ inner: FieldLike } | FieldLike;

package/src/utils/account.ts

@@ -0,0 +1,32 @@
+import { CompleteAddress, PXE } from '@aztec/circuit-types';
+import { retryUntil } from '@aztec/foundation/retry';
+
+import { DefaultWaitOpts, WaitOpts } from '../contract/index.js';
+
+/**
+ * Waits for the account to finish synchronizing with the PXE Service.
+ * @param pxe - PXE instance
+ * @param address - Address to wait for synch
+ * @param opts - Wait options
+ */
+export async function waitForAccountSynch(
+  pxe: PXE,
+  address: CompleteAddress,
+  { interval, timeout }: WaitOpts = DefaultWaitOpts,
+): Promise<void> {
+  const publicKey = address.publicKey.toString();
+  await retryUntil(
+    async () => {
+      const status = await pxe.getSyncStatus();
+      const accountSynchedToBlock = status.notes[publicKey];
+      if (typeof accountSynchedToBlock === 'undefined') {
+        return false;
+      } else {
+        return accountSynchedToBlock >= status.blocks;
+      }
+    },
+    'waitForAccountSynch',
+    timeout,
+    interval,
+  );
+}

package/src/utils/authwit.ts

@@ -0,0 +1,62 @@
+import { FunctionCall, PackedArguments } from '@aztec/circuit-types';
+import { AztecAddress, Fr, GeneratorIndex } from '@aztec/circuits.js';
+import { pedersenHash } from '@aztec/foundation/crypto';
+
+// docs:start:authwit_computeAuthWitMessageHash
+/**
+ * Compute an authentication witness message hash from a caller and a request
+ * H(target: AztecAddress, H(caller: AztecAddress, selector: Field, args_hash: Field))
+ * Example usage would be `bob` authenticating `alice` to perform a transfer of `10`
+ * tokens from his account to herself:
+ * H(token, H(alice, transfer_selector, H(bob, alice, 10, nonce)))
+ * `bob` then signs the message hash and gives it to `alice` who can then perform the
+ * action.
+ * @param caller - The caller approved to make the call
+ * @param request - The request to be made (function call)
+ * @returns The message hash for the witness
+ */
+export const computeAuthWitMessageHash = (caller: AztecAddress, request: FunctionCall) => {
+  return computeOuterAuthWitHash(
+    request.to.toField(),
+    computeInnerAuthWitHash([
+      caller.toField(),
+      request.functionData.selector.toField(),
+      PackedArguments.fromArgs(request.args).hash,
+    ]),
+  );
+};
+// docs:end:authwit_computeAuthWitMessageHash
+
+/**
+ * Compute the inner hash for an authentication witness.
+ * This is the "intent" of the message, before siloed with the consumer.
+ * It is used as part of the `computeAuthWitMessageHash` but can also be used
+ * in case the message is not a "call" to a function, but arbitrary data.
+ * @param args - The arguments to hash
+ * @returns The inner hash for the witness
+ */
+export const computeInnerAuthWitHash = (args: Fr[]) => {
+  return pedersenHash(
+    args.map(fr => fr.toBuffer()),
+    GeneratorIndex.AUTHWIT_INNER,
+  );
+};
+
+/**
+ * Compute the outer hash for an authentication witness.
+ * This is the value siloed with its "consumer" and what the `on_behalf_of`
+ * should be signing.
+ * The consumer is who will be consuming the message, for token approvals it
+ * is the token contract itself (because the token makes the call to check the approval).
+ * It is used as part of the `computeAuthWitMessageHash` but can also be used
+ * in case the message is not a "call" to a function, but arbitrary data.
+ * @param consumer - The address that can "consume" the authwit
+ * @param innerHash - The inner hash for the witness
+ * @returns The outer hash for the witness
+ */
+export const computeOuterAuthWitHash = (consumer: AztecAddress, innerHash: Fr) => {
+  return pedersenHash(
+    [consumer.toField(), innerHash].map(fr => fr.toBuffer()),
+    GeneratorIndex.AUTHWIT_OUTER,
+  );
+};