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

package/src/exchanges/mixin.ts

@@ -1,6 +1,11 @@
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import * as subgraph from "../subgraph";
-import { TransactionResponse, Log } from "@bosonprotocol/common";
+import {
+  TransactionResponse,
+  TransactionRequest,
+  Log,
+  Web3LibAdapter
+} from "@bosonprotocol/common";
 import { BigNumberish, BigNumber } from "@ethersproject/bignumber";
 import { getValueFromLogs } from "../utils/logs";
 import {
@@ -18,7 +23,7 @@ import {
 import { getExchangeById, getExchanges } from "./subgraph";
 import { bosonExchangeHandlerIface } from "./interface";
 
-export class ExchangesMixin extends BaseCoreSDK {
+export class ExchangesMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
   /*                          Exchange related methods                          */
   /* -------------------------------------------------------------------------- */
@@ -58,16 +63,45 @@ export class ExchangesMixin extends BaseCoreSDK {
     offerId: BigNumberish,
     overrides: Partial<{
       buyer: string;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+  public async commitToOffer(
+    offerId: BigNumberish,
+    overrides?: Partial<{
+      buyer: string;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+  public async commitToOffer(
+    offerId: BigNumberish,
+    overrides: Partial<{
+      buyer: string;
+      returnTxInfo?: boolean;
     }> = {}
-  ): Promise<TransactionResponse> {
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
     const buyer = overrides.buyer || (await this._web3Lib.getSignerAddress());
-    return commitToOffer({
+
+    const commitArgs = {
       buyer,
       offerId,
       web3Lib: this._web3Lib,
       subgraphUrl: this._subgraphUrl,
       contractAddress: this._protocolDiamond
-    });
+    } as const satisfies Parameters<typeof commitToOffer>[0];
+
+    if (returnTxInfo === true) {
+      return commitToOffer({
+        ...commitArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return commitToOffer({
+        ...commitArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -83,17 +117,48 @@ export class ExchangesMixin extends BaseCoreSDK {
     tokenId: BigNumberish,
     overrides: Partial<{
       buyer: string;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+  public async commitToConditionalOffer(
+    offerId: BigNumberish,
+    tokenId: BigNumberish,
+    overrides?: Partial<{
+      buyer: string;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+  public async commitToConditionalOffer(
+    offerId: BigNumberish,
+    tokenId: BigNumberish,
+    overrides: Partial<{
+      buyer: string;
+      returnTxInfo?: boolean;
     }> = {}
-  ): Promise<TransactionResponse> {
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
     const buyer = overrides.buyer || (await this._web3Lib.getSignerAddress());
-    return commitToConditionalOffer({
+
+    const commitArgs = {
       buyer,
       offerId,
       tokenId,
       web3Lib: this._web3Lib,
       subgraphUrl: this._subgraphUrl,
       contractAddress: this._protocolDiamond
-    });
+    } as const satisfies Parameters<typeof commitToConditionalOffer>[0];
+
+    if (returnTxInfo === true) {
+      return commitToConditionalOffer({
+        ...commitArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return commitToConditionalOffer({
+        ...commitArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -117,14 +182,35 @@ export class ExchangesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async revokeVoucher(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return revokeVoucher({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async revokeVoucher(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async revokeVoucher(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const revokeArgs = {
       web3Lib: this._web3Lib,
       contractAddress: this._protocolDiamond,
       exchangeId,
       subgraphUrl: this._subgraphUrl
-    });
+    } as const satisfies Parameters<typeof revokeVoucher>[0];
+
+    if (returnTxInfo === true) {
+      return revokeVoucher({
+        ...revokeArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return revokeVoucher({
+        ...revokeArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -134,14 +220,35 @@ export class ExchangesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async cancelVoucher(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return cancelVoucher({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async cancelVoucher(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async cancelVoucher(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const cancelArgs = {
       web3Lib: this._web3Lib,
       contractAddress: this._protocolDiamond,
       exchangeId,
       subgraphUrl: this._subgraphUrl
-    });
+    } as const satisfies Parameters<typeof cancelVoucher>[0];
+
+    if (returnTxInfo === true) {
+      return cancelVoucher({
+        ...cancelArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return cancelVoucher({
+        ...cancelArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -151,14 +258,35 @@ export class ExchangesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async redeemVoucher(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return redeemVoucher({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async redeemVoucher(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async redeemVoucher(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const redeemArgs = {
       web3Lib: this._web3Lib,
       contractAddress: this._protocolDiamond,
       exchangeId,
       subgraphUrl: this._subgraphUrl
-    });
+    } as const satisfies Parameters<typeof redeemVoucher>[0];
+
+    if (returnTxInfo === true) {
+      return redeemVoucher({
+        ...redeemArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return redeemVoucher({
+        ...redeemArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -168,14 +296,35 @@ export class ExchangesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async completeExchange(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return completeExchange({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async completeExchange(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async completeExchange(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const completeArgs = {
       web3Lib: this._web3Lib,
       contractAddress: this._protocolDiamond,
       exchangeId,
       subgraphUrl: this._subgraphUrl
-    });
+    } as const satisfies Parameters<typeof completeExchange>[0];
+
+    if (returnTxInfo === true) {
+      return completeExchange({
+        ...completeArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return completeExchange({
+        ...completeArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -185,14 +334,35 @@ export class ExchangesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async completeExchangeBatch(
-    exchangeIds: BigNumberish[]
-  ): Promise<TransactionResponse> {
-    return completeExchangeBatch({
+    exchangeIds: BigNumberish[],
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async completeExchangeBatch(
+    exchangeIds: BigNumberish[],
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async completeExchangeBatch(
+    exchangeIds: BigNumberish[],
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const batchArgs = {
       web3Lib: this._web3Lib,
       contractAddress: this._protocolDiamond,
       exchangeIds,
       subgraphUrl: this._subgraphUrl
-    });
+    } as const satisfies Parameters<typeof completeExchangeBatch>[0];
+
+    if (returnTxInfo === true) {
+      return completeExchangeBatch({
+        ...batchArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return completeExchangeBatch({
+        ...batchArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -201,14 +371,35 @@ export class ExchangesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async expireVoucher(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return expireVoucher({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async expireVoucher(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async expireVoucher(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const expireArgs = {
       web3Lib: this._web3Lib,
       contractAddress: this._protocolDiamond,
       exchangeId,
       subgraphUrl: this._subgraphUrl
-    });
+    } as const satisfies Parameters<typeof expireVoucher>[0];
+
+    if (returnTxInfo === true) {
+      return expireVoucher({
+        ...expireArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return expireVoucher({
+        ...expireArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   public getExchangeTokenId(

package/src/funds/handler.ts

@@ -1,17 +1,43 @@
 import { BigNumberish } from "@ethersproject/bignumber";
 import { isAddress } from "@ethersproject/address";
 import { AddressZero } from "@ethersproject/constants";
-import { Web3LibAdapter, TransactionResponse } from "@bosonprotocol/common";
+import {
+  Web3LibAdapter,
+  TransactionRequest,
+  TransactionResponse
+} from "@bosonprotocol/common";
 import { encodeDepositFunds, encodeWithdrawFunds } from "./interface";
 import { getFunds } from "./subgraph";
 
+// Overload: returnTxInfo is true -> returns TransactionRequest
 export async function depositFunds(args: {
   sellerId: BigNumberish;
   fundsTokenAddress?: string;
   fundsAmount: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+// Overload: returnTxInfo is false or undefined -> returns TransactionResponse
+export async function depositFunds(args: {
+  sellerId: BigNumberish;
+  fundsTokenAddress?: string;
+  fundsAmount: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+// Implementation
+export async function depositFunds(args: {
+  sellerId: BigNumberish;
+  fundsTokenAddress?: string;
+  fundsAmount: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   const { fundsTokenAddress = AddressZero } = args;
 
   if (!isAddress(fundsTokenAddress)) {
@@ -20,40 +46,94 @@ export async function depositFunds(args: {
 
   const isNativeCoin = fundsTokenAddress === AddressZero;
 
-  return args.web3Lib.sendTransaction({
+  const transactionRequest: TransactionRequest = {
     to: args.contractAddress,
     data: encodeDepositFunds(
       args.sellerId,
-      args.fundsTokenAddress,
+      fundsTokenAddress,
       args.fundsAmount
     ),
     value: isNativeCoin ? args.fundsAmount : "0"
-  });
+  };
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true -> returns TransactionRequest
+export async function withdrawFunds(args: {
+  entityId: BigNumberish;
+  tokensToWithdraw: Array<string>;
+  amountsToWithdraw: Array<BigNumberish>;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+// Overload: returnTxInfo is false or undefined -> returns TransactionResponse
 export async function withdrawFunds(args: {
   entityId: BigNumberish;
   tokensToWithdraw: Array<string>;
   amountsToWithdraw: Array<BigNumberish>;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+// Implementation
+export async function withdrawFunds(args: {
+  entityId: BigNumberish;
+  tokensToWithdraw: Array<string>;
+  amountsToWithdraw: Array<BigNumberish>;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
+  const transactionRequest: TransactionRequest = {
     to: args.contractAddress,
     data: encodeWithdrawFunds(
       args.entityId,
       args.tokensToWithdraw,
       args.amountsToWithdraw
     )
-  });
+  };
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true -> returns TransactionRequest
+export async function withdrawAllAvailableFunds(args: {
+  entityId: BigNumberish;
+  subgraphUrl: string;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+// Overload: returnTxInfo is false or undefined -> returns TransactionResponse
+export async function withdrawAllAvailableFunds(args: {
+  entityId: BigNumberish;
+  subgraphUrl: string;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+// Implementation
 export async function withdrawAllAvailableFunds(args: {
   entityId: BigNumberish;
   subgraphUrl: string;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   const funds = await getFunds(args.subgraphUrl, {
     fundsFilter: {
       accountId: args.entityId.toString()
@@ -69,17 +149,23 @@ export async function withdrawAllAvailableFunds(args: {
         return acc;
       },
       {
-        tokensToWithdraw: [],
-        amountsToWithdraw: []
+        tokensToWithdraw: [] as string[],
+        amountsToWithdraw: [] as BigNumberish[]
       }
     );
 
-  return args.web3Lib.sendTransaction({
+  const transactionRequest: TransactionRequest = {
     to: args.contractAddress,
     data: encodeWithdrawFunds(
       args.entityId,
       tokensToWithdraw,
       amountsToWithdraw
     )
-  });
+  };
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }