@bosonprotocol/core-sdk 1.44.0-alpha.0 → 1.44.0-alpha.10

package/src/voucher/mixin.ts

@@ -1,4 +1,8 @@
-import { TransactionResponse } from "@bosonprotocol/common";
+import {
+  TransactionResponse,
+  TransactionRequest,
+  Web3LibAdapter
+} from "@bosonprotocol/common";
 import { Range } from "@bosonprotocol/common/src/types";
 import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
 import { handler } from ".";
@@ -7,92 +11,299 @@ import { getOfferById } from "../offers/subgraph";
 import { encodeValidate, Order as SeaportOrder } from "../seaport/interface";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 
-export class VoucherMixin extends BaseCoreSDK {
+export class VoucherMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /**
-   * Burns preminted vouchers from an offer
-   * @param offerId -  Offer ID
+   * Burns preminted vouchers from an offer by calling the voucher contract.
+   * This transaction only succeeds if there is an existing seller account for connected signer.
+   * @param offerId - Offer ID
+   * @param amount - Amount to burn
    * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
+  // Overload: returnTxInfo is true → returns TransactionRequest
   public async burnPremintedVouchers(
     offerId: BigNumberish,
     amount: BigNumberish,
     overrides: Partial<{
       contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async burnPremintedVouchers(
+    offerId: BigNumberish,
+    amount: BigNumberish,
+    overrides?: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async burnPremintedVouchers(
+    offerId: BigNumberish,
+    amount: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
     }> = {}
-  ): Promise<TransactionResponse> {
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
     const offerFromSubgraph = await getOfferById(this._subgraphUrl, offerId);
-    return handler.burnPremintedVouchers({
+
+    const burnArgs = {
       offerId,
       amount,
       contractAddress:
         overrides.contractAddress ||
         offerFromSubgraph.seller.voucherCloneAddress,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof handler.burnPremintedVouchers>[0];
+
+    if (returnTxInfo === true) {
+      return handler.burnPremintedVouchers({
+        ...burnArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return handler.burnPremintedVouchers({
+        ...burnArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
-   * Gets the number of vouchers available to be pre-minted for an offer.
-   * @param offerId -  Offer ID
+   * Pre-mints all or part of an offer's reserved vouchers by calling the voucher contract.
+   * This transaction only succeeds if there is an existing seller account for connected signer.
+   * @param offerId - Offer ID
+   * @param amount - Amount to pre-mint
    * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
-  public async getAvailablePreMints(
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async preMint(
     offerId: BigNumberish,
+    amount: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async preMint(
+    offerId: BigNumberish,
+    amount: BigNumberish,
+    overrides?: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async preMint(
+    offerId: BigNumberish,
+    amount: BigNumberish,
     overrides: Partial<{
       contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
     }> = {}
-  ): Promise<string> {
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
     const offerFromSubgraph = await getOfferById(this._subgraphUrl, offerId);
-    return handler.getAvailablePreMints({
+
+    const preMintArgs = {
       offerId,
+      amount,
       contractAddress:
         overrides.contractAddress ||
         offerFromSubgraph.seller.voucherCloneAddress,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof handler.preMint>[0];
+
+    if (returnTxInfo === true) {
+      return handler.preMint({
+        ...preMintArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return handler.preMint({
+        ...preMintArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
-   * Gets the range for an offer.
-   * @param offerId -  Offer ID
+   * Transfers voucher from one address to another by calling the voucher contract.
+   * This transaction only succeeds if there is an existing seller account for connected signer.
+   * @param offerId - Offer ID
+   * @param to - Recipient address
+   * @param tokenId - Token ID to transfer
    * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
-  public async getRangeByOfferId(
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async transferFrom(
+    offerId: BigNumberish,
+    to: BigNumberish,
+    tokenId: BigNumberish,
+    overrides: Partial<{
+      owner: BigNumberish;
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async transferFrom(
+    offerId: BigNumberish,
+    to: BigNumberish,
+    tokenId: BigNumberish,
+    overrides?: Partial<{
+      owner: BigNumberish;
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async transferFrom(
     offerId: BigNumberish,
+    to: BigNumberish,
+    tokenId: BigNumberish,
     overrides: Partial<{
+      owner: BigNumberish;
       contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
     }> = {}
-  ): Promise<Range> {
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
     const offerFromSubgraph = await getOfferById(this._subgraphUrl, offerId);
-    return handler.getRangeByOfferId({
-      offerId,
+
+    const transferArgs = {
+      from: overrides.owner || (await this._web3Lib.getSignerAddress()),
+      to,
+      tokenId,
       contractAddress:
         overrides.contractAddress ||
         offerFromSubgraph.seller.voucherCloneAddress,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof handler.transferFrom>[0];
+
+    if (returnTxInfo === true) {
+      return handler.transferFrom({
+        ...transferArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return handler.transferFrom({
+        ...transferArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
-   * Pre-mints all or part of an offer's reserved vouchers.
-   * @param offerId -  Offer ID
+   * Sets contract URI by calling the voucher contract.
+   * This transaction only succeeds if there is an existing seller account for connected signer.
+   * @param contractURI - Contract URI
+   * @param collectionIndex - Collection index
    * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
-  public async preMint(
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async setContractURI(
+    contractURI: string,
+    collectionIndex: BigNumberish,
+    overrides: Partial<{
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async setContractURI(
+    contractURI: string,
+    collectionIndex: BigNumberish,
+    overrides?: Partial<{
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async setContractURI(
+    contractURI: string,
+    collectionIndex: BigNumberish,
+    overrides: Partial<{
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
+    }> = {}
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+    const sellerAddress = await this._web3Lib.getSignerAddress();
+    const seller = await accounts.subgraph.getSellerByAddress(
+      this._subgraphUrl,
+      sellerAddress
+    );
+    if (!seller) {
+      throw new Error(`No seller found for wallet ${sellerAddress}`);
+    }
+    const collection = seller.collections.find((coll) =>
+      BigNumber.from(coll.collectionIndex).eq(collectionIndex)
+    );
+    if (!collection) {
+      throw new Error(
+        `Collection with index ${collectionIndex} not found for seller with id ${seller.id}`
+      );
+    }
+
+    const setContractURIArgs = {
+      contractURI,
+      contractAddress: collection.collectionContract.address,
+      web3Lib: this._web3Lib
+    } as const satisfies Parameters<typeof handler.setContractURI>[0];
+
+    if (returnTxInfo === true) {
+      return handler.setContractURI({
+        ...setContractURIArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return handler.setContractURI({
+        ...setContractURIArgs,
+        returnTxInfo: false
+      });
+    }
+  }
+
+  /**
+   * Gets the number of vouchers available to be pre-minted for an offer.
+   * @param offerId - Offer ID
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async getAvailablePreMints(
     offerId: BigNumberish,
-    amount: BigNumberish,
     overrides: Partial<{
       contractAddress: string;
     }> = {}
-  ): Promise<TransactionResponse> {
+  ): Promise<string> {
     const offerFromSubgraph = await getOfferById(this._subgraphUrl, offerId);
-    return handler.preMint({
+    return handler.getAvailablePreMints({
       offerId,
-      amount,
       contractAddress:
         overrides.contractAddress ||
         offerFromSubgraph.seller.voucherCloneAddress,
@@ -101,26 +312,20 @@ export class VoucherMixin extends BaseCoreSDK {
   }
 
   /**
-   * Pre-mints all or part of an offer's reserved vouchers.
-   * @param offerId -  Offer ID
+   * Gets the range for an offer.
+   * @param offerId - Offer ID
    * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
-  public async transferFrom(
+  public async getRangeByOfferId(
     offerId: BigNumberish,
-    to: BigNumberish,
-    tokenId: BigNumberish,
     overrides: Partial<{
-      owner: BigNumberish;
       contractAddress: string;
     }> = {}
-  ): Promise<TransactionResponse> {
+  ): Promise<Range> {
     const offerFromSubgraph = await getOfferById(this._subgraphUrl, offerId);
-
-    return handler.transferFrom({
-      from: overrides.owner || (await this._web3Lib.getSignerAddress()),
-      to,
-      tokenId,
+    return handler.getRangeByOfferId({
+      offerId,
       contractAddress:
         overrides.contractAddress ||
         offerFromSubgraph.seller.voucherCloneAddress,
@@ -187,33 +392,6 @@ export class VoucherMixin extends BaseCoreSDK {
     });
   }
 
-  public async setContractURI(
-    contractURI: string,
-    collectionIndex: BigNumberish
-  ): Promise<TransactionResponse> {
-    const sellerAddress = await this._web3Lib.getSignerAddress();
-    const seller = await accounts.subgraph.getSellerByAddress(
-      this._subgraphUrl,
-      sellerAddress
-    );
-    if (!seller) {
-      throw new Error(`No seller found for wallet ${sellerAddress}`);
-    }
-    const collection = seller.collections.find((coll) =>
-      BigNumber.from(coll.collectionIndex).eq(collectionIndex)
-    );
-    if (!collection) {
-      throw new Error(
-        `Collection with index ${collectionIndex} not found for seller with id ${seller.id}`
-      );
-    }
-    return handler.setContractURI({
-      contractURI,
-      contractAddress: collection.collectionContract.address,
-      web3Lib: this._web3Lib
-    });
-  }
-
   public async validateSeaportOrders(
     openseaConduit: string,
     seaportContract: string,