@aztec/aztec.js 0.0.0-test.0

package/src/api/ethereum/portal_manager.ts

@@ -0,0 +1,410 @@
+import type { ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
+import { extractEvent } from '@aztec/ethereum/utils';
+import { sha256ToField } from '@aztec/foundation/crypto';
+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 { FeeJuicePortalAbi, OutboxAbi, TestERC20Abi, TokenPortalAbi } from '@aztec/l1-artifacts';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computeSecretHash } from '@aztec/stdlib/hash';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+
+import { type GetContractReturnType, type Hex, getContract, toFunctionSelector } from 'viem';
+
+// 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. */
+  claimSecret: Fr;
+  /** Hash of the secret for claiming. */
+  claimSecretHash: Fr;
+  /** Hash of the message. */
+  messageHash: Hex;
+  /** 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 & {
+  /** Address that will receive the newly minted notes. */ recipient: AztecAddress;
+};
+
+/** Stringifies an eth address for logging. */
+function stringifyEthAddress(address: EthAddress | Hex, name?: string) {
+  return name ? `${name} (${address.toString()})` : address.toString();
+}
+
+/** Generates a pair secret and secret hash */
+export async function generateClaimSecret(logger?: Logger): Promise<[Fr, Fr]> {
+  const secret = Fr.random();
+  const secretHash = await computeSecretHash(secret);
+  logger?.verbose(`Generated claim secret=${secret.toString()} hash=${secretHash.toString()}`);
+  return [secret, secretHash];
+}
+
+/** Helper for managing an ERC20 on L1. */
+export class L1TokenManager {
+  private contract: GetContractReturnType<typeof TestERC20Abi, ViemWalletClient>;
+
+  public constructor(
+    /** Address of the ERC20 contract. */
+    public readonly address: EthAddress,
+    private publicClient: ViemPublicClient,
+    private walletClient: ViemWalletClient,
+    private logger: Logger,
+  ) {
+    this.contract = getContract({
+      address: this.address.toString(),
+      abi: TestERC20Abi,
+      client: this.walletClient,
+    });
+  }
+
+  /**
+   * Returns the balance of the given address.
+   * @param address - Address to get the balance of.
+   */
+  public async getL1TokenBalance(address: Hex) {
+    return await this.contract.read.balanceOf([address]);
+  }
+
+  /**
+   * Mints tokens for the given address. Returns once the tx has been mined.
+   * @param amount - Amount to mint.
+   * @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]),
+    });
+  }
+
+  /**
+   * Approves tokens for the given address. Returns once the tx has been mined.
+   * @param amount - Amount to approve.
+   * @param address - Address to approve the tokens for.
+   * @param addressName - Optional name of the address for logging.
+   */
+  public async approve(amount: bigint, address: Hex, addressName = '') {
+    this.logger.info(`Approving ${amount} tokens for ${stringifyEthAddress(address, addressName)}`);
+    await this.publicClient.waitForTransactionReceipt({
+      hash: await this.contract.write.approve([address, amount]),
+    });
+  }
+}
+
+/** Helper for interacting with the FeeJuicePortal on L1. */
+export class L1FeeJuicePortalManager {
+  private readonly tokenManager: L1TokenManager;
+  private readonly contract: GetContractReturnType<typeof FeeJuicePortalAbi, ViemWalletClient>;
+
+  constructor(
+    portalAddress: EthAddress,
+    tokenAddress: EthAddress,
+    private readonly publicClient: ViemPublicClient,
+    private readonly walletClient: ViemWalletClient,
+    private readonly logger: Logger,
+  ) {
+    this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+    this.contract = getContract({
+      address: portalAddress.toString(),
+      abi: FeeJuicePortalAbi,
+      client: this.walletClient,
+    });
+  }
+
+  /** Returns the associated token manager for the L1 ERC20. */
+  public getTokenManager() {
+    return this.tokenManager;
+  }
+
+  /**
+   * Bridges fee juice from L1 to L2 publicly. Handles L1 ERC20 approvals. Returns once the tx has been mined.
+   * @param to - Address to send the tokens to on L2.
+   * @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> {
+    const [claimSecret, claimSecretHash] = await generateClaimSecret();
+    if (mint) {
+      await this.tokenManager.mint(amount, this.walletClient.account.address);
+    }
+
+    await this.tokenManager.approve(amount, 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;
+
+    await this.contract.simulate.depositToAztecPublic(args);
+
+    const txReceipt = await this.publicClient.waitForTransactionReceipt({
+      hash: await this.contract.write.depositToAztecPublic(args),
+    });
+
+    this.logger.info('Deposited to Aztec public successfully');
+
+    const log = extractEvent(
+      txReceipt.logs,
+      this.contract.address,
+      this.contract.abi,
+      'DepositToAztecPublic',
+      log =>
+        log.args.secretHash === claimSecretHash.toString() &&
+        log.args.amount === amount &&
+        log.args.to === to.toString(),
+      this.logger,
+    );
+
+    return {
+      claimAmount: amount,
+      claimSecret,
+      claimSecretHash,
+      messageHash: log.args.key,
+      messageLeafIndex: log.args.index,
+    };
+  }
+
+  /**
+   * Creates a new instance
+   * @param pxe - 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,
+    publicClient: ViemPublicClient,
+    walletClient: ViemWalletClient,
+    logger: Logger,
+  ): Promise<L1FeeJuicePortalManager> {
+    const {
+      l1ContractAddresses: { feeJuiceAddress, feeJuicePortalAddress },
+    } = await pxe.getNodeInfo();
+
+    if (feeJuiceAddress.isZero() || feeJuicePortalAddress.isZero()) {
+      throw new Error('Portal or token not deployed on L1');
+    }
+
+    return new L1FeeJuicePortalManager(feeJuicePortalAddress, feeJuiceAddress, publicClient, walletClient, logger);
+  }
+}
+
+/** Helper for interacting with a test TokenPortal on L1 for sending tokens to L2. */
+export class L1ToL2TokenPortalManager {
+  protected readonly portal: GetContractReturnType<typeof TokenPortalAbi, ViemWalletClient>;
+  protected readonly tokenManager: L1TokenManager;
+
+  constructor(
+    portalAddress: EthAddress,
+    tokenAddress: EthAddress,
+    protected publicClient: ViemPublicClient,
+    protected walletClient: ViemWalletClient,
+    protected logger: Logger,
+  ) {
+    this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+    this.portal = getContract({
+      address: portalAddress.toString(),
+      abi: TokenPortalAbi,
+      client: this.walletClient,
+    });
+  }
+
+  /** Returns the token manager for the underlying L1 token. */
+  public getTokenManager() {
+    return this.tokenManager;
+  }
+
+  /**
+   * Bridges tokens from L1 to L2. Handles token approvals. Returns once the tx has been mined.
+   * @param to - Address to send the tokens to on L2.
+   * @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> {
+    const [claimSecret, claimSecretHash] = await this.bridgeSetup(amount, mint);
+
+    this.logger.info('Sending L1 tokens to L2 to be claimed publicly');
+    const { request } = await this.portal.simulate.depositToAztecPublic([
+      to.toString(),
+      amount,
+      claimSecretHash.toString(),
+    ]);
+
+    const txReceipt = await this.publicClient.waitForTransactionReceipt({
+      hash: await this.walletClient.writeContract(request),
+    });
+
+    const log = extractEvent(
+      txReceipt.logs,
+      this.portal.address,
+      this.portal.abi,
+      'DepositToAztecPublic',
+      log =>
+        log.args.secretHash === claimSecretHash.toString() &&
+        log.args.amount === amount &&
+        log.args.to === to.toString(),
+      this.logger,
+    );
+
+    return {
+      claimAmount: amount,
+      claimSecret,
+      claimSecretHash,
+      messageHash: log.args.key,
+      messageLeafIndex: log.args.index,
+    };
+  }
+
+  /**
+   * 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.
+   * @param amount - Amount of tokens to send.
+   * @param mint - Whether to mint the tokens before sending (only during testing).
+   */
+  public async bridgeTokensPrivate(
+    to: AztecAddress,
+    amount: bigint,
+    mint = false,
+  ): Promise<L2AmountClaimWithRecipient> {
+    const [claimSecret, claimSecretHash] = await this.bridgeSetup(amount, mint);
+
+    this.logger.info('Sending L1 tokens to L2 to be claimed privately');
+    const { request } = await this.portal.simulate.depositToAztecPrivate([amount, claimSecretHash.toString()]);
+
+    const txReceipt = await this.publicClient.waitForTransactionReceipt({
+      hash: await this.walletClient.writeContract(request),
+    });
+
+    const log = extractEvent(
+      txReceipt.logs,
+      this.portal.address,
+      this.portal.abi,
+      'DepositToAztecPrivate',
+      log => log.args.amount === amount && log.args.secretHashForL2MessageConsumption === claimSecretHash.toString(),
+      this.logger,
+    );
+
+    this.logger.info(
+      `Claim message secret: ${claimSecret.toString()}, claim message secret hash: ${claimSecretHash.toString()}`,
+    );
+
+    return {
+      claimAmount: amount,
+      claimSecret,
+      claimSecretHash,
+      recipient: to,
+      messageHash: log.args.key,
+      messageLeafIndex: log.args.index,
+    };
+  }
+
+  private async bridgeSetup(amount: bigint, mint: boolean) {
+    if (mint) {
+      await this.tokenManager.mint(amount, this.walletClient.account.address);
+    }
+    await this.tokenManager.approve(amount, this.portal.address, 'TokenPortal');
+    return generateClaimSecret();
+  }
+}
+
+/** Helper for interacting with a test TokenPortal on L1 for both withdrawing from and bridging to L2. */
+export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
+  private readonly outbox: GetContractReturnType<typeof OutboxAbi, ViemWalletClient>;
+
+  constructor(
+    portalAddress: EthAddress,
+    tokenAddress: EthAddress,
+    outboxAddress: EthAddress,
+    publicClient: ViemPublicClient,
+    walletClient: ViemWalletClient,
+    logger: Logger,
+  ) {
+    super(portalAddress, tokenAddress, publicClient, walletClient, logger);
+    this.outbox = getContract({
+      address: outboxAddress.toString(),
+      abi: OutboxAbi,
+      client: walletClient,
+    });
+  }
+
+  /**
+   * Withdraws funds from the portal by consuming an L2 to L1 message. Returns once the tx is mined on L1.
+   * @param amount - Amount to withdraw.
+   * @param recipient - Who will receive the funds.
+   * @param blockNumber - L2 block number of the message.
+   * @param messageIndex - Index of the message.
+   * @param siblingPath - Sibling path of the message.
+   */
+  public async withdrawFunds(
+    amount: bigint,
+    recipient: EthAddress,
+    blockNumber: bigint,
+    messageIndex: bigint,
+    siblingPath: SiblingPath<number>,
+  ) {
+    this.logger.info(
+      `Sending L1 tx to consume message at block ${blockNumber} index ${messageIndex} to withdraw ${amount}`,
+    );
+
+    const isConsumedBefore = await this.outbox.read.hasMessageBeenConsumedAtBlockAndIndex([blockNumber, messageIndex]);
+    if (isConsumedBefore) {
+      throw new Error(`L1 to L2 message at block ${blockNumber} index ${messageIndex} has already been consumed`);
+    }
+
+    // Call function on L1 contract to consume the message
+    const { request: withdrawRequest } = await this.portal.simulate.withdraw([
+      recipient.toString(),
+      amount,
+      false,
+      BigInt(blockNumber),
+      messageIndex,
+      siblingPath.toBufferArray().map((buf: Buffer): Hex => `0x${buf.toString('hex')}`),
+    ]);
+
+    await this.publicClient.waitForTransactionReceipt({ hash: await this.walletClient.writeContract(withdrawRequest) });
+
+    const isConsumedAfter = await this.outbox.read.hasMessageBeenConsumedAtBlockAndIndex([blockNumber, messageIndex]);
+    if (!isConsumedAfter) {
+      throw new Error(`L1 to L2 message at block ${blockNumber} index ${messageIndex} not consumed after withdrawal`);
+    }
+  }
+
+  /**
+   * Computes the L2 to L1 message leaf for the given parameters.
+   * @param amount - Amount to bridge.
+   * @param recipient - Recipient on L1.
+   * @param l2Bridge - Address of the L2 bridge.
+   * @param callerOnL1 - Caller address on L1.
+   */
+  public getL2ToL1MessageLeaf(
+    amount: bigint,
+    recipient: EthAddress,
+    l2Bridge: AztecAddress,
+    callerOnL1: EthAddress = EthAddress.ZERO,
+  ): Fr {
+    const content = sha256ToField([
+      Buffer.from(toFunctionSelector('withdraw(address,uint256,address)').substring(2), 'hex'),
+      recipient.toBuffer32(),
+      new Fr(amount).toBuffer(),
+      callerOnL1.toBuffer32(),
+    ]);
+    const leaf = sha256ToField([
+      l2Bridge.toBuffer(),
+      new Fr(1).toBuffer(), // aztec version
+      EthAddress.fromString(this.portal.address).toBuffer32() ?? Buffer.alloc(32, 0),
+      new Fr(this.publicClient.chain.id).toBuffer(), // chain id
+      content.toBuffer(),
+    ]);
+
+    return leaf;
+  }
+}

package/src/api/fee.ts

@@ -0,0 +1,5 @@
+export type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+export { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
+export { PrivateFeePaymentMethod } from '../fee/private_fee_payment_method.js';
+export { PublicFeePaymentMethod } from '../fee/public_fee_payment_method.js';
+export { FeeJuicePaymentMethodWithClaim } from '../fee/fee_juice_payment_method_with_claim.js';

package/src/api/fields.ts

@@ -0,0 +1 @@
+export { Point, Fr, Fq, GrumpkinScalar } from '@aztec/foundation/fields';

package/src/api/interfaces/pxe.ts

@@ -0,0 +1 @@
+export type { PXE } from '@aztec/stdlib/interfaces/client';

package/src/api/log.ts

@@ -0,0 +1 @@
+export { createLogger, type Logger } from '@aztec/foundation/log';

package/src/api/log_id.ts

@@ -0,0 +1 @@
+export { LogId } from '@aztec/stdlib/logs';

package/src/api/tx_hash.ts

@@ -0,0 +1 @@
+export { TxHash } from '@aztec/stdlib/tx';

package/src/api/wallet.ts

@@ -0,0 +1,7 @@
+export {
+  AccountWallet,
+  AccountWalletWithSecretKey as AccountWalletWithSecretKey,
+  SignerlessWallet,
+  type Wallet,
+  getWallet,
+} from '../wallet/index.js';

package/src/contract/base_contract_interaction.ts

@@ -0,0 +1,192 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { GasSettings } from '@aztec/stdlib/gas';
+import type { Capsule, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
+
+import type { Wallet } from '../account/wallet.js';
+import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
+import type { FeeOptions, UserFeeOptions } from '../entrypoint/payload.js';
+import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
+import { getGasLimits } from './get_gas_limits.js';
+import { ProvenTx } from './proven_tx.js';
+import { SentTx } from './sent_tx.js';
+
+/**
+ * Represents options for calling a (constrained) function in a contract.
+ * Allows the user to specify the sender address and nonce for a transaction.
+ */
+export type SendMethodOptions = {
+  /** Wether to skip the simulation of the public part of the transaction. */
+  skipPublicSimulation?: boolean;
+  /** The fee options for the transaction. */
+  fee?: UserFeeOptions;
+  /** Custom nonce to inject into the app payload of the transaction. Useful when trying to cancel an ongoing transaction by creating a new one with a higher fee */
+  nonce?: Fr;
+  /** Whether the transaction can be cancelled. If true, an extra nullifier will be emitted: H(nonce, GENERATOR_INDEX__TX_NULLIFIER) */
+  cancellable?: boolean;
+};
+
+/**
+ * Base class for an interaction with a contract, be it a deployment, a function call, or a batch.
+ * Implements the sequence create/simulate/send.
+ */
+export abstract class BaseContractInteraction {
+  protected log = createLogger('aztecjs:contract_interaction');
+
+  private capsules: Capsule[] = [];
+
+  constructor(protected wallet: Wallet) {}
+
+  /**
+   * Create a transaction execution request ready to be simulated.
+   * @param options - An optional object containing additional configuration for the transaction.
+   * @returns A transaction execution request.
+   */
+  public abstract create(options?: SendMethodOptions): Promise<TxExecutionRequest>;
+
+  /**
+   * Creates a transaction execution request, simulates and proves it. Differs from .prove in
+   * that its result does not include the wallet nor the composed tx object, but only the proving result.
+   * This object can then be used to either create a ProvenTx ready to be sent, or directly send the transaction.
+   * @param options - optional arguments to be used in the creation of the transaction
+   * @returns The proving result.
+   */
+  protected async proveInternal(options: SendMethodOptions = {}): Promise<TxProvingResult> {
+    const txRequest = await this.create(options);
+    const txSimulationResult = await this.wallet.simulateTx(txRequest, !options.skipPublicSimulation, undefined, true);
+    return await this.wallet.proveTx(txRequest, txSimulationResult.privateExecutionResult);
+  }
+
+  // docs:start:prove
+  /**
+   * Proves a transaction execution request and returns a tx object ready to be sent.
+   * @param options - optional arguments to be used in the creation of the transaction
+   * @returns The resulting transaction
+   */
+  public async prove(options: SendMethodOptions = {}): Promise<ProvenTx> {
+    // docs:end:prove
+    const txProvingResult = await this.proveInternal(options);
+    return new ProvenTx(this.wallet, txProvingResult.toTx());
+  }
+
+  // docs:start:send
+  /**
+   * Sends a transaction to the contract function with the specified options.
+   * This function throws an error if called on an unconstrained function.
+   * It creates and signs the transaction if necessary, and returns a SentTx instance,
+   * which can be used to track the transaction status, receipt, and events.
+   * @param options - An optional object containing 'from' property representing
+   * the AztecAddress of the sender. If not provided, the default address is used.
+   * @returns A SentTx instance for tracking the transaction status and information.
+   */
+  public send(options: SendMethodOptions = {}): SentTx {
+    // docs:end:send
+    const promise = (async () => {
+      const txProvingResult = await this.proveInternal(options);
+      return this.wallet.sendTx(txProvingResult.toTx());
+    })();
+    return new SentTx(this.wallet, promise);
+  }
+
+  // docs:start:estimateGas
+  /**
+   * Estimates gas for a given tx request and returns gas limits for it.
+   * @param opts - Options.
+   * @param pad - Percentage to pad the suggested gas limits by, if empty, defaults to 10%.
+   * @returns Gas limits.
+   */
+  public async estimateGas(
+    opts?: Omit<SendMethodOptions, 'estimateGas' | 'skipPublicSimulation'>,
+  ): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>> {
+    // docs:end:estimateGas
+    const txRequest = await this.create({ ...opts, fee: { ...opts?.fee, estimateGas: false } });
+    const simulationResult = await this.wallet.simulateTx(
+      txRequest,
+      true /*simulatePublic*/,
+      undefined /* msgSender */,
+      undefined /* skipTxValidation */,
+      true /* skipFeeEnforcement */,
+    );
+    const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(
+      simulationResult,
+      opts?.fee?.estimatedGasPadding,
+    );
+    return { gasLimits, teardownGasLimits };
+  }
+
+  /**
+   * Returns default fee options based on the user opts without running a simulation for gas estimation.
+   * @param fee - User-provided fee options.
+   */
+  protected async getDefaultFeeOptions(fee: UserFeeOptions | undefined): Promise<FeeOptions> {
+    const maxFeesPerGas =
+      fee?.gasSettings?.maxFeesPerGas ?? (await this.wallet.getCurrentBaseFees()).mul(1 + (fee?.baseFeePadding ?? 0.5));
+    const paymentMethod = fee?.paymentMethod ?? new FeeJuicePaymentMethod(this.wallet.getAddress());
+    const gasSettings: GasSettings = GasSettings.default({ ...fee?.gasSettings, maxFeesPerGas });
+    this.log.debug(`Using L2 gas settings`, gasSettings);
+    return { gasSettings, paymentMethod };
+  }
+
+  // docs:start:getFeeOptions
+  /**
+   * Return fee options based on the user opts, estimating tx gas if needed.
+   * @param request - Request to execute for this interaction.
+   * @param pad - Percentage to pad the suggested gas limits by, as decimal (e.g., 0.10 for 10%).
+   * @returns Fee options for the actual transaction.
+   */
+  protected async getFeeOptions(
+    request: Omit<ExecutionRequestInit, 'fee'> & { /** User-provided fee options */ fee?: UserFeeOptions },
+  ): Promise<FeeOptions> {
+    // docs:end:getFeeOptions
+    const defaultFeeOptions = await this.getDefaultFeeOptions(request.fee);
+    const paymentMethod = defaultFeeOptions.paymentMethod;
+    const maxFeesPerGas = defaultFeeOptions.gasSettings.maxFeesPerGas;
+    const maxPriorityFeesPerGas = defaultFeeOptions.gasSettings.maxPriorityFeesPerGas;
+
+    let gasSettings = defaultFeeOptions.gasSettings;
+    if (request.fee?.estimateGas) {
+      const feeForEstimation: FeeOptions = { paymentMethod, gasSettings };
+      const txRequest = await this.wallet.createTxExecutionRequest({ ...request, fee: feeForEstimation });
+      const simulationResult = await this.wallet.simulateTx(
+        txRequest,
+        true /*simulatePublic*/,
+        undefined /* msgSender */,
+        undefined /* skipTxValidation */,
+        true /* skipFeeEnforcement */,
+      );
+      const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(
+        simulationResult,
+        request.fee?.estimatedGasPadding,
+      );
+      gasSettings = GasSettings.from({ maxFeesPerGas, maxPriorityFeesPerGas, gasLimits, teardownGasLimits });
+      this.log.verbose(
+        `Estimated gas limits for tx: DA=${gasLimits.daGas} L2=${gasLimits.l2Gas} teardownDA=${teardownGasLimits.daGas} teardownL2=${teardownGasLimits.l2Gas}`,
+      );
+    }
+
+    return { gasSettings, paymentMethod };
+  }
+
+  /**
+   * Add data passed to the oracle calls during this contract interaction.
+   * @param capsule - Data passed to oracle calls.
+   */
+  public addCapsule(capsule: Capsule) {
+    this.capsules.push(capsule);
+  }
+
+  /**
+   * Add data passed to the oracle calls during this contract interaction.
+   * @param capsules - Data passed to oracle calls.
+   */
+  public addCapsules(capsules: Capsule[]) {
+    this.capsules.push(...capsules);
+  }
+
+  /**
+   * Return all capsules added for this function interaction.
+   */
+  public getCapsules() {
+    return this.capsules;
+  }
+}