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

package/src/funds/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 { AddressZero } from "@ethersproject/constants";
 import {
@@ -10,90 +14,224 @@ import {
 } from "./handler";
 import { getFundsById, getFunds } from "./subgraph";
 
-export class FundsMixin extends BaseCoreSDK {
+export class FundsMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
   /*                            Funds related methods                           */
   /* -------------------------------------------------------------------------- */
 
   /**
    * Deposit funds by calling the `FundsHandlerFacet` contract.
+   * This transaction only succeeds if there is an existing seller account for connected signer.
    * @param sellerId - ID of seller account to deposit funds for.
    * @param fundsAmount - Amount of funds.
    * @param fundsTokenAddress - Address of funds token.
+   * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async depositFunds(
+    sellerId: BigNumberish,
+    fundsAmount: BigNumberish,
+    fundsTokenAddress: string,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
   public async depositFunds(
     sellerId: BigNumberish,
     fundsAmount: BigNumberish,
-    fundsTokenAddress: string = AddressZero
-  ): Promise<TransactionResponse> {
-    return depositFunds({
+    fundsTokenAddress?: string,
+    overrides?: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async depositFunds(
+    sellerId: BigNumberish,
+    fundsAmount: BigNumberish,
+    fundsTokenAddress: string = AddressZero,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
+    }> = {}
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+
+    const depositArgs = {
       sellerId,
       fundsAmount,
       fundsTokenAddress,
-      contractAddress: this._protocolDiamond,
-      web3Lib: this._web3Lib
-    });
-  }
+      web3Lib: this._web3Lib,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    } as const satisfies Parameters<typeof depositFunds>[0];
 
-  /**
-   * Returns funds entity from subgraph.
-   * @param fundsId - ID of funds entity.
-   * @param queryVars - Optional query variables to skip, order or filter.
-   * @returns Funds entity from subgraph.
-   */
-  public async getFundsById(
-    fundsId: BigNumberish,
-    queryVars?: subgraph.GetFundsByIdQueryVariables
-  ): Promise<subgraph.FundsEntityFieldsFragment> {
-    return getFundsById(this._subgraphUrl, fundsId, queryVars);
-  }
-
-  /**
-   * Returns funds entities from subgraph.
-   * @param queryVars - Optional query variables to skip, order or filter.
-   * @returns Funds entities from subgraph.
-   */
-  public async getFunds(
-    queryVars?: subgraph.GetFundsQueryVariables
-  ): Promise<subgraph.FundsEntityFieldsFragment[]> {
-    return getFunds(this._subgraphUrl, queryVars);
+    if (returnTxInfo === true) {
+      return depositFunds({
+        ...depositArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return depositFunds({
+        ...depositArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
    * Withdraw selected funds by calling the `FundsHandlerFacet` contract.
+   * This transaction only succeeds if there is an existing account for connected signer.
    * @param entityId - ID of seller/buyer/agent account to withdraw funds for.
    * @param tokensToWithdraw - Addresses of funds tokens to withdraw.
    * @param amountsToWithdraw - Amounts of funds token to withdraw.
+   * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async withdrawFunds(
+    entityId: BigNumberish,
+    tokensToWithdraw: Array<string>,
+    amountsToWithdraw: Array<BigNumberish>,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
   public async withdrawFunds(
     entityId: BigNumberish,
     tokensToWithdraw: Array<string>,
-    amountsToWithdraw: Array<BigNumberish>
-  ): Promise<TransactionResponse> {
-    return withdrawFunds({
+    amountsToWithdraw: Array<BigNumberish>,
+    overrides?: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async withdrawFunds(
+    entityId: BigNumberish,
+    tokensToWithdraw: Array<string>,
+    amountsToWithdraw: Array<BigNumberish>,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
+    }> = {}
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+
+    const withdrawArgs = {
       entityId,
       tokensToWithdraw,
       amountsToWithdraw,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof withdrawFunds>[0];
+
+    if (returnTxInfo === true) {
+      return withdrawFunds({
+        ...withdrawArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return withdrawFunds({
+        ...withdrawArgs,
+        returnTxInfo: false
+      });
+    }
   }
 
   /**
    * Withdraw all available funds by calling the `FundsHandlerFacet` contract.
+   * This transaction only succeeds if there is an existing account for connected signer.
    * @param entityId - ID of seller/buyer/agent account to withdraw funds for.
+   * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
+  // Overload: returnTxInfo is true → returns TransactionRequest
+  public async withdrawAllAvailableFunds(
+    entityId: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async withdrawAllAvailableFunds(
+    entityId: BigNumberish,
+    overrides?: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
   public async withdrawAllAvailableFunds(
-    entityId: BigNumberish
-  ): Promise<TransactionResponse> {
-    return withdrawAllAvailableFunds({
+    entityId: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
+    }> = {}
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+
+    const withdrawAllArgs = {
       entityId,
       subgraphUrl: this._subgraphUrl,
       contractAddress: this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof withdrawAllAvailableFunds>[0];
+
+    if (returnTxInfo === true) {
+      return withdrawAllAvailableFunds({
+        ...withdrawAllArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return withdrawAllAvailableFunds({
+        ...withdrawAllArgs,
+        returnTxInfo: false
+      });
+    }
+  }
+
+  /**
+   * Returns funds entity from subgraph.
+   * @param fundsId - ID of funds entity.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Funds entity from subgraph.
+   */
+  public async getFundsById(
+    fundsId: BigNumberish,
+    queryVars?: subgraph.GetFundsByIdQueryVariables
+  ): Promise<subgraph.FundsEntityFieldsFragment> {
+    return getFundsById(this._subgraphUrl, fundsId, queryVars);
+  }
+
+  /**
+   * Returns funds entities from subgraph.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Funds entities from subgraph.
+   */
+  public async getFunds(
+    queryVars?: subgraph.GetFundsQueryVariables
+  ): Promise<subgraph.FundsEntityFieldsFragment[]> {
+    return getFunds(this._subgraphUrl, queryVars);
   }
 }

package/src/groups/handler.ts

@@ -1,17 +1,42 @@
 import {
   TransactionResponse,
+  TransactionRequest,
   CreateGroupArgs,
   Web3LibAdapter
 } from "@bosonprotocol/common";
 import { encodeCreateGroup } from "./interface";
 
+// Overload: returnTxInfo is true -> returns TransactionRequest
 export async function createGroup(args: {
   groupToCreate: CreateGroupArgs;
   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 createGroup(args: {
+  groupToCreate: CreateGroupArgs;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: false | undefined;
+}): Promise<TransactionResponse>;
+
+// Implementation
+export async function createGroup(args: {
+  groupToCreate: CreateGroupArgs;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  returnTxInfo?: boolean;
+}): Promise<TransactionRequest | TransactionResponse> {
+  const transactionRequest: TransactionRequest = {
     to: args.contractAddress,
     data: encodeCreateGroup(args.groupToCreate)
-  });
+  };
+
+  if (args.returnTxInfo) {
+    return transactionRequest;
+  } else {
+    return args.web3Lib.sendTransaction(transactionRequest);
+  }
 }

package/src/groups/mixin.ts

@@ -1,24 +1,67 @@
-import { CreateGroupArgs, TransactionResponse } from "@bosonprotocol/common";
+import {
+  CreateGroupArgs,
+  TransactionResponse,
+  TransactionRequest,
+  Web3LibAdapter
+} from "@bosonprotocol/common";
 import { handler } from ".";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 
-export class GroupsMixin extends BaseCoreSDK {
+export class GroupsMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /**
-   * Creates a group of contract addresses
-   * @param groupToCreate -  group with the contract condition
+   * Creates a group of contract addresses by calling the contract.
+   * This transaction only succeeds if there is an existing account for connected signer.
+   * @param groupToCreate - Group with the contract condition.
    * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
+  // Overload: returnTxInfo is true → returns TransactionRequest
   public async createGroup(
     groupToCreate: CreateGroupArgs,
     overrides: Partial<{
       contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo: true;
+    }>
+  ): Promise<TransactionRequest>;
+
+  // Overload: returnTxInfo is false or undefined → returns TransactionResponse
+  public async createGroup(
+    groupToCreate: CreateGroupArgs,
+    overrides?: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: false | undefined;
+    }>
+  ): Promise<TransactionResponse>;
+
+  // Implementation
+  public async createGroup(
+    groupToCreate: CreateGroupArgs,
+    overrides: Partial<{
+      contractAddress: string;
+      txRequest: TransactionRequest;
+      returnTxInfo?: boolean;
     }> = {}
-  ): Promise<TransactionResponse> {
-    return handler.createGroup({
+  ): Promise<TransactionResponse | TransactionRequest> {
+    const { returnTxInfo } = overrides;
+
+    const groupArgs = {
       groupToCreate,
       contractAddress: overrides.contractAddress || this._protocolDiamond,
       web3Lib: this._web3Lib
-    });
+    } as const satisfies Parameters<typeof handler.createGroup>[0];
+
+    if (returnTxInfo === true) {
+      return handler.createGroup({
+        ...groupArgs,
+        returnTxInfo: true
+      });
+    } else {
+      return handler.createGroup({
+        ...groupArgs,
+        returnTxInfo: false
+      });
+    }
   }
 }

package/src/index.ts

@@ -20,6 +20,7 @@ export {
   envConfigs,
   getEnvConfigs,
   getEnvConfigById,
+  getConfigFromConfigId,
   EnvironmentType,
   ConfigId,
   MetaTxConfig,

package/src/marketplaces/mixin.ts

@@ -1,3 +1,4 @@
+import { Web3LibAdapter } from "@bosonprotocol/common";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import { OpenSeaMarketplace, OpenSeaSDKHandler } from "./opensea";
 import { MarketplaceType, MarketplaceHandler } from "./types";
@@ -6,7 +7,7 @@ type MarketplaceTypeToClass = {
   [MarketplaceType.OPENSEA]: OpenSeaMarketplace;
 };
 
-export class MarketplaceMixin extends BaseCoreSDK {
+export class MarketplaceMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   public marketplace<T extends keyof MarketplaceTypeToClass>(
     type: T,
     handler: T extends MarketplaceType.OPENSEA

package/src/meta-tx/handler.ts

@@ -118,7 +118,8 @@ export async function signMetaTx(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTransaction",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -179,7 +180,8 @@ export async function signVoucherMetaTx(
       version: "0.0.1",
       chainId,
       salt: undefined
-    }
+    },
+    returnTypedDataToSign: false
   });
 
   return {
@@ -286,7 +288,8 @@ export async function signBiconomyVoucherMetaTx(
       ...biconomyForwarderDomainData
       // chainId
       // salt: undefined
-    }
+    },
+    returnTypedDataToSign: false
   });
   const signature = signatureParams.signature;
   const getDomainSeparator = async () => {
@@ -379,7 +382,8 @@ export async function relayBiconomyMetaTransaction(args: {
         transactionHash: txHash,
         logs: txReceipt?.logs || [],
         effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice),
-        blockNumber: txReceipt.blockNumber
+        blockNumber: txReceipt.blockNumber,
+        gasUsed: txReceipt.gasUsed
       };
     },
     hash: relayTxResponse.txHash
@@ -860,7 +864,8 @@ export async function signMetaTxCommitToOffer(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTxCommitToOffer",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -919,7 +924,8 @@ export async function signMetaTxCommitToConditionalOffer(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTxCommitToConditionalOffer",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -1042,7 +1048,8 @@ export async function signMetaTxResolveDispute(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTxDisputeResolution",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -1123,7 +1130,8 @@ export async function signMetaTxWithdrawFunds(
     verifyingContractAddress: args.metaTxHandlerAddress,
     customSignatureType,
     primaryType: "MetaTxFund",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -1212,7 +1220,8 @@ function makeExchangeMetaTxSigner(
       verifyingContractAddress: args.metaTxHandlerAddress,
       customSignatureType,
       primaryType: "MetaTxExchange",
-      message
+      message,
+      returnTypedDataToSign: false
     });
 
     return {
@@ -1281,7 +1290,8 @@ export async function relayMetaTransaction(args: {
         transactionHash: txHash,
         logs: txReceipt?.logs || [],
         effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice),
-        blockNumber: txReceipt?.blockNumber
+        blockNumber: txReceipt?.blockNumber,
+        gasUsed: txReceipt.gasUsed
       };
     },
     hash: relayTxResponse.txHash

package/src/meta-tx/mixin.ts

@@ -1,7 +1,8 @@
 import {
   AuthTokenType,
   MetaTxConfig,
-  TransactionResponse
+  TransactionResponse,
+  Web3LibAdapter
 } from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
 import { BytesLike } from "@ethersproject/bytes";
@@ -12,7 +13,7 @@ import { GetRetriedHashesData } from "./biconomy";
 import { accounts } from "..";
 import { AccountsMixin } from "../accounts/mixin";
 import { SellerFieldsFragment } from "../subgraph";
-export class MetaTxMixin extends BaseCoreSDK {
+export class MetaTxMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
   /*                           Meta Tx related methods                          */
   /* -------------------------------------------------------------------------- */
@@ -329,7 +330,9 @@ export class MetaTxMixin extends BaseCoreSDK {
       | "batchId"
       | "forwarderAbi"
       | "relayerUrl"
-    >,
+    > & {
+      bosonVoucherAddress?: string;
+    },
     overrides: Partial<{
       batchId?: BigNumberish;
       txGas?: number;
@@ -346,7 +349,8 @@ export class MetaTxMixin extends BaseCoreSDK {
     return handler.signMetaTxSetApprovalForAllToContract(
       {
         web3Lib: this._web3Lib,
-        bosonVoucherAddress: seller.voucherCloneAddress,
+        bosonVoucherAddress:
+          args.bosonVoucherAddress || seller.voucherCloneAddress,
         chainId: this._chainId,
         forwarderAddress,
         batchId,

package/src/metadata/mixin.ts

@@ -11,8 +11,9 @@ import {
   getAllProductsWithNotVoidedVariants,
   getBundleMetadataEntities
 } from "./subgraph";
+import { Web3LibAdapter } from "@bosonprotocol/common";
 
-export class MetadataMixin extends BaseCoreSDK {
+export class MetadataMixin<T extends Web3LibAdapter> extends BaseCoreSDK<T> {
   /* -------------------------------------------------------------------------- */
   /*                          Metadata related methods                          */
   /* -------------------------------------------------------------------------- */

package/src/mixins/base-core-sdk.ts

@@ -9,8 +9,8 @@ import {
 import { TokenInfoManager } from "../utils/tokenInfoManager";
 import { Biconomy } from "../meta-tx/biconomy";
 
-export class BaseCoreSDK {
-  protected _web3Lib: Web3LibAdapter;
+export class BaseCoreSDK<T extends Web3LibAdapter = Web3LibAdapter> {
+  protected _web3Lib: T;
   protected _metadataStorage?: MetadataStorage;
   protected _theGraphStorage?: MetadataStorage;
 
@@ -35,7 +35,7 @@ export class BaseCoreSDK {
    * @param args - Constructor args
    */
   constructor(opts: {
-    web3Lib: Web3LibAdapter;
+    web3Lib: T;
     subgraphUrl: string;
     protocolDiamond: string;
     metadataStorage?: MetadataStorage;
@@ -118,8 +118,8 @@ export class BaseCoreSDK {
 
 // Doc: https://www.typescriptlang.org/docs/handbook/mixins.html#alternative-pattern
 export function applyMixins(
-  derivedCtor: typeof BaseCoreSDK,
-  constructors: (typeof BaseCoreSDK)[]
+  derivedCtor: typeof BaseCoreSDK<Web3LibAdapter>,
+  constructors: (typeof BaseCoreSDK<Web3LibAdapter>)[]
 ) {
   constructors.forEach((baseCtor) => {
     Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {

package/src/native-meta-tx/handler.ts

@@ -86,7 +86,8 @@ export async function signNativeMetaTx(
     customSignatureType,
     customDomainData: args.domain,
     primaryType: "MetaTransaction",
-    message
+    message,
+    returnTypedDataToSign: false
   });
 
   return {
@@ -184,7 +185,8 @@ export async function relayNativeMetaTransaction(args: {
         transactionHash: txHash,
         logs: txReceipt?.logs || [],
         effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice),
-        blockNumber: txReceipt.blockNumber
+        blockNumber: txReceipt.blockNumber,
+        gasUsed: txReceipt.gasUsed
       };
     },
     hash: relayTxResponse.txHash

package/src/native-meta-tx/mixin.ts

@@ -1,10 +1,16 @@
-import { MetaTxConfig, TransactionResponse } from "@bosonprotocol/common";
+import {
+  MetaTxConfig,
+  TransactionResponse,
+  Web3LibAdapter
+} from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
 import { BytesLike } from "@ethersproject/bytes";
 import { handler } from ".";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 
-export class NativeMetaTxMixin extends BaseCoreSDK {
+export class NativeMetaTxMixin<
+  T extends Web3LibAdapter
+> extends BaseCoreSDK<T> {
   /**
    * Encodes and signs a native "token.approve()" meta transaction that can be relayed.
    * @param exchangeToken - The address of the token contract.