bitbadgesjs-sdk 0.1.86 → 0.2.0

package/dist/src/core/overlaps.js

@@ -0,0 +1,717 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateUniversalPermissionUpdate = exports.MergeUniversalPermissionDetails = exports.GetFirstMatchOnly = exports.ApprovalPermissionUsedFlags = exports.BalancesActionPermissionUsedFlags = exports.TimedUpdateWithBadgeIdsPermissionUsedFlags = exports.TimedUpdatePermissionUsedFlags = exports.ActionPermissionUsedFlags = exports.GetListWithOptions = exports.GetListIdWithOptions = exports.GetUintRangesWithOptions = exports.universalRemoveOverlaps = exports.universalRemoveOverlapFromValues = exports.getOverlapsAndNonOverlaps = void 0;
+const addressLists_1 = require("./addressLists");
+const string_numbers_1 = require("../common/string-numbers");
+const uintRanges_1 = require("./uintRanges");
+const { getReservedTrackerList } = addressLists_1.AddressList;
+function getOverlapsAndNonOverlaps(firstDetails, secondDetails) {
+    let inOldButNotNew = firstDetails;
+    let inNewButNotOld = secondDetails;
+    const allOverlaps = [];
+    for (const oldPermission of firstDetails) {
+        for (const newPermission of secondDetails) {
+            const [, overlaps] = universalRemoveOverlaps(newPermission, oldPermission);
+            for (const overlap of overlaps) {
+                allOverlaps.push({
+                    overlap,
+                    firstDetails: oldPermission,
+                    secondDetails: newPermission
+                });
+            }
+        }
+    }
+    for (const overlap of allOverlaps) {
+        [inOldButNotNew] = universalRemoveOverlapFromValues(overlap.overlap, inOldButNotNew);
+        [inNewButNotOld] = universalRemoveOverlapFromValues(overlap.overlap, inNewButNotOld);
+    }
+    return [allOverlaps, inOldButNotNew, inNewButNotOld];
+}
+exports.getOverlapsAndNonOverlaps = getOverlapsAndNonOverlaps;
+function universalRemoveOverlapFromValues(handled, valuesToCheck) {
+    const newValuesToCheck = [];
+    const removed = [];
+    for (const valueToCheck of valuesToCheck) {
+        const [remaining, overlaps] = universalRemoveOverlaps(handled, valueToCheck);
+        newValuesToCheck.push(...remaining);
+        removed.push(...overlaps);
+    }
+    return [newValuesToCheck, removed];
+}
+exports.universalRemoveOverlapFromValues = universalRemoveOverlapFromValues;
+function universalRemoveOverlaps(handled, valueToCheck) {
+    const [timelineTimesAfterRemoval, removedTimelineTimes] = valueToCheck.timelineTime.getOverlapDetails(handled.timelineTime);
+    const [badgesAfterRemoval, removedBadges] = valueToCheck.badgeId.getOverlapDetails(handled.badgeId);
+    const [transferTimesAfterRemoval, removedTransferTimes] = valueToCheck.transferTime.getOverlapDetails(handled.transferTime);
+    const [ownershipTimesAfterRemoval, removedOwnershipTimes] = valueToCheck.ownershipTime.getOverlapDetails(handled.ownershipTime);
+    const [toListAfterRemoval, removedToList] = valueToCheck.toList.getOverlapDetails(handled.toList);
+    const [fromListAfterRemoval, removedFromList] = valueToCheck.fromList.getOverlapDetails(handled.fromList);
+    const [initiatedByListAfterRemoval, removedInitiatedByList] = valueToCheck.initiatedByList.getOverlapDetails(handled.initiatedByList);
+    const [approvalIdListAfterRemoval, removedApprovalIdList] = valueToCheck.approvalIdList.getOverlapDetails(handled.approvalIdList);
+    const [amountTrackerIdListAfterRemoval, removedAmountTrackerIdList] = valueToCheck.amountTrackerIdList.getOverlapDetails(handled.amountTrackerIdList);
+    const [challengeTrackerIdListAfterRemoval, removedChallengeTrackerIdList] = valueToCheck.challengeTrackerIdList.getOverlapDetails(handled.challengeTrackerIdList);
+    const removedToListIsEmpty = removedToList.isEmpty();
+    const removedFromListIsEmpty = removedFromList.isEmpty();
+    const removedInitiatedByListIsEmpty = removedInitiatedByList.isEmpty();
+    const removedApprovalIdListIsEmpty = removedApprovalIdList.isEmpty();
+    const removedAmountTrackerIdListIsEmpty = removedAmountTrackerIdList.isEmpty();
+    const removedChallengeTrackerIdListIsEmpty = removedChallengeTrackerIdList.isEmpty();
+    const remaining = [];
+    if (removedTimelineTimes.length === 0 ||
+        removedBadges.length === 0 ||
+        removedTransferTimes.length === 0 ||
+        removedOwnershipTimes.length === 0 ||
+        removedToListIsEmpty ||
+        removedFromListIsEmpty ||
+        removedInitiatedByListIsEmpty ||
+        removedApprovalIdListIsEmpty ||
+        removedAmountTrackerIdListIsEmpty ||
+        removedChallengeTrackerIdListIsEmpty) {
+        remaining.push(valueToCheck);
+        return [remaining, []];
+    }
+    for (const timelineTimeAfterRemoval of timelineTimesAfterRemoval) {
+        remaining.push({
+            timelineTime: timelineTimeAfterRemoval,
+            badgeId: valueToCheck.badgeId,
+            transferTime: valueToCheck.transferTime,
+            ownershipTime: valueToCheck.ownershipTime,
+            toList: valueToCheck.toList,
+            fromList: valueToCheck.fromList,
+            initiatedByList: valueToCheck.initiatedByList,
+            approvalIdList: valueToCheck.approvalIdList,
+            amountTrackerIdList: valueToCheck.amountTrackerIdList,
+            challengeTrackerIdList: valueToCheck.challengeTrackerIdList,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    for (const badgeAfterRemoval of badgesAfterRemoval) {
+        remaining.push({
+            timelineTime: removedTimelineTimes[0],
+            badgeId: badgeAfterRemoval,
+            transferTime: valueToCheck.transferTime,
+            ownershipTime: valueToCheck.ownershipTime,
+            toList: valueToCheck.toList,
+            fromList: valueToCheck.fromList,
+            initiatedByList: valueToCheck.initiatedByList,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            approvalIdList: valueToCheck.approvalIdList,
+            amountTrackerIdList: valueToCheck.amountTrackerIdList,
+            challengeTrackerIdList: valueToCheck.challengeTrackerIdList,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    for (const transferTimeAfterRemoval of transferTimesAfterRemoval) {
+        remaining.push({
+            timelineTime: removedTimelineTimes[0],
+            badgeId: removedBadges[0],
+            transferTime: transferTimeAfterRemoval,
+            ownershipTime: valueToCheck.ownershipTime,
+            toList: valueToCheck.toList,
+            fromList: valueToCheck.fromList,
+            initiatedByList: valueToCheck.initiatedByList,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            approvalIdList: valueToCheck.approvalIdList,
+            amountTrackerIdList: valueToCheck.amountTrackerIdList,
+            challengeTrackerIdList: valueToCheck.challengeTrackerIdList,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    for (const ownershipTimeAfterRemoval of ownershipTimesAfterRemoval) {
+        remaining.push({
+            timelineTime: removedTimelineTimes[0],
+            badgeId: removedBadges[0],
+            transferTime: removedTransferTimes[0],
+            ownershipTime: ownershipTimeAfterRemoval,
+            toList: valueToCheck.toList,
+            fromList: valueToCheck.fromList,
+            initiatedByList: valueToCheck.initiatedByList,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            approvalIdList: valueToCheck.approvalIdList,
+            amountTrackerIdList: valueToCheck.amountTrackerIdList,
+            challengeTrackerIdList: valueToCheck.challengeTrackerIdList,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    if (!toListAfterRemoval.isEmpty()) {
+        remaining.push({
+            timelineTime: removedTimelineTimes[0],
+            badgeId: removedBadges[0],
+            transferTime: removedTransferTimes[0],
+            ownershipTime: removedOwnershipTimes[0],
+            toList: toListAfterRemoval,
+            fromList: valueToCheck.fromList,
+            initiatedByList: valueToCheck.initiatedByList,
+            approvalIdList: valueToCheck.approvalIdList,
+            amountTrackerIdList: valueToCheck.amountTrackerIdList,
+            challengeTrackerIdList: valueToCheck.challengeTrackerIdList,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    if (!fromListAfterRemoval.isEmpty()) {
+        remaining.push({
+            timelineTime: removedTimelineTimes[0],
+            badgeId: removedBadges[0],
+            transferTime: removedTransferTimes[0],
+            ownershipTime: removedOwnershipTimes[0],
+            toList: removedToList,
+            fromList: fromListAfterRemoval,
+            initiatedByList: valueToCheck.initiatedByList,
+            approvalIdList: valueToCheck.approvalIdList,
+            amountTrackerIdList: valueToCheck.amountTrackerIdList,
+            challengeTrackerIdList: valueToCheck.challengeTrackerIdList,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    if (!initiatedByListAfterRemoval.isEmpty()) {
+        remaining.push({
+            timelineTime: removedTimelineTimes[0],
+            badgeId: removedBadges[0],
+            transferTime: removedTransferTimes[0],
+            ownershipTime: removedOwnershipTimes[0],
+            toList: removedToList,
+            fromList: removedFromList,
+            initiatedByList: initiatedByListAfterRemoval,
+            approvalIdList: valueToCheck.approvalIdList,
+            amountTrackerIdList: valueToCheck.amountTrackerIdList,
+            challengeTrackerIdList: valueToCheck.challengeTrackerIdList,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    if (!approvalIdListAfterRemoval.isEmpty()) {
+        remaining.push({
+            timelineTime: removedTimelineTimes[0],
+            badgeId: removedBadges[0],
+            transferTime: removedTransferTimes[0],
+            ownershipTime: removedOwnershipTimes[0],
+            toList: removedToList,
+            fromList: removedFromList,
+            initiatedByList: removedInitiatedByList,
+            approvalIdList: approvalIdListAfterRemoval,
+            amountTrackerIdList: valueToCheck.amountTrackerIdList,
+            challengeTrackerIdList: valueToCheck.challengeTrackerIdList,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    if (!amountTrackerIdListAfterRemoval.isEmpty()) {
+        remaining.push({
+            timelineTime: removedTimelineTimes[0],
+            badgeId: removedBadges[0],
+            transferTime: removedTransferTimes[0],
+            ownershipTime: removedOwnershipTimes[0],
+            toList: removedToList,
+            fromList: removedFromList,
+            initiatedByList: removedInitiatedByList,
+            approvalIdList: removedApprovalIdList,
+            amountTrackerIdList: amountTrackerIdListAfterRemoval,
+            challengeTrackerIdList: valueToCheck.challengeTrackerIdList,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    if (!challengeTrackerIdListAfterRemoval.isEmpty()) {
+        remaining.push({
+            timelineTime: removedTimelineTimes[0],
+            badgeId: removedBadges[0],
+            transferTime: removedTransferTimes[0],
+            ownershipTime: removedOwnershipTimes[0],
+            toList: removedToList,
+            fromList: removedFromList,
+            initiatedByList: removedInitiatedByList,
+            approvalIdList: removedApprovalIdList,
+            amountTrackerIdList: removedAmountTrackerIdList,
+            challengeTrackerIdList: challengeTrackerIdListAfterRemoval,
+            arbitraryValue: valueToCheck.arbitraryValue,
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([])
+        });
+    }
+    const removed = [];
+    for (const removedTimelineTime of removedTimelineTimes) {
+        for (const removedBadge of removedBadges) {
+            for (const removedTransferTime of removedTransferTimes) {
+                for (const removedOwnershipTime of removedOwnershipTimes) {
+                    removed.push({
+                        timelineTime: removedTimelineTime,
+                        badgeId: removedBadge,
+                        transferTime: removedTransferTime,
+                        ownershipTime: removedOwnershipTime,
+                        toList: removedToList,
+                        fromList: removedFromList,
+                        initiatedByList: removedInitiatedByList,
+                        approvalIdList: removedApprovalIdList,
+                        amountTrackerIdList: removedAmountTrackerIdList,
+                        challengeTrackerIdList: removedChallengeTrackerIdList,
+                        arbitraryValue: valueToCheck.arbitraryValue,
+                        permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]),
+                        permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([])
+                    });
+                }
+            }
+        }
+    }
+    return [remaining, removed];
+}
+exports.universalRemoveOverlaps = universalRemoveOverlaps;
+function GetUintRangesWithOptions(_ranges, uses) {
+    let ranges = _ranges.map((x) => x.convert(string_numbers_1.BigIntify));
+    if (!uses) {
+        ranges = [new uintRanges_1.UintRange({ start: BigInt(1), end: BigInt(1) })];
+        return uintRanges_1.UintRangeArray.From(ranges);
+    }
+    return uintRanges_1.UintRangeArray.From(ranges);
+}
+exports.GetUintRangesWithOptions = GetUintRangesWithOptions;
+function GetListIdWithOptions(listId, uses) {
+    if (!uses) {
+        listId = 'All';
+    }
+    return listId;
+}
+exports.GetListIdWithOptions = GetListIdWithOptions;
+function GetListWithOptions(_list, uses) {
+    const list = new addressLists_1.AddressList(_list);
+    if (!uses) {
+        list.addresses = [];
+        list.whitelist = false;
+    }
+    return list;
+}
+exports.GetListWithOptions = GetListWithOptions;
+exports.ActionPermissionUsedFlags = {
+    usesBadgeIds: false,
+    usesTimelineTimes: false,
+    usesTransferTimes: false,
+    usesToList: false,
+    usesFromList: false,
+    usesInitiatedByList: false,
+    usesOwnershipTimes: false,
+    usesApprovalIdList: false,
+    usesAmountTrackerIdList: false,
+    usesChallengeTrackerIdList: false
+};
+exports.TimedUpdatePermissionUsedFlags = {
+    usesBadgeIds: false,
+    usesTimelineTimes: true,
+    usesTransferTimes: false,
+    usesToList: false,
+    usesFromList: false,
+    usesInitiatedByList: false,
+    usesOwnershipTimes: false,
+    usesApprovalIdList: false,
+    usesAmountTrackerIdList: false,
+    usesChallengeTrackerIdList: false
+};
+exports.TimedUpdateWithBadgeIdsPermissionUsedFlags = {
+    usesBadgeIds: true,
+    usesTimelineTimes: true,
+    usesTransferTimes: false,
+    usesToList: false,
+    usesFromList: false,
+    usesInitiatedByList: false,
+    usesOwnershipTimes: false,
+    usesApprovalIdList: false,
+    usesAmountTrackerIdList: false,
+    usesChallengeTrackerIdList: false
+};
+exports.BalancesActionPermissionUsedFlags = {
+    usesBadgeIds: true,
+    usesTimelineTimes: false,
+    usesTransferTimes: false,
+    usesToList: false,
+    usesFromList: false,
+    usesInitiatedByList: false,
+    usesOwnershipTimes: true,
+    usesApprovalIdList: false,
+    usesAmountTrackerIdList: false,
+    usesChallengeTrackerIdList: false
+};
+exports.ApprovalPermissionUsedFlags = {
+    usesBadgeIds: true,
+    usesTimelineTimes: false,
+    usesTransferTimes: true,
+    usesToList: true,
+    usesFromList: true,
+    usesInitiatedByList: true,
+    usesOwnershipTimes: true,
+    usesApprovalIdList: true,
+    usesAmountTrackerIdList: true,
+    usesChallengeTrackerIdList: true
+};
+function GetFirstMatchOnly(permissions, handleAllPossibleCombinations, usesFlags) {
+    const handled = [];
+    if (handleAllPossibleCombinations && !usesFlags)
+        throw new Error('handleAllPossibleCombinations is true but usesFlags is null');
+    if (handleAllPossibleCombinations && usesFlags) {
+        permissions.push({
+            timelineTimes: uintRanges_1.UintRangeArray.FullRanges(),
+            fromList: addressLists_1.AddressList.AllAddresses(),
+            toList: addressLists_1.AddressList.AllAddresses(),
+            initiatedByList: addressLists_1.AddressList.AllAddresses(),
+            approvalIdList: getReservedTrackerList('All'),
+            amountTrackerIdList: getReservedTrackerList('All'),
+            challengeTrackerIdList: getReservedTrackerList('All'),
+            transferTimes: uintRanges_1.UintRangeArray.FullRanges(),
+            badgeIds: uintRanges_1.UintRangeArray.FullRanges(),
+            ownershipTimes: uintRanges_1.UintRangeArray.FullRanges(),
+            permanentlyPermittedTimes: uintRanges_1.UintRangeArray.From([]),
+            permanentlyForbiddenTimes: uintRanges_1.UintRangeArray.From([]),
+            ...usesFlags,
+            arbitraryValue: {}
+        });
+    }
+    for (const permission of permissions) {
+        const badgeIds = GetUintRangesWithOptions(permission.badgeIds, permission.usesBadgeIds);
+        const timelineTimes = GetUintRangesWithOptions(permission.timelineTimes, permission.usesTimelineTimes);
+        const transferTimes = GetUintRangesWithOptions(permission.transferTimes, permission.usesTransferTimes);
+        const ownershipTimes = GetUintRangesWithOptions(permission.ownershipTimes, permission.usesOwnershipTimes);
+        const permanentlyPermittedTimes = GetUintRangesWithOptions(permission.permanentlyPermittedTimes, true);
+        const permanentlyForbiddenTimes = GetUintRangesWithOptions(permission.permanentlyForbiddenTimes, true);
+        const arbitraryValue = permission.arbitraryValue;
+        const toList = GetListWithOptions(permission.toList, permission.usesToList);
+        const fromList = GetListWithOptions(permission.fromList, permission.usesFromList);
+        const initiatedByList = GetListWithOptions(permission.initiatedByList, permission.usesInitiatedByList);
+        const approvalIdList = GetListWithOptions(permission.approvalIdList, permission.usesApprovalIdList);
+        const amountTrackerIdList = GetListWithOptions(permission.amountTrackerIdList, permission.usesAmountTrackerIdList);
+        const challengeTrackerIdList = GetListWithOptions(permission.challengeTrackerIdList, permission.usesChallengeTrackerIdList);
+        for (const badgeId of badgeIds) {
+            for (const timelineTime of timelineTimes) {
+                for (const transferTime of transferTimes) {
+                    for (const ownershipTime of ownershipTimes) {
+                        const brokenDown = [
+                            {
+                                badgeId: badgeId,
+                                timelineTime: timelineTime,
+                                transferTime: transferTime,
+                                ownershipTime: ownershipTime,
+                                toList: toList,
+                                fromList: fromList,
+                                initiatedByList: initiatedByList,
+                                approvalIdList: approvalIdList,
+                                amountTrackerIdList: amountTrackerIdList,
+                                challengeTrackerIdList: challengeTrackerIdList,
+                                permanentlyPermittedTimes: permanentlyPermittedTimes,
+                                permanentlyForbiddenTimes: permanentlyForbiddenTimes,
+                                arbitraryValue
+                            }
+                        ];
+                        const [, remainingAfterHandledIsRemoved] = getOverlapsAndNonOverlaps(brokenDown, handled);
+                        for (const remaining of remainingAfterHandledIsRemoved) {
+                            handled.push({
+                                timelineTime: remaining.timelineTime,
+                                badgeId: remaining.badgeId,
+                                transferTime: remaining.transferTime,
+                                ownershipTime: remaining.ownershipTime,
+                                toList: remaining.toList,
+                                fromList: remaining.fromList,
+                                initiatedByList: remaining.initiatedByList,
+                                approvalIdList: remaining.approvalIdList,
+                                amountTrackerIdList: remaining.amountTrackerIdList,
+                                challengeTrackerIdList: remaining.challengeTrackerIdList,
+                                permanentlyPermittedTimes: permanentlyPermittedTimes,
+                                permanentlyForbiddenTimes: permanentlyForbiddenTimes,
+                                arbitraryValue: arbitraryValue
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return handled;
+}
+exports.GetFirstMatchOnly = GetFirstMatchOnly;
+function MergeUniversalPermissionDetails(permissions, doNotMerge) {
+    let merged = permissions.map((permission) => {
+        return {
+            badgeIds: uintRanges_1.UintRangeArray.From([permission.badgeId]),
+            timelineTimes: uintRanges_1.UintRangeArray.From([permission.timelineTime]),
+            transferTimes: uintRanges_1.UintRangeArray.From([permission.transferTime]),
+            ownershipTimes: uintRanges_1.UintRangeArray.From([permission.ownershipTime]),
+            toList: permission.toList,
+            fromList: permission.fromList,
+            initiatedByList: permission.initiatedByList,
+            approvalIdList: permission.approvalIdList,
+            amountTrackerIdList: permission.amountTrackerIdList,
+            challengeTrackerIdList: permission.challengeTrackerIdList,
+            permanentlyPermittedTimes: permission.permanentlyPermittedTimes,
+            permanentlyForbiddenTimes: permission.permanentlyForbiddenTimes,
+            arbitraryValue: permission.arbitraryValue
+        };
+    });
+    if (doNotMerge) {
+        return merged;
+    }
+    let unhandledLeft = true;
+    while (unhandledLeft) {
+        unhandledLeft = false;
+        for (let i = 0; i < merged.length; i++) {
+            for (let j = i + 1; j < merged.length; j++) {
+                const first = merged[i];
+                const second = merged[j];
+                const badgeIdsAreSame = JSON.stringify(first.badgeIds) === JSON.stringify(second.badgeIds);
+                const timelineTimesAreSame = JSON.stringify(first.timelineTimes) === JSON.stringify(second.timelineTimes);
+                const transferTimesAreSame = JSON.stringify(first.transferTimes) === JSON.stringify(second.transferTimes);
+                const ownershipTimesAreSame = JSON.stringify(first.ownershipTimes) === JSON.stringify(second.ownershipTimes);
+                const toListsAreSame = first.toList.whitelist === second.toList.whitelist && JSON.stringify(first.toList.addresses) === JSON.stringify(second.toList.addresses);
+                const fromListsAreSame = first.fromList.whitelist === second.fromList.whitelist &&
+                    JSON.stringify(first.fromList.addresses) === JSON.stringify(second.fromList.addresses);
+                const initiatedByListsAreSame = first.initiatedByList.whitelist === second.initiatedByList.whitelist &&
+                    JSON.stringify(first.initiatedByList.addresses) === JSON.stringify(second.initiatedByList.addresses);
+                const approvalIdListsAreSame = first.approvalIdList.whitelist === second.approvalIdList.whitelist &&
+                    JSON.stringify(first.approvalIdList.addresses) === JSON.stringify(second.approvalIdList.addresses);
+                const amountTrackerIdListsAreSame = first.amountTrackerIdList.whitelist === second.amountTrackerIdList.whitelist &&
+                    JSON.stringify(first.amountTrackerIdList.addresses) === JSON.stringify(second.amountTrackerIdList.addresses);
+                const challengeTrackerIdListsAreSame = first.challengeTrackerIdList.whitelist === second.challengeTrackerIdList.whitelist &&
+                    JSON.stringify(first.challengeTrackerIdList.addresses) === JSON.stringify(second.challengeTrackerIdList.addresses);
+                const permittedTimesAreSame = JSON.stringify(first.permanentlyPermittedTimes) === JSON.stringify(second.permanentlyPermittedTimes);
+                const forbiddenTimesAreSame = JSON.stringify(first.permanentlyForbiddenTimes) === JSON.stringify(second.permanentlyForbiddenTimes);
+                const arbitraryValuesAreSame = JSON.stringify(first.arbitraryValue) === JSON.stringify(second.arbitraryValue);
+                if (badgeIdsAreSame)
+                    first.badgeIds.push(...second.badgeIds);
+                if (timelineTimesAreSame)
+                    first.timelineTimes.push(...second.timelineTimes);
+                if (transferTimesAreSame)
+                    first.transferTimes.push(...second.transferTimes);
+                if (ownershipTimesAreSame)
+                    first.ownershipTimes.push(...second.ownershipTimes);
+                first.badgeIds.sortAndMerge();
+                first.timelineTimes.sortAndMerge();
+                first.transferTimes.sortAndMerge();
+                first.ownershipTimes.sortAndMerge();
+                const newBadgeIds = first.badgeIds;
+                const newTimelineTimes = first.timelineTimes;
+                const newTransferTimes = first.transferTimes;
+                const newOwnershipTimes = first.ownershipTimes;
+                let sameCount = 0;
+                if (badgeIdsAreSame)
+                    sameCount++;
+                if (timelineTimesAreSame)
+                    sameCount++;
+                if (transferTimesAreSame)
+                    sameCount++;
+                if (ownershipTimesAreSame)
+                    sameCount++;
+                let addressSameCount = 0;
+                if (toListsAreSame)
+                    addressSameCount++;
+                if (fromListsAreSame)
+                    addressSameCount++;
+                if (initiatedByListsAreSame)
+                    addressSameCount++;
+                if (approvalIdListsAreSame)
+                    addressSameCount++;
+                if (amountTrackerIdListsAreSame)
+                    addressSameCount++;
+                if (challengeTrackerIdListsAreSame)
+                    addressSameCount++;
+                if (sameCount === 3 &&
+                    approvalIdListsAreSame &&
+                    amountTrackerIdListsAreSame &&
+                    challengeTrackerIdListsAreSame &&
+                    toListsAreSame &&
+                    fromListsAreSame &&
+                    initiatedByListsAreSame &&
+                    permittedTimesAreSame &&
+                    forbiddenTimesAreSame &&
+                    arbitraryValuesAreSame) {
+                    merged.push({
+                        badgeIds: newBadgeIds,
+                        timelineTimes: newTimelineTimes,
+                        transferTimes: newTransferTimes,
+                        ownershipTimes: newOwnershipTimes,
+                        toList: first.toList,
+                        fromList: first.fromList,
+                        initiatedByList: first.initiatedByList,
+                        approvalIdList: first.approvalIdList,
+                        amountTrackerIdList: first.amountTrackerIdList,
+                        challengeTrackerIdList: first.challengeTrackerIdList,
+                        permanentlyPermittedTimes: first.permanentlyPermittedTimes,
+                        permanentlyForbiddenTimes: first.permanentlyForbiddenTimes,
+                        arbitraryValue: first.arbitraryValue
+                    });
+                    merged = merged.filter((_, idx) => idx !== i && idx !== j);
+                    unhandledLeft = true;
+                    i = Number.MAX_SAFE_INTEGER;
+                    j = Number.MAX_SAFE_INTEGER;
+                }
+                else if (sameCount === 4 && addressSameCount == 5 && permittedTimesAreSame && forbiddenTimesAreSame && arbitraryValuesAreSame) {
+                    merged.push({
+                        badgeIds: newBadgeIds,
+                        timelineTimes: newTimelineTimes,
+                        transferTimes: newTransferTimes,
+                        ownershipTimes: newOwnershipTimes,
+                        toList: !toListsAreSame && first.toList.whitelist === second.toList.whitelist
+                            ? new addressLists_1.AddressList({
+                                ...first.toList,
+                                addresses: [...new Set([...first.toList.addresses, ...second.toList.addresses])]
+                            })
+                            : first.toList,
+                        fromList: !fromListsAreSame && first.fromList.whitelist === second.fromList.whitelist
+                            ? new addressLists_1.AddressList({
+                                ...first.fromList,
+                                addresses: [...new Set([...first.fromList.addresses, ...second.fromList.addresses])]
+                            })
+                            : first.fromList,
+                        initiatedByList: !initiatedByListsAreSame && first.initiatedByList.whitelist === second.initiatedByList.whitelist
+                            ? new addressLists_1.AddressList({
+                                ...first.initiatedByList,
+                                addresses: [...new Set([...first.initiatedByList.addresses, ...second.initiatedByList.addresses])]
+                            })
+                            : first.initiatedByList,
+                        approvalIdList: !approvalIdListsAreSame && first.approvalIdList.whitelist === second.approvalIdList.whitelist
+                            ? new addressLists_1.AddressList({
+                                ...first.approvalIdList,
+                                addresses: [...new Set([...first.approvalIdList.addresses, ...second.approvalIdList.addresses])]
+                            })
+                            : first.approvalIdList,
+                        amountTrackerIdList: !amountTrackerIdListsAreSame && first.amountTrackerIdList.whitelist === second.amountTrackerIdList.whitelist
+                            ? new addressLists_1.AddressList({
+                                ...first.amountTrackerIdList,
+                                addresses: [...new Set([...first.amountTrackerIdList.addresses, ...second.amountTrackerIdList.addresses])]
+                            })
+                            : first.amountTrackerIdList,
+                        challengeTrackerIdList: !challengeTrackerIdListsAreSame && first.challengeTrackerIdList.whitelist === second.challengeTrackerIdList.whitelist
+                            ? new addressLists_1.AddressList({
+                                ...first.challengeTrackerIdList,
+                                addresses: [...new Set([...first.challengeTrackerIdList.addresses, ...second.challengeTrackerIdList.addresses])]
+                            })
+                            : first.challengeTrackerIdList,
+                        permanentlyPermittedTimes: first.permanentlyPermittedTimes,
+                        permanentlyForbiddenTimes: first.permanentlyForbiddenTimes,
+                        arbitraryValue: first.arbitraryValue
+                    });
+                    merged = merged.filter((_, idx) => idx !== i && idx !== j);
+                    unhandledLeft = true;
+                    i = Number.MAX_SAFE_INTEGER;
+                    j = Number.MAX_SAFE_INTEGER;
+                }
+            }
+        }
+    }
+    return merged;
+}
+exports.MergeUniversalPermissionDetails = MergeUniversalPermissionDetails;
+function GetPermissionString(permission) {
+    let str = '(';
+    if (permission.badgeId.start === BigInt('18446744073709551615') || permission.badgeId.end === BigInt('18446744073709551615')) {
+        str += 'badgeId: ' + permission.badgeId.start.toString() + ' ';
+    }
+    if (permission.timelineTime.start === BigInt('18446744073709551615') || permission.timelineTime.end === BigInt('18446744073709551615')) {
+        str += 'timelineTime: ' + permission.timelineTime.start.toString() + ' ';
+    }
+    if (permission.transferTime.start === BigInt('18446744073709551615') || permission.transferTime.end === BigInt('18446744073709551615')) {
+        str += 'transferTime: ' + permission.transferTime.start.toString() + ' ';
+    }
+    if (permission.ownershipTime.start === BigInt('18446744073709551615') || permission.ownershipTime.end === BigInt('18446744073709551615')) {
+        str += 'ownershipTime: ' + permission.ownershipTime.start.toString() + ' ';
+    }
+    if (permission.toList !== null) {
+        str += 'toList: ';
+        if (!permission.toList.whitelist) {
+            str += permission.toList.addresses.length.toString() + ' addresses ';
+        }
+        else {
+            str += 'all except ' + permission.toList.addresses.length.toString() + ' addresses ';
+        }
+        if (permission.toList.addresses.length > 0 && permission.toList.addresses.length <= 5) {
+            str += '(';
+            for (const address of permission.toList.addresses) {
+                str += address + ' ';
+            }
+            str += ')';
+        }
+    }
+    if (permission.fromList !== null) {
+        str += 'fromList: ';
+        if (!permission.fromList.whitelist) {
+            str += permission.fromList.addresses.length.toString() + ' addresses ';
+        }
+        else {
+            str += 'all except ' + permission.fromList.addresses.length.toString() + ' addresses ';
+        }
+        if (permission.fromList.addresses.length > 0 && permission.fromList.addresses.length <= 5) {
+            str += '(';
+            for (const address of permission.fromList.addresses) {
+                str += address + ' ';
+            }
+            str += ')';
+        }
+    }
+    if (permission.initiatedByList !== null) {
+        str += 'initiatedByList: ';
+        if (!permission.initiatedByList.whitelist) {
+            str += permission.initiatedByList.addresses.length.toString() + ' addresses ';
+        }
+        else {
+            str += 'all except ' + permission.initiatedByList.addresses.length.toString() + ' addresses ';
+        }
+        if (permission.initiatedByList.addresses.length > 0 && permission.initiatedByList.addresses.length <= 5) {
+            str += '(';
+            for (const address of permission.initiatedByList.addresses) {
+                str += address + ' ';
+            }
+            str += ')';
+        }
+    }
+    str += ') ';
+    return str;
+}
+function ValidateUniversalPermissionUpdate(oldPermissions, newPermissions) {
+    const [allOverlaps, inOldButNotNew] = getOverlapsAndNonOverlaps(oldPermissions, newPermissions);
+    if (inOldButNotNew.length > 0) {
+        let errMsg = 'permission ';
+        errMsg += GetPermissionString(inOldButNotNew[0]);
+        errMsg += 'found in old permissions but not in new permissions';
+        if (inOldButNotNew.length > 1) {
+            errMsg += ' (along with ' + (inOldButNotNew.length - 1) + ' more)';
+        }
+        return new Error(errMsg);
+    }
+    for (const overlapObj of allOverlaps) {
+        const oldPermission = overlapObj.firstDetails;
+        const newPermission = overlapObj.secondDetails;
+        const [leftoverPermittedTimes] = oldPermission.permanentlyPermittedTimes.getOverlapDetails(newPermission.permanentlyPermittedTimes);
+        const [leftoverForbiddenTimes] = oldPermission.permanentlyForbiddenTimes.getOverlapDetails(newPermission.permanentlyForbiddenTimes);
+        if (leftoverPermittedTimes.length > 0 || leftoverForbiddenTimes.length > 0) {
+            let errMsg = 'permission ';
+            errMsg += GetPermissionString(oldPermission);
+            errMsg += 'found in both new and old permissions but ';
+            if (leftoverPermittedTimes.length > 0) {
+                errMsg += 'previously explicitly allowed the times ( ';
+                for (const oldPermittedTime of leftoverPermittedTimes) {
+                    errMsg += oldPermittedTime.start.toString() + '-' + oldPermittedTime.end.toString() + ' ';
+                }
+                errMsg += ') which are now set to disApproved';
+            }
+            if (leftoverForbiddenTimes.length > 0 && leftoverPermittedTimes.length > 0) {
+                errMsg += ' and';
+            }
+            if (leftoverForbiddenTimes.length > 0) {
+                errMsg += ' previously explicitly disApproved the times ( ';
+                for (const oldForbiddenTime of leftoverForbiddenTimes) {
+                    errMsg += oldForbiddenTime.start.toString() + '-' + oldForbiddenTime.end.toString() + ' ';
+                }
+                errMsg += ') which are now set to allowed.';
+            }
+            return new Error(errMsg);
+        }
+    }
+    return null;
+}
+exports.ValidateUniversalPermissionUpdate = ValidateUniversalPermissionUpdate;
+//# sourceMappingURL=overlaps.js.map