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

package/src/disputes/mixin.ts

@@ -1,6 +1,10 @@
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import * as subgraph from "../subgraph";
-import { TransactionResponse } from "@bosonprotocol/common";
+import {
+  TransactionResponse,
+  TransactionRequest,
+  Web3LibAdapter
+} from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
 import { BytesLike } from "@ethersproject/bytes";
 import {
@@ -21,8 +25,9 @@ import {
   getDisputeById,
   getDisputes
 } from "./subgraph";
+import { getSignatureParameters, StructuredData } from "../utils/signature";
 
-export class DisputesMixin extends BaseCoreSDK {
+export class DisputesMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
   /*                           Dispute related methods                          */
   /* -------------------------------------------------------------------------- */
@@ -57,13 +62,34 @@ export class DisputesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async raiseDispute(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return raiseDispute({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async raiseDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async raiseDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const raiseArgs = {
       exchangeId,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof raiseDispute>[0];
+
+    if (returnTxInfo === true) {
+      return raiseDispute({
+        ...raiseArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return raiseDispute({
+        ...raiseArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -72,13 +98,34 @@ export class DisputesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async retractDispute(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return retractDispute({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async retractDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async retractDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const retractArgs = {
       exchangeId,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof retractDispute>[0];
+
+    if (returnTxInfo === true) {
+      return retractDispute({
+        ...retractArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return retractDispute({
+        ...retractArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -89,14 +136,37 @@ export class DisputesMixin extends BaseCoreSDK {
    */
   public async extendDisputeTimeout(
     exchangeId: BigNumberish,
-    newDisputeTimeout: BigNumberish
-  ): Promise<TransactionResponse> {
-    return extendDisputeTimeout({
+    newDisputeTimeout: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async extendDisputeTimeout(
+    exchangeId: BigNumberish,
+    newDisputeTimeout: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async extendDisputeTimeout(
+    exchangeId: BigNumberish,
+    newDisputeTimeout: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const extendArgs = {
       exchangeId,
       newDisputeTimeout,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof extendDisputeTimeout>[0];
+
+    if (returnTxInfo === true) {
+      return extendDisputeTimeout({
+        ...extendArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return extendDisputeTimeout({
+        ...extendArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -105,13 +175,34 @@ export class DisputesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async expireDispute(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return expireDispute({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async expireDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async expireDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const expireArgs = {
       exchangeId,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof expireDispute>[0];
+
+    if (returnTxInfo === true) {
+      return expireDispute({
+        ...expireArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return expireDispute({
+        ...expireArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -120,13 +211,34 @@ export class DisputesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async expireDisputeBatch(
-    exchangeIds: BigNumberish[]
-  ): Promise<TransactionResponse> {
-    return expireDisputeBatch({
+    exchangeIds: BigNumberish[],
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async expireDisputeBatch(
+    exchangeIds: BigNumberish[],
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async expireDisputeBatch(
+    exchangeIds: BigNumberish[],
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const batchArgs = {
       exchangeIds,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof expireDisputeBatch>[0];
+
+    if (returnTxInfo === true) {
+      return expireDisputeBatch({
+        ...batchArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return expireDisputeBatch({
+        ...batchArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -148,12 +260,46 @@ export class DisputesMixin extends BaseCoreSDK {
     sigR: BytesLike;
     sigS: BytesLike;
     sigV: BigNumberish;
-  }): Promise<TransactionResponse> {
-    return resolveDispute({
-      ...args,
+    returnTxInfo: true;
+  }): Promise<TransactionRequest>;
+  public async resolveDispute(args: {
+    exchangeId: BigNumberish;
+    buyerPercentBasisPoints: BigNumberish;
+    sigR: BytesLike;
+    sigS: BytesLike;
+    sigV: BigNumberish;
+    returnTxInfo?: false | undefined;
+  }): Promise<TransactionResponse>;
+  public async resolveDispute(args: {
+    exchangeId: BigNumberish;
+    buyerPercentBasisPoints: BigNumberish;
+    sigR: BytesLike;
+    sigS: BytesLike;
+    sigV: BigNumberish;
+    returnTxInfo?: boolean;
+  }): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = args;
+    const resolveArgs = {
+      exchangeId: args.exchangeId,
+      buyerPercentBasisPoints: args.buyerPercentBasisPoints,
+      sigR: args.sigR,
+      sigS: args.sigS,
+      sigV: args.sigV,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof resolveDispute>[0];
+
+    if (returnTxInfo === true) {
+      return resolveDispute({
+        ...resolveArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return resolveDispute({
+        ...resolveArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -162,13 +308,34 @@ export class DisputesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async escalateDispute(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return escalateDispute({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async escalateDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async escalateDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const escalateArgs = {
       exchangeId,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof escalateDispute>[0];
+
+    if (returnTxInfo === true) {
+      return escalateDispute({
+        ...escalateArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return escalateDispute({
+        ...escalateArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -179,14 +346,37 @@ export class DisputesMixin extends BaseCoreSDK {
    */
   public async decideDispute(
     exchangeId: BigNumberish,
-    buyerPercent: BigNumberish
-  ): Promise<TransactionResponse> {
-    return decideDispute({
+    buyerPercent: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async decideDispute(
+    exchangeId: BigNumberish,
+    buyerPercent: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async decideDispute(
+    exchangeId: BigNumberish,
+    buyerPercent: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const decideArgs = {
       exchangeId,
       buyerPercent,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof decideDispute>[0];
+
+    if (returnTxInfo === true) {
+      return decideDispute({
+        ...decideArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return decideDispute({
+        ...decideArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -195,13 +385,34 @@ export class DisputesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async refuseEscalatedDispute(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return refuseEscalatedDispute({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async refuseEscalatedDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async refuseEscalatedDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const refuseArgs = {
       exchangeId,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof refuseEscalatedDispute>[0];
+
+    if (returnTxInfo === true) {
+      return refuseEscalatedDispute({
+        ...refuseArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return refuseEscalatedDispute({
+        ...refuseArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -210,13 +421,34 @@ export class DisputesMixin extends BaseCoreSDK {
    * @returns Transaction response.
    */
   public async expireEscalatedDispute(
-    exchangeId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return expireEscalatedDispute({
+    exchangeId: BigNumberish,
+    returnTxInfo: true
+  ): Promise<TransactionRequest>;
+  public async expireEscalatedDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: false | undefined
+  ): Promise<TransactionResponse>;
+  public async expireEscalatedDispute(
+    exchangeId: BigNumberish,
+    returnTxInfo?: boolean
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const expireEscalatedArgs = {
       exchangeId,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof expireEscalatedDispute>[0];
+
+    if (returnTxInfo === true) {
+      return expireEscalatedDispute({
+        ...expireEscalatedArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return expireEscalatedDispute({
+        ...expireEscalatedArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
@@ -229,12 +461,35 @@ export class DisputesMixin extends BaseCoreSDK {
   public async signDisputeResolutionProposal(args: {
     exchangeId: BigNumberish;
     buyerPercentBasisPoints: BigNumberish;
-  }) {
-    return signResolutionProposal({
-      ...args,
+    returnTypedDataToSign: true;
+  }): Promise<StructuredData>;
+  public async signDisputeResolutionProposal(args: {
+    exchangeId: BigNumberish;
+    buyerPercentBasisPoints: BigNumberish;
+    returnTypedDataToSign?: false;
+  }): Promise<ReturnType<typeof getSignatureParameters>>;
+  public async signDisputeResolutionProposal(args: {
+    exchangeId: BigNumberish;
+    buyerPercentBasisPoints: BigNumberish;
+    returnTypedDataToSign?: boolean;
+  }): Promise<StructuredData | ReturnType<typeof getSignatureParameters>> {
+    const { returnTypedDataToSign, ...argsWithoutReturnTypedDataToSign } = args;
+    const params = {
+      ...argsWithoutReturnTypedDataToSign,
       web3Lib: this._web3Lib,
       contractAddress: this._protocolDiamond,
       chainId: this._chainId
-    });
+    };
+    if (returnTypedDataToSign === true) {
+      return signResolutionProposal({
+        ...params,
+        returnTypedDataToSign: true
+      });
+    } else {
+      return signResolutionProposal({
+        ...params,
+        returnTypedDataToSign: false
+      });
+    }
   }
 }

package/src/erc1155/mixin.ts

@@ -1,7 +1,8 @@
+import { Web3LibAdapter } from "@bosonprotocol/common";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import { balanceOf, name, symbol, uri } from "./handler";
 
-export class ERC1155Mixin extends BaseCoreSDK {
+export class ERC1155Mixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
   /*                           ERC1155 related methods                          */
   /* -------------------------------------------------------------------------- */

package/src/erc165/mixin.ts

@@ -1,7 +1,8 @@
+import { Web3LibAdapter } from "@bosonprotocol/common";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import { supportsInterface } from "./handler";
 
-export class ERC165Mixin extends BaseCoreSDK {
+export class ERC165Mixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
   /*                           ERC20 related methods                          */
   /* -------------------------------------------------------------------------- */

package/src/erc20/handler.ts

@@ -1,19 +1,51 @@
-import { Web3LibAdapter, TransactionRequest } from "@bosonprotocol/common";
+import {
+  Web3LibAdapter,
+  TransactionRequest,
+  TransactionResponse
+} from "@bosonprotocol/common";
 import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
 import { erc20Iface } from "./interface";
 
+// Overload: returnTxInfo is true -> returns TransactionRequest
 export async function approve(args: {
   contractAddress: string;
   spender: string;
   value: BigNumberish;
   web3Lib: Web3LibAdapter;
   txRequest?: TransactionRequest;
-}) {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+// Overload: returnTxInfo is false or undefined -> returns TransactionResponse
+export async function approve(args: {
+  contractAddress: string;
+  spender: string;
+  value: BigNumberish;
+  web3Lib: Web3LibAdapter;
+  txRequest?: TransactionRequest;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+// Implementation
+export async function approve(args: {
+  contractAddress: string;
+  spender: string;
+  value: BigNumberish;
+  web3Lib: Web3LibAdapter;
+  txRequest?: TransactionRequest;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
+  const transactionRequest: TransactionRequest = {
     ...args.txRequest,
     to: args.contractAddress,
     data: erc20Iface.encodeFunctionData("approve", [args.spender, args.value])
-  });
+  };
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
 export async function getAllowance(args: {

package/src/erc20/mixin.ts

@@ -1,3 +1,8 @@
+import {
+  Web3LibAdapter,
+  TransactionResponse,
+  TransactionRequest
+} from "@bosonprotocol/common";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import {
   approve,
@@ -9,14 +14,82 @@ import {
   balanceOf
 } from "./handler";
 
-export class ERC20Mixin extends BaseCoreSDK {
+export class ERC20Mixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
   /*                           ERC20 related methods                          */
   /* -------------------------------------------------------------------------- */
+
+  /**
+   * Approves ERC20 token spending allowance.
+   * This transaction only succeeds if the token contract exists and caller has sufficient balance.
+   * @param args - Approval arguments.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async erc20Approve(
+    args: Omit<
+      Parameters<typeof approve>[0],
+      "web3Lib" | "theGraphStorage" | "metadataStorage"
+    >,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async erc20Approve(
+    args: Omit<
+      Parameters<typeof approve>[0],
+      "web3Lib" | "theGraphStorage" | "metadataStorage"
+    >,
+    overrides?: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
   public async erc20Approve(
-    args: Omit<Parameters<typeof approve>[0], "web3Lib">
-  ): Promise<ReturnType<typeof approve>> {
-    return approve({ web3Lib: this._web3Lib, ...args });
+    args: Omit<
+      Parameters<typeof approve>[0],
+      "web3Lib" | "theGraphStorage" | "metadataStorage"
+    >,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
+    }> = {}
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+
+    const approveArgs = {
+      ...args,
+      web3Lib: this._web3Lib,
+      contractAddress: overrides.contractAddress,
+      txRequest: overrides.txRequest
+    } as const satisfies Parameters<typeof approve>[0];
+
+    if (returnTxInfo === true) {
+      return approve({
+        ...approveArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return approve({
+        ...approveArgs,
+        returnTxInfo: false
+      });
+    }
+  }
+
+  public async erc20EnsureAllowance(
+    args: Omit<Parameters<typeof ensureAllowance>[0], "web3Lib">
+  ): Promise<ReturnType<typeof ensureAllowance>> {
+    return ensureAllowance({ web3Lib: this._web3Lib, ...args });
   }
 
   public async erc20GetAllowance(
@@ -43,12 +116,6 @@ export class ERC20Mixin extends BaseCoreSDK {
     return getName({ web3Lib: this._web3Lib, ...args });
   }
 
-  public async erc20EnsureAllowance(
-    args: Omit<Parameters<typeof ensureAllowance>[0], "web3Lib">
-  ): Promise<ReturnType<typeof ensureAllowance>> {
-    return ensureAllowance({ web3Lib: this._web3Lib, ...args });
-  }
-
   public async erc20BalanceOf(
     args: Omit<Parameters<typeof balanceOf>[0], "web3Lib">
   ): Promise<ReturnType<typeof balanceOf>> {