import {
  AuthTokenType,
  MetaTxConfig,
  TransactionResponse,
  Web3LibAdapter
} from "@bosonprotocol/common";
import { BigNumberish } from "@ethersproject/bignumber";
import { BytesLike } from "@ethersproject/bytes";
import { handler } from ".";
import { getOfferById } from "../offers/subgraph";
import { BaseCoreSDK } from "./../mixins/base-core-sdk";
import { GetRetriedHashesData } from "./biconomy";
import { accounts } from "..";
import { AccountsMixin } from "../accounts/mixin";
import { SellerFieldsFragment } from "../subgraph";
import { SignedMetaTx, UnsignedMetaTx } from "./handler";
import { TransferAuthorization } from "../erc20/handler";
export class MetaTxMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
  /* -------------------------------------------------------------------------- */
  /*                           Meta Tx related methods                          */
  /* -------------------------------------------------------------------------- */

  /**
   * Encodes and signs a meta transaction that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTx(
    args: Omit<
      Parameters<typeof handler.signMetaTx>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTx(
    args: Omit<
      Parameters<typeof handler.signMetaTx>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTx(
    args: Omit<
      Parameters<typeof handler.signMetaTx>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTx({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTx({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `createSeller` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCreateSeller(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateSeller>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCreateSeller(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateSeller>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCreateSeller(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateSeller>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCreateSeller({
        web3Lib: this._web3Lib,
        theGraphStorage: this._theGraphStorage,
        metadataStorage: this._metadataStorage,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCreateSeller({
      web3Lib: this._web3Lib,
      theGraphStorage: this._theGraphStorage,
      metadataStorage: this._metadataStorage,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxUpdateSeller(
    args: Omit<
      Parameters<typeof handler.signMetaTxUpdateSeller>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxUpdateSeller(
    args: Omit<
      Parameters<typeof handler.signMetaTxUpdateSeller>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxUpdateSeller(
    args: Omit<
      Parameters<typeof handler.signMetaTxUpdateSeller>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxUpdateSeller({
        web3Lib: this._web3Lib,
        theGraphStorage: this._theGraphStorage,
        metadataStorage: this._metadataStorage,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxUpdateSeller({
      web3Lib: this._web3Lib,
      theGraphStorage: this._theGraphStorage,
      metadataStorage: this._metadataStorage,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxOptInToSellerUpdate(
    args: Omit<
      Parameters<typeof handler.signMetaTxOptInToSellerUpdate>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxOptInToSellerUpdate(
    args: Omit<
      Parameters<typeof handler.signMetaTxOptInToSellerUpdate>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxOptInToSellerUpdate(
    args: Omit<
      Parameters<typeof handler.signMetaTxOptInToSellerUpdate>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxOptInToSellerUpdate({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxOptInToSellerUpdate({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  public async signMetaTxUpdateSellerAndOptIn(
    sellerUpdates: accounts.UpdateSellerArgs
  ): Promise<TransactionResponse> {
    let nonce = Date.now();
    const updateMetaTx = await this.signMetaTxUpdateSeller({
      updateSellerArgs: sellerUpdates,
      nonce,
      theGraphStorage: this._theGraphStorage,
      metadataStorage: this._metadataStorage
    });
    const updateTx = await this.relayMetaTransaction({
      functionName: updateMetaTx.functionName,
      functionSignature: updateMetaTx.functionSignature,
      sigR: updateMetaTx.r,
      sigS: updateMetaTx.s,
      sigV: updateMetaTx.v,
      nonce
    });
    await updateTx.wait();
    let seller: SellerFieldsFragment | undefined;
    let count = 200;
    while ((!seller || !seller.pendingSeller) && count-- > 0) {
      await new Promise((resolve) => setTimeout(resolve, 300));
      type getSellerById = typeof AccountsMixin.prototype.getSellerById;
      seller = await (this["getSellerById"] as getSellerById)(sellerUpdates.id);
    }
    if (!seller) {
      throw new Error(
        "[signMetaTxUpdateSellerAndOptIn] seller could not be retrieved in time"
      );
    }
    const pendingSellerUpdate = seller.pendingSeller;
    if (!pendingSellerUpdate) {
      throw new Error(
        "[signMetaTxUpdateSellerAndOptIn] seller.pendingSeller could not be retrieved in time"
      );
    }
    // Find all updates that can be opted in by the current account
    const currentAccount = (
      await this._web3Lib.getSignerAddress()
    ).toLowerCase();
    const fieldsToUpdate = {
      assistant:
        currentAccount === pendingSellerUpdate.assistant?.toLowerCase(),
      admin: currentAccount === pendingSellerUpdate.admin?.toLowerCase(),
      authToken:
        pendingSellerUpdate.authTokenType !== undefined &&
        pendingSellerUpdate.authTokenType !== null &&
        pendingSellerUpdate.authTokenType !== AuthTokenType.NONE
    };
    if (
      fieldsToUpdate.assistant ||
      fieldsToUpdate.admin ||
      fieldsToUpdate.authToken
    ) {
      nonce = Date.now();
      const optInMetaTx = await this.signMetaTxOptInToSellerUpdate({
        optInToSellerUpdateArgs: {
          id: sellerUpdates.id,
          fieldsToUpdate: {
            assistant:
              currentAccount === pendingSellerUpdate.assistant.toLowerCase(),
            admin: currentAccount === pendingSellerUpdate.admin.toLowerCase(),
            authToken: pendingSellerUpdate.authTokenType !== AuthTokenType.NONE
          }
        },
        nonce
      });
      return this.relayMetaTransaction({
        functionName: optInMetaTx.functionName,
        functionSignature: optInMetaTx.functionSignature,
        sigR: optInMetaTx.r,
        sigS: optInMetaTx.s,
        sigV: optInMetaTx.v,
        nonce
      });
    }
    // If there is nothing to optIn from the current account, then return the response from updateSeller
    return updateTx;
  }

  /**
   * Encodes and signs a meta transaction for `createOffer` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCreateOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCreateOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCreateOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCreateOffer({
        web3Lib: this._web3Lib,
        theGraphStorage: this._theGraphStorage,
        metadataStorage: this._metadataStorage,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCreateOffer({
      web3Lib: this._web3Lib,
      theGraphStorage: this._theGraphStorage,
      metadataStorage: this._metadataStorage,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `createOfferBatch` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCreateOfferBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCreateOfferBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCreateOfferBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCreateOfferBatch({
        web3Lib: this._web3Lib,
        theGraphStorage: this._theGraphStorage,
        metadataStorage: this._metadataStorage,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCreateOfferBatch({
      web3Lib: this._web3Lib,
      theGraphStorage: this._theGraphStorage,
      metadataStorage: this._metadataStorage,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `createGroup` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCreateGroup(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateGroup>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCreateGroup(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateGroup>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCreateGroup(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateGroup>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCreateGroup({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCreateGroup({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxReserveRange(
    args: Omit<
      Parameters<typeof handler.signMetaTxReserveRange>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId" | "to"
    > & { to: "seller" | "contract"; returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxReserveRange(
    args: Omit<
      Parameters<typeof handler.signMetaTxReserveRange>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId" | "to"
    > & { to: "seller" | "contract"; returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxReserveRange(
    args: Omit<
      Parameters<typeof handler.signMetaTxReserveRange>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId" | "to"
    > & { to: "seller" | "contract" }
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    const offer = await getOfferById(this._subgraphUrl, args.offerId);

    if (args.returnTypedDataToSign) {
      return handler.signMetaTxReserveRange({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        to:
          args.to === "contract"
            ? offer.seller.voucherCloneAddress
            : offer.seller.assistant,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxReserveRange({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      to:
        args.to === "contract"
          ? offer.seller.voucherCloneAddress
          : offer.seller.assistant,
      returnTypedDataToSign: false
    });
  }

  public async signMetaTxPreMint(
    args: Omit<
      Parameters<typeof handler.signMetaTxPreMint>[0],
      | "web3Lib"
      | "bosonVoucherAddress"
      | "chainId"
      | "forwarderAddress"
      | "batchId"
      | "forwarderAbi"
      | "relayerUrl"
    >,
    overrides: Partial<{
      batchId: BigNumberish;
    }> = {}
  ) {
    const forwarderAddress = this._contracts.forwarder;
    const batchId = overrides.batchId || 0;
    const offerFromSubgraph = await getOfferById(
      this._subgraphUrl,
      args.offerId
    );
    return handler.signMetaTxPreMint({
      web3Lib: this._web3Lib,
      bosonVoucherAddress: offerFromSubgraph.seller.voucherCloneAddress,
      chainId: this._chainId,
      forwarderAddress,
      batchId,
      forwarderAbi: this._metaTxConfig.forwarderAbi,
      relayerUrl: this._metaTxConfig.relayerUrl,
      ...args
    });
  }

  public async signMetaTxSetApprovalForAll(
    args: Omit<
      Parameters<typeof handler.signMetaTxSetApprovalForAll>[0],
      | "web3Lib"
      | "bosonVoucherAddress"
      | "chainId"
      | "nonce"
      | "forwarderAddress"
      | "batchId"
      | "forwarderAbi"
      | "relayerUrl"
    >,
    overrides: Partial<{
      batchId: BigNumberish;
    }> = {}
  ) {
    const sellerAddress = await this._web3Lib.getSignerAddress();
    const seller = await accounts.subgraph.getSellerByAddress(
      this._subgraphUrl,
      sellerAddress
    );
    const forwarderAddress = this._contracts.forwarder;
    const batchId = overrides.batchId || 0;

    return handler.signMetaTxSetApprovalForAll({
      web3Lib: this._web3Lib,
      bosonVoucherAddress: seller.voucherCloneAddress,
      chainId: this._chainId,
      forwarderAddress,
      batchId,
      forwarderAbi: this._metaTxConfig.forwarderAbi,
      relayerUrl: this._metaTxConfig.relayerUrl,
      ...args
    });
  }

  public async signMetaTxSetApprovalForAllToContract(
    args: Omit<
      Parameters<typeof handler.signMetaTxSetApprovalForAllToContract>[0],
      | "web3Lib"
      | "bosonVoucherAddress"
      | "chainId"
      | "nonce"
      | "forwarderAddress"
      | "batchId"
      | "forwarderAbi"
      | "relayerUrl"
    > & {
      bosonVoucherAddress?: string;
    },
    overrides: Partial<{
      batchId?: BigNumberish;
      txGas?: number;
    }> = {}
  ) {
    const sellerAddress = await this._web3Lib.getSignerAddress();
    const seller = await accounts.subgraph.getSellerByAddress(
      this._subgraphUrl,
      sellerAddress
    );
    const forwarderAddress = this._contracts.forwarder;
    const batchId = overrides.batchId || 0;

    return handler.signMetaTxSetApprovalForAllToContract(
      {
        web3Lib: this._web3Lib,
        bosonVoucherAddress:
          args.bosonVoucherAddress || seller.voucherCloneAddress,
        chainId: this._chainId,
        forwarderAddress,
        batchId,
        forwarderAbi: this._metaTxConfig.forwarderAbi,
        relayerUrl: this._metaTxConfig.relayerUrl,
        ...args
      },
      {
        txGas: overrides.txGas
      }
    );
  }

  public async signMetaTxCallExternalContract(
    args: Omit<
      Parameters<typeof handler.signMetaTxCallExternalContract>[0],
      | "web3Lib"
      | "bosonVoucherAddress"
      | "chainId"
      | "nonce"
      | "forwarderAddress"
      | "batchId"
      | "forwarderAbi"
      | "relayerUrl"
    >,
    overrides: Partial<{
      batchId?: BigNumberish;
      txGas?: number;
    }> = {}
  ) {
    const sellerAddress = await this._web3Lib.getSignerAddress();
    const seller = await accounts.subgraph.getSellerByAddress(
      this._subgraphUrl,
      sellerAddress
    );
    const forwarderAddress = this._contracts.forwarder;
    const batchId = overrides.batchId || 0;

    return handler.signMetaTxCallExternalContract(
      {
        web3Lib: this._web3Lib,
        bosonVoucherAddress: seller.voucherCloneAddress,
        chainId: this._chainId,
        forwarderAddress,
        batchId,
        forwarderAbi: this._metaTxConfig.forwarderAbi,
        relayerUrl: this._metaTxConfig.relayerUrl,
        ...args
      },
      {
        txGas: overrides.txGas
      }
    );
  }

  public async relayBiconomyMetaTransaction(
    contractAddress: string,
    metaTxParams: {
      request: Parameters<
        (typeof handler)["relayBiconomyMetaTransaction"]
      >[0]["metaTx"]["params"]["request"];
      domainSeparator: Parameters<
        (typeof handler)["relayBiconomyMetaTransaction"]
      >[0]["metaTx"]["params"]["domainSeparator"];
      signature: Parameters<
        (typeof handler)["relayBiconomyMetaTransaction"]
      >[0]["metaTx"]["params"]["signature"];
    },
    overrides: Partial<{
      userAddress: string;
      metaTxConfig: Partial<
        Omit<MetaTxConfig, "apiIds" | "forwarderAbi"> & { apiId: string }
      >;
      metaTransactionMethod: string;
    }> = {}
  ): Promise<TransactionResponse> {
    const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl } =
      this.assertAndGetMetaTxConfig({ ...overrides, contractAddress });

    return handler.relayBiconomyMetaTransaction({
      web3LibAdapter: this._web3Lib,
      contractAddress,
      chainId: this._chainId,
      metaTx: {
        config: {
          relayerUrl: metaTxRelayerUrl,
          apiId: metaTxApiId,
          apiKey: metaTxApiKey
        },
        params: {
          userAddress:
            overrides.userAddress || (await this._web3Lib.getSignerAddress()),
          request: metaTxParams.request,
          domainSeparator: metaTxParams.domainSeparator,
          signature: metaTxParams.signature
        }
      }
    });
  }

  /**
   * Encodes and signs a meta transaction for `createOfferWithCondition` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCreateOfferWithCondition(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferWithCondition>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCreateOfferWithCondition(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferWithCondition>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCreateOfferWithCondition(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferWithCondition>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCreateOfferWithCondition({
        web3Lib: this._web3Lib,
        theGraphStorage: this._theGraphStorage,
        metadataStorage: this._metadataStorage,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCreateOfferWithCondition({
      web3Lib: this._web3Lib,
      theGraphStorage: this._theGraphStorage,
      metadataStorage: this._metadataStorage,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `voidOffer` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxVoidOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxVoidOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxVoidOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxVoidOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxVoidOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxVoidOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxVoidOffer({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxVoidOffer({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `voidOfferBatch` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxVoidOfferBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxVoidOfferBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxVoidOfferBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxVoidOfferBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxVoidOfferBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxVoidOfferBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxVoidOfferBatch({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxVoidOfferBatch({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `extendOffer` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxExtendOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxExtendOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxExtendOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxExtendOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxExtendOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxExtendOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxExtendOffer({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxExtendOffer({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `extendOfferBatch` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxExtendOfferBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxExtendOfferBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxExtendOfferBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxExtendOfferBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxExtendOfferBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxExtendOfferBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxExtendOfferBatch({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxExtendOfferBatch({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `completeExchange` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCompleteExchange(
    args: Omit<
      Parameters<typeof handler.signMetaTxCompleteExchange>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCompleteExchange(
    args: Omit<
      Parameters<typeof handler.signMetaTxCompleteExchange>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCompleteExchange(
    args: Omit<
      Parameters<typeof handler.signMetaTxCompleteExchange>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCompleteExchange({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCompleteExchange({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `completeExchangeBatch` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCompleteExchangeBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxCompleteExchangeBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCompleteExchangeBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxCompleteExchangeBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCompleteExchangeBatch(
    args: Omit<
      Parameters<typeof handler.signMetaTxCompleteExchangeBatch>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCompleteExchangeBatch({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCompleteExchangeBatch({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `commitToOffer` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCommitToOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCommitToOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCommitToOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    const offer = await getOfferById(this._subgraphUrl, args.offerId);

    if (offer.condition) {
      // keep compatibility with previous version
      // Using type assertion because TypeScript can't resolve overloads inside the implementation body
      // when the args type comes from a complex Omit<Parameters<...>[0], ...> expression
      const self = this as {
        signMetaTxCommitToConditionalOffer: (
          args: Record<string, unknown>
        ) => Promise<SignedMetaTx | UnsignedMetaTx>;
      };
      const conditionalArgs = {
        ...(args as Record<string, unknown>),
        tokenId: offer.condition.minTokenId
      };
      return self.signMetaTxCommitToConditionalOffer(conditionalArgs);
    }

    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCommitToOffer({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCommitToOffer({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `commitToConditionalOffer` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCommitToConditionalOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToConditionalOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCommitToConditionalOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToConditionalOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCommitToConditionalOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToConditionalOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCommitToConditionalOffer({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCommitToConditionalOffer({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `commitToBuyerOffer` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCommitToBuyerOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToBuyerOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCommitToBuyerOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToBuyerOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCommitToBuyerOffer(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToBuyerOffer>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCommitToBuyerOffer({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCommitToBuyerOffer({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `createOfferAndCommit` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCreateOfferAndCommit(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferAndCommit>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCreateOfferAndCommit(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferAndCommit>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCreateOfferAndCommit(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferAndCommit>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCreateOfferAndCommit({
        web3Lib: this._web3Lib,
        theGraphStorage: this._theGraphStorage,
        metadataStorage: this._metadataStorage,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCreateOfferAndCommit({
      web3Lib: this._web3Lib,
      theGraphStorage: this._theGraphStorage,
      metadataStorage: this._metadataStorage,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `commitToOfferAndRedeemVoucher`
   * that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCommitToOfferAndRedeemVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToOfferAndRedeemVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCommitToOfferAndRedeemVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToOfferAndRedeemVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCommitToOfferAndRedeemVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxCommitToOfferAndRedeemVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCommitToOfferAndRedeemVoucher({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCommitToOfferAndRedeemVoucher({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for
   * `commitToConditionalOfferAndRedeemVoucher` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCommitToConditionalOfferAndRedeemVoucher(
    args: Omit<
      Parameters<
        typeof handler.signMetaTxCommitToConditionalOfferAndRedeemVoucher
      >[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCommitToConditionalOfferAndRedeemVoucher(
    args: Omit<
      Parameters<
        typeof handler.signMetaTxCommitToConditionalOfferAndRedeemVoucher
      >[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCommitToConditionalOfferAndRedeemVoucher(
    args: Omit<
      Parameters<
        typeof handler.signMetaTxCommitToConditionalOfferAndRedeemVoucher
      >[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCommitToConditionalOfferAndRedeemVoucher({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCommitToConditionalOfferAndRedeemVoucher({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `createOfferCommitAndRedeem` that
   * can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCreateOfferCommitAndRedeem(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferCommitAndRedeem>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCreateOfferCommitAndRedeem(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferCommitAndRedeem>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCreateOfferCommitAndRedeem(
    args: Omit<
      Parameters<typeof handler.signMetaTxCreateOfferCommitAndRedeem>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCreateOfferCommitAndRedeem({
        web3Lib: this._web3Lib,
        theGraphStorage: this._theGraphStorage,
        metadataStorage: this._metadataStorage,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCreateOfferCommitAndRedeem({
      web3Lib: this._web3Lib,
      theGraphStorage: this._theGraphStorage,
      metadataStorage: this._metadataStorage,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `cancelVoucher` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxCancelVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxCancelVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxCancelVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxCancelVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxCancelVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxCancelVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxCancelVoucher({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxCancelVoucher({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `redeemVoucher` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxRedeemVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxRedeemVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxRedeemVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxRedeemVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxRedeemVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxRedeemVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxRedeemVoucher({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxRedeemVoucher({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `expireVoucher` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxExpireVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxExpireVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxExpireVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxExpireVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxExpireVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxExpireVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxExpireVoucher({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxExpireVoucher({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `revokeVoucher` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxRevokeVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxRevokeVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxRevokeVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxRevokeVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxRevokeVoucher(
    args: Omit<
      Parameters<typeof handler.signMetaTxRevokeVoucher>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxRevokeVoucher({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxRevokeVoucher({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `retractDispute` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxRetractDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxRetractDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxRetractDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxRetractDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxRetractDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxRetractDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxRetractDispute({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxRetractDispute({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `escalateDispute` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxEscalateDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxEscalateDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxEscalateDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxEscalateDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxEscalateDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxEscalateDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxEscalateDispute({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxEscalateDispute({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `raiseDispute` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxRaiseDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxRaiseDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxRaiseDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxRaiseDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxRaiseDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxRaiseDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxRaiseDispute({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxRaiseDispute({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `resolveDispute` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxResolveDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxResolveDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxResolveDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxResolveDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxResolveDispute(
    args: Omit<
      Parameters<typeof handler.signMetaTxResolveDispute>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxResolveDispute({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxResolveDispute({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `extendDisputeTimeout` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxExtendDisputeTimeout(
    args: Omit<
      Parameters<typeof handler.signMetaTxExtendDisputeTimeout>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxExtendDisputeTimeout(
    args: Omit<
      Parameters<typeof handler.signMetaTxExtendDisputeTimeout>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxExtendDisputeTimeout(
    args: Omit<
      Parameters<typeof handler.signMetaTxExtendDisputeTimeout>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxExtendDisputeTimeout({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxExtendDisputeTimeout({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `withdrawFunds` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxWithdrawFunds(
    args: Omit<
      Parameters<typeof handler.signMetaTxWithdrawFunds>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxWithdrawFunds(
    args: Omit<
      Parameters<typeof handler.signMetaTxWithdrawFunds>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxWithdrawFunds(
    args: Omit<
      Parameters<typeof handler.signMetaTxWithdrawFunds>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxWithdrawFunds({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxWithdrawFunds({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Encodes and signs a meta transaction for `depositFunds` that can be relayed.
   * @param args - Meta transaction args.
   * @returns Signature.
   */
  // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
  public async signMetaTxDepositFunds(
    args: Omit<
      Parameters<typeof handler.signMetaTxDepositFunds>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign: true }
  ): Promise<UnsignedMetaTx>;
  // Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
  public async signMetaTxDepositFunds(
    args: Omit<
      Parameters<typeof handler.signMetaTxDepositFunds>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    > & { returnTypedDataToSign?: false | undefined }
  ): Promise<SignedMetaTx>;
  // Implementation
  public async signMetaTxDepositFunds(
    args: Omit<
      Parameters<typeof handler.signMetaTxDepositFunds>[0],
      "web3Lib" | "metaTxHandlerAddress" | "chainId"
    >
  ): Promise<SignedMetaTx | UnsignedMetaTx> {
    if (args.returnTypedDataToSign) {
      return handler.signMetaTxDepositFunds({
        web3Lib: this._web3Lib,
        metaTxHandlerAddress: this._protocolDiamond,
        chainId: this._chainId,
        ...args,
        returnTypedDataToSign: true
      });
    }
    return handler.signMetaTxDepositFunds({
      web3Lib: this._web3Lib,
      metaTxHandlerAddress: this._protocolDiamond,
      chainId: this._chainId,
      ...args,
      returnTypedDataToSign: false
    });
  }

  /**
   * Relay a meta transaction,
   * @param metaTxParams - Required params for meta transaction.
   * @param overrides - Optional overrides.
   * @returns Transaction response.
   */
  public async relayMetaTransaction(
    metaTxParams: {
      functionName: string;
      functionSignature: BytesLike;
      nonce: BigNumberish;
      sigR: BytesLike;
      sigS: BytesLike;
      sigV: BigNumberish;
      transferAuthorizations?: TransferAuthorization[];
    },
    overrides: Partial<{
      userAddress: string;
      contractAddress: string;
      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
      metaTransactionMethod: string;
    }> = {}
  ): Promise<TransactionResponse> {
    const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl, contractAddress } =
      this.assertAndGetMetaTxConfig(overrides);

    return handler.relayMetaTransaction({
      web3LibAdapter: this._web3Lib,
      contractAddress,
      chainId: this._chainId,
      metaTx: {
        config: {
          relayerUrl: metaTxRelayerUrl,
          apiId: metaTxApiId,
          apiKey: metaTxApiKey
        },
        params: {
          userAddress:
            overrides.userAddress || (await this._web3Lib.getSignerAddress()),
          functionName: metaTxParams.functionName,
          functionSignature: metaTxParams.functionSignature,
          nonce: metaTxParams.nonce,
          sigR: metaTxParams.sigR,
          sigS: metaTxParams.sigS,
          sigV: metaTxParams.sigV,
          transferAuthorizations: metaTxParams.transferAuthorizations
        }
      }
    });
  }

  /**
   * Execute a signed meta transaction directly on-chain (no Biconomy relayer).
   * Routes to `executeMetaTransaction` or `executeMetaTransactionWithTokenTransferAuthorization`
   * depending on whether `transferAuthorizations` is provided and non-empty.
   * The wallet backing the SDK pays the gas; pass `overrides.userAddress` when
   * the meta-tx signer differs from that wallet.
   * @param metaTxParams - Required params for meta transaction.
   * @param overrides - Optional overrides.
   * @returns Transaction response.
   */
  public async executeMetaTransaction(
    metaTxParams: {
      functionName: string;
      functionSignature: BytesLike;
      nonce: BigNumberish;
      sigR: BytesLike;
      sigS: BytesLike;
      sigV: BigNumberish;
      transferAuthorizations?: TransferAuthorization[];
    },
    overrides: Partial<{
      userAddress: string;
      contractAddress: string;
    }> = {}
  ): Promise<TransactionResponse> {
    const userAddress =
      overrides.userAddress || (await this._web3Lib.getSignerAddress());
    const contractAddress = overrides.contractAddress || this._protocolDiamond;

    if (metaTxParams.transferAuthorizations?.length) {
      return handler.executeMetaTransactionWithTokenTransferAuthorization({
        web3Lib: this._web3Lib,
        contractAddress,
        userAddress,
        functionName: metaTxParams.functionName,
        functionSignature: metaTxParams.functionSignature,
        nonce: metaTxParams.nonce,
        sigR: metaTxParams.sigR,
        sigS: metaTxParams.sigS,
        sigV: metaTxParams.sigV,
        transferAuthorizations: metaTxParams.transferAuthorizations
      });
    }

    return handler.executeMetaTransaction({
      web3Lib: this._web3Lib,
      contractAddress,
      userAddress,
      functionName: metaTxParams.functionName,
      functionSignature: metaTxParams.functionSignature,
      nonce: metaTxParams.nonce,
      sigR: metaTxParams.sigR,
      sigS: metaTxParams.sigS,
      sigV: metaTxParams.sigV
    });
  }

  /**
   * Returns information of submitted meta transaction.
   * See https://docs.biconomy.io/api/native-meta-tx/get-retried-hashes.
   * @param originalMetaTxHash - Original meta transaction as returned by `coreSDK.relayMetaTransaction`
   * @param overrides - Optional overrides for meta transaction config.
   * @returns - Additional meta transaction information.
   */
  public async getResubmittedMetaTx(
    originalMetaTxHash: string,
    overrides: Partial<{
      contractAddress: string;
      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
      metaTransactionMethod: string;
    }> = {}
  ): Promise<GetRetriedHashesData> {
    const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl } =
      this.assertAndGetMetaTxConfig(overrides);

    return handler.getResubmitted({
      chainId: this._chainId,
      metaTx: {
        config: {
          relayerUrl: metaTxRelayerUrl,
          apiId: metaTxApiId,
          apiKey: metaTxApiKey
        },
        originalHash: originalMetaTxHash
      }
    });
  }
}