@bosonprotocol/core-sdk 1.48.0-alpha.0 → 1.48.0-alpha.2

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;

package/src/orchestration/interface.ts

@@ -1,7 +1,8 @@
-import { abis, ConditionStruct } from "@bosonprotocol/common";
+import { abis, ConditionStruct, FullOfferArgs } from "@bosonprotocol/common";
 import { Interface } from "@ethersproject/abi";
 import { createSellerArgsToStruct } from "../accounts/interface";
 import { createOfferArgsToStructs } from "../offers/interface";
+import { fullOfferArgsToStruct } from "../exchanges/interface";
 
 import { CreateSellerArgs } from "../accounts/types";
 import { CreateOfferArgs } from "../offers/types";
@@ -181,3 +182,32 @@ export function encodeRaiseAndEscalateDispute(exchangeId: BigNumberish) {
     [exchangeId]
   );
 }
+
+export function encodeCommitToOfferAndRedeemVoucher(offerId: BigNumberish) {
+  return bosonOrchestrationHandlerIface.encodeFunctionData(
+    "commitToOfferAndRedeemVoucher",
+    [offerId]
+  );
+}
+
+export function encodeCommitToConditionalOfferAndRedeemVoucher(
+  offerId: BigNumberish,
+  tokenId: BigNumberish
+) {
+  return bosonOrchestrationHandlerIface.encodeFunctionData(
+    "commitToConditionalOfferAndRedeemVoucher",
+    [offerId, tokenId]
+  );
+}
+
+export function encodeCreateOfferCommitAndRedeem(args: FullOfferArgs) {
+  return bosonOrchestrationHandlerIface.encodeFunctionData(
+    "createOfferCommitAndRedeem",
+    [
+      fullOfferArgsToStruct(args),
+      args.offerCreator,
+      args.signature,
+      args.conditionalTokenId || "0"
+    ]
+  );
+}

package/src/orchestration/mixin.ts

@@ -1,5 +1,6 @@
 import {
   ConditionStruct,
+  FullOfferArgs,
   TransactionResponse,
   TransactionRequest,
   Web3LibAdapter
@@ -415,6 +416,192 @@ export class OrchestrationMixin<
     }
   }
 
+  /**
+   * Commits to a seller-initiated offer and immediately redeems the voucher in
+   * a single transaction by calling the `OrchestrationHandler`.
+   * @param offerId - ID of offer to commit to.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async commitToOfferAndRedeemVoucher(
+    offerId: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async commitToOfferAndRedeemVoucher(
+    offerId: BigNumberish,
+    overrides?: Partial<{
+      contractAddress: string;
+      returnTxInfo?: false;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async commitToOfferAndRedeemVoucher(
+    offerId: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+      returnTxInfo?: boolean;
+    }> = {}
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+
+    const commitArgs = {
+      offerId,
+      web3Lib: this._web3Lib,
+      subgraphUrl: this._subgraphUrl,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    } as const satisfies Parameters<
+      typeof handler.commitToOfferAndRedeemVoucher
+    >[0];
+
+    if (returnTxInfo === true) {
+      return handler.commitToOfferAndRedeemVoucher({
+        ...commitArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return handler.commitToOfferAndRedeemVoucher({
+        ...commitArgs,
+        returnTxInfo: false
+      });
+    }
+  }
+
+  /**
+   * Commits to a conditional offer and immediately redeems the voucher in a
+   * single transaction by calling the `OrchestrationHandler`.
+   * @param offerId - ID of offer to commit to.
+   * @param tokenId - ID of the token to use for the conditional commit.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async commitToConditionalOfferAndRedeemVoucher(
+    offerId: BigNumberish,
+    tokenId: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async commitToConditionalOfferAndRedeemVoucher(
+    offerId: BigNumberish,
+    tokenId: BigNumberish,
+    overrides?: Partial<{
+      contractAddress: string;
+      returnTxInfo?: false;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async commitToConditionalOfferAndRedeemVoucher(
+    offerId: BigNumberish,
+    tokenId: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+      returnTxInfo?: boolean;
+    }> = {}
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+
+    const commitArgs = {
+      offerId,
+      tokenId,
+      web3Lib: this._web3Lib,
+      subgraphUrl: this._subgraphUrl,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    } as const satisfies Parameters<
+      typeof handler.commitToConditionalOfferAndRedeemVoucher
+    >[0];
+
+    if (returnTxInfo === true) {
+      return handler.commitToConditionalOfferAndRedeemVoucher({
+        ...commitArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return handler.commitToConditionalOfferAndRedeemVoucher({
+        ...commitArgs,
+        returnTxInfo: false
+      });
+    }
+  }
+
+  /**
+   * Creates an offer, commits to it and immediately redeems the voucher in a
+   * single transaction by calling the `OrchestrationHandler`.
+   * @param createOfferAndCommitArgs - Offer and commit arguments.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async createOfferCommitAndRedeem(
+    createOfferAndCommitArgs: FullOfferArgs,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async createOfferCommitAndRedeem(
+    createOfferAndCommitArgs: FullOfferArgs,
+    overrides?: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async createOfferCommitAndRedeem(
+    createOfferAndCommitArgs: FullOfferArgs,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
+    }> = {}
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+
+    const offerArgs = {
+      createOfferAndCommitArgs,
+      web3Lib: this._web3Lib,
+      subgraphUrl: this._subgraphUrl,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      txRequest: overrides.txRequest
+    } as const satisfies Parameters<
+      typeof handler.createOfferCommitAndRedeem
+    >[0];
+
+    if (returnTxInfo === true) {
+      return handler.createOfferCommitAndRedeem({
+        ...offerArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return handler.createOfferCommitAndRedeem({
+        ...offerArgs,
+        returnTxInfo: false
+      });
+    }
+  }
+
   /**
    * Raises a dispute and immediately escalates it
    * @param exchangeId - Exchange ID