bitbadgesjs-sdk 0.0.7 → 0.1.1

package/dist/utils/api/BitBadgesCollection.js

@@ -0,0 +1,765 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshStatusRouteSuccessResponse = exports.RefreshMetadataRouteSuccessResponse = exports.GetCollectionByIdRouteSuccessResponse = exports.GetCollectionBatchRouteSuccessResponse = exports.GetBadgeActivityRouteSuccessResponse = exports.GetBadgeBalanceByAddressRouteSuccessResponse = exports.GetOwnersForBadgeRouteSuccessResponse = exports.FilterBadgesInCollectionSuccessResponse = exports.pruneMetadataToFetch = exports.convertCollectionMap = exports.BitBadgesCollection = exports.updateCollectionWithResponse = void 0;
+const permissions_1 = require("../../types/badges/permissions");
+const typeUtils_1 = require("../../types/badges/typeUtils");
+const string_numbers_1 = require("../../types/string-numbers");
+const base_1 = require("../../types/base");
+const aliases_1 = require("../aliases");
+const badgeMetadata_1 = require("../badgeMetadata");
+const firstMatches_1 = require("../firstMatches");
+const metadataIds_1 = require("../metadataIds");
+const activity_1 = require("../types/activity");
+const collections_1 = require("../types/collections");
+const db_1 = require("../types/db");
+const metadata_1 = require("../types/metadata");
+const routes_1 = require("../types/routes");
+const userBalances_1 = require("../../types/badges/userBalances");
+const badgeMetadata_2 = require("../badgeMetadata");
+const { removeUintRangesFromUintRanges, sortAndMerge } = typeUtils_1.UintRange;
+const NEW_COLLECTION_ID = 0n;
+function updateCollectionWithResponse(oldCollection, newCollectionResponse) {
+    let cachedCollection = oldCollection ? oldCollection.convert(base_1.deepCopy) : undefined;
+    if (!cachedCollection)
+        return newCollectionResponse;
+    const newCollection = newCollectionResponse;
+    const newBadgeMetadata = newCollection.cachedBadgeMetadata && newCollection.cachedBadgeMetadata.length > 0
+        ? (0, badgeMetadata_2.batchUpdateBadgeMetadata)(cachedCollection.cachedBadgeMetadata, (0, base_1.deepCopy)(newCollection.cachedBadgeMetadata))
+        : cachedCollection.cachedBadgeMetadata;
+    const newViews = cachedCollection?.views || {};
+    if (newCollection.views) {
+        for (const [key, val] of Object.entries(newCollection.views)) {
+            if (!val)
+                continue;
+            const oldVal = cachedCollection?.views[key];
+            const newVal = val;
+            newViews[key] = {
+                ids: [...(oldVal?.ids || []), ...(newVal?.ids || [])].filter((val, index, self) => self.findIndex(x => x === val) === index),
+                pagination: newVal.pagination,
+                type: val.type
+            };
+        }
+    }
+    const reviews = cachedCollection.reviews || [];
+    for (const newReview of newCollection.reviews || []) {
+        const existingReview = reviews.findIndex(x => x._docId === newReview._docId);
+        if (existingReview !== -1) {
+            reviews[existingReview] = newReview;
+        }
+        else {
+            reviews.push(newReview);
+        }
+    }
+    const activity = cachedCollection.activity || [];
+    for (const newActivity of newCollection.activity || []) {
+        const existingActivity = activity.findIndex(x => x._docId === newActivity._docId);
+        if (existingActivity !== -1) {
+            activity[existingActivity] = newActivity;
+        }
+        else {
+            activity.push(newActivity);
+        }
+    }
+    const owners = cachedCollection.owners || [];
+    for (const newOwner of newCollection.owners || []) {
+        const existingOwner = owners.findIndex(x => x._docId === newOwner._docId);
+        if (existingOwner !== -1) {
+            owners[existingOwner] = newOwner;
+        }
+        else {
+            owners.push(newOwner);
+        }
+    }
+    const merkleChallenges = cachedCollection.merkleChallenges || [];
+    for (const newMerkleChallenge of newCollection.merkleChallenges || []) {
+        const existingMerkleChallenge = merkleChallenges.findIndex(x => x._docId === newMerkleChallenge._docId);
+        if (existingMerkleChallenge !== -1) {
+            merkleChallenges[existingMerkleChallenge] = newMerkleChallenge;
+        }
+        else {
+            merkleChallenges.push(newMerkleChallenge);
+        }
+    }
+    const approvalTrackers = cachedCollection.approvalTrackers || [];
+    for (const newApprovalTracker of newCollection.approvalTrackers || []) {
+        const existingApprovalTracker = approvalTrackers.findIndex(x => x._docId === newApprovalTracker._docId);
+        if (existingApprovalTracker !== -1) {
+            approvalTrackers[existingApprovalTracker] = newApprovalTracker;
+        }
+        else {
+            approvalTrackers.push(newApprovalTracker);
+        }
+    }
+    cachedCollection = new BitBadgesCollection({
+        ...cachedCollection,
+        ...newCollection,
+        cachedCollectionMetadata: newCollection.cachedCollectionMetadata || cachedCollection?.cachedCollectionMetadata,
+        cachedBadgeMetadata: newBadgeMetadata,
+        reviews,
+        activity,
+        owners,
+        merkleChallenges,
+        approvalTrackers,
+        views: newViews,
+    });
+    if (cachedCollection.collectionId === NEW_COLLECTION_ID) {
+        delete cachedCollection.cachedCollectionMetadata?.fetchedAt;
+        delete cachedCollection.cachedCollectionMetadata?.fetchedAtBlock;
+        for (const metadataDetails of cachedCollection.cachedBadgeMetadata) {
+            delete metadataDetails.metadata?.fetchedAt;
+            delete metadataDetails.metadata?.fetchedAtBlock;
+        }
+    }
+    return cachedCollection;
+}
+exports.updateCollectionWithResponse = updateCollectionWithResponse;
+class BitBadgesCollection extends base_1.BaseNumberTypeClass {
+    _docId;
+    _id;
+    collectionId;
+    collectionMetadataTimeline;
+    badgeMetadataTimeline;
+    balancesType;
+    offChainBalancesMetadataTimeline;
+    customDataTimeline;
+    managerTimeline;
+    standardsTimeline;
+    isArchivedTimeline;
+    createdBy;
+    createdBlock;
+    createdTimestamp;
+    updateHistory;
+    aliasAddress;
+    collectionApprovals;
+    collectionPermissions;
+    defaultBalances;
+    cachedCollectionMetadata;
+    cachedBadgeMetadata;
+    activity;
+    reviews;
+    owners;
+    merkleChallenges;
+    approvalTrackers;
+    nsfw;
+    reported;
+    views;
+    constructor(data) {
+        super();
+        this._docId = data._docId;
+        this._id = data._id;
+        this.collectionId = data.collectionId;
+        this.collectionMetadataTimeline = data.collectionMetadataTimeline.map((timelineItem) => new typeUtils_1.CollectionMetadataTimeline(timelineItem));
+        this.badgeMetadataTimeline = data.badgeMetadataTimeline.map((timelineItem) => new typeUtils_1.BadgeMetadataTimeline(timelineItem));
+        this.balancesType = data.balancesType;
+        this.offChainBalancesMetadataTimeline = data.offChainBalancesMetadataTimeline.map((timelineItem) => new typeUtils_1.OffChainBalancesMetadataTimeline(timelineItem));
+        this.customDataTimeline = data.customDataTimeline.map((timelineItem) => new typeUtils_1.CustomDataTimeline(timelineItem));
+        this.managerTimeline = data.managerTimeline.map((timelineItem) => new typeUtils_1.ManagerTimeline(timelineItem));
+        this.standardsTimeline = data.standardsTimeline.map((timelineItem) => new typeUtils_1.StandardsTimeline(timelineItem));
+        this.isArchivedTimeline = data.isArchivedTimeline.map((timelineItem) => new typeUtils_1.IsArchivedTimeline(timelineItem));
+        this.createdBy = data.createdBy;
+        this.createdBlock = data.createdBlock;
+        this.createdTimestamp = data.createdTimestamp;
+        this.updateHistory = data.updateHistory.map((updateHistoryItem) => ({ ...updateHistoryItem }));
+        this.aliasAddress = data.aliasAddress;
+        this.collectionApprovals = data.collectionApprovals.map((collectionApproval) => new collections_1.CollectionApprovalWithDetails(collectionApproval));
+        this.collectionPermissions = new permissions_1.CollectionPermissionsWithDetails(data.collectionPermissions);
+        this.defaultBalances = new userBalances_1.UserBalanceStoreWithDetails(data.defaultBalances);
+        this.cachedCollectionMetadata = data.cachedCollectionMetadata ? new metadata_1.Metadata(data.cachedCollectionMetadata) : undefined;
+        this.cachedBadgeMetadata = data.cachedBadgeMetadata.map((metadata) => new metadata_1.BadgeMetadataDetails(metadata));
+        this.activity = data.activity.map((activityItem) => new activity_1.TransferActivityDoc(activityItem));
+        this.reviews = data.reviews.map((activityItem) => new activity_1.ReviewDoc(activityItem));
+        this.owners = data.owners.map((balance) => new db_1.BalanceDocWithDetails(balance));
+        this.merkleChallenges = data.merkleChallenges.map((merkleChallenge) => new db_1.MerkleChallengeDoc(merkleChallenge));
+        this.approvalTrackers = data.approvalTrackers.map((approvalTracker) => new db_1.ApprovalTrackerDoc(approvalTracker));
+        this.nsfw = data.nsfw;
+        this.reported = data.reported;
+        this.views = data.views;
+    }
+    convert(convertFunction) {
+        return new BitBadgesCollection((0, base_1.deepCopy)({
+            ...this,
+            ...new db_1.CollectionDoc(this).convert(convertFunction),
+            collectionApprovals: this.collectionApprovals.map((collectionApproval) => collectionApproval.convert(convertFunction)),
+            defaultBalances: this.defaultBalances.convert(convertFunction),
+            collectionPermissions: this.collectionPermissions.convert(convertFunction),
+            cachedCollectionMetadata: this.cachedCollectionMetadata ? this.cachedCollectionMetadata.convert(convertFunction) : undefined,
+            cachedBadgeMetadata: this.cachedBadgeMetadata.map((metadata) => metadata.convert(convertFunction)),
+            activity: this.activity.map((activityItem) => activityItem.convert(convertFunction)),
+            reviews: this.reviews.map((activityItem) => activityItem.convert(convertFunction)),
+            owners: this.owners.map((balance) => balance.convert(convertFunction)),
+            merkleChallenges: this.merkleChallenges.map((merkleChallenge) => merkleChallenge.convert(convertFunction)),
+            approvalTrackers: this.approvalTrackers.map((approvalTracker) => approvalTracker.convert(convertFunction)),
+            _rev: undefined,
+            _deleted: undefined,
+            nsfw: this.nsfw ? { ...this.nsfw, badgeIds: this.nsfw.badgeIds.map((UintRange) => UintRange.convert(convertFunction)) } : undefined,
+            reported: this.reported ? { ...this.reported, badgeIds: this.reported.badgeIds.map((UintRange) => UintRange.convert(convertFunction)) } : undefined,
+        }));
+    }
+    getOwnerInfo(address, throwIfNotFound = true) {
+        const owner = this.owners.find((x) => x.cosmosAddress === address);
+        if (!owner && throwIfNotFound)
+            throw new Error(`Owner not found for address ${address}. Balance not fetched yet. Missing doc for '${address}' in owners.`);
+        return owner;
+    }
+    getOwnerBalances(address, throwIfNotFound = true) {
+        return this.getOwnerInfo(address, throwIfNotFound)?.balances;
+    }
+    getMaxBadgeId() {
+        const totalSupplyBalance = this.getOwnerBalances('Total')?.map((balance) => balance.convert(string_numbers_1.BigIntify)) ?? [];
+        const defaultBalances = this.defaultBalances.balances.map((balance) => balance.convert(string_numbers_1.BigIntify));
+        let maxBadgeId = 0n;
+        for (const balance of [...totalSupplyBalance, ...defaultBalances]) {
+            for (const badgeIdRange of balance.badgeIds) {
+                if (badgeIdRange.end > maxBadgeId) {
+                    maxBadgeId = badgeIdRange.end;
+                }
+            }
+        }
+        return maxBadgeId;
+    }
+    getTimelineValuesAtTime(time) {
+        const coll = this.convert(string_numbers_1.BigIntify);
+        return {
+            manager: (0, collections_1.getValueAtTimeForTimeline)(coll.managerTimeline, time)?.manager ?? "",
+            collectionMetadata: (0, collections_1.getValueAtTimeForTimeline)(coll.collectionMetadataTimeline, time)?.collectionMetadata ?? {
+                uri: '',
+                customData: '',
+            },
+            badgeMetadata: (0, collections_1.getValueAtTimeForTimeline)(coll.badgeMetadataTimeline, time)?.badgeMetadata ?? [],
+            offChainBalancesMetadata: (0, collections_1.getValueAtTimeForTimeline)(coll.offChainBalancesMetadataTimeline, time)?.offChainBalancesMetadata ?? {
+                uri: '',
+                customData: '',
+            },
+            customData: (0, collections_1.getValueAtTimeForTimeline)(coll.customDataTimeline, time)?.customData ?? "",
+            standards: (0, collections_1.getValueAtTimeForTimeline)(coll.standardsTimeline, time)?.standards ?? [],
+            isArchived: (0, collections_1.getValueAtTimeForTimeline)(coll.isArchivedTimeline, time)?.isArchived ?? false,
+        };
+    }
+    getManager(time) {
+        return this.getTimelineValuesAtTime(time).manager;
+    }
+    getCollectionMetadata() {
+        return this.cachedCollectionMetadata;
+    }
+    getBadgeMetadata(badgeId) {
+        return (0, badgeMetadata_1.getMetadataForBadgeId)(badgeId, this.cachedBadgeMetadata);
+    }
+    getBadgeMetadataDetails(badgeId) {
+        return (0, badgeMetadata_1.getMetadataDetailsForBadgeId)(badgeId, this.cachedBadgeMetadata);
+    }
+    getCollectionMetadataTimelineValue(time) {
+        return this.getTimelineValuesAtTime(time).collectionMetadata;
+    }
+    getBadgeMetadataTimelineValue(time) {
+        return this.getTimelineValuesAtTime(time).badgeMetadata;
+    }
+    getOffChainBalancesMetadata(time) {
+        return this.getTimelineValuesAtTime(time).offChainBalancesMetadata;
+    }
+    getCustomData(time) {
+        return this.getTimelineValuesAtTime(time).customData;
+    }
+    getStandards(time) {
+        return this.getTimelineValuesAtTime(time).standards;
+    }
+    getIsArchived(time) {
+        return this.getTimelineValuesAtTime(time).isArchived;
+    }
+    getDefaultUserBalance() {
+        return (0, base_1.deepCopy)(new userBalances_1.UserBalanceStore({ ...this.defaultBalances }));
+    }
+    pruneMetadataToFetch(metadataToFetch) {
+        return (0, exports.pruneMetadataToFetch)(this.convert(string_numbers_1.BigIntify), metadataToFetch);
+    }
+    getMaxMetadataId() {
+        return (0, metadataIds_1.getMaxMetadataId)(this.convert(string_numbers_1.BigIntify).getBadgeMetadataTimelineValue());
+    }
+    validatePermissionsUpdate(newPermissions) {
+        const result = (0, permissions_1.validatePermissionsUpdate)(this.convert(string_numbers_1.BigIntify).collectionPermissions, newPermissions.convert(string_numbers_1.BigIntify));
+        return result;
+    }
+    validatePermissionUpdate(permissionName, newPermissions) {
+        const { validatePermissionUpdateFunction } = (0, permissions_1.getPermissionVariablesFromName)(permissionName);
+        const oldPermissions = this.collectionPermissions[permissionName];
+        const result = validatePermissionUpdateFunction(oldPermissions, newPermissions);
+        return result;
+    }
+    validateCollectionApprovalsUpdate(newApprovals) {
+        const result = (0, permissions_1.validateCollectionApprovalsUpdate)(this.convert(string_numbers_1.BigIntify).collectionApprovals, newApprovals.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateCollectionApprovals);
+        return result;
+    }
+    validateBadgeMetadataUpdate(newBadgeMetadata) {
+        const result = (0, permissions_1.validateBadgeMetadataUpdate)(this.convert(string_numbers_1.BigIntify).badgeMetadataTimeline, newBadgeMetadata.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateBadgeMetadata);
+        return result;
+    }
+    validateOffChainBalancesMetadataUpdate(newOffChainBalancesMetadata) {
+        const result = (0, permissions_1.validateOffChainBalancesMetadataUpdate)(this.convert(string_numbers_1.BigIntify).offChainBalancesMetadataTimeline, newOffChainBalancesMetadata.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateOffChainBalancesMetadata);
+        return result;
+    }
+    validateCustomDataUpdate(newCustomData) {
+        const result = (0, permissions_1.validateCustomDataUpdate)(this.convert(string_numbers_1.BigIntify).customDataTimeline, newCustomData.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateCustomData);
+        return result;
+    }
+    validateStandardsUpdate(newStandards) {
+        const result = (0, permissions_1.validateStandardsUpdate)(this.convert(string_numbers_1.BigIntify).standardsTimeline, newStandards.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateStandards);
+        return result;
+    }
+    validateIsArchivedUpdate(newIsArchived) {
+        const result = (0, permissions_1.validateIsArchivedUpdate)(this.convert(string_numbers_1.BigIntify).isArchivedTimeline, newIsArchived.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canArchiveCollection);
+        return result;
+    }
+    validateManagerUpdate(newManager) {
+        const result = (0, permissions_1.validateManagerUpdate)(this.convert(string_numbers_1.BigIntify).managerTimeline, newManager.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateManager);
+        return result;
+    }
+    checkCanDeleteCollection(time) {
+        return (0, permissions_1.checkIfActionPermissionPermits)(this.convert(string_numbers_1.BigIntify).collectionPermissions.canDeleteCollection, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanArchiveCollection(timelineTimes, time) {
+        return (0, permissions_1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canArchiveCollection, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateManager(timelineTimes, time) {
+        return (0, permissions_1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateManager, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateOffChainBalancesMetadata(timelineTimes, time) {
+        return (0, permissions_1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateOffChainBalancesMetadata, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateStandards(timelineTimes, time) {
+        return (0, permissions_1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateStandards, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateCustomData(timelineTimes, time) {
+        return (0, permissions_1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateCustomData, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateCollectionMetadata(timelineTimes, time) {
+        return (0, permissions_1.checkIfTimedUpdatePermissionPermits)(timelineTimes.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateCollectionMetadata, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanCreateMoreBadges(balances, time) {
+        return (0, permissions_1.checkIfBalancesActionPermissionPermits)(balances.map(x => x.convert(string_numbers_1.BigIntify)), this.convert(string_numbers_1.BigIntify).collectionPermissions.canCreateMoreBadges, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateBadgeMetadata(details, time) {
+        return (0, permissions_1.checkIfTimedUpdateWithBadgeIdsPermissionPermits)(details.map(x => {
+            return {
+                timelineTimes: x.timelineTimes.map(y => y.convert(string_numbers_1.BigIntify)),
+                badgeIds: x.badgeIds.map(y => y.convert(string_numbers_1.BigIntify))
+            };
+        }), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateBadgeMetadata, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    checkCanUpdateCollectionApprovals(details, time) {
+        return (0, permissions_1.checkIfCollectionApprovalPermissionPermits)(details.map(x => {
+            return {
+                ...x,
+                timelineTimes: x.timelineTimes.map(y => y.convert(string_numbers_1.BigIntify)),
+                badgeIds: x.badgeIds.map(y => y.convert(string_numbers_1.BigIntify)),
+                ownershipTimes: x.ownershipTimes.map(y => y.convert(string_numbers_1.BigIntify)),
+                transferTimes: x.transferTimes.map(y => y.convert(string_numbers_1.BigIntify)),
+            };
+        }), this.convert(string_numbers_1.BigIntify).collectionPermissions.canUpdateCollectionApprovals, time ? BigInt(time) : BigInt(Date.now()));
+    }
+    static async FetchAndInitialize(api, options) {
+        const collection = await BitBadgesCollection.GetCollections(api, { collectionsToFetch: [options] }).then((x) => x.collections[0]);
+        return new BitBadgesCollection(collection);
+    }
+    static async GetCollections(api, requestBody) {
+        try {
+            const response = await api.axios.post(`${api.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetCollectionBatchRoute()}`, requestBody);
+            return new GetCollectionBatchRouteSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    static async GetBadgeBalanceByAddress(api, collectionId, cosmosAddress, requestBody) {
+        try {
+            api.assertPositiveInteger(collectionId);
+            const response = await api.axios.post(`${api.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetBadgeBalanceByAddressRoute(collectionId, cosmosAddress)}`, requestBody);
+            return new GetBadgeBalanceByAddressRouteSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    static async FetchAndInitializeBatch(api, collectionsToFetch) {
+        const collection = await BitBadgesCollection.GetCollections(api, { collectionsToFetch: collectionsToFetch });
+        return collection.collections.map((x) => new BitBadgesCollection(x));
+    }
+    async fetchOwnerInfo(api, address, forceful) {
+        const currOwnerInfo = this.getOwnerInfo(address, false);
+        if (currOwnerInfo && !forceful)
+            return currOwnerInfo;
+        const newOwnerInfo = await BitBadgesCollection.GetBadgeBalanceByAddress(api, this.collectionId, address);
+        if (currOwnerInfo) {
+            Object.assign(currOwnerInfo, newOwnerInfo);
+            return currOwnerInfo;
+        }
+        else {
+            this.owners.push(newOwnerInfo);
+        }
+        return newOwnerInfo;
+    }
+    isRedundantRequest(options) {
+        const cachedCollection = this.convert(string_numbers_1.BigIntify);
+        const prunedMetadataToFetch = (0, exports.pruneMetadataToFetch)(cachedCollection, options.metadataToFetch);
+        const shouldFetchMetadata = (prunedMetadataToFetch.uris && prunedMetadataToFetch.uris.length > 0) || !prunedMetadataToFetch.doNotFetchCollectionMetadata;
+        const viewsToFetch = (options.viewsToFetch || []).filter(x => this.viewHasMore(x.viewId));
+        const hasTotalAndMint = cachedCollection.owners.find(x => x.cosmosAddress === "Mint") && cachedCollection.owners.find(x => x.cosmosAddress === "Total");
+        const shouldFetchTotalAndMint = !hasTotalAndMint && options.fetchTotalAndMintBalances;
+        const shouldFetchMerkleChallengeIds = (options.challengeTrackersToFetch ?? []).find(x => {
+            const match = cachedCollection.merkleChallenges.find(y => y.challengeId === x.challengeId && x.approverAddress === y.approverAddress && x.collectionId === y.collectionId && x.challengeLevel === y.challengeLevel);
+            return !match;
+        }) !== undefined;
+        const shouldFetchAmountTrackerIds = (options.approvalTrackersToFetch ?? []).find(x => {
+            const match = cachedCollection.approvalTrackers.find(y => y.amountTrackerId === x.amountTrackerId && x.approverAddress === y.approverAddress && x.collectionId === y.collectionId && y.approvedAddress === x.approvedAddress && y.trackerType === x.trackerType);
+            return !match;
+        }) !== undefined;
+        return !(shouldFetchMetadata || viewsToFetch.length > 0 || shouldFetchTotalAndMint || shouldFetchMerkleChallengeIds || shouldFetchAmountTrackerIds);
+    }
+    async fetchAndUpdate(api, options, forceful) {
+        if (!forceful) {
+            if (this.isRedundantRequest(options))
+                return;
+            if (options.metadataToFetch)
+                options.metadataToFetch = this.pruneMetadataToFetch(options.metadataToFetch);
+            options.viewsToFetch = (options.viewsToFetch || []).filter(x => this.viewHasMore(x.viewId));
+        }
+        const collection = await BitBadgesCollection.GetCollections(api, { collectionsToFetch: [{ collectionId: this.collectionId, ...options }] }).then((x) => x.collections[0]);
+        this.updateWithNewResponse(collection, forceful);
+    }
+    updateWithNewResponse(newResponse, forceful) {
+        if (forceful) {
+            const newCollectionInfo = new BitBadgesCollection(newResponse);
+            Object.assign(this, newCollectionInfo);
+            return;
+        }
+        else {
+            const newCollectionInfo = updateCollectionWithResponse(this, newResponse);
+            Object.assign(this, newCollectionInfo);
+            return;
+        }
+    }
+    async fetchMetadata(api, options, forceful) {
+        if (!forceful) {
+            if (options.metadataToFetch)
+                options.metadataToFetch = this.pruneMetadataToFetch(options.metadataToFetch);
+        }
+        await this.fetchAndUpdate(api, options, forceful);
+    }
+    viewHasMore(viewId) {
+        return this.views[viewId]?.pagination?.hasMore || true;
+    }
+    getViewPagination(viewId) {
+        return this.views[viewId]?.pagination;
+    }
+    getViewBookmark(viewId) {
+        return this.views[viewId]?.pagination?.bookmark;
+    }
+    async fetchNextForView(api, viewType, viewId) {
+        if (!this.viewHasMore(viewId))
+            return;
+        await this.fetchAndUpdate(api, {
+            viewsToFetch: [{
+                    viewType: viewType,
+                    viewId: viewId,
+                    bookmark: this.views[viewId]?.pagination?.bookmark || ''
+                }]
+        });
+    }
+    async fetchAllForView(api, viewType, viewId) {
+        while (this.viewHasMore(viewId)) {
+            await this.fetchNextForView(api, viewType, viewId);
+            await new Promise(r => setTimeout(r, 1000));
+        }
+    }
+    getActivityView(viewId) {
+        return this.views[viewId]?.ids.map(x => {
+            return this.activity.find(y => y._docId === x);
+        });
+    }
+    getReviewsView(viewId) {
+        return this.views[viewId]?.ids.map(x => {
+            return this.reviews.find(y => y._docId === x);
+        });
+    }
+    getOwnersView(viewId) {
+        return this.views[viewId]?.ids.map(x => {
+            return this.owners.find(y => y._docId === x);
+        });
+    }
+    getMerkleChallengesView(viewId) {
+        return this.views[viewId]?.ids.map(x => {
+            return this.merkleChallenges.find(y => y._docId === x);
+        });
+    }
+    getApprovalTrackersView(viewId) {
+        return this.views[viewId]?.ids.map(x => {
+            return this.approvalTrackers.find(y => y._docId === x);
+        });
+    }
+    generateAliasForBadgeId(badgeId) {
+        const moduleName = 'badges';
+        const derivationKeys = (0, aliases_1.getAliasDerivationKeysForBadge)(this.collectionId, badgeId);
+        return (0, aliases_1.generateAlias)(moduleName, derivationKeys);
+    }
+    getUnhandledCollectionApprovals() {
+        return (0, firstMatches_1.getUnhandledCollectionApprovals)(this.convert(string_numbers_1.BigIntify).collectionApprovals, true);
+    }
+    getNonMintCollectionApprovals() {
+        return (0, firstMatches_1.getNonMintApprovals)(this.convert(string_numbers_1.BigIntify).collectionApprovals);
+    }
+    getMintCollectionApprovals() {
+        return (0, firstMatches_1.getMintApprovals)(this.convert(string_numbers_1.BigIntify).collectionApprovals);
+    }
+    static async GetRefreshStatus(api, collectionId) {
+        try {
+            api.assertPositiveInteger(collectionId);
+            const response = await api.axios.get(`${api.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetRefreshStatusRoute(collectionId)}`);
+            return new RefreshStatusRouteSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async getRefreshStatus(api) {
+        return await BitBadgesCollection.GetRefreshStatus(api, this.collectionId);
+    }
+    static async RefreshMetadata(api, collectionId, requestBody) {
+        try {
+            api.assertPositiveInteger(collectionId);
+            const response = await api.axios.post(`${api.BACKEND_URL}${routes_1.BitBadgesApiRoutes.RefreshMetadataRoute(collectionId)}`, requestBody);
+            return new RefreshMetadataRouteSuccessResponse(response.data);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async refresh(api) {
+        return await BitBadgesCollection.RefreshMetadata(api, this.collectionId);
+    }
+    static async GetBadgeActivity(api, collectionId, badgeId, requestBody) {
+        try {
+            api.assertPositiveInteger(collectionId);
+            api.assertPositiveInteger(badgeId);
+            const response = await api.axios.post(`${api.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetBadgeActivityRoute(collectionId, badgeId)}`, requestBody);
+            return new GetBadgeActivityRouteSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async getBadgeActivity(api, badgeId, body) {
+        return await BitBadgesCollection.GetBadgeActivity(api, this.collectionId, badgeId, body);
+    }
+    static async GetOwnersForBadge(api, collectionId, badgeId, requestBody) {
+        try {
+            api.assertPositiveInteger(collectionId);
+            api.assertPositiveInteger(badgeId);
+            const response = await api.axios.post(`${api.BACKEND_URL}${routes_1.BitBadgesApiRoutes.GetOwnersForBadgeRoute(collectionId, badgeId)}`, requestBody);
+            return new GetOwnersForBadgeRouteSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async getOwnersForBadge(api, badgeId, body) {
+        return await BitBadgesCollection.GetOwnersForBadge(api, this.collectionId, badgeId, body);
+    }
+    static async FilterBadgesInCollection(api, requestBody) {
+        try {
+            const response = await api.axios.post(`${api.BACKEND_URL}${routes_1.BitBadgesApiRoutes.FilterBadgesInCollectionRoute()}`, requestBody);
+            return new FilterBadgesInCollectionSuccessResponse(response.data).convert(api.ConvertFunction);
+        }
+        catch (error) {
+            await api.handleApiError(error);
+            return Promise.reject(error);
+        }
+    }
+    async filterBadgesInCollection(api, bodyOptions) {
+        return await BitBadgesCollection.FilterBadgesInCollection(api, { collectionId: this.collectionId, ...bodyOptions });
+    }
+}
+exports.BitBadgesCollection = BitBadgesCollection;
+function convertCollectionMap(item, convertFunction) {
+    return Object.fromEntries(Object.entries(item).map(([key, value]) => {
+        return [key, value ? value.convert(convertFunction) : undefined];
+    }));
+}
+exports.convertCollectionMap = convertCollectionMap;
+const pruneMetadataToFetch = (cachedCollection, metadataFetchReq) => {
+    if (!cachedCollection)
+        throw new Error('Collection does not exist');
+    const metadataToFetch = {
+        doNotFetchCollectionMetadata: cachedCollection.cachedCollectionMetadata !== undefined || metadataFetchReq?.doNotFetchCollectionMetadata || false,
+        uris: [],
+        badgeIds: [],
+        metadataIds: [],
+    };
+    if (metadataFetchReq) {
+        const collectionMetadata = cachedCollection.getCollectionMetadataTimelineValue();
+        const badgeMetadata = cachedCollection.getBadgeMetadataTimelineValue();
+        if (metadataFetchReq.uris) {
+            for (const uri of metadataFetchReq.uris) {
+                if (!cachedCollection.cachedBadgeMetadata.find(x => x.uri === uri)) {
+                    metadataToFetch.uris.push(uri);
+                }
+            }
+        }
+        const metadataIdsToCheck = [];
+        if (metadataFetchReq.metadataIds) {
+            for (const metadataId of metadataFetchReq.metadataIds) {
+                const metadataIdCastedAsUintRange = metadataId;
+                const metadataIdCastedAsNumber = metadataId;
+                if (typeof metadataIdCastedAsNumber === 'object' && metadataIdCastedAsUintRange.start && metadataIdCastedAsUintRange.end) {
+                    const uintRange = metadataIdCastedAsUintRange.convert(string_numbers_1.BigIntify);
+                    for (let i = uintRange.start; i <= uintRange.end; i++) {
+                        metadataIdsToCheck.push(BigInt(i));
+                    }
+                }
+                else {
+                    metadataIdsToCheck.push(BigInt(metadataIdCastedAsNumber));
+                }
+            }
+        }
+        if (metadataFetchReq.badgeIds) {
+            for (const badgeId of metadataFetchReq.badgeIds) {
+                const badgeIdCastedAsUintRange = badgeId;
+                const badgeIdCastedAsNumber = badgeId;
+                if (typeof badgeIdCastedAsNumber === 'object' && badgeIdCastedAsUintRange.start && badgeIdCastedAsUintRange.end) {
+                    let badgeIdsLeft = [badgeIdCastedAsUintRange.convert(string_numbers_1.BigIntify)];
+                    while (badgeIdsLeft.length > 0) {
+                        const currBadgeUintRange = badgeIdsLeft[0];
+                        const metadataId = (0, metadataIds_1.getMetadataIdForBadgeId)(BigInt(currBadgeUintRange.start), badgeMetadata);
+                        if (metadataId === -1)
+                            break;
+                        metadataIdsToCheck.push(BigInt(metadataId));
+                        const otherMatchingBadgeUintRanges = (0, metadataIds_1.getBadgeIdsForMetadataId)(BigInt(metadataId), badgeMetadata);
+                        const [remaining,] = removeUintRangesFromUintRanges(otherMatchingBadgeUintRanges, badgeIdsLeft);
+                        badgeIdsLeft = remaining;
+                        badgeIdsLeft = sortAndMerge(badgeIdsLeft);
+                    }
+                }
+                else {
+                    const metadataId = (0, metadataIds_1.getMetadataIdForBadgeId)(BigInt(badgeIdCastedAsNumber), badgeMetadata);
+                    if (metadataId === -1)
+                        break;
+                    metadataIdsToCheck.push(BigInt(metadataId));
+                }
+            }
+        }
+        const uris = (0, metadataIds_1.getUrisForMetadataIds)(metadataIdsToCheck, collectionMetadata?.uri || '', badgeMetadata);
+        for (const uri of uris) {
+            const existingMetadata = cachedCollection.cachedBadgeMetadata.find(x => x.uri === uri);
+            if (!existingMetadata)
+                metadataToFetch.uris.push(uri);
+        }
+    }
+    return {
+        ...metadataToFetch,
+        uris: metadataToFetch.uris ?? [],
+    };
+};
+exports.pruneMetadataToFetch = pruneMetadataToFetch;
+class FilterBadgesInCollectionSuccessResponse extends base_1.CustomTypeClass {
+    badgeIds;
+    pagination;
+    constructor(data) {
+        super();
+        this.badgeIds = data.badgeIds;
+        this.pagination = data.pagination;
+    }
+    convert(convertFunction) {
+        return new FilterBadgesInCollectionSuccessResponse((0, base_1.deepCopy)({
+            ...this,
+            badgeIds: this.badgeIds.map((badgeId) => badgeId.convert(convertFunction)),
+        }));
+    }
+}
+exports.FilterBadgesInCollectionSuccessResponse = FilterBadgesInCollectionSuccessResponse;
+class GetOwnersForBadgeRouteSuccessResponse extends base_1.CustomTypeClass {
+    owners;
+    pagination;
+    constructor(data) {
+        super();
+        this.owners = data.owners.map((balance) => new db_1.BalanceDocWithDetails(balance));
+        this.pagination = data.pagination;
+    }
+    convert(convertFunction) {
+        return new GetOwnersForBadgeRouteSuccessResponse((0, base_1.deepCopy)({
+            owners: this.owners.map((balance) => balance.convert(convertFunction)),
+            pagination: this.pagination,
+        }));
+    }
+}
+exports.GetOwnersForBadgeRouteSuccessResponse = GetOwnersForBadgeRouteSuccessResponse;
+class GetBadgeBalanceByAddressRouteSuccessResponse extends db_1.BalanceDocWithDetails {
+}
+exports.GetBadgeBalanceByAddressRouteSuccessResponse = GetBadgeBalanceByAddressRouteSuccessResponse;
+class GetBadgeActivityRouteSuccessResponse extends base_1.CustomTypeClass {
+    activity;
+    pagination;
+    constructor(data) {
+        super();
+        this.activity = data.activity.map((activity) => new activity_1.TransferActivityDoc(activity));
+        this.pagination = data.pagination;
+    }
+    convert(convertFunction) {
+        return new GetBadgeActivityRouteSuccessResponse((0, base_1.deepCopy)({
+            activity: this.activity.map((activity) => activity.convert(convertFunction)),
+            pagination: this.pagination,
+        }));
+    }
+}
+exports.GetBadgeActivityRouteSuccessResponse = GetBadgeActivityRouteSuccessResponse;
+class GetCollectionBatchRouteSuccessResponse extends base_1.CustomTypeClass {
+    collections;
+    constructor(data) {
+        super();
+        this.collections = data.collections.map((collection) => new BitBadgesCollection(collection));
+    }
+    convert(convertFunction) {
+        return new GetCollectionBatchRouteSuccessResponse((0, base_1.deepCopy)({
+            collections: this.collections.map((collection) => collection.convert(convertFunction)),
+        }));
+    }
+}
+exports.GetCollectionBatchRouteSuccessResponse = GetCollectionBatchRouteSuccessResponse;
+class GetCollectionByIdRouteSuccessResponse extends base_1.CustomTypeClass {
+    collection;
+    constructor(data) {
+        super();
+        this.collection = new BitBadgesCollection(data.collection);
+    }
+    convert(convertFunction) {
+        return new GetCollectionByIdRouteSuccessResponse((0, base_1.deepCopy)({
+            collection: this.collection.convert(convertFunction),
+        }));
+    }
+}
+exports.GetCollectionByIdRouteSuccessResponse = GetCollectionByIdRouteSuccessResponse;
+class RefreshMetadataRouteSuccessResponse extends base_1.EmptyResponseClass {
+}
+exports.RefreshMetadataRouteSuccessResponse = RefreshMetadataRouteSuccessResponse;
+class RefreshStatusRouteSuccessResponse extends base_1.CustomTypeClass {
+    inQueue;
+    errorDocs;
+    refreshDoc;
+    constructor(data) {
+        super();
+        this.inQueue = data.inQueue;
+        this.errorDocs = data.errorDocs.map((errorDoc) => new db_1.QueueDoc(errorDoc));
+        this.refreshDoc = new db_1.RefreshDoc(data.refreshDoc);
+    }
+    convert(convertFunction) {
+        return new RefreshStatusRouteSuccessResponse((0, base_1.deepCopy)({
+            inQueue: this.inQueue,
+            errorDocs: this.errorDocs.map((errorDoc) => errorDoc.convert(convertFunction)),
+            refreshDoc: this.refreshDoc.convert(convertFunction),
+        }));
+    }
+}
+exports.RefreshStatusRouteSuccessResponse = RefreshStatusRouteSuccessResponse;
+//# sourceMappingURL=BitBadgesCollection.js.map