bitbadgesjs-sdk 0.3.148 → 0.3.149

package/dist/esm/core/approvals.js

@@ -1,1098 +0,0 @@
-import { BaseNumberTypeClass, CustomTypeClass, convertClassPropertiesAndMaintainNumberTypes, deepCopyPrimitives } from '../common/base.js';
-import * as proto from '../proto/index.js';
-import { BigIntify, Stringify } from '../common/string-numbers.js';
-import { AddressList } from './addressLists.js';
-import { Balance, BalanceArray } from './balances.js';
-import { CoinTransfer, MerkleChallenge, MustOwnBadges, ZkProof } from './misc.js';
-import { GetListIdWithOptions, GetListWithOptions, GetUintRangesWithOptions, getOverlapsAndNonOverlaps } from './overlaps.js';
-import { CollectionApprovalPermission } from './permissions.js';
-import { UintRange, UintRangeArray } from './uintRanges.js';
-import { AllDefaultValues, getPotentialUpdatesForTimelineValues, getUpdateCombinationsToCheck } from './validate-utils.js';
-const { getReservedAddressList, getReservedTrackerList } = AddressList;
-export class UserOutgoingApproval extends BaseNumberTypeClass {
-    toListId;
-    initiatedByListId;
-    transferTimes;
-    badgeIds;
-    ownershipTimes;
-    approvalId;
-    uri;
-    customData;
-    approvalCriteria;
-    constructor(msg) {
-        super();
-        this.toListId = msg.toListId;
-        this.initiatedByListId = msg.initiatedByListId;
-        this.transferTimes = UintRangeArray.From(msg.transferTimes);
-        this.badgeIds = UintRangeArray.From(msg.badgeIds);
-        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
-        this.approvalId = msg.approvalId;
-        this.uri = msg.uri;
-        this.customData = msg.customData;
-        this.approvalCriteria = msg.approvalCriteria ? new OutgoingApprovalCriteria(msg.approvalCriteria) : undefined;
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    toProto() {
-        return new proto.badges.UserOutgoingApproval(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return UserOutgoingApproval.fromProto(proto.badges.UserOutgoingApproval.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return UserOutgoingApproval.fromProto(proto.badges.UserOutgoingApproval.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new UserOutgoingApproval({
-            toListId: item.toListId,
-            initiatedByListId: item.initiatedByListId,
-            transferTimes: item.transferTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            badgeIds: item.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
-            ownershipTimes: item.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            approvalId: item.approvalId,
-            uri: item.uri,
-            customData: item.customData,
-            approvalCriteria: item.approvalCriteria ? OutgoingApprovalCriteria.fromProto(item.approvalCriteria, convertFunction) : undefined
-        });
-    }
-}
-export class OutgoingApprovalCriteria extends BaseNumberTypeClass {
-    mustOwnBadges;
-    merkleChallenges;
-    predeterminedBalances;
-    approvalAmounts;
-    maxNumTransfers;
-    requireToEqualsInitiatedBy;
-    requireToDoesNotEqualInitiatedBy;
-    zkProofs;
-    coinTransfers;
-    constructor(msg) {
-        super();
-        this.mustOwnBadges = msg.mustOwnBadges?.map((x) => new MustOwnBadges(x));
-        this.merkleChallenges = msg.merkleChallenges?.map((x) => new MerkleChallenge(x));
-        this.predeterminedBalances = msg.predeterminedBalances ? new PredeterminedBalances(msg.predeterminedBalances) : undefined;
-        this.approvalAmounts = msg.approvalAmounts ? new ApprovalAmounts(msg.approvalAmounts) : undefined;
-        this.maxNumTransfers = msg.maxNumTransfers ? new MaxNumTransfers(msg.maxNumTransfers) : undefined;
-        this.requireToEqualsInitiatedBy = msg.requireToEqualsInitiatedBy;
-        this.requireToDoesNotEqualInitiatedBy = msg.requireToDoesNotEqualInitiatedBy;
-        this.coinTransfers = msg.coinTransfers ? msg.coinTransfers.map((x) => new CoinTransfer(x)) : undefined;
-        this.zkProofs = msg.zkProofs ? msg.zkProofs.map((x) => new ZkProof(x)) : undefined;
-    }
-    convert(convertFunction) {
-        return new OutgoingApprovalCriteria(deepCopyPrimitives({
-            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
-            merkleChallenges: this.merkleChallenges?.map((x) => x.convert(convertFunction)),
-            predeterminedBalances: this.predeterminedBalances?.convert(convertFunction),
-            approvalAmounts: this.approvalAmounts?.convert(convertFunction),
-            maxNumTransfers: this.maxNumTransfers?.convert(convertFunction),
-            requireToEqualsInitiatedBy: this.requireToEqualsInitiatedBy,
-            requireToDoesNotEqualInitiatedBy: this.requireToDoesNotEqualInitiatedBy,
-            zkProofs: this.zkProofs?.map((x) => x),
-            coinTransfers: this.coinTransfers?.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto.badges.OutgoingApprovalCriteria(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return OutgoingApprovalCriteria.fromProto(proto.badges.OutgoingApprovalCriteria.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return OutgoingApprovalCriteria.fromProto(proto.badges.OutgoingApprovalCriteria.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new OutgoingApprovalCriteria({
-            mustOwnBadges: item.mustOwnBadges.map((x) => MustOwnBadges.fromProto(x, convertFunction)),
-            merkleChallenges: item.merkleChallenges.map((x) => MerkleChallenge.fromProto(x, convertFunction)),
-            predeterminedBalances: item.predeterminedBalances ? PredeterminedBalances.fromProto(item.predeterminedBalances, convertFunction) : undefined,
-            approvalAmounts: item.approvalAmounts ? ApprovalAmounts.fromProto(item.approvalAmounts, convertFunction) : undefined,
-            maxNumTransfers: item.maxNumTransfers ? MaxNumTransfers.fromProto(item.maxNumTransfers, convertFunction) : undefined,
-            requireToEqualsInitiatedBy: item.requireToEqualsInitiatedBy,
-            requireToDoesNotEqualInitiatedBy: item.requireToDoesNotEqualInitiatedBy,
-            zkProofs: item.zkProofs,
-            coinTransfers: item.coinTransfers ? item.coinTransfers.map((x) => CoinTransfer.fromProto(x, convertFunction)) : undefined
-        });
-    }
-    castToCollectionApprovalCriteria() {
-        return new ApprovalCriteria({
-            approvalAmounts: this.approvalAmounts,
-            maxNumTransfers: this.maxNumTransfers,
-            requireToEqualsInitiatedBy: this.requireToEqualsInitiatedBy,
-            requireToDoesNotEqualInitiatedBy: this.requireToDoesNotEqualInitiatedBy,
-            predeterminedBalances: this.predeterminedBalances,
-            mustOwnBadges: this.mustOwnBadges,
-            merkleChallenges: this.merkleChallenges,
-            zkProofs: this.zkProofs,
-            coinTransfers: this.coinTransfers,
-            requireFromEqualsInitiatedBy: false,
-            requireFromDoesNotEqualInitiatedBy: false,
-            overridesFromOutgoingApprovals: false,
-            overridesToIncomingApprovals: false
-        });
-    }
-}
-export class PredeterminedBalances extends BaseNumberTypeClass {
-    manualBalances;
-    incrementedBalances;
-    orderCalculationMethod;
-    constructor(msg) {
-        super();
-        this.manualBalances = msg.manualBalances.map((x) => new ManualBalances(x));
-        this.incrementedBalances = new IncrementedBalances(msg.incrementedBalances);
-        this.orderCalculationMethod = new PredeterminedOrderCalculationMethod(msg.orderCalculationMethod);
-    }
-    convert(convertFunction) {
-        return new PredeterminedBalances(deepCopyPrimitives({
-            manualBalances: this.manualBalances.map((x) => x.convert(convertFunction)),
-            incrementedBalances: this.incrementedBalances.convert(convertFunction),
-            orderCalculationMethod: this.orderCalculationMethod
-        }));
-    }
-    toProto() {
-        return new proto.badges.PredeterminedBalances(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return PredeterminedBalances.fromProto(proto.badges.PredeterminedBalances.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return PredeterminedBalances.fromProto(proto.badges.PredeterminedBalances.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new PredeterminedBalances({
-            manualBalances: item.manualBalances.map((x) => ManualBalances.fromProto(x, convertFunction)),
-            incrementedBalances: item.incrementedBalances
-                ? IncrementedBalances.fromProto(item.incrementedBalances, convertFunction)
-                : new IncrementedBalances({
-                    startBalances: [],
-                    incrementBadgeIdsBy: convertFunction(0),
-                    incrementOwnershipTimesBy: convertFunction(0)
-                }),
-            orderCalculationMethod: item.orderCalculationMethod
-                ? PredeterminedOrderCalculationMethod.fromProto(item.orderCalculationMethod)
-                : new PredeterminedOrderCalculationMethod({
-                    useOverallNumTransfers: false,
-                    usePerFromAddressNumTransfers: false,
-                    usePerToAddressNumTransfers: false,
-                    usePerInitiatedByAddressNumTransfers: false,
-                    useMerkleChallengeLeafIndex: false,
-                    challengeTrackerId: ''
-                })
-        });
-    }
-}
-export class ManualBalances extends BaseNumberTypeClass {
-    balances;
-    constructor(msg) {
-        super();
-        this.balances = BalanceArray.From(msg.balances);
-    }
-    convert(convertFunction) {
-        return new ManualBalances(deepCopyPrimitives({
-            balances: this.balances.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto.badges.ManualBalances(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return ManualBalances.fromProto(proto.badges.ManualBalances.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return ManualBalances.fromProto(proto.badges.ManualBalances.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new ManualBalances({
-            balances: item.balances.map((x) => Balance.fromProto(x, convertFunction))
-        });
-    }
-}
-export class IncrementedBalances extends BaseNumberTypeClass {
-    startBalances;
-    incrementBadgeIdsBy;
-    incrementOwnershipTimesBy;
-    constructor(msg) {
-        super();
-        this.startBalances = BalanceArray.From(msg.startBalances);
-        this.incrementBadgeIdsBy = msg.incrementBadgeIdsBy;
-        this.incrementOwnershipTimesBy = msg.incrementOwnershipTimesBy;
-    }
-    getNumberFieldNames() {
-        return ['incrementBadgeIdsBy', 'incrementOwnershipTimesBy'];
-    }
-    convert(convertFunction) {
-        return new IncrementedBalances(deepCopyPrimitives({
-            startBalances: this.startBalances.map((x) => x.convert(convertFunction)),
-            incrementBadgeIdsBy: convertFunction(this.incrementBadgeIdsBy),
-            incrementOwnershipTimesBy: convertFunction(this.incrementOwnershipTimesBy)
-        }));
-    }
-    toProto() {
-        return new proto.badges.IncrementedBalances(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return IncrementedBalances.fromProto(proto.badges.IncrementedBalances.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return IncrementedBalances.fromProto(proto.badges.IncrementedBalances.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new IncrementedBalances({
-            startBalances: item.startBalances.map((x) => Balance.fromProto(x, convertFunction)),
-            incrementBadgeIdsBy: convertFunction(item.incrementBadgeIdsBy),
-            incrementOwnershipTimesBy: convertFunction(item.incrementOwnershipTimesBy)
-        });
-    }
-}
-export class PredeterminedOrderCalculationMethod extends CustomTypeClass {
-    useOverallNumTransfers;
-    usePerToAddressNumTransfers;
-    usePerFromAddressNumTransfers;
-    usePerInitiatedByAddressNumTransfers;
-    useMerkleChallengeLeafIndex;
-    challengeTrackerId;
-    constructor(msg) {
-        super();
-        this.useOverallNumTransfers = msg.useOverallNumTransfers;
-        this.usePerToAddressNumTransfers = msg.usePerToAddressNumTransfers;
-        this.usePerFromAddressNumTransfers = msg.usePerFromAddressNumTransfers;
-        this.usePerInitiatedByAddressNumTransfers = msg.usePerInitiatedByAddressNumTransfers;
-        this.useMerkleChallengeLeafIndex = msg.useMerkleChallengeLeafIndex;
-        this.challengeTrackerId = msg.challengeTrackerId;
-    }
-    toProto() {
-        return new proto.badges.PredeterminedOrderCalculationMethod(this.toJson());
-    }
-    static fromJson(jsonValue, options) {
-        return PredeterminedOrderCalculationMethod.fromJson(jsonValue, options);
-    }
-    static fromJsonString(jsonString, options) {
-        return PredeterminedOrderCalculationMethod.fromJsonString(jsonString, options);
-    }
-    static fromProto(item) {
-        return new PredeterminedOrderCalculationMethod({
-            useOverallNumTransfers: item.useOverallNumTransfers,
-            usePerToAddressNumTransfers: item.usePerToAddressNumTransfers,
-            usePerFromAddressNumTransfers: item.usePerFromAddressNumTransfers,
-            usePerInitiatedByAddressNumTransfers: item.usePerInitiatedByAddressNumTransfers,
-            useMerkleChallengeLeafIndex: item.useMerkleChallengeLeafIndex,
-            challengeTrackerId: item.challengeTrackerId
-        });
-    }
-}
-export class ApprovalAmounts extends BaseNumberTypeClass {
-    overallApprovalAmount;
-    perToAddressApprovalAmount;
-    perFromAddressApprovalAmount;
-    perInitiatedByAddressApprovalAmount;
-    amountTrackerId;
-    constructor(msg) {
-        super();
-        this.overallApprovalAmount = msg.overallApprovalAmount;
-        this.perToAddressApprovalAmount = msg.perToAddressApprovalAmount;
-        this.perFromAddressApprovalAmount = msg.perFromAddressApprovalAmount;
-        this.perInitiatedByAddressApprovalAmount = msg.perInitiatedByAddressApprovalAmount;
-        this.amountTrackerId = msg.amountTrackerId;
-    }
-    getNumberFieldNames() {
-        return ['overallApprovalAmount', 'perToAddressApprovalAmount', 'perFromAddressApprovalAmount', 'perInitiatedByAddressApprovalAmount'];
-    }
-    convert(convertFunction) {
-        return new ApprovalAmounts(deepCopyPrimitives({
-            overallApprovalAmount: convertFunction(this.overallApprovalAmount),
-            perToAddressApprovalAmount: convertFunction(this.perToAddressApprovalAmount),
-            perFromAddressApprovalAmount: convertFunction(this.perFromAddressApprovalAmount),
-            perInitiatedByAddressApprovalAmount: convertFunction(this.perInitiatedByAddressApprovalAmount),
-            amountTrackerId: this.amountTrackerId
-        }));
-    }
-    toProto() {
-        return new proto.badges.ApprovalAmounts(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return ApprovalAmounts.fromProto(proto.badges.ApprovalAmounts.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return ApprovalAmounts.fromProto(proto.badges.ApprovalAmounts.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new ApprovalAmounts({
-            overallApprovalAmount: convertFunction(item.overallApprovalAmount),
-            perToAddressApprovalAmount: convertFunction(item.perToAddressApprovalAmount),
-            perFromAddressApprovalAmount: convertFunction(item.perFromAddressApprovalAmount),
-            perInitiatedByAddressApprovalAmount: convertFunction(item.perInitiatedByAddressApprovalAmount),
-            amountTrackerId: item.amountTrackerId
-        });
-    }
-}
-export class MaxNumTransfers extends BaseNumberTypeClass {
-    overallMaxNumTransfers;
-    perToAddressMaxNumTransfers;
-    perFromAddressMaxNumTransfers;
-    perInitiatedByAddressMaxNumTransfers;
-    amountTrackerId;
-    constructor(msg) {
-        super();
-        this.overallMaxNumTransfers = msg.overallMaxNumTransfers;
-        this.perToAddressMaxNumTransfers = msg.perToAddressMaxNumTransfers;
-        this.perFromAddressMaxNumTransfers = msg.perFromAddressMaxNumTransfers;
-        this.perInitiatedByAddressMaxNumTransfers = msg.perInitiatedByAddressMaxNumTransfers;
-        this.amountTrackerId = msg.amountTrackerId;
-    }
-    getNumberFieldNames() {
-        return ['overallMaxNumTransfers', 'perToAddressMaxNumTransfers', 'perFromAddressMaxNumTransfers', 'perInitiatedByAddressMaxNumTransfers'];
-    }
-    convert(convertFunction) {
-        return new MaxNumTransfers(deepCopyPrimitives({
-            overallMaxNumTransfers: convertFunction(this.overallMaxNumTransfers),
-            perToAddressMaxNumTransfers: convertFunction(this.perToAddressMaxNumTransfers),
-            perFromAddressMaxNumTransfers: convertFunction(this.perFromAddressMaxNumTransfers),
-            perInitiatedByAddressMaxNumTransfers: convertFunction(this.perInitiatedByAddressMaxNumTransfers),
-            amountTrackerId: this.amountTrackerId
-        }));
-    }
-    toProto() {
-        return new proto.badges.MaxNumTransfers(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return MaxNumTransfers.fromProto(proto.badges.MaxNumTransfers.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return MaxNumTransfers.fromProto(proto.badges.MaxNumTransfers.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new MaxNumTransfers({
-            overallMaxNumTransfers: convertFunction(item.overallMaxNumTransfers),
-            perToAddressMaxNumTransfers: convertFunction(item.perToAddressMaxNumTransfers),
-            perFromAddressMaxNumTransfers: convertFunction(item.perFromAddressMaxNumTransfers),
-            perInitiatedByAddressMaxNumTransfers: convertFunction(item.perInitiatedByAddressMaxNumTransfers),
-            amountTrackerId: item.amountTrackerId
-        });
-    }
-}
-export class UserIncomingApproval extends BaseNumberTypeClass {
-    fromListId;
-    initiatedByListId;
-    transferTimes;
-    badgeIds;
-    ownershipTimes;
-    approvalId;
-    uri;
-    customData;
-    approvalCriteria;
-    constructor(msg) {
-        super();
-        this.fromListId = msg.fromListId;
-        this.initiatedByListId = msg.initiatedByListId;
-        this.transferTimes = UintRangeArray.From(msg.transferTimes);
-        this.badgeIds = UintRangeArray.From(msg.badgeIds);
-        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
-        this.approvalId = msg.approvalId;
-        this.uri = msg.uri;
-        this.customData = msg.customData;
-        this.approvalCriteria = msg.approvalCriteria ? new IncomingApprovalCriteria(msg.approvalCriteria) : undefined;
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    toProto() {
-        return new proto.badges.UserIncomingApproval(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return UserIncomingApproval.fromProto(proto.badges.UserIncomingApproval.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return UserIncomingApproval.fromProto(proto.badges.UserIncomingApproval.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new UserIncomingApproval({
-            fromListId: item.fromListId,
-            initiatedByListId: item.initiatedByListId,
-            transferTimes: item.transferTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            badgeIds: item.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
-            ownershipTimes: item.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            approvalId: item.approvalId,
-            uri: item.uri,
-            customData: item.customData,
-            approvalCriteria: item.approvalCriteria ? IncomingApprovalCriteria.fromProto(item.approvalCriteria, convertFunction) : undefined
-        });
-    }
-    castToCollectionTransfer(toAddress) {
-        return new CollectionApproval({
-            ...this,
-            toListId: toAddress,
-            approvalCriteria: this.approvalCriteria?.castToCollectionApprovalCriteria()
-        });
-    }
-}
-export class IncomingApprovalCriteria extends BaseNumberTypeClass {
-    mustOwnBadges;
-    merkleChallenges;
-    predeterminedBalances;
-    approvalAmounts;
-    maxNumTransfers;
-    requireFromEqualsInitiatedBy;
-    requireFromDoesNotEqualInitiatedBy;
-    zkProofs;
-    coinTransfers;
-    constructor(msg) {
-        super();
-        this.mustOwnBadges = msg.mustOwnBadges?.map((x) => new MustOwnBadges(x));
-        this.merkleChallenges = msg.merkleChallenges?.map((x) => new MerkleChallenge(x));
-        this.predeterminedBalances = msg.predeterminedBalances ? new PredeterminedBalances(msg.predeterminedBalances) : undefined;
-        this.approvalAmounts = msg.approvalAmounts ? new ApprovalAmounts(msg.approvalAmounts) : undefined;
-        this.maxNumTransfers = msg.maxNumTransfers ? new MaxNumTransfers(msg.maxNumTransfers) : undefined;
-        this.requireFromEqualsInitiatedBy = msg.requireFromEqualsInitiatedBy;
-        this.requireFromDoesNotEqualInitiatedBy = msg.requireFromDoesNotEqualInitiatedBy;
-        this.zkProofs = msg.zkProofs ? msg.zkProofs.map((x) => new ZkProof(x)) : undefined;
-        this.coinTransfers = msg.coinTransfers ? msg.coinTransfers.map((x) => new CoinTransfer(x)) : undefined;
-    }
-    convert(convertFunction) {
-        return new IncomingApprovalCriteria(deepCopyPrimitives({
-            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
-            merkleChallenge: this.merkleChallenges?.map((x) => x.convert(convertFunction)),
-            predeterminedBalances: this.predeterminedBalances ? this.predeterminedBalances.convert(convertFunction) : undefined,
-            approvalAmounts: this.approvalAmounts ? this.approvalAmounts.convert(convertFunction) : undefined,
-            maxNumTransfers: this.maxNumTransfers ? this.maxNumTransfers.convert(convertFunction) : undefined,
-            requireFromEqualsInitiatedBy: this.requireFromEqualsInitiatedBy,
-            requireFromDoesNotEqualInitiatedBy: this.requireFromDoesNotEqualInitiatedBy,
-            zkProofs: this.zkProofs?.map((x) => x),
-            coinTransfers: this.coinTransfers?.map((x) => x.convert(convertFunction))
-        }));
-    }
-    toProto() {
-        return new proto.badges.IncomingApprovalCriteria(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return IncomingApprovalCriteria.fromProto(proto.badges.IncomingApprovalCriteria.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return IncomingApprovalCriteria.fromProto(proto.badges.IncomingApprovalCriteria.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new IncomingApprovalCriteria({
-            mustOwnBadges: item.mustOwnBadges.map((x) => MustOwnBadges.fromProto(x, convertFunction)),
-            merkleChallenges: item.merkleChallenges.map((x) => MerkleChallenge.fromProto(x, convertFunction)),
-            predeterminedBalances: item.predeterminedBalances ? PredeterminedBalances.fromProto(item.predeterminedBalances, convertFunction) : undefined,
-            approvalAmounts: item.approvalAmounts ? ApprovalAmounts.fromProto(item.approvalAmounts, convertFunction) : undefined,
-            maxNumTransfers: item.maxNumTransfers ? MaxNumTransfers.fromProto(item.maxNumTransfers, convertFunction) : undefined,
-            requireFromEqualsInitiatedBy: item.requireFromEqualsInitiatedBy,
-            requireFromDoesNotEqualInitiatedBy: item.requireFromDoesNotEqualInitiatedBy,
-            zkProofs: item.zkProofs?.map((x) => ZkProof.fromProto(x)),
-            coinTransfers: item.coinTransfers ? item.coinTransfers.map((x) => CoinTransfer.fromProto(x, convertFunction)) : undefined
-        });
-    }
-    castToCollectionApprovalCriteria() {
-        return new ApprovalCriteria({
-            approvalAmounts: this.approvalAmounts,
-            maxNumTransfers: this.maxNumTransfers,
-            requireFromEqualsInitiatedBy: this.requireFromEqualsInitiatedBy,
-            requireFromDoesNotEqualInitiatedBy: this.requireFromDoesNotEqualInitiatedBy,
-            predeterminedBalances: this.predeterminedBalances,
-            mustOwnBadges: this.mustOwnBadges,
-            zkProofs: this.zkProofs,
-            merkleChallenges: this.merkleChallenges,
-            coinTransfers: this.coinTransfers,
-            requireToEqualsInitiatedBy: false,
-            requireToDoesNotEqualInitiatedBy: false,
-            overridesFromOutgoingApprovals: false,
-            overridesToIncomingApprovals: false
-        });
-    }
-}
-export class CollectionApproval extends BaseNumberTypeClass {
-    toListId;
-    fromListId;
-    initiatedByListId;
-    transferTimes;
-    badgeIds;
-    ownershipTimes;
-    approvalId;
-    uri;
-    customData;
-    approvalCriteria;
-    constructor(msg) {
-        super();
-        this.toListId = msg.toListId;
-        this.fromListId = msg.fromListId;
-        this.initiatedByListId = msg.initiatedByListId;
-        this.transferTimes = UintRangeArray.From(msg.transferTimes);
-        this.badgeIds = UintRangeArray.From(msg.badgeIds);
-        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
-        this.approvalId = msg.approvalId;
-        this.uri = msg.uri;
-        this.customData = msg.customData;
-        this.approvalCriteria = msg.approvalCriteria ? new ApprovalCriteria(msg.approvalCriteria) : undefined;
-    }
-    static validateUpdate(oldApprovals, newApprovals, canUpdateCollectionApprovals) {
-        return validateCollectionApprovalsUpdate(oldApprovals.map((x) => x.convert(BigIntify)), newApprovals.map((x) => x.convert(BigIntify)), canUpdateCollectionApprovals.map((x) => x.convert(BigIntify)));
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    toProto() {
-        return new proto.badges.CollectionApproval(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return CollectionApproval.fromProto(proto.badges.CollectionApproval.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return CollectionApproval.fromProto(proto.badges.CollectionApproval.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new CollectionApproval({
-            toListId: item.toListId,
-            fromListId: item.fromListId,
-            initiatedByListId: item.initiatedByListId,
-            transferTimes: item.transferTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            badgeIds: item.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
-            ownershipTimes: item.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
-            approvalId: item.approvalId,
-            uri: item.uri,
-            customData: item.customData,
-            approvalCriteria: item.approvalCriteria ? ApprovalCriteria.fromProto(item.approvalCriteria, convertFunction) : undefined
-        });
-    }
-    castToOutgoingApproval() {
-        return new UserOutgoingApproval({
-            ...this,
-            toListId: this.toListId,
-            initiatedByListId: this.initiatedByListId,
-            transferTimes: this.transferTimes,
-            badgeIds: this.badgeIds,
-            ownershipTimes: this.ownershipTimes,
-            approvalCriteria: this.approvalCriteria
-        });
-    }
-    castToIncomingApproval() {
-        return new UserIncomingApproval({
-            ...this,
-            fromListId: this.fromListId,
-            initiatedByListId: this.initiatedByListId,
-            transferTimes: this.transferTimes,
-            badgeIds: this.badgeIds,
-            ownershipTimes: this.ownershipTimes,
-            approvalCriteria: this.approvalCriteria
-        });
-    }
-}
-export class ApprovalCriteria extends BaseNumberTypeClass {
-    mustOwnBadges;
-    merkleChallenges;
-    predeterminedBalances;
-    approvalAmounts;
-    maxNumTransfers;
-    requireToEqualsInitiatedBy;
-    requireFromEqualsInitiatedBy;
-    requireToDoesNotEqualInitiatedBy;
-    requireFromDoesNotEqualInitiatedBy;
-    overridesFromOutgoingApprovals;
-    overridesToIncomingApprovals;
-    zkProofs;
-    coinTransfers;
-    constructor(msg) {
-        super();
-        this.mustOwnBadges = msg.mustOwnBadges?.map((x) => new MustOwnBadges(x));
-        this.merkleChallenges = msg.merkleChallenges?.map((x) => new MerkleChallenge(x));
-        this.predeterminedBalances = msg.predeterminedBalances ? new PredeterminedBalances(msg.predeterminedBalances) : undefined;
-        this.approvalAmounts = msg.approvalAmounts ? new ApprovalAmounts(msg.approvalAmounts) : undefined;
-        this.maxNumTransfers = msg.maxNumTransfers ? new MaxNumTransfers(msg.maxNumTransfers) : undefined;
-        this.requireToEqualsInitiatedBy = msg.requireToEqualsInitiatedBy;
-        this.requireFromEqualsInitiatedBy = msg.requireFromEqualsInitiatedBy;
-        this.requireToDoesNotEqualInitiatedBy = msg.requireToDoesNotEqualInitiatedBy;
-        this.requireFromDoesNotEqualInitiatedBy = msg.requireFromDoesNotEqualInitiatedBy;
-        this.overridesFromOutgoingApprovals = msg.overridesFromOutgoingApprovals;
-        this.overridesToIncomingApprovals = msg.overridesToIncomingApprovals;
-        this.zkProofs = msg.zkProofs ? msg.zkProofs.map((x) => new ZkProof(x)) : undefined;
-        this.coinTransfers = msg.coinTransfers ? msg.coinTransfers.map((x) => new CoinTransfer(x)) : undefined;
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    toProto() {
-        return new proto.badges.ApprovalCriteria(this.convert(Stringify));
-    }
-    static fromJson(jsonValue, convertFunction, options) {
-        return ApprovalCriteria.fromProto(proto.badges.ApprovalCriteria.fromJson(jsonValue, options), convertFunction);
-    }
-    static fromJsonString(jsonString, convertFunction, options) {
-        return ApprovalCriteria.fromProto(proto.badges.ApprovalCriteria.fromJsonString(jsonString, options), convertFunction);
-    }
-    static fromProto(item, convertFunction) {
-        return new ApprovalCriteria({
-            mustOwnBadges: item.mustOwnBadges.map((x) => MustOwnBadges.fromProto(x, convertFunction)),
-            merkleChallenges: item.merkleChallenges.map((x) => MerkleChallenge.fromProto(x, convertFunction)),
-            predeterminedBalances: item.predeterminedBalances ? PredeterminedBalances.fromProto(item.predeterminedBalances, convertFunction) : undefined,
-            approvalAmounts: item.approvalAmounts ? ApprovalAmounts.fromProto(item.approvalAmounts, convertFunction) : undefined,
-            maxNumTransfers: item.maxNumTransfers ? MaxNumTransfers.fromProto(item.maxNumTransfers, convertFunction) : undefined,
-            zkProofs: item.zkProofs.map((x) => ZkProof.fromProto(x)),
-            coinTransfers: item.coinTransfers ? item.coinTransfers.map((x) => CoinTransfer.fromProto(x, convertFunction)) : undefined,
-            requireToEqualsInitiatedBy: item.requireToEqualsInitiatedBy,
-            requireFromEqualsInitiatedBy: item.requireFromEqualsInitiatedBy,
-            requireToDoesNotEqualInitiatedBy: item.requireToDoesNotEqualInitiatedBy,
-            requireFromDoesNotEqualInitiatedBy: item.requireFromDoesNotEqualInitiatedBy,
-            overridesFromOutgoingApprovals: item.overridesFromOutgoingApprovals,
-            overridesToIncomingApprovals: item.overridesToIncomingApprovals
-        });
-    }
-}
-export class UserOutgoingApprovalWithDetails extends UserOutgoingApproval {
-    toList;
-    initiatedByList;
-    approvalCriteria;
-    details;
-    constructor(data) {
-        super(data);
-        this.toList = new AddressList(data.toList);
-        this.initiatedByList = new AddressList(data.initiatedByList);
-        this.approvalCriteria = data.approvalCriteria ? new OutgoingApprovalCriteriaWithDetails(data.approvalCriteria) : undefined;
-        this.details = data.details ? new ApprovalInfoDetails(data.details) : undefined;
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    clone() {
-        return super.clone();
-    }
-    castToCollectionTransfer(fromAddress) {
-        return new CollectionApprovalWithDetails({
-            ...this,
-            fromListId: fromAddress,
-            fromList: getReservedAddressList(fromAddress),
-            approvalCriteria: this.approvalCriteria?.castToCollectionApprovalCriteria()
-        });
-    }
-    castToUniversalPermission(fromAddress) {
-        return this.castToCollectionTransfer(fromAddress).castToUniversalPermission();
-    }
-}
-export class UserIncomingApprovalWithDetails extends UserIncomingApproval {
-    details;
-    fromList;
-    initiatedByList;
-    approvalCriteria;
-    constructor(data) {
-        super(data);
-        this.details = data.details ? new ApprovalInfoDetails(data.details) : undefined;
-        this.fromList = new AddressList(data.fromList);
-        this.initiatedByList = new AddressList(data.initiatedByList);
-        this.approvalCriteria = data.approvalCriteria ? new IncomingApprovalCriteriaWithDetails(data.approvalCriteria) : undefined;
-    }
-    clone() {
-        return super.clone();
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    castToCollectionTransfer(toAddress) {
-        return new CollectionApprovalWithDetails({
-            ...this,
-            toList: getReservedAddressList(toAddress),
-            toListId: toAddress,
-            approvalCriteria: this.approvalCriteria?.castToCollectionApprovalCriteria()
-        });
-    }
-    castToUniversalPermission(toAddress) {
-        return this.castToCollectionTransfer(toAddress).castToUniversalPermission();
-    }
-}
-export class ChallengeDetails extends BaseNumberTypeClass {
-    treeOptions;
-    numLeaves;
-    leaves;
-    isHashed;
-    preimages;
-    seedCode;
-    tree;
-    constructor(data) {
-        super();
-        this.treeOptions = data.treeOptions;
-        this.numLeaves = data.numLeaves;
-        this.leaves = data.leaves;
-        this.isHashed = data.isHashed;
-        this.preimages = data.preimages;
-        this.seedCode = data.seedCode;
-    }
-    getNumberFieldNames() {
-        return ['numLeaves'];
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-}
-export class ChallengeInfoDetails extends BaseNumberTypeClass {
-    challengeDetails;
-    claim;
-    constructor(data) {
-        super();
-        this.challengeDetails = new ChallengeDetails(data.challengeDetails);
-        this.claim = data.claim;
-    }
-    convert(convertFunction) {
-        return new ChallengeInfoDetails(deepCopyPrimitives({
-            ...this,
-            challengeDetails: this.challengeDetails.convert(convertFunction)
-        }));
-    }
-}
-export class ApprovalInfoDetails extends BaseNumberTypeClass {
-    name;
-    description;
-    constructor(data) {
-        super();
-        this.name = data.name;
-        this.description = data.description;
-    }
-    convert(convertFunction) {
-        return new ApprovalInfoDetails(deepCopyPrimitives({ ...this }));
-    }
-}
-export class MerkleChallengeWithDetails extends MerkleChallenge {
-    challengeInfoDetails;
-    constructor(data) {
-        super(data);
-        this.challengeInfoDetails = new ChallengeInfoDetails(data.challengeInfoDetails);
-    }
-    getNumberFieldNames() {
-        return super.getNumberFieldNames().concat(this.challengeInfoDetails.challengeDetails.getNumberFieldNames());
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    clone() {
-        return super.clone();
-    }
-}
-export class ApprovalCriteriaWithDetails extends ApprovalCriteria {
-    merkleChallenges;
-    constructor(data) {
-        super(data);
-        this.merkleChallenges = data.merkleChallenges?.map((x) => new MerkleChallengeWithDetails(x));
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    clone() {
-        return super.clone();
-    }
-}
-export class IncomingApprovalCriteriaWithDetails extends IncomingApprovalCriteria {
-    merkleChallenges;
-    constructor(data) {
-        super(data);
-        this.merkleChallenges = data.merkleChallenges?.map((x) => new MerkleChallengeWithDetails(x));
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    clone() {
-        return super.clone();
-    }
-    castToCollectionApprovalCriteria() {
-        return new ApprovalCriteriaWithDetails({
-            approvalAmounts: this.approvalAmounts,
-            maxNumTransfers: this.maxNumTransfers,
-            predeterminedBalances: this.predeterminedBalances,
-            mustOwnBadges: this.mustOwnBadges,
-            zkProofs: this.zkProofs,
-            merkleChallenges: this.merkleChallenges,
-            coinTransfers: this.coinTransfers,
-            requireFromEqualsInitiatedBy: false,
-            requireFromDoesNotEqualInitiatedBy: false,
-            overridesFromOutgoingApprovals: false,
-            overridesToIncomingApprovals: false
-        });
-    }
-}
-export class OutgoingApprovalCriteriaWithDetails extends OutgoingApprovalCriteria {
-    merkleChallenges;
-    constructor(data) {
-        super(data);
-        this.merkleChallenges = data.merkleChallenges?.map((x) => new MerkleChallengeWithDetails(x));
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    clone() {
-        return super.clone();
-    }
-    castToCollectionApprovalCriteria() {
-        return new ApprovalCriteriaWithDetails({
-            approvalAmounts: this.approvalAmounts,
-            maxNumTransfers: this.maxNumTransfers,
-            predeterminedBalances: this.predeterminedBalances,
-            mustOwnBadges: this.mustOwnBadges,
-            zkProofs: this.zkProofs,
-            merkleChallenges: this.merkleChallenges,
-            coinTransfers: this.coinTransfers,
-            requireToEqualsInitiatedBy: false,
-            requireToDoesNotEqualInitiatedBy: false,
-            overridesFromOutgoingApprovals: false,
-            overridesToIncomingApprovals: false
-        });
-    }
-}
-export class CollectionApprovalWithDetails extends CollectionApproval {
-    details;
-    toList;
-    fromList;
-    initiatedByList;
-    approvalCriteria;
-    constructor(data) {
-        super(data);
-        this.details = data.details ? new ApprovalInfoDetails(data.details) : undefined;
-        this.toList = new AddressList(data.toList);
-        this.fromList = new AddressList(data.fromList);
-        this.initiatedByList = new AddressList(data.initiatedByList);
-        this.approvalCriteria = data.approvalCriteria ? new ApprovalCriteriaWithDetails(data.approvalCriteria) : undefined;
-    }
-    convert(convertFunction) {
-        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
-    }
-    clone() {
-        return super.clone();
-    }
-    castToUniversalPermission() {
-        return {
-            ...AllDefaultValues,
-            badgeIds: this.badgeIds.convert(BigIntify),
-            transferTimes: this.transferTimes.convert(BigIntify),
-            ownershipTimes: this.ownershipTimes.convert(BigIntify),
-            fromList: this.fromList,
-            toList: this.toList,
-            initiatedByList: this.initiatedByList,
-            approvalIdList: getReservedTrackerList(this.approvalId),
-            usesApprovalIdList: true,
-            usesBadgeIds: true,
-            usesTransferTimes: true,
-            usesToList: true,
-            usesFromList: true,
-            usesInitiatedByList: true,
-            usesOwnershipTimes: true,
-            arbitraryValue: {
-                approvalId: this.approvalId,
-                approvalCriteria: {
-                    ...this.approvalCriteria,
-                    merkleChallenges: this.approvalCriteria?.merkleChallenges
-                        ?.map((x) => x.convert(BigIntify))
-                        .map((x) => {
-                        return {
-                            ...x,
-                            challengeInfoDetails: undefined
-                        };
-                    })
-                },
-                approvalCriteriaWithDetails: this.approvalCriteria?.convert(BigIntify)
-            }
-        };
-    }
-    castToOutgoingApproval() {
-        return new UserOutgoingApprovalWithDetails({
-            ...this,
-            toListId: this.toListId,
-            toList: this.toList,
-            initiatedByList: this.initiatedByList,
-            initiatedByListId: this.initiatedByListId,
-            transferTimes: this.transferTimes,
-            badgeIds: this.badgeIds,
-            ownershipTimes: this.ownershipTimes,
-            approvalCriteria: this.approvalCriteria
-        });
-    }
-    castToIncomingApproval() {
-        return new UserIncomingApprovalWithDetails({
-            ...this,
-            fromList: this.fromList,
-            fromListId: this.fromListId,
-            initiatedByListId: this.initiatedByListId,
-            transferTimes: this.transferTimes,
-            badgeIds: this.badgeIds,
-            ownershipTimes: this.ownershipTimes,
-            approvalCriteria: this.approvalCriteria
-        });
-    }
-    static validateUpdate(oldApprovals, newApprovals, canUpdateCollectionApprovals) {
-        return validateCollectionApprovalsUpdate(oldApprovals.map((x) => x.convert(BigIntify)), newApprovals.map((x) => x.convert(BigIntify)), canUpdateCollectionApprovals.map((x) => x.convert(BigIntify)));
-    }
-}
-export function getFirstMatchOnlyWithApprovalCriteria(permissions) {
-    let handled = [];
-    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);
-        for (const badgeId of badgeIds) {
-            for (const timelineTime of timelineTimes) {
-                for (const transferTime of transferTimes) {
-                    for (const ownershipTime of ownershipTimes) {
-                        const approvalCriteria = [permission.arbitraryValue.approvalCriteria ?? null];
-                        const isApproved = permission.arbitraryValue.isApproved;
-                        const arbValue = {
-                            isApproved: isApproved,
-                            approvalCriteria: approvalCriteria
-                        };
-                        const brokenDown = [
-                            {
-                                badgeId: badgeId,
-                                timelineTime: timelineTime,
-                                transferTime: transferTime,
-                                ownershipTime: ownershipTime,
-                                toList: permission.toList,
-                                fromList: permission.fromList,
-                                initiatedByList: permission.initiatedByList,
-                                approvalIdList: permission.approvalIdList,
-                                permanentlyPermittedTimes: permanentlyPermittedTimes,
-                                permanentlyForbiddenTimes: permanentlyForbiddenTimes,
-                                arbitraryValue: arbValue
-                            }
-                        ];
-                        const [overlaps, inBrokenDownButNotHandled, inHandledButNotBrokenDown] = getOverlapsAndNonOverlaps(brokenDown, handled);
-                        handled = [];
-                        handled.push(...inHandledButNotBrokenDown);
-                        handled.push(...inBrokenDownButNotHandled);
-                        for (const overlap of overlaps) {
-                            const mergedApprovalCriteria = overlap.secondDetails.arbitraryValue.approvalCriteria.concat(overlap.firstDetails.arbitraryValue.approvalCriteria);
-                            const isApprovedFirst = overlap.firstDetails.arbitraryValue.isApproved;
-                            const isApprovedSecond = overlap.secondDetails.arbitraryValue.isApproved;
-                            const isApproved = isApprovedFirst && isApprovedSecond;
-                            const newArbValue = {
-                                isApproved: isApproved,
-                                approvalCriteria: mergedApprovalCriteria
-                            };
-                            handled.push({
-                                timelineTime: overlap.overlap.timelineTime,
-                                badgeId: overlap.overlap.badgeId,
-                                transferTime: overlap.overlap.transferTime,
-                                ownershipTime: overlap.overlap.ownershipTime,
-                                toList: overlap.overlap.toList,
-                                fromList: overlap.overlap.fromList,
-                                initiatedByList: overlap.overlap.initiatedByList,
-                                approvalIdList: overlap.overlap.approvalIdList,
-                                permanentlyPermittedTimes: permanentlyPermittedTimes,
-                                permanentlyForbiddenTimes: permanentlyForbiddenTimes,
-                                arbitraryValue: newArbValue
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-    const returnArr = [];
-    for (const handledItem of handled) {
-        let idxToInsert = 0;
-        while (idxToInsert < returnArr.length && handledItem.badgeId.start > returnArr[idxToInsert].badgeId.start) {
-            idxToInsert++;
-        }
-        returnArr.push(null);
-        returnArr.copyWithin(idxToInsert + 1, idxToInsert);
-        returnArr[idxToInsert] = handledItem;
-    }
-    return returnArr;
-}
-export function validateCollectionApprovalsUpdate(oldApprovals, newApprovals, canUpdateCollectionApprovals) {
-    const dummyRanges = [UintRangeArray.From([{ start: 1n, end: 1n }])];
-    const oldTimelineFirstMatches = getPotentialUpdatesForTimelineValues(dummyRanges.map((x) => x.clone()), [oldApprovals.map((x) => x.convert(BigIntify))]);
-    const newTimelineFirstMatches = getPotentialUpdatesForTimelineValues(dummyRanges.map((x) => x.clone()), [newApprovals.map((x) => x.convert(BigIntify))]);
-    const detailsToCheck = getUpdateCombinationsToCheck(oldTimelineFirstMatches, newTimelineFirstMatches, [], function (oldValue, newValue) {
-        const expandedOldApprovals = expandCollectionApprovals(oldValue);
-        const expandedNewApprovals = expandCollectionApprovals(newValue);
-        const oldApprovals = expandedOldApprovals.map((x) => x.castToUniversalPermission());
-        if (!oldApprovals) {
-            throw new Error('InvalidOldValue');
-        }
-        const newApprovals = expandedNewApprovals.map((x) => x.castToUniversalPermission());
-        if (!newApprovals) {
-            throw new Error('InvalidNewValue');
-        }
-        const firstMatchesForOld = getFirstMatchOnlyWithApprovalCriteria(oldApprovals);
-        const firstMatchesForNew = getFirstMatchOnlyWithApprovalCriteria(newApprovals);
-        const detailsToReturn = [];
-        const [overlapObjects, inOldButNotNew, inNewButNotOld] = getOverlapsAndNonOverlaps(firstMatchesForOld, firstMatchesForNew);
-        for (const overlapObject of overlapObjects) {
-            const overlap = overlapObject.overlap;
-            const oldDetails = overlapObject.firstDetails;
-            const newDetails = overlapObject.secondDetails;
-            let different = false;
-            if ((oldDetails.arbitraryValue === null && newDetails.arbitraryValue !== null) ||
-                (oldDetails.arbitraryValue !== null && newDetails.arbitraryValue === null)) {
-                different = true;
-            }
-            else {
-                const oldArbVal = oldDetails.arbitraryValue;
-                const newArbVal = newDetails.arbitraryValue;
-                const oldVal = oldArbVal.approvalCriteria;
-                const newVal = newArbVal.approvalCriteria;
-                if (oldArbVal.isApproved !== newArbVal.isApproved) {
-                    different = true;
-                }
-                if (oldVal.length !== newVal.length) {
-                    different = true;
-                }
-                else {
-                    for (let i = 0; i < oldVal.length; i++) {
-                        if (JSON.stringify(oldVal[i]) !== JSON.stringify(newVal[i])) {
-                            different = true;
-                        }
-                    }
-                }
-            }
-            if (different) {
-                detailsToReturn.push(overlap);
-            }
-        }
-        detailsToReturn.push(...inOldButNotNew);
-        detailsToReturn.push(...inNewButNotOld);
-        return detailsToReturn;
-    });
-    const details = detailsToCheck.map((x) => {
-        const result = {
-            badgeIds: UintRangeArray.From([x.badgeId]),
-            ownershipTimes: UintRangeArray.From([x.ownershipTime]),
-            transferTimes: UintRangeArray.From([x.transferTime]),
-            toList: x.toList,
-            fromList: x.fromList,
-            initiatedByList: x.initiatedByList,
-            approvalIdList: x.approvalIdList
-        };
-        return result;
-    });
-    const err = CollectionApprovalPermission.check(details, canUpdateCollectionApprovals.map((x) => x.convert(BigIntify)));
-    if (err) {
-        return err;
-    }
-    return null;
-}
-export function expandCollectionApprovals(approvals) {
-    const newCurrApprovals = [];
-    for (const approval of approvals) {
-        const badgeIds = GetUintRangesWithOptions(approval.badgeIds, true);
-        const ownershipTimes = GetUintRangesWithOptions(approval.ownershipTimes, true);
-        const times = GetUintRangesWithOptions(approval.transferTimes, true);
-        const toListId = GetListIdWithOptions(approval.toListId, true);
-        const fromListId = GetListIdWithOptions(approval.fromListId, true);
-        const initiatedByListId = GetListIdWithOptions(approval.initiatedByListId, true);
-        const toList = GetListWithOptions(approval.toList, true);
-        const fromList = GetListWithOptions(approval.fromList, true);
-        const initiatedByList = GetListWithOptions(approval.initiatedByList, true);
-        newCurrApprovals.push(new CollectionApprovalWithDetails({
-            ...approval,
-            toListId: toListId,
-            fromListId: fromListId,
-            initiatedByListId: initiatedByListId,
-            transferTimes: times,
-            badgeIds: badgeIds,
-            ownershipTimes: ownershipTimes,
-            toList: toList,
-            fromList: fromList,
-            initiatedByList: initiatedByList,
-            approvalCriteria: approval.approvalCriteria,
-            approvalId: approval.approvalId
-        }));
-    }
-    return newCurrApprovals;
-}
-//# sourceMappingURL=approvals.js.map