@aztec/aztec.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/src/contract/interaction_options.ts

@@ -1,39 +1,67 @@
-import type { UserFeeOptions } from '@aztec/entrypoints/interfaces';
-import type { Fr } from '@aztec/foundation/fields';
+import type { FieldsOf } from '@aztec/foundation/types';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { Capsule } from '@aztec/stdlib/tx';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { Capsule, OffchainEffect, SimulationStats } from '@aztec/stdlib/tx';
+
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+import type { ProfileOptions, SendOptions, SimulateOptions } from '../wallet/index.js';
+
+/**
+ * Options used to tweak the simulation and add gas estimation capabilities
+ */
+export type FeeEstimationOptions = {
+  /** Whether to modify the fee settings of the simulation with high gas limit to figure out actual gas settings. */
+  estimateGas?: boolean;
+  /** Percentage to pad the estimated gas limits by, if empty, defaults to 0.1. Only relevant if estimateGas is set. */
+  estimatedGasPadding?: number;
+};
+
+/**
+ * Interactions allow configuring a custom fee payment method that gets bundled with the transaction before
+ * sending it to the wallet
+ */
+export type FeePaymentMethodOption = {
+  /** Fee payment method to embed in the interaction */
+  paymentMethod?: FeePaymentMethod;
+};
+
+/**
+ * User-defined partial gas settings for the interaction. This type is completely optional since
+ * the wallet will fill in the missing options
+ */
+export type GasSettingsOption = {
+  /** The gas settings */
+  gasSettings?: Partial<FieldsOf<GasSettings>>;
+};
+
+/** Fee options as set by a user. */
+export type InteractionFeeOptions = GasSettingsOption & FeePaymentMethodOption;
+
+/**  Fee options that can be set for simulation *only* */
+export type SimulationInteractionFeeOptions = InteractionFeeOptions & FeeEstimationOptions;
 
 /**
  * Represents the options to configure a request from a contract interaction.
  * Allows specifying additional auth witnesses and capsules to use during execution
  */
-export type RequestMethodOptions = {
+export type RequestInteractionOptions = {
   /** Extra authwits to use during execution */
   authWitnesses?: AuthWitness[];
   /** Extra capsules to use during execution */
   capsules?: Capsule[];
+  /** Fee payment method to embed in the interaction request */
+  fee?: FeePaymentMethodOption;
 };
 
 /**
  * Represents options for calling a (constrained) function in a contract.
  */
-export type SendMethodOptions = RequestMethodOptions & {
+export type SendInteractionOptions = RequestInteractionOptions & {
   /** The sender's Aztec address. */
   from: AztecAddress;
   /** The fee options for the transaction. */
-  fee?: UserFeeOptions;
-  /**
-   * 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;
-  /**
-   * Whether the transaction can be cancelled by submitting a new transaction with the same txNonce but
-   * higher fee.
-   */
-  cancellable?: boolean;
+  fee?: InteractionFeeOptions;
 };
 
 /**
@@ -41,10 +69,9 @@ export type SendMethodOptions = RequestMethodOptions & {
  * Allows specifying the address from which the method should be called.
  * Disregarded for simulation of public functions
  */
-export type SimulateMethodOptions = Pick<
-  SendMethodOptions,
-  'from' | 'authWitnesses' | 'capsules' | 'fee' | 'txNonce' | 'cancellable'
-> & {
+export type SimulateInteractionOptions = Omit<SendInteractionOptions, 'fee'> & {
+  /** The fee options for the transaction. */
+  fee?: SimulationInteractionFeeOptions;
   /** Simulate without checking for the validity of the resulting transaction, e.g. whether it emits any existing nullifiers. */
   skipTxValidation?: boolean;
   /** Whether to ensure the fee payer is not empty and has enough balance to pay for the fee. */
@@ -57,11 +84,86 @@ export type SimulateMethodOptions = Pick<
 /**
  * Represents the options for profiling an interaction.
  */
-// docs:start:profile-method-options
-export type ProfileMethodOptions = SimulateMethodOptions & {
+export type ProfileInteractionOptions = SimulateInteractionOptions & {
   /** Whether to return gates information or the bytecode/witnesses. */
   profileMode: 'gates' | 'execution-steps' | 'full';
   /** Whether to generate a ClientIVC proof or not */
   skipProofGeneration?: boolean;
 };
-// docs:end:profile-method-options
+
+/**
+ * Represents the result type of a simulation.
+ * By default, it will just be the return value of the simulated function
+ * If `includeMetadata` is set to true in `SimulateInteractionOptions` on the input of `simulate(...)`,
+ * it will provide extra information.
+ */
+export type SimulationReturn<T extends boolean | undefined> = T extends true
+  ? {
+      /** Additional stats about the simulation */
+      stats: SimulationStats;
+      /** Offchain effects generated during the simulation */
+      offchainEffects: OffchainEffect[];
+      /**  Return value of the function */
+      result: any;
+      /** Gas estimation results */
+      estimatedGas: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>;
+    }
+  : any;
+
+/**
+ * Transforms and cleans up the higher level SendInteractionOptions defined by the interaction into
+ * SendOptions, which are the ones that can be serialized and forwarded to the wallet
+ */
+export async function toSendOptions(options: SendInteractionOptions): Promise<SendOptions> {
+  return {
+    ...options,
+    fee: {
+      // If this interaction includes a fee payment method, pass the fee payer
+      // as a hint to the wallet
+      embeddedPaymentMethodFeePayer: await options.fee?.paymentMethod?.getFeePayer(),
+      // If a payment method that includes gas settings was used,
+      // try to reuse as much as possible while still allowing
+      // manual override. CAREFUL: this can cause mismatches during proving
+      gasSettings: {
+        ...options.fee?.paymentMethod?.getGasSettings(),
+        ...options.fee?.gasSettings,
+      },
+    },
+  };
+}
+
+/**
+ * Transforms and cleans up the higher level SimulateInteractionOptions defined by the interaction into
+ * SimulateOptions, which are the ones that can be serialized and forwarded to the wallet
+ */
+export async function toSimulateOptions(options: SimulateInteractionOptions): Promise<SimulateOptions> {
+  return {
+    ...options,
+    fee: {
+      // If this interaction includes a fee payment method, pass the fee payer
+      // as a hint to the wallet
+      embeddedPaymentMethodFeePayer: await options.fee?.paymentMethod?.getFeePayer(),
+      // If a payment method that includes gas settings was used,
+      // try to reuse as much as possible while still allowing
+      // manual override. CAREFUL: this can cause mismatches during proving
+      gasSettings: {
+        ...options.fee?.paymentMethod?.getGasSettings(),
+        ...options.fee?.gasSettings,
+      },
+      estimateGas: options.fee?.estimateGas,
+      estimatedGasPadding: options.fee?.estimatedGasPadding,
+    },
+  };
+}
+
+/**
+ * Transforms and cleans up the higher level ProfileInteractionOptions defined by the interaction into
+ * ProfileOptions, which are the ones that can be serialized and forwarded to the wallet
+ */
+export async function toProfileOptions(options: ProfileInteractionOptions): Promise<ProfileOptions> {
+  return {
+    ...(await toSimulateOptions(options)),
+    profileMode: options.profileMode,
+    skipProofGeneration: options.skipProofGeneration,
+  };
+}

package/src/contract/sent_tx.ts

@@ -1,7 +1,7 @@
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { retryUntil } from '@aztec/foundation/retry';
 import type { FieldsOf } from '@aztec/foundation/types';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { TxHash, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../wallet/wallet.js';
@@ -34,7 +34,7 @@ export class SentTx {
   protected txHash?: TxHash;
 
   constructor(
-    protected pxeWalletOrNode: Wallet | AztecNode | PXE,
+    protected walletOrNode: Wallet | AztecNode,
     sendTx: () => Promise<TxHash>,
   ) {
     const { promise, resolve } = promiseWithResolvers<void>();
@@ -80,7 +80,7 @@ export class SentTx {
    */
   public async getReceipt(): Promise<TxReceipt> {
     const txHash = await this.getTxHash();
-    return await this.pxeWalletOrNode.getTxReceipt(txHash);
+    return await this.walletOrNode.getTxReceipt(txHash);
   }
 
   /**
@@ -105,7 +105,7 @@ export class SentTx {
 
     return await retryUntil(
       async () => {
-        const txReceipt = await this.pxeWalletOrNode.getTxReceipt(txHash);
+        const txReceipt = await this.walletOrNode.getTxReceipt(txHash);
         // If receipt is not yet available, try again
         if (txReceipt.status === TxStatus.PENDING) {
           return undefined;

package/src/contract/wait_for_proven.ts

@@ -1,7 +1,7 @@
 import { retryUntil } from '@aztec/foundation/retry';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { TxReceipt } from '@aztec/stdlib/tx';
 
-import type { TxReceipt } from '../index.js';
 import { DefaultWaitOpts } from './sent_tx.js';
 
 /**
@@ -22,13 +22,13 @@ export const DefaultWaitForProvenOpts: WaitForProvenOpts = {
 /**
  * Wait for a transaction to be proven by polling the node
  */
-export async function waitForProven(pxeOrNode: PXE | AztecNode, receipt: TxReceipt, opts?: WaitForProvenOpts) {
+export async function waitForProven(node: AztecNode, receipt: TxReceipt, opts?: WaitForProvenOpts) {
   if (!receipt.blockNumber) {
     throw new Error(`Cannot wait for proven: receipt of tx ${receipt.txHash} does not have a block number`);
   }
   return await retryUntil(
     async () => {
-      const provenBlock = await pxeOrNode.getProvenBlockNumber();
+      const provenBlock = await node.getProvenBlockNumber();
       return provenBlock >= receipt.blockNumber! ? provenBlock : undefined;
     },
     'isProven',

package/src/deployment/publish_instance.ts

@@ -2,7 +2,7 @@ import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
 import { getInstanceRegistryContract } from '../contract/protocol_contracts.js';
-import type { Wallet } from '../wallet/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 
 /**
  * Sets up a call to the canonical contract instance registry to publish a contract instance.
@@ -14,13 +14,8 @@ export async function publishInstance(
   instance: ContractInstanceWithAddress,
 ): Promise<ContractFunctionInteraction> {
   const contractInstanceRegistry = await getInstanceRegistryContract(wallet);
-  const { salt, currentContractClassId: contractClassId, publicKeys, deployer } = instance;
-  const isUniversalDeploy = deployer.isZero();
-  if (!isUniversalDeploy && !wallet.getAddress().equals(deployer)) {
-    throw new Error(
-      `Expected deployer ${deployer.toString()} does not match sender wallet ${wallet.getAddress().toString()}`,
-    );
-  }
+  const { salt, currentContractClassId: contractClassId, publicKeys, deployer: instanceDeployer } = instance;
+  const isUniversalDeploy = instanceDeployer.isZero();
   return contractInstanceRegistry.methods.publish_for_public_execution(
     salt,
     contractClassId,

package/src/ethereum/portal_manager.ts

@@ -12,15 +12,11 @@ import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
 import { TokenPortalAbi } from '@aztec/l1-artifacts/TokenPortalAbi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computeL2ToL1MessageHash, computeSecretHash } from '@aztec/stdlib/hash';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { getL2ToL1MessageLeafId } from '@aztec/stdlib/messaging';
 
 import { 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. */
 export type L2Claim = {
   /** Secret for claiming. */
@@ -32,11 +28,9 @@ export type L2Claim = {
   /** Leaf index in the L1 to L2 message tree. */
   messageLeafIndex: bigint;
 };
-// docs:end:claim_type
 
 /** L1 to L2 message info that corresponds to an amount to claim. */
 export type L2AmountClaim = L2Claim & { /** Amount to claim */ claimAmount: bigint };
-// docs:end:claim_type_amount
 
 /** L1 to L2 message info that corresponds to an amount to claim with associated recipient. */
 export type L2AmountClaimWithRecipient = L2AmountClaim & {
@@ -208,18 +202,18 @@ export class L1FeeJuicePortalManager {
 
   /**
    * Creates a new instance
-   * @param walletOrPxe - Wallet or PXE client used for retrieving the L1 contract addresses.
+   * @param node - Aztec node client used for retrieving the L1 contract addresses.
    * @param extendedClient - Wallet client, extended with public actions.
    * @param logger - Logger.
    */
   public static async new(
-    walletOrPxe: Wallet | PXE,
+    node: AztecNode,
     extendedClient: ExtendedViemWalletClient,
     logger: Logger,
   ): Promise<L1FeeJuicePortalManager> {
     const {
       l1ContractAddresses: { feeJuiceAddress, feeJuicePortalAddress, feeAssetHandlerAddress },
-    } = await walletOrPxe.getNodeInfo();
+    } = await node.getNodeInfo();
 
     if (feeJuiceAddress.isZero() || feeJuicePortalAddress.isZero()) {
       throw new Error('Portal or token not deployed on L1');
@@ -304,7 +298,6 @@ 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.
@@ -316,7 +309,6 @@ 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');

package/src/fee/fee_juice_payment_method_with_claim.ts

@@ -2,42 +2,39 @@ import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { Fr } from '@aztec/foundation/fields';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
 
-import { getFeeJuice } from '../contract/protocol_contracts.js';
 import type { L2AmountClaim } from '../ethereum/portal_manager.js';
-import type { Wallet } from '../wallet/index.js';
-import { FeeJuicePaymentMethod } from './fee_juice_payment_method.js';
+import type { FeePaymentMethod } from './fee_payment_method.js';
 
 /**
- * Pay fee directly with Fee Juice claimed on the same tx.
+ * Pay fee directly with Fee Juice claimed in the same tx. Claiming consumes an L1 to L2 message that "contains"
+ * the fee juice bridged from L1.
  */
-export class FeeJuicePaymentMethodWithClaim extends FeeJuicePaymentMethod {
+export class FeeJuicePaymentMethodWithClaim implements FeePaymentMethod {
   constructor(
-    private senderWallet: Wallet,
+    private sender: AztecAddress,
     private claim: Pick<L2AmountClaim, 'claimAmount' | 'claimSecret' | 'messageLeafIndex'>,
-  ) {
-    super(senderWallet.getAddress());
-  }
+  ) {}
 
   /**
    * Creates an execution payload to pay the fee in Fee Juice.
-   * @returns An execution payload that just contains the claim function call.
+   * @returns An execution payload that just contains the `claim_and_end_setup` function call.
    */
-  override async getExecutionPayload(): Promise<ExecutionPayload> {
-    const canonicalFeeJuice = await getFeeJuice(this.senderWallet);
-    const selector = await FunctionSelector.fromNameAndParameters(
-      canonicalFeeJuice.artifact.functions.find(f => f.name === 'claim')!,
-    );
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    const selector = await FunctionSelector.fromSignature('claim_and_end_setup((Field),u128,Field,Field)');
 
     return new ExecutionPayload(
       [
         {
           to: ProtocolContractAddress.FeeJuice,
-          name: 'claim',
+          name: 'claim_and_end_setup',
           selector,
+          hideMsgSender: false,
           isStatic: false,
           args: [
-            this.senderWallet.getAddress().toField(),
+            this.sender.toField(),
             new Fr(this.claim.claimAmount),
             this.claim.claimSecret,
             new Fr(this.claim.messageLeafIndex),
@@ -50,4 +47,16 @@ export class FeeJuicePaymentMethodWithClaim extends FeeJuicePaymentMethod {
       [],
     );
   }
+
+  getAsset() {
+    return Promise.resolve(ProtocolContractAddress.FeeJuice);
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.sender);
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return;
+  }
 }

package/src/fee/fee_payment_method.ts

@@ -0,0 +1,26 @@
+import type { ExecutionPayload } from '@aztec/entrypoints/payload';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+
+/**
+ * Holds information about how the fee for a transaction is to be paid.
+ */
+export interface FeePaymentMethod {
+  /** The asset used to pay the fee. */
+  getAsset(): Promise<AztecAddress>;
+  /**
+   * Returns the data to be added to the final execution request
+   * to pay the fee in the given asset
+   * @returns The function calls to pay the fee.
+   */
+  getExecutionPayload(): Promise<ExecutionPayload>;
+  /**
+   * The expected fee payer for this tx.
+   */
+  getFeePayer(): Promise<AztecAddress>;
+  /**
+   * The gas settings (if any) used to compute the
+   * execution payload of the payment method
+   */
+  getGasSettings(): GasSettings | undefined;
+}

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 { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
 
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
 import type { Wallet } from '../wallet/wallet.js';
-import { simulateWithoutSignature } from './utils.js';
+import type { FeePaymentMethod } from './fee_payment_method.js';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
@@ -21,10 +21,18 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
     private paymentContract: AztecAddress,
 
     /**
-     * An auth witness provider to authorize fee payments
+     * Address of the account that will pay the fee
      */
-    private wallet: Wallet,
+    private sender: AztecAddress,
 
+    /**
+     * A wallet to perform the simulation to get the accepted asset
+     */
+    private wallet: Wallet,
+    /**
+     * Gas settings used to compute the maximum fee the user is willing to pay
+     */
+    protected gasSettings: GasSettings,
     /**
      * If true, the max fee will be set to 1.
      * TODO(#7694): Remove this param once the lacking feature in TXE is implemented.
@@ -36,38 +44,43 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
    * The asset used to pay the fee.
    * @returns The asset used to pay the fee.
    */
-  getAsset(): Promise<AztecAddress> {
+  async getAsset(): Promise<AztecAddress> {
     if (!this.assetPromise) {
-      // 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',
-          functionType: FunctionType.PRIVATE,
-          isInternal: false,
-          isStatic: false,
-          parameters: [],
-          returnTypes: [
-            {
-              kind: 'struct',
-              path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
-              fields: [
-                {
-                  name: 'inner',
-                  type: {
-                    kind: 'field',
-                  },
+      const abi = {
+        name: 'get_accepted_asset',
+        functionType: FunctionType.PRIVATE,
+        isInternal: false,
+        isStatic: false,
+        parameters: [],
+        returnTypes: [
+          {
+            kind: 'struct',
+            path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+            fields: [
+              {
+                name: 'inner',
+                type: {
+                  kind: 'field',
                 },
-              ],
-            },
-          ],
-          errorTypes: {},
-          isInitializer: false,
-        },
-        [],
-      ) as Promise<AztecAddress>;
+              },
+            ],
+          },
+        ],
+        errorTypes: {},
+        isInitializer: false,
+      } as FunctionAbi;
+      const interaction = new ContractFunctionInteraction(this.wallet, this.paymentContract, abi, []);
+
+      const executionPayload = await interaction.request();
+      this.assetPromise = this.wallet
+        .simulateTx(executionPayload, {
+          from: AztecAddress.ZERO,
+          skipFeeEnforcement: true,
+        })
+        .then(simulationResult => {
+          const rawReturnValues = simulationResult.getPrivateReturnValues().nested[0].values;
+          return decodeFromAbi(abi.returnTypes, rawReturnValues!);
+        }) as Promise<AztecAddress>;
     }
     return this.assetPromise!;
   }
@@ -81,19 +94,20 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
    * @param gasSettings - The gas settings.
    * @returns An execution payload that contains the required function calls and auth witnesses.
    */
-  async getExecutionPayload(gasSettings: GasSettings): Promise<ExecutionPayload> {
+  async getExecutionPayload(): 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 maxFee = this.setMaxFeeToOne ? Fr.ONE : this.gasSettings.getFeeLimit();
     const txNonce = Fr.random();
 
-    const witness = await this.wallet.createAuthWit({
+    const witness = await this.wallet.createAuthWit(this.sender, {
       caller: this.paymentContract,
-      action: {
+      call: {
         name: 'transfer_to_public',
-        args: [this.wallet.getAddress().toField(), this.paymentContract.toField(), maxFee, txNonce],
+        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
         selector: await FunctionSelector.fromSignature('transfer_to_public((Field),(Field),u128,Field)'),
         type: FunctionType.PRIVATE,
+        hideMsgSender: false,
         isStatic: false,
         to: await this.getAsset(),
         returnTypes: [],
@@ -107,6 +121,7 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
           to: this.paymentContract,
           selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
           type: FunctionType.PRIVATE,
+          hideMsgSender: false,
           isStatic: false,
           args: [maxFee, txNonce],
           returnTypes: [],
@@ -116,4 +131,8 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
       [],
     );
   }
+
+  getGasSettings(): GasSettings | undefined {
+    return this.gasSettings;
+  }
 }