@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/api/authorization.ts

@@ -0,0 +1,15 @@
+export { AuthWitness } from '@aztec/stdlib/auth-witness';
+export {
+  SetPublicAuthwitContractInteraction,
+  type ContractFunctionInteractionCallIntent,
+  isContractFunctionInteractionCallIntent,
+  getMessageHashFromIntent,
+  computeAuthWitMessageHash,
+  computeInnerAuthWitHashFromAction,
+  lookupValidity,
+  type CallIntent,
+  type IntentInnerHash,
+} from '../utils/authwit.js';
+export { computeInnerAuthWitHash } from '@aztec/stdlib/auth-witness';
+
+export { CallAuthorizationRequest } from '../authorization/call_authorization_request.js';

package/src/api/block.ts

@@ -0,0 +1,2 @@
+export { Body, L2Block } from '@aztec/stdlib/block';
+export { getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';

package/src/api/contract.ts

@@ -0,0 +1,88 @@
+/**
+ * The `contract` module provides utilities for deploying and interacting with contracts, based on a
+ * `Wallet` instance and a compiled artifact. Refer to the {@link account} module for how to obtain a valid
+ * `Wallet` instance, and to the {@link https://docs.aztec.network/developers/aztec-nr/how_to_compile_contract | Compiling contracts}
+ * section of the documentation for how to generate an artifact out of your Noir source code.
+ *
+ * The {@link Contract} class is the main class in this module, and provides static methods for deploying
+ * a contract or interacting with an already deployed one. The `methods` property of the contract instance
+ * provides access to private, public, and simulate methods, that can be invoked in a transaction via `send()`,
+ * or can be queried via `simulate()`.
+ *
+ * ```ts
+ * // Deploy and get the contract instance directly (default behavior)
+ * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send({ from: accountAddress });
+ * console.log(`Contract deployed at ${contract.address}`);
+ *
+ * // Or get the full receipt with contract and instance
+ * const receipt = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send({
+ *   from: accountAddress,
+ *   wait: { returnReceipt: true }
+ * });
+ * console.log(`Contract deployed at ${receipt.contract.address}`);
+ * ```
+ *
+ * ```ts
+ * const contract = Contract.at(address, MyContractArtifact, wallet);
+ * await contract.methods.mint(1000, owner).send({ from: accountAddress });
+ * console.log(`Total supply is now ${await contract.methods.totalSupply().simulate()}`);
+ * ```
+ *
+ * The result of calling a method in a contract instance, such as `contract.methods.mint(1000, owner)`
+ * in the example, is a {@link ContractFunctionInteraction} instance. Usually this will be just sent as
+ * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
+ * or obtaining the `request` for aggregating into a {@link BatchCall}.
+ *
+ * The `send` method returns a {@link TxReceipt} by default (waits for the transaction to be mined).
+ * If you pass `wait: NO_WAIT` in the options, it will return a {@link TxHash} immediately without waiting.
+ *
+ * @remarks If you are using typescript, consider using the
+ * {@link https://docs.aztec.network/developers/aztec-nr/how_to_compile_contract#use-generated-interfaces | autogenerated type-safe interfaces}
+ * for interacting with your contracts.
+ *
+ * @packageDocumentation
+ */
+export { Contract } from '../contract/contract.js';
+export { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+
+export {
+  NO_WAIT,
+  type NoWait,
+  type RequestInteractionOptions,
+  type SendInteractionOptions,
+  type ProfileInteractionOptions,
+  type SimulateInteractionOptions,
+  type InteractionFeeOptions,
+  type InteractionWaitOptions,
+  type GasSettingsOption,
+  type SendReturn,
+  type SimulationReturn,
+  toProfileOptions,
+  toSendOptions,
+  toSimulateOptions,
+} from '../contract/interaction_options.js';
+
+export { DefaultWaitOpts, type WaitOpts } from '../contract/wait_opts.js';
+export { ContractBase, type ContractMethod, type ContractStorageLayout } from '../contract/contract_base.js';
+export { BatchCall } from '../contract/batch_call.js';
+export {
+  type DeployOptions,
+  type DeployReturn,
+  type DeployTxReceipt,
+  type DeployWaitOptions,
+  type DeployInteractionWaitOptions,
+  DeployMethod,
+  type RequestDeployOptions,
+  type SimulateDeployOptions,
+} from '../contract/deploy_method.js';
+export { waitForProven, type WaitForProvenOpts, DefaultWaitForProvenOpts } from '../contract/wait_for_proven.js';
+export { getGasLimits } from '../contract/get_gas_limits.js';
+
+export {
+  type PartialAddress,
+  type ContractClassWithId,
+  type ContractInstanceWithAddress,
+  getContractClassFromArtifact,
+  getContractInstanceFromInstantiationParams,
+  type NodeInfo,
+} from '@aztec/stdlib/contract';

package/src/api/crypto.ts

@@ -0,0 +1 @@
+export { computeSecretHash } from '@aztec/stdlib/hash';

package/src/api/deployment.ts

@@ -1,3 +1,4 @@
-export { registerContractClass } from '../deployment/register_class.js';
-export { broadcastPrivateFunction, broadcastUnconstrainedFunction } from '../deployment/broadcast_function.js';
-export { deployInstance } from '../deployment/deploy_instance.js';
+export { publishContractClass } from '../deployment/publish_class.js';
+export { broadcastPrivateFunction, broadcastUtilityFunction } from '../deployment/broadcast_function.js';
+export { publishInstance } from '../deployment/publish_instance.js';
+export { ContractDeployer } from '../deployment/contract_deployer.js';

package/src/api/ethereum.ts

@@ -0,0 +1,10 @@
+export {
+  L1FeeJuicePortalManager,
+  L1ToL2TokenPortalManager,
+  L1TokenManager,
+  L1TokenPortalManager,
+  type L2AmountClaim,
+  type L2AmountClaimWithRecipient,
+  type L2Claim,
+  generateClaimSecret,
+} from '../ethereum/portal_manager.js';

package/src/api/events.ts

@@ -0,0 +1,44 @@
+import { type EventMetadataDefinition, EventSelector, decodeFromAbi } from '@aztec/stdlib/abi';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+/**
+ * Returns decoded public events given search parameters.
+ * @param node - The node to request events from
+ * @param eventMetadata - Metadata of the event. This should be the class generated from the contract. e.g. Contract.events.Event
+ * @param from - The block number to search from.
+ * @param limit - The amount of blocks to search.
+ * @returns - The deserialized events.
+ */
+export async function getDecodedPublicEvents<T>(
+  node: AztecNode,
+  eventMetadataDef: EventMetadataDefinition,
+  from: number,
+  limit: number,
+): Promise<T[]> {
+  const { logs } = await node.getPublicLogs({
+    fromBlock: from,
+    toBlock: from + limit,
+  });
+
+  const decodedEvents = logs
+    .map(log => {
+      // +1 for the event selector
+      const expectedLength = eventMetadataDef.fieldNames.length + 1;
+      if (log.log.fields.length !== expectedLength) {
+        throw new Error(
+          `Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length. Expected ${expectedLength}. Got ${log.log.fields.length}.`,
+        );
+      }
+
+      const logFields = log.log.getEmittedFields();
+      // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission.
+      if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadataDef.eventSelector)) {
+        return undefined;
+      }
+
+      return decodeFromAbi([eventMetadataDef.abiType], log.log.fields) as T;
+    })
+    .filter(log => log !== undefined) as T[];
+
+  return decodedEvents;
+}

package/src/api/fee.ts

@@ -1,5 +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';
+export { SponsoredFeePaymentMethod } from '../fee/sponsored_fee_payment.js';

package/src/api/fee_testing.ts

@@ -0,0 +1 @@
+export { SponsoredFeePaymentMethod } from '../fee/sponsored_fee_payment.js';

package/src/api/fields.ts

@@ -1 +1,2 @@
-export { Point, Fr, Fq, GrumpkinScalar } from '@aztec/foundation/fields';
+export { Fr, Fq } from '@aztec/foundation/curves/bn254';
+export { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';

package/src/api/keys.ts

@@ -0,0 +1,8 @@
+export { type PublicKey, PublicKeys } from '@aztec/stdlib/keys';
+export {
+  computeAppNullifierSecretKey,
+  deriveKeys,
+  deriveMasterIncomingViewingSecretKey,
+  deriveMasterNullifierSecretKey,
+} from '@aztec/stdlib/keys';
+export { generatePublicKey } from '../utils/pub_key.js';

package/src/api/log.ts

@@ -1 +1,2 @@
 export { createLogger, type Logger } from '@aztec/foundation/log';
+export { LogId, type LogFilter } from '@aztec/stdlib/logs';

package/src/api/messaging.ts

@@ -0,0 +1,2 @@
+export { L1ToL2Message, L2Actor, L1Actor } from '@aztec/stdlib/messaging';
+export { isL1ToL2MessageReady, waitForL1ToL2MessageReady } from '../utils/cross_chain.js';

package/src/api/node.ts

@@ -0,0 +1,24 @@
+/**
+ * The `node` module provides utilities for connecting to and interacting with an Aztec node.
+ *
+ * The primary function is {@link createAztecNodeClient}, which creates a JSON-RPC client
+ * that connects to a running Aztec node instance. Use {@link waitForNode} to wait for
+ * the node to be ready before proceeding, and {@link waitForTx} to wait for a transaction
+ * to be mined.
+ *
+ * @example
+ * ```ts
+ * import { createAztecNodeClient, waitForNode, waitForTx } from '@aztec/aztec.js/node';
+ *
+ * const node = createAztecNodeClient('http://localhost:8080');
+ * await waitForNode(node);
+ * const blockNumber = await node.getBlockNumber();
+ *
+ * // Wait for a transaction
+ * const receipt = await waitForTx(node, txHash);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createAztecNodeClient, waitForNode, waitForTx, type AztecNode } from '../utils/node.js';
+export { type NodeInfo } from '@aztec/stdlib/contract';

package/src/api/note.ts

@@ -0,0 +1 @@
+export { Comparator, Note } from '@aztec/stdlib/note';

package/src/api/protocol.ts

@@ -0,0 +1,9 @@
+export { ProtocolContractAddress } from '@aztec/protocol-contracts';
+export { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+
+export { AuthRegistryContract } from '../contract/protocol_contracts/auth-registry.js';
+export { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
+export { ContractInstanceRegistryContract } from '../contract/protocol_contracts/contract-instance-registry.js';
+export { FeeJuiceContract } from '../contract/protocol_contracts/fee-juice.js';
+export { MultiCallEntrypointContract } from '../contract/protocol_contracts/multi-call-entrypoint.js';
+export { PublicChecksContract } from '../contract/protocol_contracts/public-checks.js';

package/src/api/trees.ts

@@ -0,0 +1,2 @@
+export { SiblingPath } from '@aztec/foundation/trees';
+export { MerkleTreeId, merkleTreeIds } from '@aztec/stdlib/trees';

package/src/api/tx.ts

@@ -0,0 +1,15 @@
+export {
+  Tx,
+  TxExecutionRequest,
+  TxExecutionResult,
+  TxHash,
+  TxReceipt,
+  TxStatus,
+  SortedTxStatuses,
+  Capsule,
+  HashedValues,
+  GlobalVariables,
+  TxProfileResult,
+  ExecutionPayload,
+  mergeExecutionPayloads,
+} from '@aztec/stdlib/tx';

package/src/api/utils.ts

@@ -0,0 +1,14 @@
+/**
+ * Utility functions for aztec.js.
+ *
+ * NOTE: This module contains low-usage utilities and may be deprecated in the future.
+ * Prefer using more specific modules:
+ * - Node connection utilities → `@aztec/aztec.js/node`
+ * - Type converters → `@aztec/aztec.js/abi`
+ * - Key generation → `@aztec/aztec.js/keys`
+ * - Messaging utilities → `@aztec/aztec.js/messaging`
+ */
+
+// Low-usage utilities - consider these internal/experimental
+export { getFeeJuiceBalance } from '../utils/fee_juice.js';
+export { readFieldCompressedString } from '../utils/field_compressed_string.js';

package/src/api/wallet.ts

@@ -1,7 +1,36 @@
 export {
-  AccountWallet,
-  AccountWalletWithSecretKey as AccountWalletWithSecretKey,
-  SignerlessWallet,
+  type Aliased,
+  type SimulateOptions,
+  type ProfileOptions,
+  type SendOptions,
+  type BatchableMethods,
+  type BatchedMethod,
+  type BatchedMethodResult,
+  type BatchedMethodResultWrapper,
+  type BatchResults,
   type Wallet,
-  getWallet,
-} from '../wallet/index.js';
+  type PrivateEvent,
+  type PrivateEventFilter,
+  type ContractMetadata,
+  type ContractClassMetadata,
+  FunctionCallSchema,
+  ExecutionPayloadSchema,
+  GasSettingsOptionSchema,
+  WalletSimulationFeeOptionSchema,
+  WaitOptsSchema,
+  SendOptionsSchema,
+  SimulateOptionsSchema,
+  ProfileOptionsSchema,
+  MessageHashOrIntentSchema,
+  BatchedMethodSchema,
+  EventMetadataDefinitionSchema,
+  PrivateEventSchema,
+  PrivateEventFilterSchema,
+  ContractClassMetadataSchema,
+  ContractMetadataSchema,
+  WalletSchema,
+} from '../wallet/wallet.js';
+
+export { AccountManager } from '../wallet/account_manager.js';
+
+export { type DeployAccountOptions, DeployAccountMethod } from '../wallet/deploy_account_method.js';

package/src/authorization/call_authorization_request.ts

@@ -0,0 +1,63 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { FieldReader } from '@aztec/foundation/serialize';
+import { AuthorizationSelector, FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+/**
+ * An authwit request for a function call. Includes the preimage of the data
+ * to be signed, as opposed of just the inner hash.
+ */
+export class CallAuthorizationRequest {
+  constructor(
+    /**
+     * The selector of the authwit type, used to identify it
+     * when emitted from `emit_offchain_effect`oracle.
+     * Computed as poseidon2("CallAuthwit((Field),(u32),Field)".to_bytes())
+     */
+    public selector: AuthorizationSelector,
+    /**
+     * The inner hash of the authwit, computed as
+     * poseidon2([msg_sender, selector, args_hash])
+     */
+    public innerHash: Fr,
+    /**
+     * The address performing the call
+     */
+    public msgSender: AztecAddress,
+    /**
+     * The selector of the function that is to be authorized
+     * */
+    public functionSelector: FunctionSelector,
+    /**
+     * The hash of the arguments to the function call,
+     */
+    public argsHash: Fr,
+    /**
+     * The arguments to the function call.
+     */
+    public args: Fr[],
+  ) {}
+
+  static getSelector(): Promise<AuthorizationSelector> {
+    return AuthorizationSelector.fromSignature('CallAuthorization((Field),(u32),Field)');
+  }
+
+  static async fromFields(fields: Fr[]): Promise<CallAuthorizationRequest> {
+    const expectedSelector = await CallAuthorizationRequest.getSelector();
+    const reader = FieldReader.asReader(fields);
+    const selector = AuthorizationSelector.fromField(reader.readField());
+    if (!selector.equals(expectedSelector)) {
+      throw new Error(
+        `Invalid authorization selector for CallAuthwit: expected ${expectedSelector.toString()}, got ${selector.toString()}`,
+      );
+    }
+    return new CallAuthorizationRequest(
+      selector,
+      reader.readField(),
+      AztecAddress.fromField(reader.readField()),
+      FunctionSelector.fromField(reader.readField()),
+      reader.readField(),
+      reader.readFieldArray(reader.remainingFields()),
+    );
+  }
+}

package/src/contract/base_contract_interaction.ts

@@ -1,30 +1,16 @@
-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;
-};
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { Capsule, ExecutionPayload, TxReceipt } from '@aztec/stdlib/tx';
+
+import type { Wallet } from '../wallet/wallet.js';
+import {
+  type InteractionWaitOptions,
+  type RequestInteractionOptions,
+  type SendInteractionOptions,
+  type SendInteractionOptionsWithoutWait,
+  type SendReturn,
+  toSendOptions,
+} from './interaction_options.js';
 
 /**
  * Base class for an interaction with a contract, be it a deployment, a function call, or a batch.
@@ -33,160 +19,43 @@ export type SendMethodOptions = {
 export abstract class BaseContractInteraction {
   protected log = createLogger('aztecjs:contract_interaction');
 
-  private capsules: Capsule[] = [];
-
-  constructor(protected wallet: Wallet) {}
+  constructor(
+    protected wallet: Wallet,
+    protected authWitnesses: AuthWitness[] = [],
+    protected capsules: Capsule[] = [],
+  ) {}
 
   /**
-   * Create a transaction execution request ready to be simulated.
+   * Returns an execution request that represents this operation.
+   * Can be used as a building block for constructing batch requests.
    * @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
+   * @returns An execution request wrapped in promise.
    */
-  public async prove(options: SendMethodOptions = {}): Promise<ProvenTx> {
-    // docs:end:prove
-    const txProvingResult = await this.proveInternal(options);
-    return new ProvenTx(this.wallet, txProvingResult.toTx());
-  }
+  public abstract request(options?: RequestInteractionOptions): Promise<ExecutionPayload>;
 
   // 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 {
+   * By default, waits for the transaction to be mined and returns the receipt (or custom type).
+   * @param options - An object containing 'from' property representing
+   * the AztecAddress of the sender, optional fee configuration, and optional wait settings
+   * @returns TReturn (if wait is undefined/WaitOpts) or TxHash (if wait is NO_WAIT)
+   */
+  // Overload for when wait is not specified at all - returns TReturn
+  public send<TReturn = TxReceipt>(options: SendInteractionOptionsWithoutWait): Promise<TReturn>;
+  // Generic overload for explicit wait values
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public send<TReturn = TxReceipt, W extends InteractionWaitOptions = undefined>(
+    options: SendInteractionOptions<W>,
+  ): Promise<SendReturn<W, TReturn>>;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public async send<TReturn = TxReceipt>(
+    options: SendInteractionOptions<InteractionWaitOptions>,
+  ): Promise<SendReturn<typeof options.wait, TReturn>> {
     // docs:end:send
-    const promise = (async () => {
-      const txProvingResult = await this.proveInternal(options);
-      return this.wallet.sendTx(txProvingResult.toTx());
-    })();
-    return new SentTx(this.wallet, promise);
-  }
+    const executionPayload = await this.request(options);
+    const sendOptions = toSendOptions(options);
 
-  // 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;
+    return (await this.wallet.sendTx(executionPayload, sendOptions as any)) as SendReturn<typeof options.wait, TReturn>;
   }
 }