@aztec/aztec.js 0.81.0 → 0.82.0

package/src/ethereum/portal_manager.ts

@@ -5,6 +5,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
 import type { SiblingPath } from '@aztec/foundation/trees';
+import { FeeAssetHandlerAbi } from '@aztec/l1-artifacts/FeeAssetHandlerAbi';
 import { FeeJuicePortalAbi } from '@aztec/l1-artifacts/FeeJuicePortalAbi';
 import { OutboxAbi } from '@aztec/l1-artifacts/OutboxAbi';
 import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
@@ -15,6 +16,8 @@ import type { PXE } from '@aztec/stdlib/interfaces/client';
 
 import { type GetContractReturnType, type Hex, getContract, toFunctionSelector } from 'viem';
 
+import type { Wallet } from '../index.js';
+
 // docs:start:claim_type
 // docs:start:claim_type_amount
 /** L1 to L2 message info to claim it on L2. */
@@ -55,19 +58,39 @@ export async function generateClaimSecret(logger?: Logger): Promise<[Fr, Fr]> {
 /** Helper for managing an ERC20 on L1. */
 export class L1TokenManager {
   private contract: GetContractReturnType<typeof TestERC20Abi, ViemWalletClient>;
+  private handler: GetContractReturnType<typeof FeeAssetHandlerAbi, ViemWalletClient> | undefined;
 
   public constructor(
     /** Address of the ERC20 contract. */
-    public readonly address: EthAddress,
+    public readonly tokenAddress: EthAddress,
+    /** Address of the handler/faucet contract. */
+    public readonly handlerAddress: EthAddress | undefined,
     private publicClient: ViemPublicClient,
     private walletClient: ViemWalletClient,
     private logger: Logger,
   ) {
     this.contract = getContract({
-      address: this.address.toString(),
+      address: this.tokenAddress.toString(),
       abi: TestERC20Abi,
       client: this.walletClient,
     });
+    if (this.handlerAddress) {
+      this.handler = getContract({
+        address: this.handlerAddress.toString(),
+        abi: FeeAssetHandlerAbi,
+        client: this.walletClient,
+      });
+    }
+  }
+
+  /** Returns the amount of tokens available to mint via the handler.
+   * @throws if the handler is not provided.
+   */
+  public async getMintAmount() {
+    if (!this.handler) {
+      throw new Error('Minting handler was not provided');
+    }
+    return await this.handler.read.mintAmount();
   }
 
   /**
@@ -79,16 +102,18 @@ export class L1TokenManager {
   }
 
   /**
-   * Mints tokens for the given address. Returns once the tx has been mined.
-   * @param amount - Amount to mint.
+   * Mints a fixed amount of tokens for the given address. Returns once the tx has been mined.
    * @param address - Address to mint the tokens for.
    * @param addressName - Optional name of the address for logging.
    */
-  public async mint(amount: bigint, address: Hex, addressName?: string) {
-    this.logger.info(`Minting ${amount} tokens for ${stringifyEthAddress(address, addressName)}`);
-    await this.publicClient.waitForTransactionReceipt({
-      hash: await this.contract.write.mint([address, amount]),
-    });
+  public async mint(address: Hex, addressName?: string) {
+    if (!this.handler) {
+      throw new Error('Minting handler was not provided');
+    }
+    const mintAmount = await this.getMintAmount();
+    this.logger.info(`Minting ${mintAmount} tokens for ${stringifyEthAddress(address, addressName)}`);
+    // NOTE: the handler mints a fixed amount.
+    await this.handler.write.mint([address]);
   }
 
   /**
@@ -113,11 +138,12 @@ export class L1FeeJuicePortalManager {
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
+    handlerAddress: EthAddress,
     private readonly publicClient: ViemPublicClient,
     private readonly walletClient: ViemWalletClient,
     private readonly logger: Logger,
   ) {
-    this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+    this.tokenManager = new L1TokenManager(tokenAddress, handlerAddress, publicClient, walletClient, logger);
     this.contract = getContract({
       address: portalAddress.toString(),
       abi: FeeJuicePortalAbi,
@@ -136,16 +162,21 @@ export class L1FeeJuicePortalManager {
    * @param amount - Amount of tokens to send.
    * @param mint - Whether to mint the tokens before sending (only during testing).
    */
-  public async bridgeTokensPublic(to: AztecAddress, amount: bigint, mint = false): Promise<L2AmountClaim> {
+  public async bridgeTokensPublic(to: AztecAddress, amount: bigint | undefined, mint = false): Promise<L2AmountClaim> {
     const [claimSecret, claimSecretHash] = await generateClaimSecret();
+    const mintableAmount = await this.tokenManager.getMintAmount();
+    const amountToBridge = amount ?? mintableAmount;
     if (mint) {
-      await this.tokenManager.mint(amount, this.walletClient.account.address);
+      if (amountToBridge !== mintableAmount) {
+        throw new Error(`Minting amount must be ${mintableAmount}`);
+      }
+      await this.tokenManager.mint(this.walletClient.account.address);
     }
 
-    await this.tokenManager.approve(amount, this.contract.address, 'FeeJuice Portal');
+    await this.tokenManager.approve(amountToBridge, this.contract.address, 'FeeJuice Portal');
 
     this.logger.info('Sending L1 Fee Juice to L2 to be claimed publicly');
-    const args = [to.toString(), amount, claimSecretHash.toString()] as const;
+    const args = [to.toString(), amountToBridge, claimSecretHash.toString()] as const;
 
     await this.contract.simulate.depositToAztecPublic(args);
 
@@ -162,13 +193,13 @@ export class L1FeeJuicePortalManager {
       'DepositToAztecPublic',
       log =>
         log.args.secretHash === claimSecretHash.toString() &&
-        log.args.amount === amount &&
+        log.args.amount === amountToBridge &&
         log.args.to === to.toString(),
       this.logger,
     );
 
     return {
-      claimAmount: amount,
+      claimAmount: amountToBridge,
       claimSecret,
       claimSecretHash,
       messageHash: log.args.key,
@@ -178,26 +209,36 @@ export class L1FeeJuicePortalManager {
 
   /**
    * Creates a new instance
-   * @param pxe - PXE client used for retrieving the L1 contract addresses.
+   * @param walletOrPxe - Wallet or PXE client used for retrieving the L1 contract addresses.
    * @param publicClient - L1 public client.
    * @param walletClient - L1 wallet client.
    * @param logger - Logger.
    */
   public static async new(
-    pxe: PXE,
+    walletOrPxe: Wallet | PXE,
     publicClient: ViemPublicClient,
     walletClient: ViemWalletClient,
     logger: Logger,
   ): Promise<L1FeeJuicePortalManager> {
     const {
-      l1ContractAddresses: { feeJuiceAddress, feeJuicePortalAddress },
-    } = await pxe.getNodeInfo();
+      l1ContractAddresses: { feeJuiceAddress, feeJuicePortalAddress, feeAssetHandlerAddress },
+    } = await walletOrPxe.getNodeInfo();
 
     if (feeJuiceAddress.isZero() || feeJuicePortalAddress.isZero()) {
       throw new Error('Portal or token not deployed on L1');
     }
+    if (!feeAssetHandlerAddress || feeAssetHandlerAddress.isZero()) {
+      throw new Error('Handler not deployed on L1, or handler address is zero');
+    }
 
-    return new L1FeeJuicePortalManager(feeJuicePortalAddress, feeJuiceAddress, publicClient, walletClient, logger);
+    return new L1FeeJuicePortalManager(
+      feeJuicePortalAddress,
+      feeJuiceAddress,
+      feeAssetHandlerAddress,
+      publicClient,
+      walletClient,
+      logger,
+    );
   }
 }
 
@@ -209,11 +250,12 @@ export class L1ToL2TokenPortalManager {
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
+    handlerAddress: EthAddress | undefined,
     protected publicClient: ViemPublicClient,
     protected walletClient: ViemWalletClient,
     protected logger: Logger,
   ) {
-    this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+    this.tokenManager = new L1TokenManager(tokenAddress, handlerAddress, publicClient, walletClient, logger);
     this.portal = getContract({
       address: portalAddress.toString(),
       abi: TokenPortalAbi,
@@ -267,6 +309,7 @@ export class L1ToL2TokenPortalManager {
     };
   }
 
+  // docs:start:bridge_tokens_private
   /**
    * Bridges tokens from L1 to L2 privately. Handles token approvals. Returns once the tx has been mined.
    * @param to - Address to send the tokens to on L2.
@@ -278,6 +321,7 @@ export class L1ToL2TokenPortalManager {
     amount: bigint,
     mint = false,
   ): Promise<L2AmountClaimWithRecipient> {
+    // docs:end:bridge_tokens_private
     const [claimSecret, claimSecretHash] = await this.bridgeSetup(amount, mint);
 
     this.logger.info('Sending L1 tokens to L2 to be claimed privately');
@@ -312,7 +356,11 @@ export class L1ToL2TokenPortalManager {
 
   private async bridgeSetup(amount: bigint, mint: boolean) {
     if (mint) {
-      await this.tokenManager.mint(amount, this.walletClient.account.address);
+      const mintableAmount = await this.tokenManager.getMintAmount();
+      if (amount !== mintableAmount) {
+        throw new Error(`Minting amount must be ${mintableAmount} for testing`);
+      }
+      await this.tokenManager.mint(this.walletClient.account.address);
     }
     await this.tokenManager.approve(amount, this.portal.address, 'TokenPortal');
     return generateClaimSecret();
@@ -326,12 +374,13 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
+    handlerAddress: EthAddress | undefined,
     outboxAddress: EthAddress,
     publicClient: ViemPublicClient,
     walletClient: ViemWalletClient,
     logger: Logger,
   ) {
-    super(portalAddress, tokenAddress, publicClient, walletClient, logger);
+    super(portalAddress, tokenAddress, handlerAddress, publicClient, walletClient, logger);
     this.outbox = getContract({
       address: outboxAddress.toString(),
       abi: OutboxAbi,

package/src/fee/fee_juice_payment_method.ts

@@ -1,9 +1,8 @@
+import type { FeePaymentMethod } from '@aztec/entrypoints/interfaces';
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import type { FunctionCall } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import type { FeePaymentMethod } from './fee_payment_method.js';
-
 // docs:start:fee_juice_method
 /**
  * Pay fee directly in the Fee Juice.
@@ -16,8 +15,8 @@ export class FeeJuicePaymentMethod implements FeePaymentMethod {
     return Promise.resolve(ProtocolContractAddress.FeeJuice);
   }
 
-  getFunctionCalls(): Promise<FunctionCall[]> {
-    return Promise.resolve([]);
+  getExecutionPayload(): Promise<ExecutionPayload> {
+    return Promise.resolve(ExecutionPayload.empty());
   }
 
   getFeePayer(): Promise<AztecAddress> {

package/src/fee/fee_juice_payment_method_with_claim.ts

@@ -1,6 +1,6 @@
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { Fr } from '@aztec/foundation/fields';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import type { FunctionCall } from '@aztec/stdlib/abi';
 import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 
 import { getFeeJuice } from '../contract/protocol_contracts.js';
@@ -20,30 +20,34 @@ export class FeeJuicePaymentMethodWithClaim extends FeeJuicePaymentMethod {
   }
 
   /**
-   * Creates a function call to pay the fee in Fee Juice.
-   * @returns A function call
+   * Creates an execution payload to pay the fee in Fee Juice.
+   * @returns An execution payload that just contains the claim function call.
    */
-  override async getFunctionCalls(): Promise<FunctionCall[]> {
+  override async getExecutionPayload(): Promise<ExecutionPayload> {
     const canonicalFeeJuice = await getFeeJuice(this.senderWallet);
     const selector = await FunctionSelector.fromNameAndParameters(
       canonicalFeeJuice.artifact.functions.find(f => f.name === 'claim')!,
     );
 
-    return Promise.resolve([
-      {
-        to: ProtocolContractAddress.FeeJuice,
-        name: 'claim',
-        selector,
-        isStatic: false,
-        args: [
-          this.senderWallet.getAddress().toField(),
-          new Fr(this.claim.claimAmount),
-          this.claim.claimSecret,
-          new Fr(this.claim.messageLeafIndex),
-        ],
-        returnTypes: [],
-        type: FunctionType.PRIVATE,
-      },
-    ]);
+    return new ExecutionPayload(
+      [
+        {
+          to: ProtocolContractAddress.FeeJuice,
+          name: 'claim',
+          selector,
+          isStatic: false,
+          args: [
+            this.senderWallet.getAddress().toField(),
+            new Fr(this.claim.claimAmount),
+            this.claim.claimSecret,
+            new Fr(this.claim.messageLeafIndex),
+          ],
+          returnTypes: [],
+          type: FunctionType.PRIVATE,
+        },
+      ],
+      [],
+      [],
+    );
   }
 }

package/src/fee/private_fee_payment_method.ts

@@ -1,12 +1,12 @@
+import type { FeePaymentMethod } from '@aztec/entrypoints/interfaces';
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { Fr } from '@aztec/foundation/fields';
-import { type FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
 
-import type { Wallet } from '../account/wallet.js';
-import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { SignerlessWallet } from '../wallet/signerless_wallet.js';
-import type { FeePaymentMethod } from './fee_payment_method.js';
+import type { Wallet } from '../wallet/wallet.js';
+import { simulateWithoutSignature } from './utils.js';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
@@ -38,11 +38,10 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
    */
   getAsset(): Promise<AztecAddress> {
     if (!this.assetPromise) {
-      // We use signer-less wallet because this function could be triggered before the associated account is deployed.
-      const signerlessWallet = new SignerlessWallet(this.wallet);
-
-      const interaction = new ContractFunctionInteraction(
-        signerlessWallet,
+      // We use the utility method to avoid a signature because this function could be triggered
+      // before the associated account is deployed.
+      this.assetPromise = simulateWithoutSignature(
+        this.wallet,
         this.paymentContract,
         {
           name: 'get_accepted_asset',
@@ -68,9 +67,7 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
           isInitializer: false,
         },
         [],
-      );
-
-      this.assetPromise = interaction.simulate();
+      ) as Promise<AztecAddress>;
     }
     return this.assetPromise!;
   }
@@ -80,17 +77,17 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
   }
 
   /**
-   * Creates a function call to pay the fee in the given asset.
+   * Creates an execution payload to pay the fee using a private function through an FPC in the desired asset
    * @param gasSettings - The gas settings.
-   * @returns The function call to pay the fee.
+   * @returns An execution payload that contains the required function calls and auth witnesses.
    */
-  async getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
+  async getExecutionPayload(gasSettings: GasSettings): Promise<ExecutionPayload> {
     // We assume 1:1 exchange rate between fee juice and token. But in reality you would need to convert feeLimit
     // (maxFee) to be in token denomination.
     const maxFee = this.setMaxFeeToOne ? Fr.ONE : gasSettings.getFeeLimit();
     const nonce = Fr.random();
 
-    await this.wallet.createAuthWit({
+    const witness = await this.wallet.createAuthWit({
       caller: this.paymentContract,
       action: {
         name: 'transfer_to_public',
@@ -103,16 +100,20 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
       },
     });
 
-    return [
-      {
-        name: 'fee_entrypoint_private',
-        to: this.paymentContract,
-        selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
-        type: FunctionType.PRIVATE,
-        isStatic: false,
-        args: [maxFee, nonce],
-        returnTypes: [],
-      },
-    ];
+    return new ExecutionPayload(
+      [
+        {
+          name: 'fee_entrypoint_private',
+          to: this.paymentContract,
+          selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
+          type: FunctionType.PRIVATE,
+          isStatic: false,
+          args: [maxFee, nonce],
+          returnTypes: [],
+        },
+      ],
+      [witness],
+      [],
+    );
   }
 }

package/src/fee/public_fee_payment_method.ts

@@ -1,13 +1,12 @@
+import type { FeePaymentMethod } from '@aztec/entrypoints/interfaces';
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { Fr } from '@aztec/foundation/fields';
-import type { FunctionCall } from '@aztec/stdlib/abi';
 import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { GasSettings } from '@aztec/stdlib/gas';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasSettings } from '@aztec/stdlib/gas';
 
-import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
 import type { AccountWallet } from '../wallet/account_wallet.js';
-import { SignerlessWallet } from '../wallet/signerless_wallet.js';
-import type { FeePaymentMethod } from './fee_payment_method.js';
+import { simulateWithoutSignature } from './utils.js';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
@@ -32,11 +31,10 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
    */
   getAsset(): Promise<AztecAddress> {
     if (!this.assetPromise) {
-      // We use signer-less wallet because this function could be triggered before the associated account is deployed.
-      const signerlessWallet = new SignerlessWallet(this.wallet);
-
-      const interaction = new ContractFunctionInteraction(
-        signerlessWallet,
+      // We use the utility method to avoid a signature because this function could be triggered
+      // before the associated account is deployed.
+      this.assetPromise = simulateWithoutSignature(
+        this.wallet,
         this.paymentContract,
         {
           name: 'get_accepted_asset',
@@ -62,9 +60,7 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
           isInitializer: false,
         },
         [],
-      );
-
-      this.assetPromise = interaction.simulate();
+      ) as Promise<AztecAddress>;
     }
     return this.assetPromise!;
   }
@@ -74,11 +70,11 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
   }
 
   /**
-   * Creates a function call to pay the fee in the given asset.
+   * Creates an execution payload to pay the fee using a public function through an FPC in the desired asset
    * @param gasSettings - The gas settings.
-   * @returns The function call to pay the fee.
+   * @returns An execution payload that contains the required function calls.
    */
-  async getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
+  async getExecutionPayload(gasSettings: GasSettings): Promise<ExecutionPayload> {
     const nonce = Fr.random();
     const maxFee = gasSettings.getFeeLimit();
 
@@ -98,17 +94,21 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
       true,
     );
 
-    return [
-      ...(await setPublicAuthWitInteraction.request()).calls,
-      {
-        name: 'fee_entrypoint_public',
-        to: this.paymentContract,
-        selector: await FunctionSelector.fromSignature('fee_entrypoint_public(u128,Field)'),
-        type: FunctionType.PRIVATE,
-        isStatic: false,
-        args: [maxFee, nonce],
-        returnTypes: [],
-      },
-    ];
+    return new ExecutionPayload(
+      [
+        ...(await setPublicAuthWitInteraction.request()).calls,
+        {
+          name: 'fee_entrypoint_public',
+          to: this.paymentContract,
+          selector: await FunctionSelector.fromSignature('fee_entrypoint_public(u128,Field)'),
+          type: FunctionType.PRIVATE,
+          isStatic: false,
+          args: [maxFee, nonce],
+          returnTypes: [],
+        },
+      ],
+      [],
+      [],
+    );
   }
 }

package/src/fee/utils.ts

@@ -0,0 +1,39 @@
+import { DefaultEntrypoint } from '@aztec/entrypoints/default';
+import { type FunctionAbi, decodeFromAbi } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasSettings } from '@aztec/stdlib/gas';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import type { Wallet } from '../wallet/wallet.js';
+import { FeeJuicePaymentMethod } from './fee_juice_payment_method.js';
+
+/**
+ * Use a wallet to simulate a function avoiding the wallet's entrypoint, as a SignerlessWallet would do
+ * @param wallet - The wallet to use for the simulation.
+ * @param contractAddress - The address of the contract to call.
+ * @param abi - The ABI of the function to simulate.
+ * @param args - The arguments to pass to the function.
+ * @returns The return values of the function call.
+ */
+export async function simulateWithoutSignature(
+  wallet: Wallet,
+  contractAddress: AztecAddress,
+  abi: FunctionAbi,
+  args: any[],
+) {
+  const interaction = new ContractFunctionInteraction(wallet, contractAddress, abi, args);
+
+  const request = await interaction.request();
+  const maxFeesPerGas = (await wallet.getCurrentBaseFees()).mul(1.5);
+  const paymentMethod = new FeeJuicePaymentMethod(AztecAddress.ZERO);
+  const gasSettings = GasSettings.default({ maxFeesPerGas });
+  const fee = { gasSettings, paymentMethod };
+
+  const { l1ChainId: chainId, protocolVersion } = await wallet.getNodeInfo();
+  const entrypoint = new DefaultEntrypoint(chainId, protocolVersion);
+  const signerlessTxExecutionRequest = await entrypoint.createTxExecutionRequest(request, fee, {});
+
+  const simulationResult = await wallet.simulateTx(signerlessTxExecutionRequest, false, undefined, undefined, true);
+  const rawReturnValues = simulationResult.getPrivateReturnValues().values;
+  return decodeFromAbi(abi.returnTypes, rawReturnValues!);
+}

package/src/utils/authwit.ts

@@ -1,7 +1,6 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import type { FunctionCall } from '@aztec/stdlib/abi';
+import { computeInnerAuthWitHash, computeOuterAuthWitHash } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { HashedValues } from '@aztec/stdlib/tx';
 
@@ -58,13 +57,13 @@ export const computeAuthWitMessageHash = async (intent: IntentInnerHash | Intent
   const version = metadata.version;
 
   if ('caller' in intent) {
-    const action =
+    const fnCall =
       intent.action instanceof ContractFunctionInteraction ? (await intent.action.request()).calls[0] : intent.action;
     return computeOuterAuthWitHash(
-      action.to,
+      fnCall.to,
       chainId,
       version,
-      await computeInnerAuthWitHashFromAction(intent.caller, action),
+      await computeInnerAuthWitHashFromFunctionCall(intent.caller, fnCall),
     );
   } else {
     const inner = Buffer.isBuffer(intent.innerHash) ? Fr.fromBuffer(intent.innerHash) : intent.innerHash;
@@ -73,39 +72,37 @@ export const computeAuthWitMessageHash = async (intent: IntentInnerHash | Intent
 };
 // docs:end:authwit_computeAuthWitMessageHash
 
-export const computeInnerAuthWitHashFromAction = async (caller: AztecAddress, action: FunctionCall) =>
-  computeInnerAuthWitHash([
+/**
+ * Computes the inner authwitness hash for a function call, for it to later be combined with the metadata
+ * required for the outer hash and eventually the full AuthWitness.
+ * @param caller - Who is going to be calling the function
+ * @param fnCall - The function call to compute the inner hash from
+ * @returns The inner hash for the function call
+ **/
+export const computeInnerAuthWitHashFromFunctionCall = async (caller: AztecAddress, fnCall: FunctionCall) => {
+  return computeInnerAuthWitHash([
     caller.toField(),
-    action.selector.toField(),
-    (await HashedValues.fromValues(action.args)).hash,
+    fnCall.selector.toField(),
+    (await HashedValues.fromValues(fnCall.args)).hash,
   ]);
-
-/**
- * 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 poseidon2HashWithSeparator(args, 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 chainId - The chain id that can "consume" the authwit
- * @param version - The version that can "consume" the authwit
- * @param innerHash - The inner hash for the witness
- * @returns The outer hash for the witness
- */
-const computeOuterAuthWitHash = (consumer: AztecAddress, chainId: Fr, version: Fr, innerHash: Fr) => {
-  return poseidon2HashWithSeparator([consumer.toField(), chainId, version, innerHash], GeneratorIndex.AUTHWIT_OUTER);
+ * Computes the inner authwitness hash for an action, that can either be a ContractFunctionInteraction
+ * or an isolated FunctionCall. Since the former is just a wrapper around the latter, we can just extract
+ * the first (and only) call from the ContractFunctionInteraction and use it to compute the inner hash.
+ * @param caller - Who is going to be performing the action
+ * @param action - The ContractFunctionInteraction or FunctionCall to compute the inner hash for
+ * @returns The inner hash for the action
+ **/
+export const computeInnerAuthWitHashFromAction = async (
+  caller: AztecAddress,
+  action: FunctionCall | ContractFunctionInteraction,
+) => {
+  action = action instanceof ContractFunctionInteraction ? (await action.request()).calls[0] : action;
+  return computeInnerAuthWitHash([
+    caller.toField(),
+    action.selector.toField(),
+    (await HashedValues.fromValues(action.args)).hash,
+  ]);
 };