@bosonprotocol/core-sdk 1.47.1-alpha.0 → 1.48.0-alpha.1

package/src/meta-tx/handler.ts

@@ -51,7 +51,12 @@ import { AddressZero } from "@ethersproject/constants";
 import { encodeDepositFunds, encodeWithdrawFunds } from "../funds/interface";
 import { bosonDisputeHandlerIface } from "../disputes/interface";
 import { encodeCreateGroup } from "../groups/interface";
-import { encodeCreateOfferWithCondition } from "../orchestration/interface";
+import {
+  encodeCommitToConditionalOfferAndRedeemVoucher,
+  encodeCommitToOfferAndRedeemVoucher,
+  encodeCreateOfferCommitAndRedeem,
+  encodeCreateOfferWithCondition
+} from "../orchestration/interface";
 import {
   encodeCallExternalContract,
   encodePreMint,
@@ -61,6 +66,10 @@ import {
 import { keccak256 } from "@ethersproject/keccak256";
 import { id } from "@ethersproject/hash";
 import { defaultAbiCoder } from "@ethersproject/abi";
+import {
+  TransferAuthorization,
+  encodeTransferAuthorizationQueue
+} from "../erc20/handler";
 import { ERC20ForwardRequest } from "../forwarder/biconomy-interface";
 import { getNonce, verifyEIP712 } from "../forwarder/handler";
 import { MockForwardRequest } from "../forwarder/mock-interface";
@@ -1473,6 +1482,133 @@ export async function signMetaTxCreateOfferAndCommit(
   return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
 
+// Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
+export async function signMetaTxCommitToOfferAndRedeemVoucher(
+  args: BaseMetaTxArgs & {
+    offerId: BigNumberish;
+    returnTypedDataToSign: true;
+  }
+): Promise<UnsignedMetaTx>;
+// Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
+export async function signMetaTxCommitToOfferAndRedeemVoucher(
+  args: BaseMetaTxArgs & {
+    offerId: BigNumberish;
+    returnTypedDataToSign?: false | undefined;
+  }
+): Promise<SignedMetaTx>;
+// Implementation
+export async function signMetaTxCommitToOfferAndRedeemVoucher(
+  args: BaseMetaTxArgs & {
+    offerId: BigNumberish;
+    returnTypedDataToSign?: boolean;
+  }
+): Promise<SignedMetaTx | UnsignedMetaTx> {
+  const signMetaTxArgs = {
+    ...args,
+    functionName: "commitToOfferAndRedeemVoucher(uint256)",
+    functionSignature: encodeCommitToOfferAndRedeemVoucher(args.offerId)
+  };
+  if (args.returnTypedDataToSign) {
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+  }
+  return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
+}
+
+// Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
+export async function signMetaTxCommitToConditionalOfferAndRedeemVoucher(
+  args: BaseMetaTxArgs & {
+    offerId: BigNumberish;
+    tokenId: BigNumberish;
+    returnTypedDataToSign: true;
+  }
+): Promise<UnsignedMetaTx>;
+// Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
+export async function signMetaTxCommitToConditionalOfferAndRedeemVoucher(
+  args: BaseMetaTxArgs & {
+    offerId: BigNumberish;
+    tokenId: BigNumberish;
+    returnTypedDataToSign?: false | undefined;
+  }
+): Promise<SignedMetaTx>;
+// Implementation
+export async function signMetaTxCommitToConditionalOfferAndRedeemVoucher(
+  args: BaseMetaTxArgs & {
+    offerId: BigNumberish;
+    tokenId: BigNumberish;
+    returnTypedDataToSign?: boolean;
+  }
+): Promise<SignedMetaTx | UnsignedMetaTx> {
+  const signMetaTxArgs = {
+    ...args,
+    functionName: "commitToConditionalOfferAndRedeemVoucher(uint256,uint256)",
+    functionSignature: encodeCommitToConditionalOfferAndRedeemVoucher(
+      args.offerId,
+      args.tokenId
+    )
+  };
+  if (args.returnTypedDataToSign) {
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+  }
+  return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
+}
+
+// Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
+export async function signMetaTxCreateOfferCommitAndRedeem(
+  args: BaseMetaTxArgs & {
+    createOfferAndCommitArgs: FullOfferArgs;
+    metadataStorage?: MetadataStorage;
+    theGraphStorage?: MetadataStorage;
+    returnTypedDataToSign: true;
+  }
+): Promise<UnsignedMetaTx>;
+// Overload: returnTypedDataToSign is false or undefined → returns SignedMetaTx
+export async function signMetaTxCreateOfferCommitAndRedeem(
+  args: BaseMetaTxArgs & {
+    createOfferAndCommitArgs: FullOfferArgs;
+    metadataStorage?: MetadataStorage;
+    theGraphStorage?: MetadataStorage;
+    returnTypedDataToSign?: false | undefined;
+  }
+): Promise<SignedMetaTx>;
+// Implementation
+export async function signMetaTxCreateOfferCommitAndRedeem(
+  args: BaseMetaTxArgs & {
+    createOfferAndCommitArgs: FullOfferArgs;
+    metadataStorage?: MetadataStorage;
+    theGraphStorage?: MetadataStorage;
+    returnTypedDataToSign?: boolean;
+  }
+): Promise<SignedMetaTx | UnsignedMetaTx> {
+  utils.validation.createOfferAndCommitArgsSchema.validateSync(
+    args.createOfferAndCommitArgs,
+    { abortEarly: false }
+  );
+
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.createOfferAndCommitArgs.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
+
+  await storeMetadataItems({
+    ...args,
+    createOffersArgs: [args.createOfferAndCommitArgs]
+  });
+
+  const signMetaTxArgs = {
+    ...args,
+    functionName:
+      "createOfferCommitAndRedeem(((uint256,uint256,uint256,uint256,uint256,uint256,address,uint8,uint8,string,string,bool,uint256,(address[],uint256[])[],uint256),(uint256,uint256,uint256,uint256),(uint256,uint256,uint256),(uint256,address),(uint8,uint8,address,uint8,uint256,uint256,uint256,uint256),uint256,uint256,bool),address,bytes,uint256)",
+    functionSignature: encodeCreateOfferCommitAndRedeem(
+      args.createOfferAndCommitArgs
+    )
+  };
+  if (args.returnTypedDataToSign) {
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+  }
+  return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
+}
+
 // Overload: returnTypedDataToSign is true → returns UnsignedMetaTx
 export async function signMetaTxCancelVoucher(
   args: BaseMetaTxArgs & {
@@ -2018,6 +2154,7 @@ export async function relayMetaTransaction(args: {
       sigR: BytesLike;
       sigS: BytesLike;
       sigV: BigNumberish;
+      transferAuthorizations?: TransferAuthorization[];
     };
   };
 }): Promise<TransactionResponse> {
@@ -2029,19 +2166,27 @@ export async function relayMetaTransaction(args: {
     metaTx.config.apiId
   );
 
+  const baseParams: unknown[] = [
+    metaTx.params.userAddress,
+    metaTx.params.functionName,
+    metaTx.params.functionSignature,
+    metaTx.params.nonce,
+    rebuildSignature({
+      r: metaTx.params.sigR.toString(),
+      s: metaTx.params.sigS.toString(),
+      v: Number(metaTx.params.sigV)
+    })
+  ];
+  const params = metaTx.params.transferAuthorizations?.length
+    ? [
+        ...baseParams,
+        encodeTransferAuthorizationQueue(metaTx.params.transferAuthorizations)
+      ]
+    : baseParams;
+
   const relayTxResponse = await biconomy.relayTransaction({
     to: contractAddress,
-    params: [
-      metaTx.params.userAddress,
-      metaTx.params.functionName,
-      metaTx.params.functionSignature,
-      metaTx.params.nonce,
-      rebuildSignature({
-        r: metaTx.params.sigR.toString(),
-        s: metaTx.params.sigS.toString(),
-        v: Number(metaTx.params.sigV)
-      })
-    ],
+    params,
     from: metaTx.params.userAddress
   });
 

package/src/meta-tx/mixin.ts

@@ -14,6 +14,7 @@ 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                          */
@@ -1174,6 +1175,151 @@ export class MetaTxMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
     });
   }
 
+  /**
+   * 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.
@@ -1672,6 +1818,7 @@ export class MetaTxMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
       sigR: BytesLike;
       sigS: BytesLike;
       sigV: BigNumberish;
+      transferAuthorizations?: TransferAuthorization[];
     },
     overrides: Partial<{
       userAddress: string;
@@ -1701,7 +1848,8 @@ export class MetaTxMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
           nonce: metaTxParams.nonce,
           sigR: metaTxParams.sigR,
           sigS: metaTxParams.sigS,
-          sigV: metaTxParams.sigV
+          sigV: metaTxParams.sigV,
+          transferAuthorizations: metaTxParams.transferAuthorizations
         }
       }
     });

package/src/native-meta-tx/handler.ts

@@ -128,7 +128,7 @@ export async function signNativeMetaTx(
   };
 }
 
-type ApproveExchangeTokenBaseArgs = {
+export type ApproveExchangeTokenBaseArgs = {
   web3Lib: Web3LibAdapter;
   chainId: number;
   user: string;

package/src/orchestration/handler.ts

@@ -4,9 +4,14 @@ import {
   TransactionResponse,
   MetadataStorage,
   utils,
-  ConditionStruct
+  ConditionStruct,
+  FullOfferArgs,
+  OfferCreator
 } from "@bosonprotocol/common";
 import {
+  encodeCommitToConditionalOfferAndRedeemVoucher,
+  encodeCommitToOfferAndRedeemVoucher,
+  encodeCreateOfferCommitAndRedeem,
   encodeCreateOfferWithCondition,
   encodeCreatePremintedOfferAddToGroup,
   encodeCreatePremintedOfferWithCondition,
@@ -17,6 +22,7 @@ import {
   encodeRaiseAndEscalateDispute
 } from "./interface";
 import { storeMetadataOnTheGraph } from "../offers/storage";
+import { AddressZero } from "@ethersproject/constants";
 
 import { CreateOfferArgs } from "../offers/types";
 import { CreateSellerArgs } from "../accounts/types";
@@ -24,6 +30,13 @@ import { BigNumberish } from "@ethersproject/bignumber";
 import { findCollectionSalt } from "../accounts/handler";
 import { PremintParametersStruct } from "@bosonprotocol/common/src";
 import { storeMetadataItems } from "../metadata/storeMetadataItems";
+import { getOfferById } from "../offers/subgraph";
+import {
+  checkOfferIsCommittable,
+  isFullOfferVoided
+} from "../exchanges/handler";
+import { ensureAllowance } from "../erc20/handler";
+import { getDisputeResolverById } from "../accounts/subgraph";
 
 // createOfferAndSeller overloads
 export async function createOfferAndSeller(args: {
@@ -510,6 +523,259 @@ export async function createSellerAndPremintedOfferWithCondition(args: {
   }
 }
 
+// commitToOfferAndRedeemVoucher overloads
+export async function commitToOfferAndRedeemVoucher(args: {
+  offerId: BigNumberish;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+export async function commitToOfferAndRedeemVoucher(args: {
+  offerId: BigNumberish;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function commitToOfferAndRedeemVoucher(args: {
+  offerId: BigNumberish;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
+  const offer = await getOfferById(args.subgraphUrl, args.offerId);
+
+  await checkOfferIsCommittable(args.offerId, offer);
+
+  if (offer.creator !== OfferCreator.Seller) {
+    throw new Error(
+      `Offer with id ${args.offerId.toString()} is not seller initiated`
+    );
+  }
+
+  if (offer.condition) {
+    // keep compatibility with previous version
+    if (args.returnTxInfo) {
+      return commitToConditionalOfferAndRedeemVoucher({
+        ...args,
+        returnTxInfo: true,
+        tokenId: offer.condition.minTokenId
+      });
+    }
+    return commitToConditionalOfferAndRedeemVoucher({
+      ...args,
+      returnTxInfo: false,
+      tokenId: offer.condition.minTokenId
+    });
+  }
+
+  if (offer.exchangeToken.address !== AddressZero) {
+    const owner = await args.web3Lib.getSignerAddress();
+    await ensureAllowance({
+      owner,
+      spender: args.contractAddress,
+      contractAddress: offer.exchangeToken.address,
+      value: offer.price,
+      web3Lib: args.web3Lib
+    });
+  }
+
+  const transactionRequest = {
+    to: args.contractAddress,
+    data: encodeCommitToOfferAndRedeemVoucher(args.offerId),
+    value: offer.exchangeToken.address === AddressZero ? offer.price : "0"
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
+}
+
+// commitToConditionalOfferAndRedeemVoucher overloads
+export async function commitToConditionalOfferAndRedeemVoucher(args: {
+  offerId: BigNumberish;
+  tokenId: BigNumberish;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+export async function commitToConditionalOfferAndRedeemVoucher(args: {
+  offerId: BigNumberish;
+  tokenId: BigNumberish;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function commitToConditionalOfferAndRedeemVoucher(args: {
+  offerId: BigNumberish;
+  tokenId: BigNumberish;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
+  const offer = await getOfferById(args.subgraphUrl, args.offerId);
+
+  await checkOfferIsCommittable(args.offerId, offer);
+
+  if (offer.exchangeToken.address !== AddressZero) {
+    const owner = await args.web3Lib.getSignerAddress();
+    await ensureAllowance({
+      owner,
+      spender: args.contractAddress,
+      contractAddress: offer.exchangeToken.address,
+      value: offer.price,
+      web3Lib: args.web3Lib
+    });
+  }
+
+  const transactionRequest = {
+    to: args.contractAddress,
+    data: encodeCommitToConditionalOfferAndRedeemVoucher(
+      args.offerId,
+      args.tokenId
+    ),
+    value: offer.exchangeToken.address === AddressZero ? offer.price : "0"
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
+}
+
+// createOfferCommitAndRedeem overloads
+export async function createOfferCommitAndRedeem(args: {
+  createOfferAndCommitArgs: FullOfferArgs;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  txRequest?: TransactionRequest;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+export async function createOfferCommitAndRedeem(args: {
+  createOfferAndCommitArgs: FullOfferArgs;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  txRequest?: TransactionRequest;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function createOfferCommitAndRedeem(args: {
+  createOfferAndCommitArgs: FullOfferArgs;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  txRequest?: TransactionRequest;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
+  utils.validation.createOfferAndCommitArgsSchema.validateSync(
+    args.createOfferAndCommitArgs,
+    {
+      abortEarly: false
+    }
+  );
+
+  const { disputeResolverId, exchangeToken, price, sellerDeposit, creator } =
+    args.createOfferAndCommitArgs;
+  const disputeResolver = await getDisputeResolverById(
+    args.subgraphUrl,
+    disputeResolverId
+  );
+  if (!disputeResolver) {
+    throw new Error(
+      `Dispute resolver with id "${disputeResolverId}" does not exist`
+    );
+  }
+  if (
+    !disputeResolver.fees.some(
+      (fee) => fee.token.address.toLowerCase() === exchangeToken.toLowerCase()
+    )
+  ) {
+    throw new Error(
+      `Dispute resolver with id "${disputeResolverId}" does not support exchange token "${exchangeToken}"`
+    );
+  }
+
+  if (
+    await isFullOfferVoided({
+      ...args,
+      fullOfferArgsUnsigned: args.createOfferAndCommitArgs
+    })
+  ) {
+    throw new Error(`The offer has been voided`);
+  }
+
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.createOfferAndCommitArgs.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
+
+  await storeMetadataItems({
+    ...args,
+    createOffersArgs: [args.createOfferAndCommitArgs]
+  });
+
+  const committerPayment =
+    creator === OfferCreator.Buyer ? sellerDeposit : price;
+
+  if (exchangeToken !== AddressZero) {
+    const owner = await args.web3Lib.getSignerAddress();
+    await ensureAllowance({
+      owner,
+      spender: args.contractAddress,
+      contractAddress: exchangeToken,
+      value: committerPayment,
+      web3Lib: args.web3Lib
+    });
+  }
+
+  const transactionRequest = {
+    ...args.txRequest,
+    to: args.contractAddress,
+    data: encodeCreateOfferCommitAndRedeem(args.createOfferAndCommitArgs),
+    value: exchangeToken === AddressZero ? committerPayment : "0"
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
+}
+
 // raiseAndEscalateDispute overloads
 export async function raiseAndEscalateDispute(args: {
   exchangeId: BigNumberish;