@cheqd/studio 3.15.0-develop.1 → 3.15.0-develop.3

package/dist/services/api/credential-status.js

@@ -0,0 +1,923 @@
+import { fromString } from 'uint8arrays';
+import { IdentityServiceStrategySetup } from '../identity/index.js';
+import { DefaultStatusActionPurposeMap, StatusRegistryState, StatusListType } from '../../types/credential-status.js';
+import { Cheqd, } from '@cheqd/did-provider-cheqd';
+import { toNetwork } from '../../helpers/helpers.js';
+import { eventTracker } from '../track/tracker.js';
+import { OperationCategoryNameEnum, OperationNameEnum } from '../../types/constants.js';
+import { FeeAnalyzer } from '../../helpers/fee-analyzer.js';
+import { Like } from 'typeorm';
+import { StatusRegistryEntity } from '../../database/entities/status-registry.entity.js';
+import { Connection } from '../../database/connection/connection.js';
+import { v4 } from 'uuid';
+import { IdentifierService } from './identifier.js';
+import { CredentialCategory } from '../../types/credential.js';
+import { StatusCodes } from 'http-status-codes';
+export class CredentialStatusService {
+    static instance = new CredentialStatusService();
+    repository;
+    constructor() {
+        this.repository = Connection.instance.dbConnection.getRepository(StatusRegistryEntity);
+    }
+    async createUnencryptedStatusList(body, query, customer, user) {
+        const { did, encodedList, statusListName, alsoKnownAs, statusListVersion = '1.0', length, encoding, statusSize: size, ttl, statusMessages, state, credentialCategory = CredentialCategory.CREDENTIAL, } = body;
+        const { listType, statusPurpose } = query;
+        const data = encodedList ? fromString(encodedList, encoding) : undefined;
+        const identityServiceStrategySetup = new IdentityServiceStrategySetup(customer.customerId);
+        try {
+            // validate identifier
+            const identifier = await IdentifierService.instance.get(did, customer);
+            if (!identifier) {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.NOT_FOUND,
+                    error: `Identifier ${did} not found for the customer ${customer.customerId}`,
+                };
+            }
+            if (data) {
+                let result;
+                if (listType === StatusListType.Bitstring) {
+                    result = await identityServiceStrategySetup.agent.broadcastBitstringStatusList(did, {
+                        data,
+                        name: statusListName,
+                        alsoKnownAs,
+                        version: statusListVersion,
+                    }, customer);
+                }
+                else {
+                    result = await identityServiceStrategySetup.agent.broadcastStatusList2021(did, {
+                        data,
+                        name: statusListName,
+                        alsoKnownAs,
+                        version: statusListVersion,
+                    }, { encoding, statusPurpose: statusPurpose }, customer);
+                }
+                return {
+                    success: result,
+                    statusCode: StatusCodes.OK,
+                    data,
+                };
+            }
+            let result;
+            let statusSize;
+            if (listType === StatusListType.Bitstring) {
+                result = (await identityServiceStrategySetup.agent.createUnencryptedBitstringStatusList(did, {
+                    name: statusListName,
+                    alsoKnownAs,
+                    version: statusListVersion,
+                }, {
+                    length,
+                    size,
+                    statusMessages,
+                    ttl,
+                    encoding,
+                    statusPurpose,
+                }, customer));
+                statusSize = result.resource.metadata.length;
+            }
+            else {
+                result = (await identityServiceStrategySetup.agent.createUnencryptedStatusList2021(did, {
+                    name: statusListName,
+                    alsoKnownAs,
+                    version: statusListVersion,
+                }, {
+                    length,
+                    encoding,
+                    statusPurpose: statusPurpose,
+                }, customer));
+                statusSize = length || Cheqd.defaultStatusList2021Length;
+            }
+            if (result.error) {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.BAD_REQUEST,
+                    error: result.error?.message || result.error.toString(),
+                };
+            }
+            // persist status list in the db
+            const statusRegistry = new StatusRegistryEntity({
+                registryId: v4(),
+                uri: `${did}?resourceName=${result.resourceMetadata.resourceName}&resourceType=${result.resourceMetadata.resourceType}`,
+                registryType: result.resourceMetadata.resourceType,
+                registryName: statusListName,
+                credentialCategory,
+                version: 1,
+                registrySize: statusSize,
+                writeCursor: 0,
+                state: state || StatusRegistryState.Active,
+                storageType: 'cheqd',
+                identifier,
+                customer,
+                metadata: {
+                    statusPurpose,
+                },
+            });
+            await this.repository.save(statusRegistry);
+            const trackInfo = {
+                category: OperationCategoryNameEnum.CREDENTIAL_STATUS,
+                name: OperationNameEnum.CREDENTIAL_STATUS_CREATE_UNENCRYPTED,
+                customer,
+                user,
+                data: {
+                    did,
+                    registryId: statusRegistry.registryId,
+                    resource: result.resourceMetadata,
+                    encrypted: result.resource?.metadata?.encrypted,
+                    symmetricKey: '',
+                },
+            };
+            eventTracker.emit('track', trackInfo);
+            return {
+                success: true,
+                statusCode: StatusCodes.OK,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `Internal error: ${error?.message || error}`,
+            };
+        }
+    }
+    async createEncryptedStatusList(body, query, customer, user) {
+        const { did, statusListName, alsoKnownAs, statusListVersion = '1.0', length, statusSize: size, ttl, statusMessages, encoding, paymentConditions, feePaymentAddress, feePaymentAmount, feePaymentWindow, state, credentialCategory = CredentialCategory.CREDENTIAL, } = body;
+        const { listType, statusPurpose } = query;
+        const identityServiceStrategySetup = new IdentityServiceStrategySetup(customer.customerId);
+        try {
+            let result;
+            let statusSize;
+            // validate identifier
+            const identifier = await IdentifierService.instance.get(did, customer);
+            if (!identifier) {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.NOT_FOUND,
+                    error: `Identifier ${did} not found for the customer ${customer.customerId}`,
+                };
+            }
+            if (listType === StatusListType.Bitstring) {
+                result = (await identityServiceStrategySetup.agent.createEncryptedBitstringStatusList(did, {
+                    name: statusListName,
+                    alsoKnownAs,
+                    version: statusListVersion,
+                }, {
+                    length,
+                    size,
+                    statusMessages,
+                    ttl,
+                    encoding,
+                    statusPurpose,
+                    paymentConditions,
+                    feePaymentAddress,
+                    feePaymentAmount,
+                    feePaymentWindow,
+                }, customer));
+                statusSize = result.resource.metadata.length;
+            }
+            else {
+                result = (await identityServiceStrategySetup.agent.createEncryptedStatusList2021(did, {
+                    name: statusListName,
+                    alsoKnownAs,
+                    version: statusListVersion,
+                }, {
+                    length,
+                    encoding,
+                    statusPurpose: statusPurpose,
+                    paymentConditions,
+                    feePaymentAddress,
+                    feePaymentAmount,
+                    feePaymentWindow,
+                }, customer));
+                statusSize = size || Cheqd.defaultStatusList2021Length;
+            }
+            if (result.error) {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.BAD_REQUEST,
+                    error: result.error?.message || result.error.toString(),
+                };
+            }
+            // persist status list in the db
+            const statusRegistry = new StatusRegistryEntity({
+                registryId: v4(),
+                uri: `${did}?resourceName=${result.resourceMetadata.resourceName}&resourceType=${result.resourceMetadata.resourceType}`,
+                registryType: result.resourceMetadata.resourceType,
+                registryName: statusListName,
+                credentialCategory,
+                version: 1,
+                registrySize: statusSize,
+                writeCursor: 0,
+                state: state || StatusRegistryState.Active,
+                storageType: 'cheqd',
+                identifier,
+                customer,
+                encrypted: true,
+                metadata: {
+                    statusPurpose,
+                    paymentConditions,
+                    feePaymentAddress,
+                    feePaymentAmount,
+                    feePaymentWindow,
+                },
+            });
+            await this.repository.save(statusRegistry);
+            const trackInfo = {
+                name: OperationNameEnum.CREDENTIAL_STATUS_CREATE_ENCRYPTED,
+                category: OperationCategoryNameEnum.CREDENTIAL_STATUS,
+                customer,
+                user,
+                data: {
+                    did,
+                    registryId: statusRegistry.registryId,
+                    resource: result.resourceMetadata,
+                    encrypted: true,
+                    symmetricKey: '',
+                },
+                feePaymentOptions: [],
+            };
+            eventTracker.emit('track', trackInfo);
+            return {
+                success: true,
+                statusCode: StatusCodes.OK,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `Internal error: ${error?.message || error}`,
+            };
+        }
+    }
+    async updateUnencryptedStatusList(body, query, customer, user) {
+        const { did, statusListName, statusListVersion = '1.0', indices } = body;
+        const { statusAction, listType } = query;
+        const identityServiceStrategySetup = new IdentityServiceStrategySetup(customer.customerId);
+        const unencrypted = await identityServiceStrategySetup.agent.searchStatusList(did, statusListName, listType, DefaultStatusActionPurposeMap[statusAction]);
+        if (unencrypted.error) {
+            if (unencrypted.error === 'notFound') {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.NOT_FOUND,
+                    error: `update: error: status list '${statusListName}' not found`,
+                };
+            }
+            return {
+                success: false,
+                statusCode: StatusCodes.BAD_REQUEST,
+                error: `update: error: ${unencrypted.error}`,
+            };
+        }
+        if (unencrypted.resource?.metadata?.encrypted) {
+            return {
+                success: false,
+                statusCode: StatusCodes.BAD_REQUEST,
+                error: `update: error: status list '${statusListName}' is encrypted`,
+            };
+        }
+        try {
+            const result = (await identityServiceStrategySetup.agent.updateUnencryptedStatusList(did, listType, {
+                indices: typeof indices === 'number' ? [indices] : indices,
+                statusListName,
+                statusListVersion,
+                statusAction,
+            }, customer));
+            result.updated = (function (that) {
+                if (that?.revoked?.every((item) => !!item) &&
+                    that?.revoked?.length !== 0)
+                    return true;
+                if (that?.suspended?.every((item) => !!item) &&
+                    that?.suspended?.length !== 0)
+                    return true;
+                if (that?.unsuspended?.every((item) => !!item) &&
+                    that?.unsuspended?.length !== 0)
+                    return true;
+                return false;
+            })(result);
+            if (result.error) {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.BAD_REQUEST,
+                    error: result.error?.message || result.error.toString(),
+                };
+            }
+            const formatted = {
+                updated: true,
+                revoked: result?.revoked || undefined,
+                suspended: result?.suspended || undefined,
+                unsuspended: result?.unsuspended || undefined,
+                resource: result.statusList,
+                resourceMetadata: result.resourceMetadata,
+            };
+            if (result.resourceMetadata) {
+                const trackInfo = {
+                    category: OperationCategoryNameEnum.CREDENTIAL_STATUS,
+                    name: OperationNameEnum.CREDENTIAL_STATUS_UPDATE_UNENCRYPTED,
+                    customer,
+                    user,
+                    data: {
+                        did,
+                        resource: result.resourceMetadata,
+                        encrypted: false,
+                        symmetricKey: '',
+                    },
+                };
+                eventTracker.emit('track', trackInfo);
+            }
+            return {
+                success: true,
+                statusCode: StatusCodes.OK,
+                data: formatted,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `Internal error: ${error?.message || error}`,
+            };
+        }
+    }
+    async updateEncryptedStatusList(body, query, customer, user) {
+        const { did, statusListName, statusListVersion, indices, symmetricKey, paymentConditions, feePaymentAddress, feePaymentAmount, feePaymentWindow, } = body;
+        const { statusAction, listType } = query;
+        const identityServiceStrategySetup = new IdentityServiceStrategySetup(customer.customerId);
+        const encrypted = await identityServiceStrategySetup.agent.searchStatusList(did, statusListName, listType, DefaultStatusActionPurposeMap[statusAction]);
+        if (encrypted.error) {
+            if (encrypted.error === 'notFound') {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.NOT_FOUND,
+                    error: `update: error: status list '${statusListName}' not found`,
+                };
+            }
+            return {
+                success: false,
+                statusCode: StatusCodes.BAD_REQUEST,
+                error: `update: error: ${encrypted.error}`,
+            };
+        }
+        if (!encrypted.resource?.metadata?.encrypted) {
+            return {
+                success: false,
+                statusCode: StatusCodes.BAD_REQUEST,
+                error: `update: error: status list '${statusListName}' is unencrypted`,
+            };
+        }
+        try {
+            const result = (await identityServiceStrategySetup.agent.updateEncryptedStatusList(did, listType, {
+                indices: typeof indices === 'number' ? [indices] : indices,
+                statusListName,
+                statusListVersion,
+                statusAction,
+                paymentConditions,
+                symmetricKey,
+                feePaymentAddress,
+                feePaymentAmount,
+                feePaymentWindow,
+            }, customer));
+            result.updated = (function (that) {
+                if (that?.revoked?.every((item) => !!item) &&
+                    that?.revoked?.length !== 0)
+                    return true;
+                if (that?.suspended?.every((item) => !!item) &&
+                    that?.suspended?.length !== 0)
+                    return true;
+                if (that?.unsuspended?.every((item) => !!item) &&
+                    that?.unsuspended?.length !== 0)
+                    return true;
+                return false;
+            })(result);
+            if (result.error) {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.BAD_REQUEST,
+                    error: result.error?.message || result.error.toString(),
+                };
+            }
+            const formatted = {
+                updated: true,
+                revoked: result?.revoked || undefined,
+                suspended: result?.suspended || undefined,
+                unsuspended: result?.unsuspended || undefined,
+                resource: result.statusList,
+                resourceMetadata: result.resourceMetadata,
+                symmetricKey: result.symmetricKey,
+            };
+            if (result.resourceMetadata) {
+                const trackInfo = {
+                    category: OperationCategoryNameEnum.CREDENTIAL_STATUS,
+                    name: OperationNameEnum.CREDENTIAL_STATUS_UPDATE_ENCRYPTED,
+                    customer,
+                    user,
+                    data: {
+                        did,
+                        resource: result.resourceMetadata,
+                        encrypted: true,
+                        symmetricKey: '',
+                    },
+                    feePaymentOptions: [],
+                };
+                eventTracker.emit('track', trackInfo);
+            }
+            return {
+                success: true,
+                statusCode: StatusCodes.OK,
+                data: formatted,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `Internal error: ${error?.message || error}`,
+            };
+        }
+    }
+    async checkStatusList(body, query, customer, user) {
+        const feePaymentOptions = [];
+        // collect request parameters - case: body
+        const { did, statusListName, index, makeFeePayment, statusListCredential, statusSize, statusMessage } = body;
+        // collect request parameters - case: query
+        const { statusPurpose, listType } = query;
+        // Make the base body for tracking
+        const trackInfo = {
+            name: OperationNameEnum.CREDENTIAL_STATUS_CHECK,
+            category: OperationCategoryNameEnum.CREDENTIAL_STATUS,
+            customer,
+            user,
+            successful: false,
+            data: {
+                did,
+                registryId: '',
+            },
+        };
+        if (listType === StatusListType.Bitstring) {
+            if (!statusListCredential)
+                return {
+                    statusCode: StatusCodes.BAD_REQUEST,
+                    success: false,
+                    error: `check: error: 'statusListCredential' is required for BitstringStatusList type`,
+                };
+            if (statusSize && statusSize > 1 && !statusMessage)
+                return {
+                    statusCode: StatusCodes.BAD_REQUEST,
+                    success: false,
+                    error: `check: error: 'statusMessage' is required when 'statusSize' is greater than 1 for BitstringStatusList type`,
+                };
+        }
+        const identityServiceStrategySetup = new IdentityServiceStrategySetup(customer.customerId);
+        const statusList = await identityServiceStrategySetup.agent.searchStatusList(did, statusListName, listType, statusPurpose);
+        if (statusList.error) {
+            if (statusList.error === 'notFound') {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.NOT_FOUND,
+                    error: `check: error: status list '${statusListName}' not found`,
+                };
+            }
+            return {
+                success: false,
+                statusCode: StatusCodes.BAD_REQUEST,
+                error: `check: error: ${statusList.error}`,
+            };
+        }
+        try {
+            // make fee payment, if defined
+            if (makeFeePayment && statusList?.resource?.metadata?.encrypted) {
+                const feePaymentResult = await Promise.all(statusList?.resource?.metadata?.paymentConditions?.map(async (condition) => {
+                    return await identityServiceStrategySetup.agent.remunerateStatusList2021({
+                        feePaymentAddress: condition.feePaymentAddress,
+                        feePaymentAmount: condition.feePaymentAmount,
+                        feePaymentNetwork: toNetwork(did),
+                        memo: 'Automated status check fee payment, orchestrated by CaaS.',
+                    }, customer);
+                }) || []);
+                // Track the operation
+                await Promise.all(feePaymentResult.map(async (result) => {
+                    const portion = await FeeAnalyzer.getPaymentTrack(result, toNetwork(did));
+                    feePaymentOptions.push(...portion);
+                }));
+                // handle error
+                if (feePaymentResult.some((result) => result.error)) {
+                    trackInfo.data = {
+                        did: did,
+                        resource: statusList.resourceMetadata,
+                        encrypted: statusList.resource?.metadata?.encrypted,
+                    };
+                    trackInfo.successful = false;
+                    trackInfo.feePaymentOptions = feePaymentOptions;
+                    eventTracker.emit('track', trackInfo);
+                    return {
+                        success: false,
+                        statusCode: StatusCodes.BAD_REQUEST,
+                        error: `check: payment: error: ${feePaymentResult.find((result) => result.error)?.error}`,
+                    };
+                }
+            }
+            // check status list
+            let result;
+            if (listType === StatusListType.Bitstring) {
+                result = await identityServiceStrategySetup.agent.checkBitstringStatusList(did, {
+                    id: statusListCredential + '#' + index,
+                    type: 'BitstringStatusListEntry',
+                    statusPurpose,
+                    statusListIndex: index.toString(),
+                    statusListCredential: statusListCredential || '',
+                    statusSize: statusSize,
+                    statusMessage: statusMessage,
+                }, customer);
+            }
+            else {
+                result = await identityServiceStrategySetup.agent.checkStatusList2021(did, {
+                    statusListIndex: index,
+                    statusListName,
+                    statusPurpose,
+                }, customer);
+            }
+            if ('error' in result && result.error) {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.BAD_REQUEST,
+                    error: typeof result.error === 'string'
+                        ? result.error
+                        : result.error.message || result.error.toString(),
+                };
+            }
+            trackInfo.data = {
+                did: did,
+                resource: statusList.resourceMetadata,
+                encrypted: statusList.resource?.metadata?.encrypted,
+            };
+            trackInfo.successful = true;
+            trackInfo.feePaymentOptions = feePaymentOptions;
+            eventTracker.emit('track', trackInfo);
+            return {
+                success: true,
+                statusCode: StatusCodes.OK,
+                data: result,
+            };
+        }
+        catch (error) {
+            const errorRef = error;
+            if (errorRef?.errorCode === 'NodeAccessControlConditionsReturnedNotAuthorized') {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.UNAUTHORIZED,
+                    error: `check: error: ${errorRef?.message
+                        ? 'unauthorized: decryption conditions are not met'
+                        : error.toString()}`,
+                };
+            }
+            if (errorRef?.errorCode === 'incorrect_access_control_conditions') {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.BAD_REQUEST,
+                    error: `check: error: ${errorRef?.message
+                        ? 'incorrect access control conditions'
+                        : error.toString()}`,
+                };
+            }
+            return {
+                success: false,
+                statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `Internal error: ${errorRef?.message || errorRef.toString()}`,
+            };
+        }
+    }
+    async searchStatusList(query) {
+        const { did, statusListName, listType, statusPurpose } = query;
+        try {
+            // find in registry and retreive uri
+            const result = await new IdentityServiceStrategySetup().agent.searchStatusList(did, statusListName, listType, statusPurpose);
+            if (result.error) {
+                if (result.error === 'notFound') {
+                    return {
+                        success: false,
+                        statusCode: StatusCodes.NOT_FOUND,
+                        error: `search: error: status list '${statusListName}' not found`,
+                    };
+                }
+                return {
+                    success: false,
+                    statusCode: StatusCodes.BAD_REQUEST,
+                    error: `search: error: ${result.error}`,
+                };
+            }
+            return {
+                success: true,
+                statusCode: StatusCodes.OK,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `Internal error: ${error?.message || error}`,
+            };
+        }
+    }
+    /**
+     * Helper method to determine the next resource name in the registry chain
+     * Examples:
+     *   "test-list" -> "test-list-ext1"
+     *   "test-list-ext1" -> "test-list-ext2"
+     *   "test-list-ext5" -> "test-list-ext6"
+     */
+    getNextResourceName(currentRegistryName) {
+        // Check if already has extension
+        const extMatch = currentRegistryName.match(/^(.+)-ext(\d+)$/);
+        if (extMatch) {
+            // Already has extension, increment it
+            const baseName = extMatch[1];
+            const currentExt = parseInt(extMatch[2], 10);
+            return `${baseName}-ext${currentExt + 1}`;
+        }
+        else {
+            // First extension
+            return `${currentRegistryName}-ext1`;
+        }
+    }
+    /**
+     * Update registry using CAS (Compare-And-Swap) pattern for optimistic locking
+     * @returns true if update succeeded, false if concurrent modification detected
+     */
+    async updateRegistryWithCAS(registryId, currentVersion, updates) {
+        const result = await this.repository
+            .createQueryBuilder()
+            .update(StatusRegistryEntity)
+            .set({
+            ...updates,
+            version: currentVersion + 1,
+            updatedAt: new Date(),
+        })
+            .where('registryId = :registryId', { registryId })
+            .andWhere('version = :version', { version: currentVersion })
+            .execute();
+        return (result.affected ?? 0) === 1;
+    }
+    /**
+     * Find registry by URI
+     */
+    async findRegistryByUri(uri, customer) {
+        return await this.repository.findOne({
+            where: {
+                uri,
+                customer,
+            },
+            relations: ['identifier'],
+        });
+    }
+    /**
+     * Create STANDBY registry linked to the active registry
+     */
+    async createStandbyRegistry(activeRegistry, customer) {
+        const nextResourceName = this.getNextResourceName(activeRegistry.registryName);
+        const nextUri = `${activeRegistry.identifier.did}?resourceName=${nextResourceName}&resourceType=${activeRegistry.registryType}`;
+        // Create new STANDBY registry
+        const newRegistryRequestBody = {
+            ...activeRegistry.metadata,
+            encoding: activeRegistry.metadata?.encoding,
+            did: activeRegistry.identifier.did,
+            statusListName: nextResourceName,
+            statusListVersion: '1',
+            length: activeRegistry.registrySize,
+            state: StatusRegistryState.Standby,
+            credentialCategory: activeRegistry.credentialCategory,
+            prev_uri: activeRegistry.uri,
+        };
+        const newRegistryQuery = {
+            listType: activeRegistry.registryType,
+            statusPurpose: activeRegistry.metadata?.statusPurpose,
+        };
+        const res = activeRegistry.encrypted
+            ? await this.createEncryptedStatusList(newRegistryRequestBody, newRegistryQuery, customer)
+            : await this.createUnencryptedStatusList(newRegistryRequestBody, newRegistryQuery, customer);
+        if (res.error) {
+            throw new Error(`Failed to create STANDBY registry: ${res.error}`);
+        }
+        // Update current registry with next_uri using CAS
+        const updated = await this.updateRegistryWithCAS(activeRegistry.registryId, activeRegistry.version, {
+            next_uri: nextUri,
+        });
+        if (!updated) {
+            throw new Error('Failed to update next_uri - concurrent modification detected');
+        }
+    }
+    /**
+     * Rotate status list based on capacity threshold
+     * This function handles:
+     * 1. Creating STANDBY when threshold is reached
+     * 2. Promoting STANDBY to ACTIVE when registry is FULL
+     * 3. Marking current registry as FULL
+     */
+    async rotateStatusList(statusListId, customer) {
+        // Find existing registry
+        const registry = await this.repository.findOne({
+            where: {
+                registryId: statusListId,
+                customer,
+            },
+            relations: ['identifier'],
+        });
+        if (!registry) {
+            throw new Error('Registry not found');
+        }
+        // Calculate utilization
+        const utilizationPercent = (registry.writeCursor / registry.registrySize) * 100;
+        const isFull = registry.writeCursor >= registry.registrySize;
+        const isAtThreshold = utilizationPercent >= registry.threshold_percentage;
+        if (isFull) {
+            // Registry is FULL - promote STANDBY to ACTIVE
+            await this.handleFullRegistry(registry, customer);
+        }
+        else if (isAtThreshold) {
+            // Threshold reached - create STANDBY if not exists
+            await this.handleThresholdReached(registry, customer);
+        }
+        else {
+            throw new Error(`Registry is not at threshold (${utilizationPercent.toFixed(2)}% < ${registry.threshold_percentage}%)`);
+        }
+    }
+    /**
+     * Handle registry that has reached threshold
+     * Creates STANDBY if one doesn't exist
+     */
+    async handleThresholdReached(registry, customer) {
+        // Check if STANDBY already exists
+        if (registry.next_uri) {
+            // STANDBY already exists, nothing to do
+            console.log(`STANDBY already exists for registry ${registry.registryId}`);
+            return;
+        }
+        // Create STANDBY registry
+        await this.createStandbyRegistry(registry, customer);
+    }
+    /**
+     * Handle registry that is FULL
+     * Promotes STANDBY to ACTIVE and creates new STANDBY
+     */
+    async handleFullRegistry(registry, customer) {
+        // Check if next_uri exists (STANDBY)
+        if (!registry.next_uri) {
+            throw new Error('Registry is FULL but no STANDBY exists. Create STANDBY first.');
+        }
+        // Mark current as FULL using CAS
+        const markedFull = await this.updateRegistryWithCAS(registry.registryId, registry.version, {
+            state: StatusRegistryState.Full,
+            sealedAt: new Date(), // TODO include sealed commitment
+        });
+        if (!markedFull) {
+            throw new Error('Failed to mark registry as FULL - concurrent modification detected');
+        }
+        // Find STANDBY registry by next_uri
+        const standbyRegistry = await this.findRegistryByUri(registry.next_uri, customer);
+        if (!standbyRegistry) {
+            throw new Error('STANDBY registry not found at next_uri');
+        }
+        // Promote STANDBY to ACTIVE using CAS
+        const promoted = await this.updateRegistryWithCAS(standbyRegistry.registryId, standbyRegistry.version, {
+            state: StatusRegistryState.Active,
+        });
+        if (!promoted) {
+            throw new Error('Failed to promote STANDBY to ACTIVE - concurrent modification detected');
+        }
+        // Create new STANDBY for the newly promoted ACTIVE registry
+        await this.createStandbyRegistry(standbyRegistry, customer);
+    }
+    async listStatusList(query, customer) {
+        const { deprecated, did, state, statusListName, listType, credentialCategory } = query;
+        try {
+            const where = {
+                customer: { customerId: customer.customerId },
+            };
+            const relations = {
+                identifier: true, // Check performance for this JOIN operation
+            };
+            if (deprecated) {
+                where.deprecated = deprecated;
+            }
+            if (did) {
+                where.identifier = { did };
+            }
+            if (state) {
+                where.state = state;
+            }
+            if (listType) {
+                if (listType === StatusListType.Bitstring) {
+                    where.registryType = Like('%Bitstring%');
+                }
+                else {
+                    where.registryType = Like('%StatusList2021%');
+                }
+            }
+            if (statusListName) {
+                where.registryName = statusListName;
+            }
+            if (credentialCategory) {
+                where.credentialCategory = credentialCategory;
+            }
+            const [data, count] = await this.repository.findAndCount({ where, relations });
+            return {
+                success: true,
+                statusCode: StatusCodes.OK,
+                data: {
+                    records: data.map((item) => ({
+                        statusListId: item.registryId,
+                        statusListName: item.registryName,
+                        uri: item.uri,
+                        issuerId: item.identifier.did,
+                        previousUri: item.prev_uri,
+                        nextUri: item.next_uri,
+                        listType: item.registryType,
+                        storageType: item.storageType,
+                        encrypted: item.encrypted || false,
+                        credentialCategory: item.credentialCategory,
+                        size: item.registrySize,
+                        writeCursor: item.writeCursor,
+                        state: item.state,
+                        createdAt: item.createdAt.toISOString(),
+                        updatedAt: item.updatedAt.toISOString(),
+                        sealedAt: item.sealedAt ? item.sealedAt.toISOString() : undefined,
+                        statusPurpose: item.metadata?.statusPurpose,
+                        deprecated: item.deprecated,
+                    })),
+                    total: count,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `Internal error: ${error?.message || error}`,
+            };
+        }
+    }
+    async getStatusList(statusOptions, customer, lock = false) {
+        const where = {
+            customer: { customerId: customer.customerId },
+        };
+        if (statusOptions.statusListId) {
+            where.registryId = statusOptions.statusListId;
+        }
+        else if (statusOptions.statusListName && statusOptions.listType) {
+            where.registryName = statusOptions.statusListName;
+            where.registryType = statusOptions.listType;
+        }
+        else {
+            return {
+                success: false,
+                statusCode: StatusCodes.BAD_REQUEST,
+                error: 'Either statusListId or statusListName and listType must be provided',
+            };
+        }
+        try {
+            const item = await this.repository.findOne({
+                where,
+                relations: ['identifier'],
+                lock: lock ? { mode: 'pessimistic_write' } : undefined,
+            });
+            if (!item) {
+                return {
+                    success: false,
+                    statusCode: StatusCodes.NOT_FOUND,
+                    error: `Status list not found`,
+                };
+            }
+            return {
+                success: true,
+                statusCode: StatusCodes.OK,
+                data: {
+                    statusListId: item.registryId,
+                    statusListName: item.registryName,
+                    uri: item.uri,
+                    issuerId: item.identifier.did,
+                    previousUri: item.prev_uri,
+                    nextUri: item.next_uri,
+                    listType: item.registryType,
+                    storageType: item.storageType,
+                    encrypted: item.encrypted || false,
+                    credentialCategory: item.credentialCategory,
+                    size: item.registrySize,
+                    writeCursor: item.writeCursor,
+                    state: item.state,
+                    createdAt: item.createdAt.toISOString(),
+                    updatedAt: item.updatedAt.toISOString(),
+                    sealedAt: item.sealedAt ? item.sealedAt.toISOString() : undefined,
+                    deprecated: item.deprecated,
+                    statusPurpose: item.metadata?.statusPurpose,
+                    additionalUsedIndexes: item.metadata?.additionalUsedIndexes || [],
+                },
+            };
+        }
+        catch (error) {
+            throw new Error(`Internal error: ${error?.message || error}`);
+        }
+    }
+}
+//# sourceMappingURL=credential-status.js.map