@bosonprotocol/core-sdk 1.23.0-alpha.2 → 1.23.0-alpha.21

package/dist/esm/core-sdk.js

@@ -1,45 +1,17 @@
-import { TokenInfoManager } from "./utils/tokenInfoManager";
-import { getDefaultConfig, AuthTokenType } from "@bosonprotocol/common";
-import { BigNumber } from "@ethersproject/bignumber";
-import { AddressZero } from "@ethersproject/constants";
-import * as accounts from "./accounts";
-import * as disputes from "./disputes";
-import * as exchanges from "./exchanges";
-import * as offers from "./offers";
-import * as orchestration from "./orchestration";
-import * as groups from "./groups";
-import * as erc20 from "./erc20";
-import * as erc721 from "./erc721";
-import * as funds from "./funds";
-import * as metaTx from "./meta-tx";
-import * as nativeMetaTx from "./native-meta-tx";
-import * as metadata from "./metadata";
-import * as eventLogs from "./event-logs";
-import { getValueFromLogs, getValuesFromLogs } from "./utils/logs";
-export class CoreSDK {
-    _web3Lib;
-    _metadataStorage;
-    _theGraphStorage;
-    _subgraphUrl;
-    _protocolDiamond;
-    _chainId;
-    _tokenInfoManager;
-    _metaTxConfig;
-    _lensContracts;
-    /**
-     * Creates an instance of `CoreSDK`
-     * @param args - Constructor args
-     */
-    constructor(opts) {
-        this._web3Lib = opts.web3Lib;
-        this._subgraphUrl = opts.subgraphUrl;
-        this._protocolDiamond = opts.protocolDiamond;
-        this._metadataStorage = opts.metadataStorage;
-        this._theGraphStorage = opts.theGraphStorage;
-        this._chainId = opts.chainId;
-        this._metaTxConfig = opts.metaTx;
-        this._lensContracts = opts.lensContracts;
-    }
+import { OrchestrationMixin } from "./orchestration/mixin";
+import { GroupsMixin } from "./groups/mixin";
+import { NativeMetaTxMixin } from "./native-meta-tx/mixin";
+import { MetaTxMixin } from "./meta-tx/mixin";
+import { DisputesMixin } from "./disputes/mixin";
+import { applyMixins, BaseCoreSDK } from "./mixins/base-core-sdk";
+import { getDefaultConfig } from "@bosonprotocol/common";
+import { MetadataMixin } from "./metadata/mixin";
+import { AccountsMixin } from "./accounts/mixin";
+import { OfferMixin } from "./offers/mixin";
+import { FundsMixin } from "./funds/mixin";
+import { ExchangesMixin } from "./exchanges/mixin";
+import { EventLogsMixin } from "./event-logs/mixin";
+export class CoreSDK extends BaseCoreSDK {
     /**
      * Creates an instance of `CoreSDK` by using default values derived either from
      * `args.envName` or `args.chainId`.
@@ -88,1446 +60,18 @@ export class CoreSDK {
             !!this._metaTxConfig.apiKey &&
             !!this._metaTxConfig.relayerUrl);
     }
-    /* -------------------------------------------------------------------------- */
-    /*                          Metadata related methods                          */
-    /* -------------------------------------------------------------------------- */
-    /**
-     * Stores supported offer metadata via the MetadataStorage instance which was passed in
-     * at construction.
-     * @param metadata - Offer metadata of type `BASE` or `PRODUCT_V1`.
-     * @returns Metadata hash / identifier.
-     */
-    async storeMetadata(metadata) {
-        if (!this._metadataStorage) {
-            throw new Error("No metadata storage set");
-        }
-        return this._metadataStorage.storeMetadata(metadata);
-    }
-    /**
-     * Returns supported offer metadata from passed in `MetadataStorage` instance.
-     * @param metadataHashOrUri - Metadata hash or uri that can be handled by the
-     * storage instance.
-     * @returns Offer metadata.
-     */
-    async getMetadata(metadataHashOrUri) {
-        if (!this._metadataStorage) {
-            throw new Error("No metadata storage set");
-        }
-        return this._metadataStorage.getMetadata(metadataHashOrUri);
-    }
-    /**
-     * Returns `BASE` type offer metadata entities from subgraph.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns BaseMetadataEntities from subgraph.
-     */
-    async getBaseMetadataEntities(queryVars) {
-        return metadata.subgraph.getBaseMetadataEntities(this._subgraphUrl, queryVars);
-    }
-    /**
-     * Returns `PRODUCT_V1` type offer metadata entities from subgraph.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns ProductV1MetadataEntities from subgraph.
-     */
-    async getProductV1MetadataEntities(queryVars) {
-        return metadata.subgraph.getProductV1MetadataEntities(this._subgraphUrl, queryVars);
-    }
-    async getProductV1Products(queryVars) {
-        return metadata.subgraph.getProductV1Products(this._subgraphUrl, queryVars);
-    }
-    async getProductWithVariants(productUuid) {
-        return metadata.subgraph.getProductWithVariants(this._subgraphUrl, productUuid);
-    }
-    /* -------------------------------------------------------------------------- */
-    /*                           Account related methods                          */
-    /* -------------------------------------------------------------------------- */
-    /* --------------------------------- Seller --------------------------------- */
-    /**
-     * Returns seller entity from subgraph.
-     * @param sellerId - ID of seller entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Seller entity from subgraph.
-     */
-    async getSellerById(sellerId, queryVars) {
-        return accounts.subgraph.getSellerById(this._subgraphUrl, sellerId, queryVars);
-    }
-    /**
-     * Returns seller entity from subgraph.
-     * @param operator - Operator address of seller entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Seller entity from subgraph.
-     */
-    async getSellerByOperator(operator, queryVars) {
-        return accounts.subgraph.getSellerByOperator(this._subgraphUrl, operator, queryVars);
-    }
-    /**
-     * Returns seller entity from subgraph.
-     * @param clerk - Clerk address of seller entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Seller entity from subgraph.
-     */
-    async getSellerByClerk(clerk, queryVars) {
-        return accounts.subgraph.getSellerByClerk(this._subgraphUrl, clerk, queryVars);
-    }
-    /**
-     * Returns seller entity from subgraph.
-     * @param admin - Admin address of seller entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Seller entity from subgraph.
-     */
-    async getSellerByAdmin(admin, queryVars) {
-        return accounts.subgraph.getSellerByAdmin(this._subgraphUrl, admin, queryVars);
-    }
-    /**
-     * Returns seller entity from subgraph.
-     * @param treasury - Treasury address of seller entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Seller entity from subgraph.
-     */
-    async getSellerByTreasury(treasury, queryVars) {
-        return accounts.subgraph.getSellerByTreasury(this._subgraphUrl, treasury, queryVars);
-    }
-    /**
-     * Returns seller entity from subgraph. Matches `operator`, `clerk`, `admin` or `treasury`.
-     * @param address - Address of seller entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Seller entity from subgraph.
-     */
-    async getSellersByAddress(address, queryVars) {
-        if (address === AddressZero) {
-            throw new Error(`Unsupported search address '${AddressZero}'`);
-        }
-        const seller = await accounts.subgraph.getSellerByAddress(this._subgraphUrl, address, queryVars);
-        if (!seller && this._lensContracts?.LENS_HUB_CONTRACT) {
-            // If seller is not found per address, try to find per authToken
-            const tokenType = AuthTokenType.LENS; // only LENS for now
-            const tokenIds = await this.fetchUserAuthTokens(address, tokenType);
-            const promises = [];
-            for (const tokenId of tokenIds) {
-                // Just in case the user owns several auth tokens
-                const sellerPromise = this.getSellerByAuthToken(tokenId, tokenType, queryVars);
-                promises.push(sellerPromise);
-            }
-            return (await Promise.all(promises)).filter((seller) => !!seller);
-        }
-        return [seller].filter((seller) => !!seller);
-    }
-    /**
-     * Returns the array of LENS tokenIds owned by a specified address
-     * @param address - Address of seller entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Array of tokenIds
-     */
-    async fetchUserAuthTokens(address, tokenType) {
-        if (tokenType !== AuthTokenType.LENS) {
-            // only LENS for now
-            throw new Error(`Unsupported authTokenType '${tokenType}'`);
-        }
-        if (!this._lensContracts || !this._lensContracts?.LENS_HUB_CONTRACT) {
-            throw new Error("LENS contract is not configured in Core-SDK");
-        }
-        const balance = await erc721.handler.balanceOf({
-            contractAddress: this._lensContracts?.LENS_HUB_CONTRACT,
-            owner: address,
-            web3Lib: this._web3Lib
-        });
-        const balanceBN = BigNumber.from(balance);
-        const promises = [];
-        for (let index = 0; balanceBN.gt(index); index++) {
-            const tokenIdPromise = erc721.handler.tokenOfOwnerByIndex({
-                contractAddress: this._lensContracts?.LENS_HUB_CONTRACT,
-                owner: address,
-                index,
-                web3Lib: this._web3Lib
-            });
-            promises.push(tokenIdPromise);
-        }
-        const ret = await Promise.all(promises);
-        return ret;
-    }
-    /**
-     * Returns seller entity from subgraph that owns the given auth token (if any).
-     * @param tokenId - tokenId of the Auth Token.
-     * @param tokenType - Type of the Auth Token (1 for LENS, ...).
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Seller entity from subgraph.
-     */
-    async getSellerByAuthToken(tokenId, tokenType, queryVars) {
-        if (tokenType !== AuthTokenType.LENS) {
-            // only LENS for now
-            throw new Error(`Unsupported authTokenType '${tokenType}'`);
-        }
-        return accounts.subgraph.getSellerByAuthToken(this._subgraphUrl, tokenId, tokenType, queryVars);
-    }
-    /**
-     * Returns seller entities from subgraph.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Seller entities from subgraph.
-     */
-    async getSellers(queryVars) {
-        return accounts.subgraph.getSellers(this._subgraphUrl, queryVars);
-    }
-    /**
-     * Creates seller account by calling the `AccountHandlerFacet` contract.
-     * @param sellerToCreate - Addresses and contract URI to set in the seller account.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async createSeller(sellerToCreate, overrides = {}) {
-        return accounts.handler.createSeller({
-            sellerToCreate,
-            web3Lib: this._web3Lib,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /**
-     * Creates seller account and offer by calling the `OrchestrationHandlerFacet` contract.
-     * This transaction only succeeds if there is no existing seller account for the connected signer.
-     * @param sellerToCreate - Addresses to set in the seller account.
-     * @param offerToCreate - Offer arguments.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async createSellerAndOffer(sellerToCreate, offerToCreate, overrides = {}) {
-        return orchestration.handler.createOfferAndSeller({
-            sellerToCreate,
-            offerToCreate,
-            web3Lib: this._web3Lib,
-            theGraphStorage: this._theGraphStorage,
-            metadataStorage: this._metadataStorage,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /**
-     * Updates seller account by calling the `AccountHandlerFacet` contract. Only callable
-     * by admin.
-     * @param sellerUpdates - Values to update.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async updateSeller(sellerUpdates, overrides = {}) {
-        return accounts.handler.updateSeller({
-            sellerUpdates,
-            web3Lib: this._web3Lib,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /* ---------------------------------- Buyer --------------------------------- */
-    /**
-     * Returns buyer entity from subgraph.
-     * @param buyerId - ID of buyer entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Buyer entity from subgraph.
-     */
-    async getBuyerById(buyerId, queryVars) {
-        return accounts.subgraph.getBuyerById(this._subgraphUrl, buyerId, queryVars);
-    }
-    /**
-     * Returns buyer entities from subgraph.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Buyer entities from subgraph.
-     */
-    async getBuyers(queryVars) {
-        return accounts.subgraph.getBuyers(this._subgraphUrl, queryVars);
-    }
-    /* ---------------------------- Dispute Resolver ---------------------------- */
-    /**
-     * Creates a dispute resolver account by calling the `AccountHandlerFacet` contract.
-     * @param disputeResolverToCreate - Dispute resolver arguments.
-     * @returns Transaction response.
-     */
-    async createDisputeResolver(disputeResolverToCreate) {
-        return accounts.handler.createDisputeResolver({
-            disputeResolverToCreate,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Utility method to retrieve the created `exchangeId` from logs after calling `commitToOffer`.
-     * @param logs - Logs to search in.
-     * @returns Created exchange id.
-     */
-    getDisputeResolverIdFromLogs(logs) {
-        return getValueFromLogs({
-            iface: accounts.iface.bosonAccountHandlerIface,
-            logs,
-            eventArgsKey: "disputeResolverId",
-            eventName: "DisputeResolverCreated"
-        });
-    }
-    /**
-     * Updates a dispute resolver account by calling the `AccountHandlerFacet` contract.
-     * Note, that the caller must be the specified `admin` address of the dispute resolver account.
-     * @param disputeResolverId - Id of dispute resolver to update.
-     * @param updates - Values to update for the given dispute resolver.
-     * @returns Transaction response.
-     */
-    async updateDisputeResolver(disputeResolverId, updates) {
-        return accounts.handler.updateDisputeResolver({
-            disputeResolverId,
-            updates,
-            subgraphUrl: this._subgraphUrl,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Activates a dispute resolver account by calling the `AccountHandlerFacet` contract.
-     * Note, that the caller needs to have the ADMIN role.
-     * @param disputeResolverId - Id of dispute resolver to activate.
-     * @returns Transaction response.
-     */
-    async activateDisputeResolver(disputeResolverId) {
-        return accounts.handler.activateDisputeResolver({
-            disputeResolverId,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Adds fees to a dispute resolver account by calling the `AccountHandlerFacet`
-     * contract. Note, that the caller must be the specified `admin` address of the dispute
-     * resolver account.
-     * @param disputeResolverId - Id of dispute resolver.
-     * @param fees - Dispute resolution fees. Should only contain token addresses that are
-     * not already specified.
-     * @returns Transaction response.
-     */
-    async addFeesToDisputeResolver(disputeResolverId, fees) {
-        return accounts.handler.addFeesToDisputeResolver({
-            disputeResolverId,
-            fees,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Adds sellers to the allow list of a dispute resolver account by calling the
-     * `AccountHandlerFacet` contract. Note, that the caller must be the specified
-     * `admin` address of the dispute resolver account.
-     * @param disputeResolverId - Id of dispute resolver.
-     * @param sellerAllowList - List of seller ids that are allowed to use the dispute resolver.
-     *  Should only contain seller ids that are not part of the current allow list.
-     * @returns Transaction response.
-     */
-    async addSellersToDisputeResolverAllowList(disputeResolverId, sellerAllowList) {
-        return accounts.handler.addSellersToAllowList({
-            disputeResolverId,
-            sellerAllowList,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Removes fees from a dispute resolver account by calling the `AccountHandlerFacet`
-     * contract. Note, that the caller must be the specified `admin` address of the dispute
-     * resolver account.
-     * @param disputeResolverId - Id of dispute resolver.
-     * @param feeTokenAddresses - Addresses of fee tokens to remove.
-     * @returns Transaction response.
-     */
-    async removeFeesFromDisputeResolver(disputeResolverId, feeTokenAddresses) {
-        return accounts.handler.removeFeesFromDisputeResolver({
-            disputeResolverId,
-            feeTokenAddresses,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Removes sellers from the allow list of a dispute resolver account by calling the
-     * `AccountHandlerFacet` contract. Note, that the caller must be the specified
-     * `admin` address of the dispute resolver account.
-     * @param disputeResolverId - Id of dispute resolver.
-     * @param sellerAllowList - List of seller ids that should be removed from the allow
-     * list of a dispute resolver.
-     * @returns Transaction response.
-     */
-    async removeSellersFromDisputeResolverAllowList(disputeResolverId, sellerAllowList) {
-        return accounts.handler.removeSellersFromAllowList({
-            disputeResolverId,
-            sellerAllowList,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Returns dispute resolver entity from subgraph.
-     * @param disputeResolverId - ID of dispute resolver entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Dispute resolver entity from subgraph.
-     */
-    async getDisputeResolverById(disputeResolverId, queryVars) {
-        return accounts.subgraph.getDisputeResolverById(this._subgraphUrl, disputeResolverId, queryVars);
-    }
-    /**
-     * Returns dispute resolver entities from subgraph.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Dispute resolver entities from subgraph.
-     */
-    async getDisputeResolvers(queryVars) {
-        return accounts.subgraph.getDisputeResolvers(this._subgraphUrl, queryVars);
-    }
-    /* -------------------------------------------------------------------------- */
-    /*                            Offer related methods                           */
-    /* -------------------------------------------------------------------------- */
-    /**
-     * Creates offer by calling the `OfferHandlerFacet` contract.
-     * This transaction only succeeds if there is an existing seller account for connected signer.
-     * @param offerToCreate - Offer arguments.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async createOffer(offerToCreate, overrides = {}) {
-        return offers.handler.createOffer({
-            offerToCreate,
-            web3Lib: this._web3Lib,
-            theGraphStorage: this._theGraphStorage,
-            metadataStorage: this._metadataStorage,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /**
-     * Creates a batch of offers by calling the `OfferHandlerFacet` contract.
-     * This transaction only succeeds if there is an existing seller account for connected signer.
-     * @param offersToCreate - Offer arguments.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async createOfferBatch(offersToCreate, overrides = {}) {
-        return offers.handler.createOfferBatch({
-            offersToCreate,
-            web3Lib: this._web3Lib,
-            theGraphStorage: this._theGraphStorage,
-            metadataStorage: this._metadataStorage,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /**
-     * Utility method to retrieve the created `offerId` from logs after calling `createOffer`
-     * or `createOfferAndSeller`.
-     * @param logs - Logs to search in.
-     * @returns Created offer id.
-     */
-    getCreatedOfferIdFromLogs(logs) {
-        const offerId = getValueFromLogs({
-            iface: offers.iface.bosonOfferHandlerIface,
-            logs,
-            eventArgsKey: "offerId",
-            eventName: "OfferCreated"
-        });
-        return (offerId ||
-            getValueFromLogs({
-                iface: orchestration.iface.bosonOrchestrationHandlerIface,
-                logs,
-                eventArgsKey: "offerId",
-                eventName: "OfferCreated"
-            }));
-    }
-    /**
-     * Utility method to retrieve the created `offerIds` from logs after calling `createOfferBatch`
-     * @param logs - Logs to search in.
-     * @returns Array of created offerIds.
-     */
-    getCreatedOfferIdsFromLogs(logs) {
-        return getValuesFromLogs({
-            iface: offers.iface.bosonOfferHandlerIface,
-            logs,
-            eventArgsKey: "offerId",
-            eventName: "OfferCreated"
-        });
-    }
-    /**
-     * Utility method to retrieve the created `groupIds` from logs after calling `createGroup`
-     * @param logs - Logs to search in.
-     * @returns Array of group Ids.
-     */
-    getCreatedGroupIdsFromLogs(logs) {
-        return getValuesFromLogs({
-            iface: groups.iface.bosonGroupHandlerIface,
-            logs,
-            eventArgsKey: "groupId",
-            eventName: "GroupCreated"
-        });
-    }
-    /**
-     * Utility method to retrieve the created `sellerId` from logs after calling `createSeller`
-     * or `createOfferAndSeller`.
-     * @param logs - Logs to search in.
-     * @returns Created offer id.
-     */
-    getCreatedSellerIdFromLogs(logs) {
-        const sellerId = getValueFromLogs({
-            iface: accounts.iface.bosonAccountHandlerIface,
-            logs,
-            eventArgsKey: "sellerId",
-            eventName: "SellerCreated"
-        });
-        return (sellerId ||
-            getValueFromLogs({
-                iface: orchestration.iface.bosonOrchestrationHandlerIface,
-                logs,
-                eventArgsKey: "sellerId",
-                eventName: "SellerCreated"
-            }));
-    }
-    /**
-     * Voids an existing offer by calling the `OfferHandlerFacet` contract.
-     * This transaction only succeeds if the connected signer is the `operator`.
-     * @param offerId - ID of offer to void.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async voidOffer(offerId, overrides = {}) {
-        return offers.handler.voidOffer({
-            offerId,
-            web3Lib: this._web3Lib,
-            subgraphUrl: this._subgraphUrl,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /**
-     * Voids a batch of existing offers by calling the `OfferHandlerFacet` contract.
-     * This transaction only succeeds if the connected signer is the `operator` of all
-     * provided offers.
-     * @param offerIds - IDs of offers to void.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async voidOfferBatch(offerIds, overrides = {}) {
-        return offers.handler.voidOfferBatch({
-            offerIds,
-            web3Lib: this._web3Lib,
-            subgraphUrl: this._subgraphUrl,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /**
-     * Returns offer from subgraph.
-     * @param offerId - ID of offer.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Offer entity from subgraph.
-     */
-    async getOfferById(offerId, queryVars) {
-        return offers.subgraph.getOfferById(this._subgraphUrl, offerId, queryVars);
-    }
-    /**
-     * Returns offers from subgraph.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Offer entities from subgraph.
-     */
-    async getOffers(queryVars) {
-        return offers.subgraph.getOffers(this._subgraphUrl, queryVars);
-    }
-    /**
-     * Renders contractual agreement for given offer.
-     * @param offerId - Id of offer to render agreement for.
-     * @returns Contractual agreement as string.
-     */
-    async renderContractualAgreementForOffer(offerId) {
-        const offerData = await offers.subgraph.getOfferById(this._subgraphUrl, offerId);
-        return offers.renderContractualAgreementForOffer(offerData);
-    }
-    /**
-     * Renders contractual agreement for given offer.
-     * @param template - Mustache syntax based template.
-     * @param offerData - Offer data.
-     * @returns Contractual agreement as string.
-     */
-    async renderContractualAgreement(template, offerData, offerMetadata) {
-        const tokenInfo = await this.getExchangeTokenInfo(offerData.exchangeToken);
-        return offers.renderContractualAgreement(template, offerData, offerMetadata, tokenInfo);
-    }
-    /* -------------------------------------------------------------------------- */
-    /*                   ERC20 / Exchange Token related methods                   */
-    /* -------------------------------------------------------------------------- */
-    /**
-     * Returns the current allowance of the given token by calling the contract.
-     * @param exchangeToken - Address of exchange token.
-     * @param overrides - Optional overrides.
-     * @returns Allowance for given signer.
-     */
-    async getExchangeTokenAllowance(exchangeToken, overrides = {}) {
-        return erc20.handler.getAllowance({
-            web3Lib: this._web3Lib,
-            contractAddress: exchangeToken,
-            spender: overrides.spender || this._protocolDiamond,
-            owner: overrides.owner || (await this._web3Lib.getSignerAddress())
-        });
-    }
-    /**
-     * Returns `name`, `decimals` and `symbol` of the given token by calling the contract.
-     * @param exchangeToken - Address exchange token.
-     * @returns Decimals, name and symbol.
-     */
-    async getExchangeTokenInfo(exchangeToken) {
-        if (this._tokenInfoManager === undefined) {
-            this._tokenInfoManager = new TokenInfoManager(this._chainId, this._web3Lib);
-        }
-        return this._tokenInfoManager.getExchangeTokenInfo(exchangeToken);
-    }
-    /**
-     * Approves the given amount for the main protocol contract.
-     * @param exchangeToken - Address of token to approve.
-     * @param value - Amount of allowance.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async approveExchangeToken(exchangeToken, value, overrides = {}) {
-        return erc20.handler.approve({
-            contractAddress: exchangeToken,
-            spender: overrides.spender || this._protocolDiamond,
-            value,
-            web3Lib: this._web3Lib
-        });
-    }
-    async getProtocolAllowance(exchangeToken, overrides = {}) {
-        return erc20.handler.getAllowance({
-            contractAddress: exchangeToken,
-            owner: overrides.owner || (await this._web3Lib.getSignerAddress()),
-            spender: overrides.spender || this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /* -------------------------------------------------------------------------- */
-    /*                            Funds related methods                           */
-    /* -------------------------------------------------------------------------- */
-    /**
-     * Deposit funds by calling the `FundsHandlerFacet` contract.
-     * @param sellerId - ID of seller account to deposit funds for.
-     * @param fundsAmount - Amount of funds.
-     * @param fundsTokenAddress - Address of funds token.
-     * @returns Transaction response.
-     */
-    async depositFunds(sellerId, fundsAmount, fundsTokenAddress = AddressZero) {
-        return funds.handler.depositFunds({
-            sellerId,
-            fundsAmount,
-            fundsTokenAddress,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * 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.
-     */
-    async getFundsById(fundsId, queryVars) {
-        return funds.subgraph.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.
-     */
-    async getFunds(queryVars) {
-        return funds.subgraph.getFunds(this._subgraphUrl, queryVars);
-    }
-    /**
-     * Withdraw selected funds by calling the `FundsHandlerFacet` contract.
-     * @param sellerId - ID of seller account to withdraw funds for.
-     * @param tokensToWithdraw - Addresses of funds tokens to withdraw.
-     * @param amountsToWithdraw - Amounts of funds token to withdraw.
-     * @returns Transaction response.
-     */
-    async withdrawFunds(sellerId, tokensToWithdraw, amountsToWithdraw) {
-        return funds.handler.withdrawFunds({
-            sellerId,
-            tokensToWithdraw,
-            amountsToWithdraw,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Withdraw all available funds by calling the `FundsHandlerFacet` contract.
-     * @param sellerId - ID of seller account to withdraw funds for.
-     * @returns Transaction response.
-     */
-    async withdrawAllAvailableFunds(sellerId) {
-        return funds.handler.withdrawAllAvailableFunds({
-            sellerId,
-            subgraphUrl: this._subgraphUrl,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /* -------------------------------------------------------------------------- */
-    /*                          Exchange related methods                          */
-    /* -------------------------------------------------------------------------- */
-    /**
-     * Returns exchange entity from subgraph.
-     * @param exchangeId - ID of exchange entity.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Exchange entity from subgraph.
-     */
-    async getExchangeById(exchangeId, queryVars) {
-        return exchanges.subgraph.getExchangeById(this._subgraphUrl, exchangeId, queryVars);
-    }
-    /**
-     * Returns exchange entities from subgraph.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Exchange entities from subgraph.
-     */
-    async getExchanges(queryVars) {
-        return exchanges.subgraph.getExchanges(this._subgraphUrl, queryVars);
-    }
-    /**
-     * Commits to an offer by calling the `ExchangeHandlerContract`.
-     * This transaction only succeeds if the seller has deposited funds.
-     * @param offerId - ID of offer to commit to.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async commitToOffer(offerId, overrides = {}) {
-        const buyer = overrides.buyer || (await this._web3Lib.getSignerAddress());
-        return exchanges.handler.commitToOffer({
-            buyer,
-            offerId,
-            web3Lib: this._web3Lib,
-            subgraphUrl: this._subgraphUrl,
-            contractAddress: this._protocolDiamond
-        });
-    }
-    /**
-     * Utility method to retrieve the created `exchangeId` from logs after calling `commitToOffer`.
-     * @param logs - Logs to search in.
-     * @returns Created exchange id.
-     */
-    getCommittedExchangeIdFromLogs(logs) {
-        return getValueFromLogs({
-            iface: exchanges.iface.bosonExchangeHandlerIface,
-            logs,
-            eventArgsKey: "exchangeId",
-            eventName: "BuyerCommitted"
-        });
-    }
-    /**
-     * Revokes an existing voucher by calling the `ExchangeHandlerContract`.
-     * Callable by seller `operator`.
-     * @param exchangeId - ID of exchange to revoke.
-     * @returns Transaction response.
-     */
-    async revokeVoucher(exchangeId) {
-        return exchanges.handler.revokeVoucher({
-            web3Lib: this._web3Lib,
-            contractAddress: this._protocolDiamond,
-            exchangeId,
-            subgraphUrl: this._subgraphUrl
-        });
-    }
-    /**
-     * Cancels an existing voucher by calling the `ExchangeHandlerContract`.
-     * Callable by buyer.
-     * @param exchangeId - ID of exchange to cancel.
-     * @returns Transaction response.
-     */
-    async cancelVoucher(exchangeId) {
-        return exchanges.handler.cancelVoucher({
-            web3Lib: this._web3Lib,
-            contractAddress: this._protocolDiamond,
-            exchangeId,
-            subgraphUrl: this._subgraphUrl
-        });
-    }
-    /**
-     * Redeems an existing voucher by calling the `ExchangeHandlerContract`.
-     * Callable by buyer.
-     * @param exchangeId - ID of exchange to redeem.
-     * @returns Transaction response.
-     */
-    async redeemVoucher(exchangeId) {
-        return exchanges.handler.redeemVoucher({
-            web3Lib: this._web3Lib,
-            contractAddress: this._protocolDiamond,
-            exchangeId,
-            subgraphUrl: this._subgraphUrl
-        });
-    }
-    /**
-     * Completes an existing voucher by calling the `ExchangeHandlerContract`.
-     * Callable by buyer or seller operator.
-     * @param exchangeId - ID of exchange to complete.
-     * @returns Transaction response.
-     */
-    async completeExchange(exchangeId) {
-        return exchanges.handler.completeExchange({
-            web3Lib: this._web3Lib,
-            contractAddress: this._protocolDiamond,
-            exchangeId,
-            subgraphUrl: this._subgraphUrl
-        });
-    }
-    /**
-     * Completes a batch of existing vouchers by calling the `ExchangeHandlerContract`.
-     * Callable by buyer or seller operator.
-     * @param exchangeIds - IDs of exchange to complete.
-     * @returns Transaction response.
-     */
-    async completeExchangeBatch(exchangeIds) {
-        return exchanges.handler.completeExchangeBatch({
-            web3Lib: this._web3Lib,
-            contractAddress: this._protocolDiamond,
-            exchangeIds,
-            subgraphUrl: this._subgraphUrl
-        });
-    }
-    /**
-     * Expires an existing voucher by calling the `ExchangeHandlerContract`.
-     * @param exchangeId - ID of exchange to expire.
-     * @returns Transaction response.
-     */
-    async expireVoucher(exchangeId) {
-        return exchanges.handler.expireVoucher({
-            web3Lib: this._web3Lib,
-            contractAddress: this._protocolDiamond,
-            exchangeId,
-            subgraphUrl: this._subgraphUrl
-        });
-    }
-    /* -------------------------------------------------------------------------- */
-    /*                           Dispute related methods                          */
-    /* -------------------------------------------------------------------------- */
-    /**
-     * Returns dispute entity from subgraph.
-     * @param disputeId - ID of dispute entity.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Dispute entity from subgraph.
-     */
-    async getDisputeById(disputeId, queryVars) {
-        return disputes.subgraph.getDisputeById(this._subgraphUrl, disputeId, queryVars);
-    }
-    /**
-     * Returns dispute entities from subgraph.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Dispute entities from subgraph.
-     */
-    async getDisputes(queryVars) {
-        return disputes.subgraph.getDisputes(this._subgraphUrl, queryVars);
-    }
-    /**
-     * Raises a dispute by calling the `DisputeHandlerContract`.
-     * @param exchangeId - ID of exchange to dispute.
-     * @returns Transaction response.
-     */
-    async raiseDispute(exchangeId) {
-        return disputes.handler.raiseDispute({
-            exchangeId,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Retracts a dispute by calling the `DisputeHandlerContract`.
-     * @param exchangeId - ID of disputed exchange.
-     * @returns Transaction response.
-     */
-    async retractDispute(exchangeId) {
-        return disputes.handler.retractDispute({
-            exchangeId,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Extends the dispute timeout by calling the `DisputeHandlerContract`.
-     * @param exchangeId - ID of disputed exchange.
-     * @param newDisputeTimeout - New dispute timeout in seconds.
-     * @returns Transaction response.
-     */
-    async extendDisputeTimeout(exchangeId, newDisputeTimeout) {
-        return disputes.handler.extendDisputeTimeout({
-            exchangeId,
-            newDisputeTimeout,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Expires a dispute by calling the `DisputeHandlerContract`.
-     * @param exchangeId - ID of disputed exchange.
-     * @returns Transaction response.
-     */
-    async expireDispute(exchangeId) {
-        return disputes.handler.expireDispute({
-            exchangeId,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Expires many disputes by calling the `DisputeHandlerContract`.
-     * @param exchangeIds - IDs of disputed exchanges.
-     * @returns Transaction response.
-     */
-    async expireDisputeBatch(exchangeIds) {
-        return disputes.handler.expireDisputeBatch({
-            exchangeIds,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Resolves dispute by calling the `DisputeHandlerContract`. If caller is `buyer` then
-     * signature of `seller` is required as an argument. If caller if `seller` then vice-versa.
-     * The signature can be retrieved by calling the method
-     * `CoreSDK.signDisputeResolutionProposal`.
-     * @param args - Dispute resolve arguments:
-     * - `args.exchangeId` - ID of disputed exchange.
-     * - `args.buyerPercent` - Percentage of deposit the buyer gets.
-     * - `args.sigR` - r signature value of counterparty.
-     * - `args.sigS` - s signature value of counterparty.
-     * - `args.sigV` - v signature value of counterparty.
-     * @returns Transaction response.
-     */
-    async resolveDispute(args) {
-        return disputes.handler.resolveDispute({
-            ...args,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Escalates dispute by calling the `DisputeHandlerContract`.
-     * @param exchangeId - ID of disputed exchange.
-     * @returns Transaction response.
-     */
-    async escalateDispute(exchangeId) {
-        return disputes.handler.escalateDispute({
-            exchangeId,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Decides dispute by calling the `DisputeHandlerContract`.
-     * @param exchangeId - ID of disputed exchange.
-     * @param buyerPercent - Percentage of deposit buyer gets.
-     * @returns Transaction response.
-     */
-    async decideDispute(exchangeId, buyerPercent) {
-        return disputes.handler.decideDispute({
-            exchangeId,
-            buyerPercent,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Refuses escalated dispute by calling the `DisputeHandlerContract`.
-     * @param exchangeId - ID of disputed exchange.
-     * @returns Transaction response.
-     */
-    async refuseEscalatedDispute(exchangeId) {
-        return disputes.handler.refuseEscalatedDispute({
-            exchangeId,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Expires escalated dispute by calling the `DisputeHandlerContract`.
-     * @param exchangeId - ID of disputed exchange.
-     * @returns Transaction response.
-     */
-    async expireEscalatedDispute(exchangeId) {
-        return disputes.handler.expireEscalatedDispute({
-            exchangeId,
-            contractAddress: this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Signs dispute resolution message.
-     * @param args - Dispute resolve arguments:
-     * - `args.exchangeId` - ID of disputed exchange.
-     * - `args.buyerPercentBasisPoints` - Percentage of deposit the buyer gets.
-     * @returns Signature.
-     */
-    async signDisputeResolutionProposal(args) {
-        return disputes.handler.signResolutionProposal({
-            ...args,
-            web3Lib: this._web3Lib,
-            contractAddress: this._protocolDiamond,
-            chainId: this._chainId
-        });
-    }
-    /* -------------------------------------------------------------------------- */
-    /*                           Meta Tx related methods                          */
-    /* -------------------------------------------------------------------------- */
-    /**
-     * Encodes and signs a meta transaction that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTx(args) {
-        return metaTx.handler.signMetaTx({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `createSeller` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxCreateSeller(args) {
-        return metaTx.handler.signMetaTxCreateSeller({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `createOffer` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxCreateOffer(args) {
-        return metaTx.handler.signMetaTxCreateOffer({
-            web3Lib: this._web3Lib,
-            theGraphStorage: this._theGraphStorage,
-            metadataStorage: this._metadataStorage,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `createOfferBatch` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxCreateOfferBatch(args) {
-        return metaTx.handler.signMetaTxCreateOfferBatch({
-            web3Lib: this._web3Lib,
-            theGraphStorage: this._theGraphStorage,
-            metadataStorage: this._metadataStorage,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `createGroup` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxCreateGroup(args) {
-        return metaTx.handler.signMetaTxCreateGroup({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `createOfferWithCondition` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxCreateOfferWithCondition(args) {
-        return metaTx.handler.signMetaTxCreateOfferWithCondition({
-            web3Lib: this._web3Lib,
-            theGraphStorage: this._theGraphStorage,
-            metadataStorage: this._metadataStorage,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `voidOffer` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxVoidOffer(args) {
-        return metaTx.handler.signMetaTxVoidOffer({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `voidOfferBatch` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxVoidOfferBatch(args) {
-        return metaTx.handler.signMetaTxVoidOfferBatch({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `completeExchangeBatch` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxCompleteExchange(args) {
-        return metaTx.handler.signMetaTxCompleteExchange({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `completeExchangeBatch` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxCompleteExchangeBatch(args) {
-        return metaTx.handler.signMetaTxCompleteExchangeBatch({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `commitToOffer` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxCommitToOffer(args) {
-        return metaTx.handler.signMetaTxCommitToOffer({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `cancelVoucher` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxCancelVoucher(args) {
-        return metaTx.handler.signMetaTxCancelVoucher({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `redeemVoucher` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxRedeemVoucher(args) {
-        return metaTx.handler.signMetaTxRedeemVoucher({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `expireVoucher` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxExpireVoucher(args) {
-        return metaTx.handler.signMetaTxExpireVoucher({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `revokeVoucher` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxRevokeVoucher(args) {
-        return metaTx.handler.signMetaTxRevokeVoucher({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `retractDispute` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxRetractDispute(args) {
-        return metaTx.handler.signMetaTxRetractDispute({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `escalateDispute` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxEscalateDispute(args) {
-        return metaTx.handler.signMetaTxEscalateDispute({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `raiseDispute` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxRaiseDispute(args) {
-        return metaTx.handler.signMetaTxRaiseDispute({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `resolveDispute` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxResolveDispute(args) {
-        return metaTx.handler.signMetaTxResolveDispute({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `extendDisputeTimeout` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxExtendDisputeTimeout(args) {
-        return metaTx.handler.signMetaTxExtendDisputeTimeout({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `withdrawFunds` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxWithdrawFunds(args) {
-        return metaTx.handler.signMetaTxWithdrawFunds({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Encodes and signs a meta transaction for `depositFunds` that can be relayed.
-     * @param args - Meta transaction args.
-     * @returns Signature.
-     */
-    async signMetaTxDepositFunds(args) {
-        return metaTx.handler.signMetaTxDepositFunds({
-            web3Lib: this._web3Lib,
-            metaTxHandlerAddress: this._protocolDiamond,
-            chainId: this._chainId,
-            ...args
-        });
-    }
-    /**
-     * Relay a meta transaction,
-     * @param metaTxParams - Required params for meta transaction.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async relayMetaTransaction(metaTxParams, overrides = {}) {
-        const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl, contractAddress } = this.assertAndGetMetaTxConfig(overrides);
-        return metaTx.handler.relayMetaTransaction({
-            web3LibAdapter: this._web3Lib,
-            contractAddress,
-            chainId: this._chainId,
-            metaTx: {
-                config: {
-                    relayerUrl: metaTxRelayerUrl,
-                    apiId: metaTxApiId,
-                    apiKey: metaTxApiKey
-                },
-                params: {
-                    userAddress: overrides.userAddress || (await this._web3Lib.getSignerAddress()),
-                    functionName: metaTxParams.functionName,
-                    functionSignature: metaTxParams.functionSignature,
-                    nonce: metaTxParams.nonce,
-                    sigR: metaTxParams.sigR,
-                    sigS: metaTxParams.sigS,
-                    sigV: metaTxParams.sigV
-                }
-            }
-        });
-    }
-    /**
-     * Encodes and signs a native "token.approve()" meta transaction that can be relayed.
-     * @param exchangeToken - The address of the token contract.
-     * @param value - The value to be approved.
-     * @param overrides - Optionally specify a spender address (default is the protocol contract address).
-     * @returns Signature.
-     */
-    async signNativeMetaTxApproveExchangeToken(exchangeToken, value, overrides = {}) {
-        const user = await this._web3Lib.getSignerAddress();
-        return nativeMetaTx.handler.signNativeMetaTxApproveExchangeToken({
-            web3Lib: this._web3Lib,
-            chainId: this._chainId,
-            user,
-            exchangeToken,
-            spender: overrides.spender || this._protocolDiamond,
-            value
-        });
-    }
-    /**
-     * Relay a native meta transaction,
-     * @param metaTxParams - Required params for meta transaction.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async relayNativeMetaTransaction(contractAddress, metaTxParams, overrides = {}) {
-        const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl } = this.assertAndGetMetaTxConfig({ ...overrides, contractAddress });
-        return nativeMetaTx.handler.relayNativeMetaTransaction({
-            web3LibAdapter: this._web3Lib,
-            contractAddress,
-            chainId: this._chainId,
-            metaTx: {
-                config: {
-                    relayerUrl: metaTxRelayerUrl,
-                    apiId: metaTxApiId,
-                    apiKey: metaTxApiKey
-                },
-                params: {
-                    userAddress: overrides.userAddress || (await this._web3Lib.getSignerAddress()),
-                    functionSignature: metaTxParams.functionSignature,
-                    sigR: metaTxParams.sigR,
-                    sigS: metaTxParams.sigS,
-                    sigV: metaTxParams.sigV
-                }
-            }
-        });
-    }
-    /**
-     * Returns information of submitted meta transaction.
-     * See https://docs.biconomy.io/api/native-meta-tx/get-retried-hashes.
-     * @param originalMetaTxHash - Original meta transaction as returned by `coreSDK.relayMetaTransaction`
-     * @param overrides - Optional overrides for meta transaction config.
-     * @returns - Additional meta transaction information.
-     */
-    async getResubmittedMetaTx(originalMetaTxHash, overrides = {}) {
-        const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl } = this.assertAndGetMetaTxConfig(overrides);
-        return metaTx.handler.getResubmitted({
-            chainId: this._chainId,
-            metaTx: {
-                config: {
-                    relayerUrl: metaTxRelayerUrl,
-                    apiId: metaTxApiId,
-                    apiKey: metaTxApiKey
-                },
-                originalHash: originalMetaTxHash
-            }
-        });
-    }
-    assertAndGetMetaTxConfig(overrides = {}) {
-        const contractAddress = overrides.contractAddress || this._protocolDiamond;
-        const metaTransactionMethod = overrides.metaTransactionMethod || "executeMetaTransaction";
-        const metaTxRelayerUrl = overrides.metaTxConfig?.relayerUrl || this._metaTxConfig?.relayerUrl;
-        const metaTxApiKey = overrides.metaTxConfig?.apiKey || this._metaTxConfig?.apiKey;
-        // metaTxApiId is depending on the contract/method(=executeMetaTransaction) to be called with Biconomy
-        const apiIds = this._metaTxConfig?.apiIds[contractAddress.toLowerCase()];
-        const metaTxApiId = overrides.metaTxConfig?.apiId ||
-            (apiIds && apiIds[metaTransactionMethod]);
-        if (!(metaTxRelayerUrl && metaTxApiKey && metaTxApiId)) {
-            throw new Error("CoreSDK not configured to relay meta transactions. Either pass in 'relayerUrl', 'apiKey' and 'apiId' during initialization OR as overrides arguments.");
-        }
-        return {
-            metaTxRelayerUrl,
-            metaTxApiId,
-            metaTxApiKey,
-            contractAddress
-        };
-    }
-    /* -------------------------------------------------------------------------- */
-    /*                                 Event logs                                 */
-    /* -------------------------------------------------------------------------- */
-    /**
-     * Returns event logs from subgraph.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Event log entities from subgraph.
-     */
-    async getEventLogs(queryVars) {
-        return eventLogs.subgraph.getEventLogs(this._subgraphUrl, queryVars);
-    }
-    /* -------------------------------------------------------------------------- */
-    /*                             Groups                                         */
-    /* -------------------------------------------------------------------------- */
-    /**
-     * Creates a group of contract addresses
-     * @param groupToCreate -  group with the contract condition
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async createGroup(groupToCreate, overrides = {}) {
-        return groups.handler.createGroup({
-            groupToCreate,
-            contractAddress: overrides.contractAddress || this._protocolDiamond,
-            web3Lib: this._web3Lib
-        });
-    }
-    /**
-     * Creates an offer with a specific conditions
-     * @param offerToCreate - Offer arguments.
-     * @param condition -  contract condition applied to the offer
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async createOfferWithCondition(offerToCreate, condition, overrides = {}) {
-        return orchestration.handler.createOfferWithCondition({
-            offerToCreate,
-            contractAddress: overrides.contractAddress || this._protocolDiamond,
-            web3Lib: this._web3Lib,
-            metadataStorage: this._metadataStorage,
-            theGraphStorage: this._theGraphStorage,
-            condition
-        });
-    }
-    /**
-     * Creates a seller account and offer with a specific conditions
-     * This transaction only succeeds if there is no existing seller account for the connected signer.
-     * @param sellerToCreate - Addresses to set in the seller account.
-     * @param offerToCreate - Offer arguments.
-     * @param condition -  contract condition applied to the offer
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async createSellerAndOfferWithCondition(sellerToCreate, offerToCreate, condition, overrides = {}) {
-        return orchestration.handler.createSellerAndOfferWithCondition({
-            sellerToCreate,
-            offerToCreate,
-            contractAddress: overrides.contractAddress || this._protocolDiamond,
-            web3Lib: this._web3Lib,
-            metadataStorage: this._metadataStorage,
-            theGraphStorage: this._theGraphStorage,
-            condition
-        });
-    }
 }
+applyMixins(CoreSDK, [
+    MetadataMixin,
+    AccountsMixin,
+    OfferMixin,
+    FundsMixin,
+    ExchangesMixin,
+    DisputesMixin,
+    MetaTxMixin,
+    NativeMetaTxMixin,
+    GroupsMixin,
+    OrchestrationMixin,
+    EventLogsMixin
+]);
 //# sourceMappingURL=core-sdk.js.map