@bosonprotocol/core-sdk 1.29.0-ludo.1 → 1.29.0

package/dist/esm/accounts/mixin.js

@@ -1,417 +1,417 @@
-import { BaseCoreSDK } from "./../mixins/base-core-sdk";
-import * as accounts from ".";
-import * as erc721 from "../erc721";
-import { AuthTokenType } from "@bosonprotocol/common";
-import { BigNumber } from "@ethersproject/bignumber";
-import { AddressZero } from "@ethersproject/constants";
-import { orchestration } from "..";
-import { getValueFromLogs, getValuesFromLogsExt } from "../utils/logs";
-export class AccountsMixin extends BaseCoreSDK {
-    /* -------------------------------------------------------------------------- */
-    /*                           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 assistant - Assistant address of seller entity to query for.
-     * @param queryVars - Optional query variables to skip, order or filter.
-     * @returns Seller entity from subgraph.
-     */
-    async getSellerByAssistant(assistant, queryVars) {
-        return accounts.subgraph.getSellerByAssistant(this._subgraphUrl, assistant, 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 `assistant`, `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._lens?.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._lens || !this._lens?.LENS_HUB_CONTRACT) {
-            throw new Error("LENS contract is not configured in Core-SDK");
-        }
-        const balance = await erc721.handler.balanceOf({
-            contractAddress: this._lens?.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._lens?.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,
-            theGraphStorage: this._theGraphStorage,
-            metadataStorage: this._metadataStorage,
-            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,
-            theGraphStorage: this._theGraphStorage,
-            metadataStorage: this._metadataStorage,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /**
-     * Opt-in to a pending seller update by calling the `AccountHandlerFacet` contract. Only callable
-     * by admin.
-     * @param sellerUpdates - Values to update.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async optInToSellerUpdate(sellerUpdates, overrides = {}) {
-        return accounts.handler.optInToSellerUpdate({
-            sellerUpdates,
-            web3Lib: this._web3Lib,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /**
-     * Updates seller account by calling the `AccountHandlerFacet` contract,
-     * then optIn for all updates doable by the same account. Only callable
-     * by admin.
-     * @param sellerUpdates - Values to update.
-     * @param overrides - Optional overrides.
-     * @returns Transaction response.
-     */
-    async updateSellerAndOptIn(sellerUpdates, overrides = {}) {
-        const updateTx = await this.updateSeller(sellerUpdates, overrides);
-        const txReceipt = await updateTx.wait();
-        const pendingSellerUpdate = this.getPendingSellerUpdateFromLogs(txReceipt.logs);
-        // Find all updates that can be opted in by the current account
-        const currentAccount = (await this._web3Lib.getSignerAddress()).toLowerCase();
-        const fieldsToUpdate = {
-            assistant: currentAccount === pendingSellerUpdate.assistant?.toLowerCase(),
-            clerk: currentAccount === pendingSellerUpdate.clerk?.toLowerCase(),
-            admin: currentAccount === pendingSellerUpdate.admin?.toLowerCase(),
-            authToken: pendingSellerUpdate.tokenType !== undefined &&
-                pendingSellerUpdate.tokenType !== null &&
-                pendingSellerUpdate.tokenType !== AuthTokenType.NONE
-        };
-        if (fieldsToUpdate.assistant ||
-            fieldsToUpdate.clerk ||
-            fieldsToUpdate.admin ||
-            fieldsToUpdate.authToken) {
-            return this.optInToSellerUpdate({
-                id: sellerUpdates.id,
-                fieldsToUpdate: {
-                    assistant: currentAccount === pendingSellerUpdate.assistant.toLowerCase(),
-                    clerk: currentAccount === pendingSellerUpdate.clerk.toLowerCase(),
-                    admin: currentAccount === pendingSellerUpdate.admin.toLowerCase(),
-                    authToken: pendingSellerUpdate.tokenType !== AuthTokenType.NONE
-                }
-            });
-        }
-        // If there is nothing to optIn from the current account, then return the response from updateSeller
-        return updateTx;
-    }
-    /* ---------------------------------- 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"
-        });
-    }
-    /**
-     * Utility method to retrieve the pending seller update fields from logs after calling `updateSeller`.
-     * @param logs - Logs to search in.
-     * @returns Created exchange id.
-     */
-    getPendingSellerUpdateFromLogs(logs) {
-        // Extract fields pendingSeller and pendingAuthToken from
-        // SellerUpdatePending or SellerUpdateApplied events
-        const valuesFromLogs = getValuesFromLogsExt({
-            iface: accounts.iface.bosonAccountHandlerIface,
-            logs,
-            eventArgsKeys: ["pendingSeller", "pendingAuthToken"],
-            eventNames: ["SellerUpdatePending", "SellerUpdateApplied"]
-        });
-        const pendingSellerStruct = valuesFromLogs["pendingSeller"]?.[0];
-        const pendingAuthTokenStruct = valuesFromLogs["pendingAuthToken"]?.[0];
-        return {
-            assistant: pendingSellerStruct?.assistant,
-            admin: pendingSellerStruct?.admin,
-            clerk: pendingSellerStruct?.clerk,
-            tokenId: pendingAuthTokenStruct?.tokenId,
-            tokenType: pendingAuthTokenStruct?.tokenType
-        };
-    }
-    /**
-     * 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
-        });
-    }
-    async optInToDisputeResolverUpdate(disputeResolverUpdates, overrides = {}) {
-        return accounts.handler.optInToDisputeResolverUpdate({
-            disputeResolverUpdates,
-            web3Lib: this._web3Lib,
-            contractAddress: overrides.contractAddress || this._protocolDiamond
-        });
-    }
-    /**
-     * 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);
-    }
-}
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+import * as accounts from ".";
+import * as erc721 from "../erc721";
+import { AuthTokenType } from "@bosonprotocol/common";
+import { BigNumber } from "@ethersproject/bignumber";
+import { AddressZero } from "@ethersproject/constants";
+import { orchestration } from "..";
+import { getValueFromLogs, getValuesFromLogsExt } from "../utils/logs";
+export class AccountsMixin extends BaseCoreSDK {
+    /* -------------------------------------------------------------------------- */
+    /*                           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 assistant - Assistant address of seller entity to query for.
+     * @param queryVars - Optional query variables to skip, order or filter.
+     * @returns Seller entity from subgraph.
+     */
+    async getSellerByAssistant(assistant, queryVars) {
+        return accounts.subgraph.getSellerByAssistant(this._subgraphUrl, assistant, 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 `assistant`, `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._lens?.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._lens || !this._lens?.LENS_HUB_CONTRACT) {
+            throw new Error("LENS contract is not configured in Core-SDK");
+        }
+        const balance = await erc721.handler.balanceOf({
+            contractAddress: this._lens?.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._lens?.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,
+            theGraphStorage: this._theGraphStorage,
+            metadataStorage: this._metadataStorage,
+            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,
+            theGraphStorage: this._theGraphStorage,
+            metadataStorage: this._metadataStorage,
+            contractAddress: overrides.contractAddress || this._protocolDiamond
+        });
+    }
+    /**
+     * Opt-in to a pending seller update by calling the `AccountHandlerFacet` contract. Only callable
+     * by admin.
+     * @param sellerUpdates - Values to update.
+     * @param overrides - Optional overrides.
+     * @returns Transaction response.
+     */
+    async optInToSellerUpdate(sellerUpdates, overrides = {}) {
+        return accounts.handler.optInToSellerUpdate({
+            sellerUpdates,
+            web3Lib: this._web3Lib,
+            contractAddress: overrides.contractAddress || this._protocolDiamond
+        });
+    }
+    /**
+     * Updates seller account by calling the `AccountHandlerFacet` contract,
+     * then optIn for all updates doable by the same account. Only callable
+     * by admin.
+     * @param sellerUpdates - Values to update.
+     * @param overrides - Optional overrides.
+     * @returns Transaction response.
+     */
+    async updateSellerAndOptIn(sellerUpdates, overrides = {}) {
+        const updateTx = await this.updateSeller(sellerUpdates, overrides);
+        const txReceipt = await updateTx.wait();
+        const pendingSellerUpdate = this.getPendingSellerUpdateFromLogs(txReceipt.logs);
+        // Find all updates that can be opted in by the current account
+        const currentAccount = (await this._web3Lib.getSignerAddress()).toLowerCase();
+        const fieldsToUpdate = {
+            assistant: currentAccount === pendingSellerUpdate.assistant?.toLowerCase(),
+            clerk: currentAccount === pendingSellerUpdate.clerk?.toLowerCase(),
+            admin: currentAccount === pendingSellerUpdate.admin?.toLowerCase(),
+            authToken: pendingSellerUpdate.tokenType !== undefined &&
+                pendingSellerUpdate.tokenType !== null &&
+                pendingSellerUpdate.tokenType !== AuthTokenType.NONE
+        };
+        if (fieldsToUpdate.assistant ||
+            fieldsToUpdate.clerk ||
+            fieldsToUpdate.admin ||
+            fieldsToUpdate.authToken) {
+            return this.optInToSellerUpdate({
+                id: sellerUpdates.id,
+                fieldsToUpdate: {
+                    assistant: currentAccount === pendingSellerUpdate.assistant.toLowerCase(),
+                    clerk: currentAccount === pendingSellerUpdate.clerk.toLowerCase(),
+                    admin: currentAccount === pendingSellerUpdate.admin.toLowerCase(),
+                    authToken: pendingSellerUpdate.tokenType !== AuthTokenType.NONE
+                }
+            });
+        }
+        // If there is nothing to optIn from the current account, then return the response from updateSeller
+        return updateTx;
+    }
+    /* ---------------------------------- 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"
+        });
+    }
+    /**
+     * Utility method to retrieve the pending seller update fields from logs after calling `updateSeller`.
+     * @param logs - Logs to search in.
+     * @returns Created exchange id.
+     */
+    getPendingSellerUpdateFromLogs(logs) {
+        // Extract fields pendingSeller and pendingAuthToken from
+        // SellerUpdatePending or SellerUpdateApplied events
+        const valuesFromLogs = getValuesFromLogsExt({
+            iface: accounts.iface.bosonAccountHandlerIface,
+            logs,
+            eventArgsKeys: ["pendingSeller", "pendingAuthToken"],
+            eventNames: ["SellerUpdatePending", "SellerUpdateApplied"]
+        });
+        const pendingSellerStruct = valuesFromLogs["pendingSeller"]?.[0];
+        const pendingAuthTokenStruct = valuesFromLogs["pendingAuthToken"]?.[0];
+        return {
+            assistant: pendingSellerStruct?.assistant,
+            admin: pendingSellerStruct?.admin,
+            clerk: pendingSellerStruct?.clerk,
+            tokenId: pendingAuthTokenStruct?.tokenId,
+            tokenType: pendingAuthTokenStruct?.tokenType
+        };
+    }
+    /**
+     * 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
+        });
+    }
+    async optInToDisputeResolverUpdate(disputeResolverUpdates, overrides = {}) {
+        return accounts.handler.optInToDisputeResolverUpdate({
+            disputeResolverUpdates,
+            web3Lib: this._web3Lib,
+            contractAddress: overrides.contractAddress || this._protocolDiamond
+        });
+    }
+    /**
+     * 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);
+    }
+}
 //# sourceMappingURL=mixin.js.map