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

package/src/orchestration/handler.ts

@@ -1,5 +1,6 @@
 import {
   Web3LibAdapter,
+  TransactionRequest,
   TransactionResponse,
   MetadataStorage,
   utils,
@@ -24,6 +25,7 @@ import { findCollectionSalt } from "../accounts/handler";
 import { PremintParametersStruct } from "@bosonprotocol/common/src";
 import { storeMetadataItems } from "../metadata/storeMetadataItems";
 
+// createOfferAndSeller overloads
 export async function createOfferAndSeller(args: {
   offerToCreate: CreateOfferArgs;
   sellerToCreate: CreateSellerArgs;
@@ -31,7 +33,28 @@ export async function createOfferAndSeller(args: {
   web3Lib: Web3LibAdapter;
   metadataStorage?: MetadataStorage;
   theGraphStorage?: MetadataStorage;
-}): Promise<TransactionResponse> {
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+export async function createOfferAndSeller(args: {
+  offerToCreate: CreateOfferArgs;
+  sellerToCreate: CreateSellerArgs;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function createOfferAndSeller(args: {
+  offerToCreate: CreateOfferArgs;
+  sellerToCreate: CreateSellerArgs;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
     abortEarly: false
   });
@@ -60,16 +83,23 @@ export async function createOfferAndSeller(args: {
   });
 
   const collectionSalt = await findCollectionSalt(args);
-  return args.web3Lib.sendTransaction({
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeCreateSellerAndOffer(
       args.sellerToCreate,
       collectionSalt,
       args.offerToCreate
     )
-  });
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// createOfferWithCondition overloads
 export async function createOfferWithCondition(args: {
   offerToCreate: CreateOfferArgs;
   contractAddress: string;
@@ -77,7 +107,28 @@ export async function createOfferWithCondition(args: {
   metadataStorage?: MetadataStorage;
   theGraphStorage?: MetadataStorage;
   condition: ConditionStruct;
-}): Promise<TransactionResponse> {
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+export async function createOfferWithCondition(args: {
+  offerToCreate: CreateOfferArgs;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function createOfferWithCondition(args: {
+  offerToCreate: CreateOfferArgs;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
     abortEarly: false
   });
@@ -93,12 +144,19 @@ export async function createOfferWithCondition(args: {
     createOffersArgs: [args.offerToCreate]
   });
 
-  return args.web3Lib.sendTransaction({
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeCreateOfferWithCondition(args.offerToCreate, args.condition)
-  });
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// createSellerAndOfferWithCondition overloads
 export async function createSellerAndOfferWithCondition(args: {
   sellerToCreate: CreateSellerArgs;
   offerToCreate: CreateOfferArgs;
@@ -107,7 +165,30 @@ export async function createSellerAndOfferWithCondition(args: {
   metadataStorage?: MetadataStorage;
   theGraphStorage?: MetadataStorage;
   condition: ConditionStruct;
-}): Promise<TransactionResponse> {
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+export async function createSellerAndOfferWithCondition(args: {
+  sellerToCreate: CreateSellerArgs;
+  offerToCreate: CreateOfferArgs;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function createSellerAndOfferWithCondition(args: {
+  sellerToCreate: CreateSellerArgs;
+  offerToCreate: CreateOfferArgs;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
     abortEarly: false
   });
@@ -132,7 +213,7 @@ export async function createSellerAndOfferWithCondition(args: {
   });
 
   const collectionSalt = await findCollectionSalt(args);
-  return args.web3Lib.sendTransaction({
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeCreateSellerAndOfferWithCondition(
       args.sellerToCreate,
@@ -140,9 +221,27 @@ export async function createSellerAndOfferWithCondition(args: {
       args.offerToCreate,
       args.condition
     )
-  });
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// createPremintedOfferAddToGroup overloads
+export async function createPremintedOfferAddToGroup(args: {
+  offerToCreate: CreateOfferArgs;
+  premintParameters: PremintParametersStruct;
+  groupId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
 export async function createPremintedOfferAddToGroup(args: {
   offerToCreate: CreateOfferArgs;
   premintParameters: PremintParametersStruct;
@@ -151,7 +250,19 @@ export async function createPremintedOfferAddToGroup(args: {
   web3Lib: Web3LibAdapter;
   metadataStorage?: MetadataStorage;
   theGraphStorage?: MetadataStorage;
-}): Promise<TransactionResponse> {
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function createPremintedOfferAddToGroup(args: {
+  offerToCreate: CreateOfferArgs;
+  premintParameters: PremintParametersStruct;
+  groupId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
     abortEarly: false
   });
@@ -167,16 +278,45 @@ export async function createPremintedOfferAddToGroup(args: {
     createOffersArgs: [args.offerToCreate]
   });
 
-  return args.web3Lib.sendTransaction({
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeCreatePremintedOfferAddToGroup(
       args.offerToCreate,
       args.premintParameters,
       args.groupId
     )
-  });
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// createPremintedOfferWithCondition overloads
+export async function createPremintedOfferWithCondition(args: {
+  offerToCreate: CreateOfferArgs;
+  premintParameters: PremintParametersStruct;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+export async function createPremintedOfferWithCondition(args: {
+  offerToCreate: CreateOfferArgs;
+  premintParameters: PremintParametersStruct;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
 export async function createPremintedOfferWithCondition(args: {
   offerToCreate: CreateOfferArgs;
   premintParameters: PremintParametersStruct;
@@ -185,7 +325,8 @@ export async function createPremintedOfferWithCondition(args: {
   metadataStorage?: MetadataStorage;
   theGraphStorage?: MetadataStorage;
   condition: ConditionStruct;
-}): Promise<TransactionResponse> {
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
     abortEarly: false
   });
@@ -201,16 +342,23 @@ export async function createPremintedOfferWithCondition(args: {
     createOffersArgs: [args.offerToCreate]
   });
 
-  return args.web3Lib.sendTransaction({
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeCreatePremintedOfferWithCondition(
       args.offerToCreate,
       args.premintParameters,
       args.condition
     )
-  });
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// createSellerAndPremintedOffer overloads
 export async function createSellerAndPremintedOffer(args: {
   sellerToCreate: CreateSellerArgs;
   offerToCreate: CreateOfferArgs;
@@ -219,7 +367,30 @@ export async function createSellerAndPremintedOffer(args: {
   web3Lib: Web3LibAdapter;
   metadataStorage?: MetadataStorage;
   theGraphStorage?: MetadataStorage;
-}): Promise<TransactionResponse> {
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+export async function createSellerAndPremintedOffer(args: {
+  sellerToCreate: CreateSellerArgs;
+  offerToCreate: CreateOfferArgs;
+  premintParameters: PremintParametersStruct;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function createSellerAndPremintedOffer(args: {
+  sellerToCreate: CreateSellerArgs;
+  offerToCreate: CreateOfferArgs;
+  premintParameters: PremintParametersStruct;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
     abortEarly: false
   });
@@ -244,7 +415,7 @@ export async function createSellerAndPremintedOffer(args: {
   });
 
   const collectionSalt = await findCollectionSalt(args);
-  return args.web3Lib.sendTransaction({
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeCreateSellerAndPremintedOffer(
       args.sellerToCreate,
@@ -252,9 +423,16 @@ export async function createSellerAndPremintedOffer(args: {
       args.offerToCreate,
       args.premintParameters
     )
-  });
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// createSellerAndPremintedOfferWithCondition overloads
 export async function createSellerAndPremintedOfferWithCondition(args: {
   sellerToCreate: CreateSellerArgs;
   offerToCreate: CreateOfferArgs;
@@ -264,7 +442,32 @@ export async function createSellerAndPremintedOfferWithCondition(args: {
   metadataStorage?: MetadataStorage;
   theGraphStorage?: MetadataStorage;
   condition: ConditionStruct;
-}): Promise<TransactionResponse> {
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+export async function createSellerAndPremintedOfferWithCondition(args: {
+  sellerToCreate: CreateSellerArgs;
+  offerToCreate: CreateOfferArgs;
+  premintParameters: PremintParametersStruct;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function createSellerAndPremintedOfferWithCondition(args: {
+  sellerToCreate: CreateSellerArgs;
+  offerToCreate: CreateOfferArgs;
+  premintParameters: PremintParametersStruct;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
     abortEarly: false
   });
@@ -289,7 +492,7 @@ export async function createSellerAndPremintedOfferWithCondition(args: {
   });
 
   const collectionSalt = await findCollectionSalt(args);
-  return args.web3Lib.sendTransaction({
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeCreateSellerAndPremintedOfferWithCondition(
       args.sellerToCreate,
@@ -298,18 +501,50 @@ export async function createSellerAndPremintedOfferWithCondition(args: {
       args.premintParameters,
       args.condition
     )
-  });
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }
 
+// raiseAndEscalateDispute overloads
+export async function raiseAndEscalateDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
 export async function raiseAndEscalateDispute(args: {
   exchangeId: BigNumberish;
   contractAddress: string;
   web3Lib: Web3LibAdapter;
   metadataStorage?: MetadataStorage;
   theGraphStorage?: MetadataStorage;
-}): Promise<TransactionResponse> {
-  return args.web3Lib.sendTransaction({
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+export async function raiseAndEscalateDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeRaiseAndEscalateDispute(args.exchangeId)
-  });
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }

package/src/orchestration/mixin.ts

@@ -1,11 +1,17 @@
-import { ConditionStruct, TransactionResponse } from "@bosonprotocol/common";
+import {
+  ConditionStruct,
+  TransactionResponse,
+  Web3LibAdapter
+} from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
 import { handler } from ".";
 import { offers, accounts } from "..";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import { PremintParametersStruct } from "@bosonprotocol/common/src";
 
-export class OrchestrationMixin extends BaseCoreSDK {
+export class OrchestrationMixin<
+  T extends Web3LibAdapter
+> extends BaseCoreSDK<T> {
   /**
    * Creates an offer with a specific conditions
    * @param offerToCreate - Offer arguments.

package/src/price-discovery/handler.ts

@@ -1,7 +1,8 @@
 import {
   Web3LibAdapter,
   PriceDiscoveryStruct,
-  TransactionResponse
+  TransactionResponse,
+  TransactionRequest
 } from "@bosonprotocol/common";
 import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
 import * as exchanges from "../exchanges/handler";
@@ -9,6 +10,7 @@ import { getOfferById } from "../offers/subgraph";
 import { AddressZero } from "@ethersproject/constants";
 import { encodeCommitToPriceDiscoveryOffer } from "./interface";
 
+// Overload: returnTxInfo is true → returns TransactionRequest
 export async function commitToPriceDiscoveryOffer(args: {
   contractAddress: string;
   subgraphUrl: string;
@@ -16,7 +18,30 @@ export async function commitToPriceDiscoveryOffer(args: {
   buyer: string;
   tokenIdOrOfferId: BigNumberish;
   priceDiscovery: PriceDiscoveryStruct;
-}): Promise<TransactionResponse> {
+  returnTxInfo: true;
+}): Promise<TransactionRequest>;
+
+// Overload: returnTxInfo is false or undefined → returns TransactionResponse
+export async function commitToPriceDiscoveryOffer(args: {
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  buyer: string;
+  tokenIdOrOfferId: BigNumberish;
+  priceDiscovery: PriceDiscoveryStruct;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+// Implementation
+export async function commitToPriceDiscoveryOffer(args: {
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  buyer: string;
+  tokenIdOrOfferId: BigNumberish;
+  priceDiscovery: PriceDiscoveryStruct;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
   let { offerId } = exchanges.parseTokenId(args.tokenIdOrOfferId);
   if (offerId.eq(0)) {
     offerId = BigNumber.from(args.tokenIdOrOfferId);
@@ -25,7 +50,7 @@ export async function commitToPriceDiscoveryOffer(args: {
 
   // TODO: do we need to check allowance?
 
-  return args.web3Lib.sendTransaction({
+  const transactionRequest = {
     to: args.contractAddress,
     data: encodeCommitToPriceDiscoveryOffer(
       args.buyer,
@@ -33,5 +58,11 @@ export async function commitToPriceDiscoveryOffer(args: {
       args.priceDiscovery
     ),
     value: offer.exchangeToken.address === AddressZero ? offer.price : "0"
-  });
+  } satisfies TransactionRequest;
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }

package/src/price-discovery/mixin.ts

@@ -1,30 +1,81 @@
 import {
   TransactionResponse,
-  PriceDiscoveryStruct
+  TransactionRequest,
+  PriceDiscoveryStruct,
+  Web3LibAdapter
 } from "@bosonprotocol/common";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import { commitToPriceDiscoveryOffer } from "./handler";
 import { BigNumberish } from "@ethersproject/bignumber";
 
-export class PriceDiscoveryMixin extends BaseCoreSDK {
+export class PriceDiscoveryMixin<
+  T extends Web3LibAdapter
+> extends BaseCoreSDK<T> {
   /**
    * Commits to a price discovery offer (first step of an exchange)
-   * @param groupToCreate -  group with the contract condition
+   * This transaction only succeeds if there is an existing buyer account for connected signer.
+   * @param buyer - Buyer address.
+   * @param tokenIdOrOfferId - Token ID or Offer ID.
+   * @param priceDiscovery - Price discovery struct.
    * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
+  // Overload: returnTxInfo is true → returns TransactionRequest
   public async commitToPriceDiscoveryOffer(
     buyer: string,
     tokenIdOrOfferId: BigNumberish,
-    priceDiscovery: PriceDiscoveryStruct
-  ): Promise<TransactionResponse> {
-    return commitToPriceDiscoveryOffer({
+    priceDiscovery: PriceDiscoveryStruct,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async commitToPriceDiscoveryOffer(
+    buyer: string,
+    tokenIdOrOfferId: BigNumberish,
+    priceDiscovery: PriceDiscoveryStruct,
+    overrides?: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async commitToPriceDiscoveryOffer(
+    buyer: string,
+    tokenIdOrOfferId: BigNumberish,
+    priceDiscovery: PriceDiscoveryStruct,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
+    }> = {}
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+
+    const commitArgs = {
       buyer,
       tokenIdOrOfferId,
       priceDiscovery,
       web3Lib: this._web3Lib,
-      subgraphUrl: this._subgraphUrl,
-      contractAddress: this._protocolDiamond
-    });
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      subgraphUrl: this._subgraphUrl
+    } as const satisfies Parameters<typeof commitToPriceDiscoveryOffer>[0];
+
+    if (returnTxInfo === true) {
+      return commitToPriceDiscoveryOffer({
+        ...commitArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return commitToPriceDiscoveryOffer({
+        ...commitArgs,
+        returnTxInfo: false
+      });
+    }
   }
 }

package/src/protocol-config/handler.ts

@@ -4,13 +4,35 @@ import {
   decodeGetMaxRoyaltyPercentage
 } from "./interface";
 
+// Overload: returnTxInfo is true → returns call request
 export async function getMaxRoyaltyPercentage(args: {
   contractAddress: string;
   web3Lib: Web3LibAdapter;
-}): Promise<number> {
-  const result = await args.web3Lib.call({
+  returnTxInfo: true;
+}): Promise<{ to: string; data: string }>;
+
+// Overload: returnTxInfo is false or undefined → returns number
+export async function getMaxRoyaltyPercentage(args: {
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<number>;
+
+// Implementation
+export async function getMaxRoyaltyPercentage(args: {
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: boolean;
+}): Promise<number | { to: string; data: string }> {
+  const callRequest = {
     to: args.contractAddress,
     data: encodeGetMaxRoyaltyPercentage()
-  });
-  return decodeGetMaxRoyaltyPercentage(result);
+  };
+
+  if (args.returnTxInfo) {
+    return callRequest;
+  } else {
+    const result = await args.web3Lib.call(callRequest);
+    return decodeGetMaxRoyaltyPercentage(result);
+  }
 }

package/src/protocol-config/mixin.ts

@@ -1,7 +1,10 @@
 import { BaseCoreSDK } from "../mixins/base-core-sdk";
 import { handler } from ".";
+import { Web3LibAdapter } from "@bosonprotocol/common";
 
-export class ProtocolConfigMixin extends BaseCoreSDK {
+export class ProtocolConfigMixin<
+  T extends Web3LibAdapter
+> extends BaseCoreSDK<T> {
   public async getMaxRoyaltyPercentage(
     overrides: Partial<{
       contractAddress: string;