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

package/src/core-sdk.ts

@@ -30,7 +30,7 @@ import { SubgraphMixin } from "./subgraph/mixin";
 import { PriceDiscoveryMixin } from "./price-discovery/mixin";
 import { MarketplaceMixin } from "./marketplaces/mixin";
 
-export class CoreSDK extends BaseCoreSDK {
+export class CoreSDK<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /**
    * Creates an instance of `CoreSDK` by using default values derived either from
    * `args.envName` or `args.chainId`.
@@ -47,8 +47,8 @@ export class CoreSDK extends BaseCoreSDK {
    * @param args - Constructor args.
    * @returns CoreSDK instance with default values.
    */
-  static fromDefaultConfig(args: {
-    web3Lib: Web3LibAdapter;
+  static fromDefaultConfig<T extends Web3LibAdapter>(args: {
+    web3Lib: T;
     envName: EnvironmentType;
     configId: ConfigId;
     metadataStorage?: MetadataStorage;
@@ -57,7 +57,7 @@ export class CoreSDK extends BaseCoreSDK {
   }) {
     const defaultConfig = getEnvConfigById(args.envName, args.configId);
 
-    return new CoreSDK({
+    return new CoreSDK<T>({
       web3Lib: args.web3Lib,
       metadataStorage: args.metadataStorage,
       theGraphStorage: args.theGraphStorage,
@@ -132,28 +132,28 @@ export class CoreSDK extends BaseCoreSDK {
 
 // Doc: https://www.typescriptlang.org/docs/handbook/mixins.html#alternative-pattern
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface CoreSDK
-  extends MetadataMixin,
-    AccountsMixin,
-    OfferMixin,
-    FundsMixin,
-    ExchangesMixin,
-    DisputesMixin,
-    MetaTxMixin,
-    NativeMetaTxMixin,
-    GroupsMixin,
-    OrchestrationMixin,
-    EventLogsMixin,
-    VoucherMixin,
-    ERC20Mixin,
-    ERC721Mixin,
-    ERC1155Mixin,
-    ERC165Mixin,
-    ProtocolConfigMixin,
-    ErrorMixin,
-    SubgraphMixin,
-    PriceDiscoveryMixin,
-    MarketplaceMixin {}
+export interface CoreSDK<T extends Web3LibAdapter = Web3LibAdapter>
+  extends MetadataMixin<T>,
+    AccountsMixin<T>,
+    OfferMixin<T>,
+    FundsMixin<T>,
+    ExchangesMixin<T>,
+    DisputesMixin<T>,
+    MetaTxMixin<T>,
+    NativeMetaTxMixin<T>,
+    GroupsMixin<T>,
+    OrchestrationMixin<T>,
+    EventLogsMixin<T>,
+    VoucherMixin<T>,
+    ERC20Mixin<T>,
+    ERC721Mixin<T>,
+    ERC1155Mixin<T>,
+    ERC165Mixin<T>,
+    ProtocolConfigMixin<T>,
+    ErrorMixin<T>,
+    SubgraphMixin<T>,
+    PriceDiscoveryMixin<T>,
+    MarketplaceMixin<T> {}
 applyMixins(CoreSDK, [
   MetadataMixin,
   AccountsMixin,

package/src/disputes/handler.ts

@@ -1,4 +1,8 @@
-import { Web3LibAdapter, TransactionResponse } from "@bosonprotocol/common";
+import {
+  Web3LibAdapter,
+  TransactionResponse,
+  TransactionRequest
+} from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
 import { BytesLike } from "@ethersproject/bytes";
 
@@ -14,64 +18,176 @@ import {
   encodeResolveDispute,
   encodeRetractDispute
 } from "./interface";
-import { prepareDataSignatureParameters } from "../utils/signature";
+import {
+  getSignatureParameters,
+  prepareDataSignatureParameters,
+  StructuredData
+} from "../utils/signature";
 
+// Overload: returnTxInfo is true → returns TransactionRequest
+export async function raiseDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function raiseDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
 export async function raiseDispute(args: {
   exchangeId: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeRaiseDispute(args)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true → returns TransactionRequest
+export async function retractDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
 export async function retractDispute(args: {
   exchangeId: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
+export async function retractDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeRetractDispute(args.exchangeId)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true → returns TransactionRequest
+export async function extendDisputeTimeout(args: {
+  exchangeId: BigNumberish;
+  newDisputeTimeout: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function extendDisputeTimeout(args: {
+  exchangeId: BigNumberish;
+  newDisputeTimeout: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
 export async function extendDisputeTimeout(args: {
   exchangeId: BigNumberish;
   newDisputeTimeout: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeExtendDisputeTimeout(args)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true → returns TransactionRequest
+export async function expireDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function expireDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
 export async function expireDispute(args: {
   exchangeId: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeExpireDispute(args.exchangeId)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true → returns TransactionRequest
 export async function expireDisputeBatch(args: {
   exchangeIds: BigNumberish[];
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function expireDisputeBatch(args: {
+  exchangeIds: BigNumberish[];
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
+export async function expireDisputeBatch(args: {
+  exchangeIds: BigNumberish[];
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeExpireDisputeBatch(args.exchangeIds)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true → returns TransactionRequest
 export async function resolveDispute(args: {
   exchangeId: BigNumberish;
   buyerPercentBasisPoints: BigNumberish;
@@ -80,56 +196,170 @@ export async function resolveDispute(args: {
   sigV: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function resolveDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercentBasisPoints: BigNumberish;
+  sigR: BytesLike;
+  sigS: BytesLike;
+  sigV: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
+export async function resolveDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercentBasisPoints: BigNumberish;
+  sigR: BytesLike;
+  sigS: BytesLike;
+  sigV: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeResolveDispute(args)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true → returns TransactionRequest
+export async function escalateDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function escalateDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
 export async function escalateDispute(args: {
   exchangeId: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeEscalateDispute(args.exchangeId)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true → returns TransactionRequest
 export async function decideDispute(args: {
   exchangeId: BigNumberish;
   buyerPercent: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function decideDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercent: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
+export async function decideDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercent: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeDecideDispute(args)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true → returns TransactionRequest
 export async function refuseEscalatedDispute(args: {
   exchangeId: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function refuseEscalatedDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
+export async function refuseEscalatedDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeRefuseEscalatedDispute(args.exchangeId)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// Overload: returnTxInfo is true → returns TransactionRequest
+export async function expireEscalatedDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function expireEscalatedDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+// Implementation
 export async function expireEscalatedDispute(args: {
   exchangeId: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo?: boolean;
+}): Promise<TransactionResponse | TransactionRequest> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeExpireEscalatedDispute(args.exchangeId)
-  });
+  } satisfies TransactionRequest;
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
 export async function signResolutionProposal(args: {
@@ -138,7 +368,24 @@ export async function signResolutionProposal(args: {
   contractAddress: string;
   web3Lib: Web3LibAdapter;
   chainId: number;
-}) {
+  returnTypedDataToSign: true;
+}): Promise<StructuredData>;
+export async function signResolutionProposal(args: {
+  exchangeId: BigNumberish;
+  buyerPercentBasisPoints: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  chainId: number;
+  returnTypedDataToSign?: false;
+}): Promise<ReturnType<typeof getSignatureParameters>>;
+export async function signResolutionProposal(args: {
+  exchangeId: BigNumberish;
+  buyerPercentBasisPoints: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  chainId: number;
+  returnTypedDataToSign?: boolean;
+}): Promise<StructuredData | ReturnType<typeof getSignatureParameters>> {
   const customSignatureType = {
     Resolution: [
       { name: "exchangeId", type: "uint256" },
@@ -151,12 +398,24 @@ export async function signResolutionProposal(args: {
     buyerPercentBasisPoints: args.buyerPercentBasisPoints.toString()
   };
 
-  return prepareDataSignatureParameters({
+  const signatureArgs = {
     message,
     customSignatureType,
     web3Lib: args.web3Lib,
     verifyingContractAddress: args.contractAddress,
     chainId: args.chainId,
     primaryType: "Resolution"
-  });
+  } as const;
+
+  if (args.returnTypedDataToSign) {
+    return prepareDataSignatureParameters({
+      ...signatureArgs,
+      returnTypedDataToSign: true
+    });
+  } else {
+    return prepareDataSignatureParameters({
+      ...signatureArgs,
+      returnTypedDataToSign: false
+    });
+  }
 }