bitbadgesjs-sdk 0.0.3 → 0.0.5

package/dist/utils/overlaps.js

@@ -0,0 +1,667 @@
+"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 utils_1 = require("./types/utils");
+const uintRanges_1 = require("./uintRanges");
+function getOverlapsAndNonOverlaps(firstDetails, secondDetails) {
+    let inOldButNotNew = (0, utils_1.deepCopy)(firstDetails);
+    let inNewButNotOld = (0, utils_1.deepCopy)(secondDetails);
+    let allOverlaps = [];
+    for (let oldPermission of firstDetails) {
+        for (let newPermission of secondDetails) {
+            let [_, overlaps] = universalRemoveOverlaps(newPermission, oldPermission);
+            for (let overlap of overlaps) {
+                allOverlaps.push({
+                    overlap,
+                    firstDetails: oldPermission,
+                    secondDetails: newPermission
+                });
+                [inOldButNotNew, _] = universalRemoveOverlapFromValues(overlap, inOldButNotNew);
+                [inNewButNotOld, _] = universalRemoveOverlapFromValues(overlap, inNewButNotOld);
+            }
+        }
+    }
+    return [allOverlaps, inOldButNotNew, inNewButNotOld];
+}
+exports.getOverlapsAndNonOverlaps = getOverlapsAndNonOverlaps;
+function universalRemoveOverlapFromValues(handled, valuesToCheck) {
+    let newValuesToCheck = [];
+    let removed = [];
+    for (let valueToCheck of valuesToCheck) {
+        let [remaining, overlaps] = universalRemoveOverlaps(handled, valueToCheck);
+        newValuesToCheck.push(...remaining);
+        removed.push(...overlaps);
+    }
+    return [newValuesToCheck, removed];
+}
+exports.universalRemoveOverlapFromValues = universalRemoveOverlapFromValues;
+function universalRemoveOverlaps(handled, valueToCheck) {
+    let [timelineTimesAfterRemoval, removedTimelineTimes] = (0, uintRanges_1.removeUintRangeFromUintRange)(handled.timelineTime, valueToCheck.timelineTime);
+    let [badgesAfterRemoval, removedBadges] = (0, uintRanges_1.removeUintRangeFromUintRange)(handled.badgeId, valueToCheck.badgeId);
+    let [transferTimesAfterRemoval, removedTransferTimes] = (0, uintRanges_1.removeUintRangeFromUintRange)(handled.transferTime, valueToCheck.transferTime);
+    let [ownershipTimesAfterRemoval, removedOwnershipTimes] = (0, uintRanges_1.removeUintRangeFromUintRange)(handled.ownershipTime, valueToCheck.ownershipTime);
+    let [toListAfterRemoval, removedToList] = (0, addressLists_1.removeAddressListFromAddressList)(handled.toList, valueToCheck.toList);
+    let [fromListAfterRemoval, removedFromList] = (0, addressLists_1.removeAddressListFromAddressList)(handled.fromList, valueToCheck.fromList);
+    let [initiatedByListAfterRemoval, removedInitiatedByList] = (0, addressLists_1.removeAddressListFromAddressList)(handled.initiatedByList, valueToCheck.initiatedByList);
+    let [approvalIdListAfterRemoval, removedApprovalIdList] = (0, addressLists_1.removeAddressListFromAddressList)(handled.approvalIdList, valueToCheck.approvalIdList);
+    let [amountTrackerIdListAfterRemoval, removedAmountTrackerIdList] = (0, addressLists_1.removeAddressListFromAddressList)(handled.amountTrackerIdList, valueToCheck.amountTrackerIdList);
+    let [challengeTrackerIdListAfterRemoval, removedChallengeTrackerIdList] = (0, addressLists_1.removeAddressListFromAddressList)(handled.challengeTrackerIdList, valueToCheck.challengeTrackerIdList);
+    let removedToListIsEmpty = (0, addressLists_1.isAddressListEmpty)(removedToList);
+    let removedFromListIsEmpty = (0, addressLists_1.isAddressListEmpty)(removedFromList);
+    let removedInitiatedByListIsEmpty = (0, addressLists_1.isAddressListEmpty)(removedInitiatedByList);
+    let removedApprovalIdListIsEmpty = (0, addressLists_1.isAddressListEmpty)(removedApprovalIdList);
+    let removedAmountTrackerIdListIsEmpty = (0, addressLists_1.isAddressListEmpty)(removedAmountTrackerIdList);
+    let removedChallengeTrackerIdListIsEmpty = (0, addressLists_1.isAddressListEmpty)(removedChallengeTrackerIdList);
+    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 (let 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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    for (let 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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    for (let 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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    for (let 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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    if (!(0, addressLists_1.isAddressListEmpty)(toListAfterRemoval)) {
+        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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    if (!(0, addressLists_1.isAddressListEmpty)(fromListAfterRemoval)) {
+        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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    if (!(0, addressLists_1.isAddressListEmpty)(initiatedByListAfterRemoval)) {
+        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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    if (!(0, addressLists_1.isAddressListEmpty)(approvalIdListAfterRemoval)) {
+        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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    if (!(0, addressLists_1.isAddressListEmpty)(amountTrackerIdListAfterRemoval)) {
+        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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    if (!(0, addressLists_1.isAddressListEmpty)(challengeTrackerIdListAfterRemoval)) {
+        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: [],
+            permanentlyForbiddenTimes: [],
+        });
+    }
+    const removed = [];
+    for (let removedTimelineTime of removedTimelineTimes) {
+        for (let removedBadge of removedBadges) {
+            for (let removedTransferTime of removedTransferTimes) {
+                for (let 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,
+                        permanentlyPermittedTimes: [],
+                        permanentlyForbiddenTimes: [],
+                    });
+                }
+            }
+        }
+    }
+    return [remaining, removed];
+}
+exports.universalRemoveOverlaps = universalRemoveOverlaps;
+function GetUintRangesWithOptions(_ranges, uses) {
+    let ranges = (0, utils_1.deepCopy)(_ranges);
+    if (!uses) {
+        ranges = [{ start: BigInt(1), end: BigInt(1) }];
+        return ranges;
+    }
+    return ranges;
+}
+exports.GetUintRangesWithOptions = GetUintRangesWithOptions;
+function GetListIdWithOptions(listId, uses) {
+    if (!uses) {
+        listId = "All";
+    }
+    return listId;
+}
+exports.GetListIdWithOptions = GetListIdWithOptions;
+function GetListWithOptions(_list, uses) {
+    const list = (0, utils_1.deepCopy)(_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: [{ start: 1n, end: 18446744073709551615n }],
+            fromList: (0, addressLists_1.getReservedAddressList)("All"),
+            toList: (0, addressLists_1.getReservedAddressList)("All"),
+            initiatedByList: (0, addressLists_1.getReservedAddressList)("All"),
+            approvalIdList: (0, addressLists_1.getReservedTrackerList)("All"),
+            amountTrackerIdList: (0, addressLists_1.getReservedTrackerList)("All"),
+            challengeTrackerIdList: (0, addressLists_1.getReservedTrackerList)("All"),
+            transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+            badgeIds: [{ start: 1n, end: 18446744073709551615n }],
+            ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: [],
+            ...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: [permission.badgeId],
+            timelineTimes: [permission.timelineTime],
+            transferTimes: [permission.transferTime],
+            ownershipTimes: [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);
+                const newBadgeIds = badgeIdsAreSame ? first.badgeIds : (0, uintRanges_1.sortUintRangesAndMergeIfNecessary)((0, utils_1.deepCopy)([...first.badgeIds, ...second.badgeIds]), true);
+                const newTimelineTimes = timelineTimesAreSame ? first.timelineTimes : (0, uintRanges_1.sortUintRangesAndMergeIfNecessary)((0, utils_1.deepCopy)([...first.timelineTimes, ...second.timelineTimes]), true);
+                const newTransferTimes = transferTimesAreSame ? first.transferTimes : (0, uintRanges_1.sortUintRangesAndMergeIfNecessary)((0, utils_1.deepCopy)([...first.transferTimes, ...second.transferTimes]), true);
+                const newOwnershipTimes = ownershipTimesAreSame ? first.ownershipTimes : (0, uintRanges_1.sortUintRangesAndMergeIfNecessary)((0, utils_1.deepCopy)([...first.ownershipTimes, ...second.ownershipTimes]), true);
+                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 ? {
+                            ...first.toList,
+                            addresses: [...new Set([...first.toList.addresses, ...second.toList.addresses])]
+                        } : first.toList,
+                        fromList: !fromListsAreSame && first.fromList.whitelist === second.fromList.whitelist ? {
+                            ...first.fromList,
+                            addresses: [...new Set([...first.fromList.addresses, ...second.fromList.addresses])]
+                        } : first.fromList,
+                        initiatedByList: !initiatedByListsAreSame && first.initiatedByList.whitelist === second.initiatedByList.whitelist ? {
+                            ...first.initiatedByList,
+                            addresses: [...new Set([...first.initiatedByList.addresses, ...second.initiatedByList.addresses])]
+                        } : first.initiatedByList,
+                        approvalIdList: !approvalIdListsAreSame && first.approvalIdList.whitelist === second.approvalIdList.whitelist ? {
+                            ...first.approvalIdList,
+                            addresses: [...new Set([...first.approvalIdList.addresses, ...second.approvalIdList.addresses])]
+                        } : first.approvalIdList,
+                        amountTrackerIdList: !amountTrackerIdListsAreSame && first.amountTrackerIdList.whitelist === second.amountTrackerIdList.whitelist ? {
+                            ...first.amountTrackerIdList,
+                            addresses: [...new Set([...first.amountTrackerIdList.addresses, ...second.amountTrackerIdList.addresses])]
+                        } : first.amountTrackerIdList,
+                        challengeTrackerIdList: !challengeTrackerIdListsAreSame && first.challengeTrackerIdList.whitelist === second.challengeTrackerIdList.whitelist ? {
+                            ...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, _x] = (0, uintRanges_1.removeUintRangesFromUintRanges)(newPermission.permanentlyPermittedTimes, oldPermission.permanentlyPermittedTimes);
+        const [leftoverForbiddenTimes, _y] = (0, uintRanges_1.removeUintRangesFromUintRanges)(newPermission.permanentlyForbiddenTimes, oldPermission.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