bitbadgesjs-sdk 0.31.1 → 0.31.2

package/dist/esm/core/permissions.spec.js

@@ -2,6 +2,7 @@ import { genTestAddress } from './addressLists.spec.js';
 import { AddressList } from './addressLists.js';
 import { ActionPermission, TokenIdsActionPermission, CollectionApprovalPermission, CollectionApprovalPermissionWithDetails, CollectionPermissions, CollectionPermissionsWithDetails, UserPermissions, UserPermissionsWithDetails, UserOutgoingApprovalPermission, UserOutgoingApprovalPermissionWithDetails, UserIncomingApprovalPermission, UserIncomingApprovalPermissionWithDetails } from './permissions.js';
 import { UintRangeArray } from './uintRanges.js';
+import { BigIntify, Stringify } from '../common/string-numbers.js';
 BigInt.prototype.toJSON = function () {
     return this.toString();
 };
@@ -684,6 +685,1074 @@ describe('CollectionPermissions', () => {
         });
     });
 });
+describe('UserOutgoingApprovalPermission', () => {
+    const makeOutgoing = (permitted = [], forbidden = []) => new UserOutgoingApprovalPermission({
+        toListId: 'All',
+        initiatedByListId: 'All',
+        approvalId: 'All',
+        transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+        tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+        ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+        permanentlyPermittedTimes: permitted.map(([s, e]) => ({ start: s, end: e })),
+        permanentlyForbiddenTimes: forbidden.map(([s, e]) => ({ start: s, end: e }))
+    });
+    describe('construction', () => {
+        it('should create with all required fields', () => {
+            const perm = makeOutgoing([[1n, 100n]]);
+            expect(perm).toBeTruthy();
+            expect(perm.toListId).toBe('All');
+            expect(perm.initiatedByListId).toBe('All');
+            expect(perm.approvalId).toBe('All');
+            expect(perm.transferTimes.length).toBe(1);
+            expect(perm.tokenIds.length).toBe(1);
+            expect(perm.ownershipTimes.length).toBe(1);
+            expect(perm.permanentlyPermittedTimes.length).toBe(1);
+        });
+    });
+    describe('convert', () => {
+        it('should convert number type to string', () => {
+            const perm = makeOutgoing([[1n, 50n]]);
+            const stringified = perm.convert(Stringify);
+            expect(stringified.tokenIds[0].start).toBe('1');
+            expect(stringified.tokenIds[0].end).toBe('18446744073709551615');
+            expect(stringified.permanentlyPermittedTimes[0].start).toBe('1');
+            expect(stringified.permanentlyPermittedTimes[0].end).toBe('50');
+        });
+    });
+    describe('toProto / fromProto', () => {
+        it('should round-trip through proto', () => {
+            const perm = makeOutgoing([[10n, 200n]]);
+            const proto = perm.toProto();
+            expect(proto).toBeTruthy();
+            const restored = UserOutgoingApprovalPermission.fromProto(proto, BigIntify);
+            expect(restored.toListId).toBe('All');
+            expect(restored.permanentlyPermittedTimes[0].start).toBe(10n);
+            expect(restored.permanentlyPermittedTimes[0].end).toBe(200n);
+        });
+    });
+    describe('fromJson / fromJsonString', () => {
+        it('should round-trip through JSON', () => {
+            const perm = makeOutgoing([[5n, 50n]]);
+            const jsonVal = perm.toProto().toJson();
+            const restored = UserOutgoingApprovalPermission.fromJson(jsonVal, BigIntify);
+            expect(restored.permanentlyPermittedTimes[0].start).toBe(5n);
+        });
+        it('should round-trip through JSON string', () => {
+            const perm = makeOutgoing([], [[1n, 100n]]);
+            const jsonStr = perm.toProto().toJsonString();
+            const restored = UserOutgoingApprovalPermission.fromJsonString(jsonStr, BigIntify);
+            expect(restored.permanentlyForbiddenTimes[0].start).toBe(1n);
+            expect(restored.permanentlyForbiddenTimes[0].end).toBe(100n);
+        });
+    });
+    describe('castToCollectionApprovalPermission', () => {
+        it('should cast to CollectionApprovalPermission with given fromListId', () => {
+            const perm = makeOutgoing([[1n, 100n]]);
+            const addr = genTestAddress();
+            const casted = perm.castToCollectionApprovalPermission(addr);
+            expect(casted.fromListId).toBe(addr);
+        });
+    });
+    describe('toBech32Addresses', () => {
+        it('should convert listIds to bech32', () => {
+            const perm = makeOutgoing();
+            expect(() => perm.toBech32Addresses('bb')).not.toThrow();
+        });
+    });
+    describe('validateUpdate', () => {
+        it('should allow identical outgoing permissions', () => {
+            const makeWithDetails = (permitted) => new UserOutgoingApprovalPermissionWithDetails({
+                toListId: 'All',
+                initiatedByListId: 'All',
+                approvalId: 'All',
+                transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyPermittedTimes: permitted.map(([s, e]) => ({ start: s, end: e })),
+                permanentlyForbiddenTimes: [],
+                toList: allAddresses(),
+                initiatedByList: allAddresses()
+            });
+            const perms = [makeWithDetails([[1n, 100n]])];
+            const err = UserOutgoingApprovalPermission.validateUpdate(perms, perms);
+            expect(err).toBeNull();
+        });
+        it('should reject removing outgoing permission', () => {
+            const makeWithDetails = () => new UserOutgoingApprovalPermissionWithDetails({
+                toListId: 'All',
+                initiatedByListId: 'All',
+                approvalId: 'All',
+                transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                permanentlyForbiddenTimes: [],
+                toList: allAddresses(),
+                initiatedByList: allAddresses()
+            });
+            const err = UserOutgoingApprovalPermission.validateUpdate([makeWithDetails()], []);
+            expect(err).not.toBeNull();
+        });
+    });
+    describe('check', () => {
+        it('should return null when outgoing approval is permitted', () => {
+            const perm = new UserOutgoingApprovalPermissionWithDetails({
+                toListId: 'All',
+                initiatedByListId: 'All',
+                approvalId: 'All',
+                transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyPermittedTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyForbiddenTimes: [],
+                toList: allAddresses(),
+                initiatedByList: allAddresses()
+            });
+            const err = UserOutgoingApprovalPermission.check([
+                {
+                    tokenIds: UintRangeArray.From([{ start: 1n, end: 5n }]),
+                    ownershipTimes: fullRange(),
+                    transferTimes: fullRange(),
+                    toList: allAddresses(),
+                    fromList: allAddresses(),
+                    initiatedByList: allAddresses(),
+                    approvalIdList: allAddresses(),
+                    amountTrackerIdList: allAddresses(),
+                    challengeTrackerIdList: allAddresses()
+                }
+            ], [perm], 50n);
+            expect(err).toBeNull();
+        });
+        it('should return error when outgoing approval is forbidden', () => {
+            const perm = new UserOutgoingApprovalPermissionWithDetails({
+                toListId: 'All',
+                initiatedByListId: 'All',
+                approvalId: 'All',
+                transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyPermittedTimes: [],
+                permanentlyForbiddenTimes: [{ start: 1n, end: 18446744073709551615n }],
+                toList: allAddresses(),
+                initiatedByList: allAddresses()
+            });
+            const err = UserOutgoingApprovalPermission.check([
+                {
+                    tokenIds: UintRangeArray.From([{ start: 1n, end: 5n }]),
+                    ownershipTimes: fullRange(),
+                    transferTimes: fullRange(),
+                    toList: allAddresses(),
+                    fromList: allAddresses(),
+                    initiatedByList: allAddresses(),
+                    approvalIdList: allAddresses(),
+                    amountTrackerIdList: allAddresses(),
+                    challengeTrackerIdList: allAddresses()
+                }
+            ], [perm], 50n);
+            expect(err).not.toBeNull();
+        });
+    });
+});
+describe('UserIncomingApprovalPermission', () => {
+    const makeIncoming = (permitted = [], forbidden = []) => new UserIncomingApprovalPermission({
+        fromListId: 'All',
+        initiatedByListId: 'All',
+        approvalId: 'All',
+        transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+        tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+        ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+        permanentlyPermittedTimes: permitted.map(([s, e]) => ({ start: s, end: e })),
+        permanentlyForbiddenTimes: forbidden.map(([s, e]) => ({ start: s, end: e }))
+    });
+    describe('construction', () => {
+        it('should create with all required fields', () => {
+            const perm = makeIncoming([[1n, 100n]]);
+            expect(perm).toBeTruthy();
+            expect(perm.fromListId).toBe('All');
+            expect(perm.initiatedByListId).toBe('All');
+            expect(perm.approvalId).toBe('All');
+            expect(perm.permanentlyPermittedTimes.length).toBe(1);
+        });
+    });
+    describe('convert', () => {
+        it('should convert to string type', () => {
+            const perm = makeIncoming([[1n, 50n]]);
+            const stringified = perm.convert(Stringify);
+            expect(stringified.tokenIds[0].start).toBe('1');
+            expect(stringified.permanentlyPermittedTimes[0].end).toBe('50');
+        });
+    });
+    describe('toProto / fromProto', () => {
+        it('should round-trip through proto', () => {
+            const perm = makeIncoming([[10n, 200n]]);
+            const proto = perm.toProto();
+            const restored = UserIncomingApprovalPermission.fromProto(proto, BigIntify);
+            expect(restored.fromListId).toBe('All');
+            expect(restored.permanentlyPermittedTimes[0].start).toBe(10n);
+        });
+    });
+    describe('fromJson / fromJsonString', () => {
+        it('should round-trip through JSON', () => {
+            const perm = makeIncoming([[5n, 50n]]);
+            const jsonVal = perm.toProto().toJson();
+            const restored = UserIncomingApprovalPermission.fromJson(jsonVal, BigIntify);
+            expect(restored.permanentlyPermittedTimes[0].start).toBe(5n);
+        });
+        it('should round-trip through JSON string', () => {
+            const perm = makeIncoming([], [[1n, 100n]]);
+            const jsonStr = perm.toProto().toJsonString();
+            const restored = UserIncomingApprovalPermission.fromJsonString(jsonStr, BigIntify);
+            expect(restored.permanentlyForbiddenTimes[0].start).toBe(1n);
+        });
+    });
+    describe('castToCollectionApprovalPermission', () => {
+        it('should cast to CollectionApprovalPermission with given toListId', () => {
+            const perm = makeIncoming([[1n, 100n]]);
+            const addr = genTestAddress();
+            const casted = perm.castToCollectionApprovalPermission(addr);
+            expect(casted.toListId).toBe(addr);
+        });
+    });
+    describe('toBech32Addresses', () => {
+        it('should not throw when converting reserved list IDs', () => {
+            const perm = makeIncoming();
+            expect(() => perm.toBech32Addresses('bb')).not.toThrow();
+        });
+    });
+    describe('validateUpdate', () => {
+        it('should allow identical incoming permissions', () => {
+            const makeWithDetails = () => new UserIncomingApprovalPermissionWithDetails({
+                fromListId: 'All',
+                initiatedByListId: 'All',
+                approvalId: 'All',
+                transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                permanentlyForbiddenTimes: [],
+                fromList: allAddresses(),
+                initiatedByList: allAddresses()
+            });
+            const perms = [makeWithDetails()];
+            const err = UserIncomingApprovalPermission.validateUpdate(perms, perms);
+            expect(err).toBeNull();
+        });
+        it('should reject removing incoming permission', () => {
+            const makeWithDetails = () => new UserIncomingApprovalPermissionWithDetails({
+                fromListId: 'All',
+                initiatedByListId: 'All',
+                approvalId: 'All',
+                transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                permanentlyForbiddenTimes: [],
+                fromList: allAddresses(),
+                initiatedByList: allAddresses()
+            });
+            const err = UserIncomingApprovalPermission.validateUpdate([makeWithDetails()], []);
+            expect(err).not.toBeNull();
+        });
+    });
+    describe('check', () => {
+        it('should return null when incoming approval is permitted', () => {
+            const perm = new UserIncomingApprovalPermissionWithDetails({
+                fromListId: 'All',
+                initiatedByListId: 'All',
+                approvalId: 'All',
+                transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyPermittedTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyForbiddenTimes: [],
+                fromList: allAddresses(),
+                initiatedByList: allAddresses()
+            });
+            const err = UserIncomingApprovalPermission.check([
+                {
+                    tokenIds: fullRange(),
+                    ownershipTimes: fullRange(),
+                    transferTimes: fullRange(),
+                    toList: allAddresses(),
+                    fromList: allAddresses(),
+                    initiatedByList: allAddresses(),
+                    approvalIdList: allAddresses(),
+                    amountTrackerIdList: allAddresses(),
+                    challengeTrackerIdList: allAddresses()
+                }
+            ], [perm], 50n);
+            expect(err).toBeNull();
+        });
+        it('should return error when incoming approval is forbidden', () => {
+            const perm = new UserIncomingApprovalPermissionWithDetails({
+                fromListId: 'All',
+                initiatedByListId: 'All',
+                approvalId: 'All',
+                transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                permanentlyPermittedTimes: [],
+                permanentlyForbiddenTimes: [{ start: 1n, end: 18446744073709551615n }],
+                fromList: allAddresses(),
+                initiatedByList: allAddresses()
+            });
+            const err = UserIncomingApprovalPermission.check([
+                {
+                    tokenIds: fullRange(),
+                    ownershipTimes: fullRange(),
+                    transferTimes: fullRange(),
+                    toList: allAddresses(),
+                    fromList: allAddresses(),
+                    initiatedByList: allAddresses(),
+                    approvalIdList: allAddresses(),
+                    amountTrackerIdList: allAddresses(),
+                    challengeTrackerIdList: allAddresses()
+                }
+            ], [perm], 50n);
+            expect(err).not.toBeNull();
+        });
+    });
+});
+describe('CollectionPermissions - serialization', () => {
+    const makeEmpty = () => CollectionPermissions.InitEmpty();
+    describe('convert', () => {
+        it('should convert all fields when they contain data (covers map bodies in convert)', () => {
+            const perms = new CollectionPermissions({
+                canDeleteCollection: [new ActionPermission({ permanentlyPermittedTimes: [{ start: 1n, end: 50n }], permanentlyForbiddenTimes: [] })],
+                canArchiveCollection: [new ActionPermission({ permanentlyPermittedTimes: [{ start: 2n, end: 3n }], permanentlyForbiddenTimes: [] })],
+                canUpdateStandards: [new ActionPermission({ permanentlyPermittedTimes: [{ start: 4n, end: 5n }], permanentlyForbiddenTimes: [] })],
+                canUpdateCustomData: [new ActionPermission({ permanentlyPermittedTimes: [{ start: 6n, end: 7n }], permanentlyForbiddenTimes: [] })],
+                canUpdateManager: [new ActionPermission({ permanentlyPermittedTimes: [{ start: 8n, end: 9n }], permanentlyForbiddenTimes: [] })],
+                canUpdateCollectionMetadata: [new ActionPermission({ permanentlyPermittedTimes: [{ start: 10n, end: 11n }], permanentlyForbiddenTimes: [] })],
+                canUpdateValidTokenIds: [new TokenIdsActionPermission({ tokenIds: [{ start: 1n, end: 5n }], permanentlyPermittedTimes: [{ start: 1n, end: 10n }], permanentlyForbiddenTimes: [] })],
+                canUpdateTokenMetadata: [new TokenIdsActionPermission({ tokenIds: [{ start: 6n, end: 10n }], permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [{ start: 1n, end: 100n }] })],
+                canUpdateCollectionApprovals: [],
+                canAddMoreAliasPaths: [new ActionPermission({ permanentlyPermittedTimes: [{ start: 20n, end: 30n }], permanentlyForbiddenTimes: [] })],
+                canAddMoreCosmosCoinWrapperPaths: [new ActionPermission({ permanentlyPermittedTimes: [{ start: 40n, end: 50n }], permanentlyForbiddenTimes: [] })]
+            });
+            const converted = perms.convert(Stringify);
+            expect(converted.canDeleteCollection[0].permanentlyPermittedTimes[0].start).toBe('1');
+            expect(converted.canArchiveCollection[0].permanentlyPermittedTimes[0].start).toBe('2');
+            expect(converted.canUpdateStandards[0].permanentlyPermittedTimes[0].start).toBe('4');
+            expect(converted.canUpdateCustomData[0].permanentlyPermittedTimes[0].start).toBe('6');
+            expect(converted.canUpdateManager[0].permanentlyPermittedTimes[0].start).toBe('8');
+            expect(converted.canUpdateCollectionMetadata[0].permanentlyPermittedTimes[0].start).toBe('10');
+            expect(converted.canUpdateValidTokenIds[0].tokenIds[0].start).toBe('1');
+            expect(converted.canUpdateTokenMetadata[0].permanentlyForbiddenTimes[0].start).toBe('1');
+            expect(converted.canAddMoreAliasPaths[0].permanentlyPermittedTimes[0].start).toBe('20');
+            expect(converted.canAddMoreCosmosCoinWrapperPaths[0].permanentlyPermittedTimes[0].start).toBe('40');
+        });
+    });
+    describe('toProto / fromProto', () => {
+        it('should round-trip empty permissions through proto', () => {
+            const perms = makeEmpty();
+            const proto = perms.toProto();
+            const restored = CollectionPermissions.fromProto(proto, BigIntify);
+            expect(restored).toBeTruthy();
+            expect(restored.canDeleteCollection.length).toBe(0);
+            expect(restored.canUpdateManager.length).toBe(0);
+        });
+        it('should round-trip permissions with data through proto', () => {
+            const perms = new CollectionPermissions({
+                canDeleteCollection: [
+                    new ActionPermission({
+                        permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                        permanentlyForbiddenTimes: []
+                    })
+                ],
+                canArchiveCollection: [],
+                canUpdateStandards: [],
+                canUpdateCustomData: [],
+                canUpdateManager: [
+                    new ActionPermission({
+                        permanentlyPermittedTimes: [],
+                        permanentlyForbiddenTimes: [{ start: 1n, end: 50n }]
+                    })
+                ],
+                canUpdateCollectionMetadata: [],
+                canUpdateValidTokenIds: [
+                    new TokenIdsActionPermission({
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                        permanentlyForbiddenTimes: []
+                    })
+                ],
+                canUpdateTokenMetadata: [],
+                canUpdateCollectionApprovals: [],
+                canAddMoreAliasPaths: [],
+                canAddMoreCosmosCoinWrapperPaths: []
+            });
+            const proto = perms.toProto();
+            const restored = CollectionPermissions.fromProto(proto, BigIntify);
+            expect(restored.canDeleteCollection.length).toBe(1);
+            expect(restored.canDeleteCollection[0].permanentlyPermittedTimes[0].start).toBe(1n);
+            expect(restored.canDeleteCollection[0].permanentlyPermittedTimes[0].end).toBe(100n);
+            expect(restored.canUpdateManager.length).toBe(1);
+            expect(restored.canUpdateManager[0].permanentlyForbiddenTimes[0].start).toBe(1n);
+            expect(restored.canUpdateValidTokenIds.length).toBe(1);
+            expect(restored.canUpdateValidTokenIds[0].tokenIds[0].start).toBe(1n);
+        });
+    });
+    describe('fromJson / fromJsonString', () => {
+        it('should round-trip through JSON', () => {
+            const perms = new CollectionPermissions({
+                canDeleteCollection: [
+                    new ActionPermission({
+                        permanentlyPermittedTimes: [{ start: 10n, end: 20n }],
+                        permanentlyForbiddenTimes: []
+                    })
+                ],
+                canArchiveCollection: [],
+                canUpdateStandards: [],
+                canUpdateCustomData: [],
+                canUpdateManager: [],
+                canUpdateCollectionMetadata: [],
+                canUpdateValidTokenIds: [],
+                canUpdateTokenMetadata: [],
+                canUpdateCollectionApprovals: [],
+                canAddMoreAliasPaths: [],
+                canAddMoreCosmosCoinWrapperPaths: []
+            });
+            const jsonVal = perms.toProto().toJson();
+            const restored = CollectionPermissions.fromJson(jsonVal, BigIntify);
+            expect(restored.canDeleteCollection[0].permanentlyPermittedTimes[0].start).toBe(10n);
+        });
+        it('should round-trip through JSON string', () => {
+            const perms = makeEmpty();
+            const jsonStr = perms.toProto().toJsonString();
+            const restored = CollectionPermissions.fromJsonString(jsonStr, BigIntify);
+            expect(restored.canDeleteCollection.length).toBe(0);
+        });
+    });
+    describe('toBech32Addresses', () => {
+        it('should run without throwing for empty permissions', () => {
+            const perms = makeEmpty();
+            expect(() => perms.toBech32Addresses('bb')).not.toThrow();
+        });
+        it('should convert collection approval permission addresses', () => {
+            const perms = new CollectionPermissions({
+                canDeleteCollection: [],
+                canArchiveCollection: [],
+                canUpdateStandards: [],
+                canUpdateCustomData: [],
+                canUpdateManager: [],
+                canUpdateCollectionMetadata: [],
+                canUpdateValidTokenIds: [],
+                canUpdateTokenMetadata: [],
+                canUpdateCollectionApprovals: [
+                    new CollectionApprovalPermission({
+                        fromListId: 'All',
+                        toListId: 'All',
+                        initiatedByListId: 'All',
+                        approvalId: 'All',
+                        transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                        tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                        ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                        permanentlyPermittedTimes: [],
+                        permanentlyForbiddenTimes: []
+                    })
+                ],
+                canAddMoreAliasPaths: [],
+                canAddMoreCosmosCoinWrapperPaths: []
+            });
+            expect(() => perms.toBech32Addresses('bb')).not.toThrow();
+        });
+    });
+    describe('validateUpdate - more permission types', () => {
+        const makePerms = (opts) => new CollectionPermissionsWithDetails({
+            canDeleteCollection: [],
+            canArchiveCollection: [],
+            canUpdateStandards: [],
+            canUpdateCustomData: [],
+            canUpdateManager: [],
+            canUpdateCollectionMetadata: [],
+            canUpdateValidTokenIds: opts.canUpdateValidTokenIds || [],
+            canUpdateTokenMetadata: [],
+            canUpdateCollectionApprovals: opts.canUpdateCollectionApprovals || [],
+            canAddMoreAliasPaths: [],
+            canAddMoreCosmosCoinWrapperPaths: []
+        });
+        it('should reject removing canUpdateValidTokenIds permission', () => {
+            const oldPerms = makePerms({
+                canUpdateValidTokenIds: [
+                    new TokenIdsActionPermission({
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                        permanentlyForbiddenTimes: []
+                    })
+                ]
+            });
+            const newPerms = makePerms({});
+            const err = CollectionPermissionsWithDetails.validateUpdate(oldPerms, newPerms);
+            expect(err).not.toBeNull();
+        });
+        it('should allow adding canUpdateValidTokenIds when previously empty', () => {
+            const oldPerms = makePerms({});
+            const newPerms = makePerms({
+                canUpdateValidTokenIds: [
+                    new TokenIdsActionPermission({
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                        permanentlyForbiddenTimes: []
+                    })
+                ]
+            });
+            const err = CollectionPermissionsWithDetails.validateUpdate(oldPerms, newPerms);
+            expect(err).toBeNull();
+        });
+    });
+});
+describe('CollectionApprovalPermission - serialization', () => {
+    const makeApprovalBase = (permitted = [], forbidden = []) => new CollectionApprovalPermission({
+        fromListId: 'All',
+        toListId: 'All',
+        initiatedByListId: 'All',
+        approvalId: 'All',
+        transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+        tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+        ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+        permanentlyPermittedTimes: permitted.map(([s, e]) => ({ start: s, end: e })),
+        permanentlyForbiddenTimes: forbidden.map(([s, e]) => ({ start: s, end: e }))
+    });
+    it('should round-trip through proto', () => {
+        const perm = makeApprovalBase([[10n, 50n]]);
+        const proto = perm.toProto();
+        const restored = CollectionApprovalPermission.fromProto(proto, BigIntify);
+        expect(restored.fromListId).toBe('All');
+        expect(restored.permanentlyPermittedTimes[0].start).toBe(10n);
+        expect(restored.permanentlyPermittedTimes[0].end).toBe(50n);
+    });
+    it('should round-trip through JSON', () => {
+        const perm = makeApprovalBase([[5n, 100n]]);
+        const jsonVal = perm.toProto().toJson();
+        const restored = CollectionApprovalPermission.fromJson(jsonVal, BigIntify);
+        expect(restored.permanentlyPermittedTimes[0].start).toBe(5n);
+    });
+    it('should round-trip through JSON string', () => {
+        const perm = makeApprovalBase([], [[1n, 200n]]);
+        const jsonStr = perm.toProto().toJsonString();
+        const restored = CollectionApprovalPermission.fromJsonString(jsonStr, BigIntify);
+        expect(restored.permanentlyForbiddenTimes[0].start).toBe(1n);
+        expect(restored.permanentlyForbiddenTimes[0].end).toBe(200n);
+    });
+    it('should toBech32Addresses without throwing', () => {
+        const perm = makeApprovalBase();
+        expect(() => perm.toBech32Addresses('bb')).not.toThrow();
+    });
+});
+describe('TokenIdsActionPermission - serialization', () => {
+    const makePerm = (permitted = [], forbidden = []) => new TokenIdsActionPermission({
+        tokenIds: [{ start: 1n, end: 100n }],
+        permanentlyPermittedTimes: permitted.map(([s, e]) => ({ start: s, end: e })),
+        permanentlyForbiddenTimes: forbidden.map(([s, e]) => ({ start: s, end: e }))
+    });
+    it('should round-trip through proto', () => {
+        const perm = makePerm([[1n, 50n]]);
+        const proto = perm.toProto();
+        const restored = TokenIdsActionPermission.fromProto(proto, BigIntify);
+        expect(restored.tokenIds[0].start).toBe(1n);
+        expect(restored.tokenIds[0].end).toBe(100n);
+        expect(restored.permanentlyPermittedTimes[0].start).toBe(1n);
+        expect(restored.permanentlyPermittedTimes[0].end).toBe(50n);
+    });
+    it('should round-trip through JSON', () => {
+        const perm = makePerm([[5n, 80n]]);
+        const jsonVal = perm.toProto().toJson();
+        const restored = TokenIdsActionPermission.fromJson(jsonVal, BigIntify);
+        expect(restored.permanentlyPermittedTimes[0].end).toBe(80n);
+    });
+    it('should round-trip through JSON string', () => {
+        const perm = makePerm([], [[10n, 20n]]);
+        const jsonStr = perm.toProto().toJsonString();
+        const restored = TokenIdsActionPermission.fromJsonString(jsonStr, BigIntify);
+        expect(restored.permanentlyForbiddenTimes[0].start).toBe(10n);
+        expect(restored.permanentlyForbiddenTimes[0].end).toBe(20n);
+    });
+});
+describe('ActionPermission - serialization', () => {
+    it('should round-trip through proto', () => {
+        const perm = new ActionPermission({
+            permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+            permanentlyForbiddenTimes: [{ start: 200n, end: 300n }]
+        });
+        const proto = perm.toProto();
+        const restored = ActionPermission.fromProto(proto, BigIntify);
+        expect(restored.permanentlyPermittedTimes[0].start).toBe(1n);
+        expect(restored.permanentlyPermittedTimes[0].end).toBe(100n);
+        expect(restored.permanentlyForbiddenTimes[0].start).toBe(200n);
+    });
+    it('should round-trip through JSON', () => {
+        const perm = new ActionPermission({
+            permanentlyPermittedTimes: [{ start: 5n, end: 50n }],
+            permanentlyForbiddenTimes: []
+        });
+        const jsonVal = perm.toProto().toJson();
+        const restored = ActionPermission.fromJson(jsonVal, BigIntify);
+        expect(restored.permanentlyPermittedTimes[0].start).toBe(5n);
+    });
+    it('should round-trip through JSON string', () => {
+        const perm = new ActionPermission({
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: [{ start: 1n, end: 10n }]
+        });
+        const jsonStr = perm.toProto().toJsonString();
+        const restored = ActionPermission.fromJsonString(jsonStr, BigIntify);
+        expect(restored.permanentlyForbiddenTimes[0].end).toBe(10n);
+    });
+});
+describe('UserPermissions - serialization', () => {
+    it('should round-trip empty permissions through proto', () => {
+        const perms = UserPermissions.InitEmpty();
+        const proto = perms.toProto();
+        const restored = UserPermissions.fromProto(proto, BigIntify);
+        expect(restored.canUpdateOutgoingApprovals.length).toBe(0);
+        expect(restored.canUpdateIncomingApprovals.length).toBe(0);
+    });
+    it('should round-trip full UserPermissions with actual data through proto (covers fromProto map bodies)', () => {
+        const perms = new UserPermissions({
+            canUpdateOutgoingApprovals: [
+                new UserOutgoingApprovalPermission({
+                    toListId: 'All',
+                    initiatedByListId: 'All',
+                    approvalId: 'All',
+                    transferTimes: [{ start: 1n, end: 100n }],
+                    tokenIds: [{ start: 1n, end: 10n }],
+                    ownershipTimes: [{ start: 1n, end: 100n }],
+                    permanentlyPermittedTimes: [{ start: 1n, end: 50n }],
+                    permanentlyForbiddenTimes: []
+                })
+            ],
+            canUpdateIncomingApprovals: [
+                new UserIncomingApprovalPermission({
+                    fromListId: 'All',
+                    initiatedByListId: 'All',
+                    approvalId: 'All',
+                    transferTimes: [{ start: 1n, end: 100n }],
+                    tokenIds: [{ start: 1n, end: 10n }],
+                    ownershipTimes: [{ start: 1n, end: 100n }],
+                    permanentlyPermittedTimes: [],
+                    permanentlyForbiddenTimes: [{ start: 1n, end: 50n }]
+                })
+            ],
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: [
+                new ActionPermission({
+                    permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                    permanentlyForbiddenTimes: []
+                })
+            ],
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: [
+                new ActionPermission({
+                    permanentlyPermittedTimes: [],
+                    permanentlyForbiddenTimes: [{ start: 1n, end: 10n }]
+                })
+            ],
+            canUpdateAutoApproveAllIncomingTransfers: [
+                new ActionPermission({
+                    permanentlyPermittedTimes: [{ start: 10n, end: 20n }],
+                    permanentlyForbiddenTimes: []
+                })
+            ]
+        });
+        const proto = perms.toProto();
+        const restored = UserPermissions.fromProto(proto, BigIntify);
+        expect(restored.canUpdateOutgoingApprovals.length).toBe(1);
+        expect(restored.canUpdateOutgoingApprovals[0].permanentlyPermittedTimes[0].start).toBe(1n);
+        expect(restored.canUpdateIncomingApprovals.length).toBe(1);
+        expect(restored.canUpdateIncomingApprovals[0].permanentlyForbiddenTimes[0].start).toBe(1n);
+        expect(restored.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.length).toBe(1);
+        expect(restored.canUpdateAutoApproveSelfInitiatedOutgoingTransfers[0].permanentlyPermittedTimes[0].end).toBe(100n);
+        expect(restored.canUpdateAutoApproveSelfInitiatedIncomingTransfers.length).toBe(1);
+        expect(restored.canUpdateAutoApproveAllIncomingTransfers.length).toBe(1);
+        expect(restored.canUpdateAutoApproveAllIncomingTransfers[0].permanentlyPermittedTimes[0].start).toBe(10n);
+    });
+    it('should round-trip through JSON', () => {
+        const perms = UserPermissions.InitEmpty();
+        const jsonVal = perms.toProto().toJson();
+        const restored = UserPermissions.fromJson(jsonVal, BigIntify);
+        expect(restored).toBeTruthy();
+    });
+    it('should round-trip through JSON string', () => {
+        const perms = UserPermissions.InitEmpty();
+        const jsonStr = perms.toProto().toJsonString();
+        const restored = UserPermissions.fromJsonString(jsonStr, BigIntify);
+        expect(restored).toBeTruthy();
+    });
+    it('should toBech32Addresses without throwing on empty permissions', () => {
+        const perms = UserPermissions.InitEmpty();
+        expect(() => perms.toBech32Addresses('bb')).not.toThrow();
+    });
+});
+describe('UserPermissionsWithDetails - constructor with data', () => {
+    it('should map all arrays when constructed with non-empty data (covers constructor map bodies)', () => {
+        const makeOutgoingWithDetails = () => new UserOutgoingApprovalPermissionWithDetails({
+            toListId: 'All',
+            initiatedByListId: 'All',
+            approvalId: 'All',
+            transferTimes: [{ start: 1n, end: 100n }],
+            tokenIds: [{ start: 1n, end: 10n }],
+            ownershipTimes: [{ start: 1n, end: 100n }],
+            permanentlyPermittedTimes: [{ start: 1n, end: 50n }],
+            permanentlyForbiddenTimes: [],
+            toList: allAddresses(),
+            initiatedByList: allAddresses()
+        });
+        const makeIncomingWithDetails = () => new UserIncomingApprovalPermissionWithDetails({
+            fromListId: 'All',
+            initiatedByListId: 'All',
+            approvalId: 'All',
+            transferTimes: [{ start: 1n, end: 100n }],
+            tokenIds: [{ start: 1n, end: 10n }],
+            ownershipTimes: [{ start: 1n, end: 100n }],
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: [{ start: 1n, end: 50n }],
+            fromList: allAddresses(),
+            initiatedByList: allAddresses()
+        });
+        const perms = new UserPermissionsWithDetails({
+            canUpdateOutgoingApprovals: [makeOutgoingWithDetails()],
+            canUpdateIncomingApprovals: [makeIncomingWithDetails()],
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: [
+                new ActionPermission({ permanentlyPermittedTimes: [{ start: 1n, end: 100n }], permanentlyForbiddenTimes: [] })
+            ],
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: [
+                new ActionPermission({ permanentlyPermittedTimes: [], permanentlyForbiddenTimes: [{ start: 1n, end: 10n }] })
+            ],
+            canUpdateAutoApproveAllIncomingTransfers: [
+                new ActionPermission({ permanentlyPermittedTimes: [{ start: 10n, end: 20n }], permanentlyForbiddenTimes: [] })
+            ]
+        });
+        expect(perms.canUpdateOutgoingApprovals.length).toBe(1);
+        expect(perms.canUpdateOutgoingApprovals[0].toList).toBeDefined();
+        expect(perms.canUpdateIncomingApprovals.length).toBe(1);
+        expect(perms.canUpdateIncomingApprovals[0].fromList).toBeDefined();
+        expect(perms.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.length).toBe(1);
+        expect(perms.canUpdateAutoApproveSelfInitiatedIncomingTransfers.length).toBe(1);
+        expect(perms.canUpdateAutoApproveAllIncomingTransfers.length).toBe(1);
+    });
+    it('should convert UserPermissionsWithDetails using convert()', () => {
+        const perms = new UserPermissionsWithDetails({
+            canUpdateOutgoingApprovals: [
+                new UserOutgoingApprovalPermissionWithDetails({
+                    toListId: 'All',
+                    initiatedByListId: 'All',
+                    approvalId: 'All',
+                    transferTimes: [{ start: 1n, end: 100n }],
+                    tokenIds: [{ start: 1n, end: 10n }],
+                    ownershipTimes: [{ start: 1n, end: 100n }],
+                    permanentlyPermittedTimes: [{ start: 1n, end: 50n }],
+                    permanentlyForbiddenTimes: [],
+                    toList: allAddresses(),
+                    initiatedByList: allAddresses()
+                })
+            ],
+            canUpdateIncomingApprovals: [],
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: [],
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: [],
+            canUpdateAutoApproveAllIncomingTransfers: []
+        });
+        const converted = perms.convert(Stringify);
+        expect(converted.canUpdateOutgoingApprovals[0].tokenIds[0].start).toBe('1');
+    });
+});
+describe('CollectionApprovalPermissionWithDetails - clone and convert', () => {
+    it('should clone successfully', () => {
+        const perm = new CollectionApprovalPermissionWithDetails({
+            fromListId: 'All',
+            toListId: 'All',
+            initiatedByListId: 'All',
+            approvalId: 'All',
+            transferTimes: [{ start: 1n, end: 100n }],
+            tokenIds: [{ start: 1n, end: 10n }],
+            ownershipTimes: [{ start: 1n, end: 100n }],
+            permanentlyPermittedTimes: [{ start: 1n, end: 50n }],
+            permanentlyForbiddenTimes: [],
+            fromList: allAddresses(),
+            toList: allAddresses(),
+            initiatedByList: allAddresses()
+        });
+        const cloned = perm.clone();
+        expect(cloned).toBeTruthy();
+        expect(cloned.fromListId).toBe('All');
+    });
+    it('should convert to string type', () => {
+        const perm = new CollectionApprovalPermissionWithDetails({
+            fromListId: 'All',
+            toListId: 'All',
+            initiatedByListId: 'All',
+            approvalId: 'All',
+            transferTimes: [{ start: 1n, end: 100n }],
+            tokenIds: [{ start: 1n, end: 10n }],
+            ownershipTimes: [{ start: 1n, end: 100n }],
+            permanentlyPermittedTimes: [{ start: 5n, end: 50n }],
+            permanentlyForbiddenTimes: [],
+            fromList: allAddresses(),
+            toList: allAddresses(),
+            initiatedByList: allAddresses()
+        });
+        const converted = perm.convert(Stringify);
+        expect(converted.permanentlyPermittedTimes[0].start).toBe('5');
+        expect(converted.tokenIds[0].start).toBe('1');
+    });
+});
+describe('UserIncomingApprovalPermissionWithDetails - clone and convert', () => {
+    const makeIncomingWithDetails = () => new UserIncomingApprovalPermissionWithDetails({
+        fromListId: 'All',
+        initiatedByListId: 'All',
+        approvalId: 'All',
+        transferTimes: [{ start: 1n, end: 100n }],
+        tokenIds: [{ start: 1n, end: 10n }],
+        ownershipTimes: [{ start: 1n, end: 100n }],
+        permanentlyPermittedTimes: [{ start: 1n, end: 50n }],
+        permanentlyForbiddenTimes: [],
+        fromList: allAddresses(),
+        initiatedByList: allAddresses()
+    });
+    it('should clone successfully', () => {
+        const perm = makeIncomingWithDetails();
+        const cloned = perm.clone();
+        expect(cloned).toBeTruthy();
+        expect(cloned.fromListId).toBe('All');
+        expect(cloned.fromList).toBeDefined();
+    });
+    it('should convert to string type', () => {
+        const perm = makeIncomingWithDetails();
+        const converted = perm.convert(Stringify);
+        expect(converted.tokenIds[0].start).toBe('1');
+        expect(converted.permanentlyPermittedTimes[0].start).toBe('1');
+    });
+    it('should castToCollectionApprovalPermission with toList set', () => {
+        const perm = makeIncomingWithDetails();
+        const addr = genTestAddress();
+        const casted = perm.castToCollectionApprovalPermission(addr);
+        expect(casted.toListId).toBe(addr);
+        expect(casted.toList).toBeDefined();
+    });
+});
+describe('UserOutgoingApprovalPermissionWithDetails - clone and convert', () => {
+    const makeOutgoingWithDetails = () => new UserOutgoingApprovalPermissionWithDetails({
+        toListId: 'All',
+        initiatedByListId: 'All',
+        approvalId: 'All',
+        transferTimes: [{ start: 1n, end: 100n }],
+        tokenIds: [{ start: 1n, end: 10n }],
+        ownershipTimes: [{ start: 1n, end: 100n }],
+        permanentlyPermittedTimes: [{ start: 1n, end: 50n }],
+        permanentlyForbiddenTimes: [],
+        toList: allAddresses(),
+        initiatedByList: allAddresses()
+    });
+    it('should clone successfully', () => {
+        const perm = makeOutgoingWithDetails();
+        const cloned = perm.clone();
+        expect(cloned).toBeTruthy();
+        expect(cloned.toListId).toBe('All');
+        expect(cloned.toList).toBeDefined();
+    });
+    it('should convert to string type', () => {
+        const perm = makeOutgoingWithDetails();
+        const converted = perm.convert(Stringify);
+        expect(converted.tokenIds[0].start).toBe('1');
+        expect(converted.permanentlyPermittedTimes[0].start).toBe('1');
+    });
+    it('should castToCollectionApprovalPermission with fromList set', () => {
+        const perm = makeOutgoingWithDetails();
+        const addr = genTestAddress();
+        const casted = perm.castToCollectionApprovalPermission(addr);
+        expect(casted.fromListId).toBe(addr);
+        expect(casted.fromList).toBeDefined();
+    });
+});
+describe('CollectionApprovalPermission.check - extended error messages', () => {
+    it('should include timeline times in error message when usesLists=true and forbidden', () => {
+        const addr = genTestAddress();
+        const perm = new CollectionApprovalPermissionWithDetails({
+            fromListId: 'All',
+            toListId: addr,
+            initiatedByListId: 'All',
+            approvalId: 'All',
+            transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+            tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+            ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: [{ start: 1n, end: 18446744073709551615n }],
+            fromList: allAddresses(),
+            toList: whitelistOf([addr]),
+            initiatedByList: allAddresses()
+        });
+        const err = CollectionApprovalPermission.check([
+            {
+                tokenIds: UintRangeArray.From([{ start: 1n, end: 5n }]),
+                ownershipTimes: fullRange(),
+                transferTimes: fullRange(),
+                toList: whitelistOf([addr]),
+                fromList: allAddresses(),
+                initiatedByList: allAddresses(),
+                approvalIdList: allAddresses()
+            }
+        ], [perm], 50n);
+        expect(err).not.toBeNull();
+        expect(err.message).toContain('forbidden');
+    });
+});
+describe('validateUniversalPermissionUpdate - multiple missing and combined error', () => {
+    it('should mention count when multiple permissions are missing', () => {
+        const makeSimpleWithDetails = (tokenStart, tokenEnd) => new CollectionApprovalPermissionWithDetails({
+            fromListId: 'All',
+            toListId: 'All',
+            initiatedByListId: 'All',
+            approvalId: 'All',
+            transferTimes: [{ start: 1n, end: 1n }],
+            tokenIds: [{ start: tokenStart, end: tokenEnd }],
+            ownershipTimes: [{ start: 1n, end: 1n }],
+            permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+            permanentlyForbiddenTimes: [],
+            fromList: allAddresses(),
+            toList: allAddresses(),
+            initiatedByList: allAddresses()
+        });
+        const oldPerms = [makeSimpleWithDetails(1n, 5n), makeSimpleWithDetails(10n, 15n)];
+        const newPerms = [];
+        const err = CollectionApprovalPermission.validateUpdate(oldPerms, newPerms);
+        expect(err).not.toBeNull();
+        expect(err.message).toMatch(/along with|found in old/);
+    });
+    it('should produce combined permitted+forbidden error when both are being removed', () => {
+        const makeApprovalWithBoth = (permitted, forbidden) => new CollectionApprovalPermissionWithDetails({
+            fromListId: 'All',
+            toListId: 'All',
+            initiatedByListId: 'All',
+            approvalId: 'All',
+            transferTimes: [{ start: 1n, end: 1n }],
+            tokenIds: [{ start: 1n, end: 10n }],
+            ownershipTimes: [{ start: 1n, end: 1n }],
+            permanentlyPermittedTimes: permitted.map(([s, e]) => ({ start: s, end: e })),
+            permanentlyForbiddenTimes: forbidden.map(([s, e]) => ({ start: s, end: e })),
+            fromList: allAddresses(),
+            toList: allAddresses(),
+            initiatedByList: allAddresses()
+        });
+        const oldPerms = [makeApprovalWithBoth([[1n, 50n]], [[51n, 100n]])];
+        const newPerms = [makeApprovalWithBoth([], [])];
+        const err = CollectionApprovalPermission.validateUpdate(oldPerms, newPerms);
+        expect(err).not.toBeNull();
+        expect(err.message).toMatch(/allowed|disApproved/i);
+    });
+});
+describe('CollectionPermissionsWithDetails - constructor with canUpdateCollectionApprovals', () => {
+    it('should map canUpdateCollectionApprovals to CollectionApprovalPermissionWithDetails (covers lines 1014-1023)', () => {
+        const perms = new CollectionPermissionsWithDetails({
+            canDeleteCollection: [],
+            canArchiveCollection: [],
+            canUpdateStandards: [],
+            canUpdateCustomData: [],
+            canUpdateManager: [],
+            canUpdateCollectionMetadata: [],
+            canUpdateValidTokenIds: [],
+            canUpdateTokenMetadata: [],
+            canUpdateCollectionApprovals: [
+                new CollectionApprovalPermissionWithDetails({
+                    fromListId: 'All',
+                    toListId: 'All',
+                    initiatedByListId: 'All',
+                    approvalId: 'All',
+                    transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                    tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                    ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                    permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                    permanentlyForbiddenTimes: [],
+                    fromList: allAddresses(),
+                    toList: allAddresses(),
+                    initiatedByList: allAddresses()
+                })
+            ],
+            canAddMoreAliasPaths: [],
+            canAddMoreCosmosCoinWrapperPaths: []
+        });
+        expect(perms.canUpdateCollectionApprovals.length).toBe(1);
+        expect(perms.canUpdateCollectionApprovals[0].fromList).toBeDefined();
+        expect(perms.canUpdateCollectionApprovals[0].permanentlyPermittedTimes[0].start).toBe(1n);
+    });
+    it('should clone CollectionPermissionsWithDetails', () => {
+        const perms = new CollectionPermissionsWithDetails({
+            canDeleteCollection: [],
+            canArchiveCollection: [],
+            canUpdateStandards: [],
+            canUpdateCustomData: [],
+            canUpdateManager: [],
+            canUpdateCollectionMetadata: [],
+            canUpdateValidTokenIds: [],
+            canUpdateTokenMetadata: [],
+            canUpdateCollectionApprovals: [],
+            canAddMoreAliasPaths: [],
+            canAddMoreCosmosCoinWrapperPaths: []
+        });
+        const cloned = perms.clone();
+        expect(cloned).toBeTruthy();
+    });
+    it('should convert CollectionPermissionsWithDetails (covers line 1019)', () => {
+        const perms = new CollectionPermissionsWithDetails({
+            canDeleteCollection: [],
+            canArchiveCollection: [],
+            canUpdateStandards: [],
+            canUpdateCustomData: [],
+            canUpdateManager: [
+                new ActionPermission({
+                    permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+                    permanentlyForbiddenTimes: []
+                })
+            ],
+            canUpdateCollectionMetadata: [],
+            canUpdateValidTokenIds: [],
+            canUpdateTokenMetadata: [],
+            canUpdateCollectionApprovals: [
+                new CollectionApprovalPermissionWithDetails({
+                    fromListId: 'All',
+                    toListId: 'All',
+                    initiatedByListId: 'All',
+                    approvalId: 'All',
+                    transferTimes: [{ start: 1n, end: 18446744073709551615n }],
+                    tokenIds: [{ start: 1n, end: 18446744073709551615n }],
+                    ownershipTimes: [{ start: 1n, end: 18446744073709551615n }],
+                    permanentlyPermittedTimes: [{ start: 5n, end: 50n }],
+                    permanentlyForbiddenTimes: [],
+                    fromList: allAddresses(),
+                    toList: allAddresses(),
+                    initiatedByList: allAddresses()
+                })
+            ],
+            canAddMoreAliasPaths: [],
+            canAddMoreCosmosCoinWrapperPaths: []
+        });
+        const converted = perms.convert(Stringify);
+        expect(converted.canUpdateManager[0].permanentlyPermittedTimes[0].start).toBe('1');
+        expect(converted.canUpdateCollectionApprovals[0].permanentlyPermittedTimes[0].start).toBe('5');
+    });
+});
+describe('getPermissionString branches - whitelist and address listing', () => {
+    it('should produce error message with whitelist address info when whitelist=true', () => {
+        const addr1 = genTestAddress();
+        const addr2 = genTestAddress();
+        const makeWithWhitelist = () => new CollectionApprovalPermissionWithDetails({
+            fromListId: 'All',
+            toListId: 'whitelist-test',
+            initiatedByListId: 'All',
+            approvalId: 'All',
+            transferTimes: [{ start: 1n, end: 1n }],
+            tokenIds: [{ start: 1n, end: 5n }],
+            ownershipTimes: [{ start: 1n, end: 1n }],
+            permanentlyPermittedTimes: [{ start: 1n, end: 100n }],
+            permanentlyForbiddenTimes: [],
+            fromList: whitelistOf([addr1, addr2]),
+            toList: whitelistOf([addr1, addr2]),
+            initiatedByList: whitelistOf([addr1, addr2])
+        });
+        const oldPerms = [makeWithWhitelist()];
+        const newPerms = [];
+        const err = CollectionApprovalPermission.validateUpdate(oldPerms, newPerms);
+        expect(err).not.toBeNull();
+        expect(err.message).toContain('found in old permissions');
+    });
+});
 describe('UserOutgoingApprovalPermission', () => {
     const makeOutgoingPerm = (opts) => {
         return new UserOutgoingApprovalPermissionWithDetails({