@sphereon/ssi-sdk.vc-status-list 0.34.1-feature.SSISDK.17.bitstring.sl.10 → 0.34.1-feature.SSISDK.17.bitstring.sl.13

package/src/functions.ts

@@ -2,13 +2,14 @@ import type { IIdentifierResolution } from '@sphereon/ssi-sdk-ext.identifier-res
 import {
   CredentialMapper,
   type CredentialProofFormat,
-  DocumentFormat,
   type StatusListCredential,
   StatusListDriverType,
   StatusListType,
   type StatusPurpose2021,
 } from '@sphereon/ssi-types'
-import type { CredentialStatus, DIDDocument, IAgentContext, ICredentialPlugin, ProofFormat as VeramoProofFormat } from '@veramo/core'
+import type { CredentialStatus, DIDDocument, IAgentContext, ProofFormat as VeramoProofFormat } from '@veramo/core'
+
+import { IAddStatusListArgs, IBitstringStatusListEntryEntity, IStatusListEntryEntity, StatusListEntity } from '@sphereon/ssi-sdk.data-store'
 
 import { checkStatus } from '@sphereon/vc-status-list'
 
@@ -16,9 +17,12 @@ import { checkStatus } from '@sphereon/vc-status-list'
 import { CredentialJwtOrJSON, StatusMethod } from 'credential-status'
 import {
   BitstringStatus,
+  BitstringStatusListEntryCredentialStatus,
   CreateNewStatusListFuncArgs,
   Status2021,
+  StatusList2021EntryCredentialStatus,
   StatusList2021ToVerifiableCredentialArgs,
+  StatusListOAuthEntryCredentialStatus,
   StatusListResult,
   StatusOAuth,
   UpdateStatusListFromEncodedListArgs,
@@ -26,6 +30,7 @@ import {
 } from './types'
 import { assertValidProofType, determineStatusListType, getAssertedValue, getAssertedValues } from './utils'
 import { getStatusListImplementation } from './impl/StatusListFactory'
+import { IVcdmCredentialPlugin } from '@sphereon/ssi-sdk.credential-vcdm'
 
 export async function fetchStatusListCredential(args: { statusListCredential: string }): Promise<StatusListCredential> {
   const url = getAssertedValue('statusListCredential', args.statusListCredential)
@@ -146,7 +151,7 @@ export async function simpleCheckStatusFromStatusListUrl(args: {
 
 export async function checkStatusIndexFromStatusListCredential(args: {
   statusListCredential: StatusListCredential
-  statusPurpose?: StatusPurpose2021
+  statusPurpose?: StatusPurpose2021 | string | string[]
   type?: StatusListType | 'StatusList2021Entry' | 'BitstringStatusListEntry'
   id?: string
   statusListIndex: string | number
@@ -159,7 +164,7 @@ export async function checkStatusIndexFromStatusListCredential(args: {
 
 export async function createNewStatusList(
   args: CreateNewStatusListFuncArgs,
-  context: IAgentContext<(ICredentialPlugin | any) /*IvcdMCredentialPlugin is not available*/ & IIdentifierResolution>,
+  context: IAgentContext<(IVcdmCredentialPlugin | any) /*IvcdMCredentialPlugin is not available*/ & IIdentifierResolution>,
 ): Promise<StatusListResult> {
   const { type } = getAssertedValues(args)
   const implementation = getStatusListImplementation(type)
@@ -168,7 +173,7 @@ export async function createNewStatusList(
 
 export async function updateStatusIndexFromStatusListCredential(
   args: UpdateStatusListIndexArgs,
-  context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
+  context: IAgentContext<IVcdmCredentialPlugin & IIdentifierResolution>,
 ): Promise<StatusListResult> {
   const credential = getAssertedValue('statusListCredential', args.statusListCredential)
   const statusListType: StatusListType = determineStatusListType(credential)
@@ -176,54 +181,55 @@ export async function updateStatusIndexFromStatusListCredential(
   return implementation.updateStatusListIndex(args, context)
 }
 
-// Keeping helper function for backward compatibility
 export async function statusListCredentialToDetails({
+  statusListType,
   correlationId,
   driverType,
   statusListCredential,
   bitsPerStatus,
 }: {
+  statusListType: StatusListType
   statusListCredential: StatusListCredential
   correlationId?: string
   driverType?: StatusListDriverType
   bitsPerStatus?: number
-}): Promise<StatusListResult> {
+}): Promise<StatusListResult & Partial<IAddStatusListArgs>> {
   const credential = getAssertedValue('statusListCredential', statusListCredential)
-
-  let statusListType: StatusListType | undefined
-  const documentFormat = CredentialMapper.detectDocumentType(credential)
-  if (documentFormat === DocumentFormat.JWT) {
-    const [header] = credential.split('.')
-    const decodedHeader = JSON.parse(Buffer.from(header, 'base64').toString())
-
-    if (decodedHeader.typ === 'statuslist+jwt') {
-      statusListType = StatusListType.OAuthStatusList
-    }
-  } else if (documentFormat === DocumentFormat.MSO_MDOC) {
-    statusListType = StatusListType.OAuthStatusList
-    // TODO check CBOR content?
-  }
-  if (!statusListType) {
-    const uniform = CredentialMapper.toUniformCredential(credential)
-    const type = uniform.type.find((t) => t.includes('StatusList2021') || t.includes('OAuth2StatusList') || t.includes('BitstringStatusList'))
-    if (!type) {
-      throw new Error('Invalid status list credential type')
-    }
-    statusListType = type.replace('Credential', '') as StatusListType
-  }
-
   const implementation = getStatusListImplementation(statusListType)
-  return await implementation.toStatusListDetails({
+
+  // The implementation should now return all the type-specific fields needed for the entity
+  const result = await implementation.toStatusListDetails({
     statusListPayload: credential,
     correlationId: correlationId,
     driverType: driverType,
     bitsPerStatus: bitsPerStatus,
   })
+
+  return result
+}
+
+export async function createCredentialStatusFromStatusList(args: {
+  statusList: StatusListEntity
+  statusListEntry: IStatusListEntryEntity | IBitstringStatusListEntryEntity
+  statusListIndex: number
+}): Promise<StatusList2021EntryCredentialStatus | StatusListOAuthEntryCredentialStatus | BitstringStatusListEntryCredentialStatus> {
+  const { statusList, statusListEntry, statusListIndex } = args
+
+  // Determine the status list type and delegate to appropriate implementation
+  const statusListType = determineStatusListType(statusList.statusListCredential!)
+  const implementation = getStatusListImplementation(statusListType)
+
+  // Each implementation should have a method to create credential status
+  return implementation.createCredentialStatus({
+    statusList,
+    statusListEntry,
+    statusListIndex,
+  })
 }
 
 export async function updateStatusListIndexFromEncodedList(
   args: UpdateStatusListFromEncodedListArgs,
-  context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
+  context: IAgentContext<IVcdmCredentialPlugin & IIdentifierResolution>,
 ): Promise<StatusListResult> {
   const { type } = getAssertedValue('type', args)
   const implementation = getStatusListImplementation(type!)
@@ -232,7 +238,7 @@ export async function updateStatusListIndexFromEncodedList(
 
 export async function statusList2021ToVerifiableCredential(
   args: StatusList2021ToVerifiableCredentialArgs,
-  context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
+  context: IAgentContext<IVcdmCredentialPlugin & IIdentifierResolution>,
 ): Promise<StatusListCredential> {
   const { issuer, id, type } = getAssertedValues(args)
   const identifier = await context.agent.identifierManagedGet({

package/src/impl/BitstringStatusListImplementation.ts

@@ -1,5 +1,24 @@
-import type { IAgentContext, ICredentialPlugin, ProofFormat as VeramoProofFormat } from '@veramo/core'
+/**
+ * Bitstring Status List Implementation
+ *
+ * This module implements the W3C Bitstring Status List specification for managing
+ * credential status information. It provides functionality to create, update, and
+ * check the status of verifiable credentials using compressed bitstring status lists.
+ *
+ * Key features:
+ * - Create new bitstring status lists with configurable purposes and bit sizes
+ * - Update individual credential status entries in existing lists
+ * - Check the status of specific credentials by index
+ * - Support for multiple proof formats (JWT, LDS, CBOR)
+ * - Integration with Veramo agent context for credential signing
+ *
+ * @author Sphereon International B.V.
+ * @since 2024
+ */
+
+import type { IAgentContext } from '@veramo/core'
 import type { IIdentifierResolution } from '@sphereon/ssi-sdk-ext.identifier-resolution'
+
 import {
   CredentialMapper,
   type CredentialProofFormat,
@@ -9,9 +28,10 @@ import {
   StatusListType,
 } from '@sphereon/ssi-types'
 
-import type { IStatusList } from './IStatusList'
+import type { IBitstringStatusListImplementationResult, IStatusList } from './IStatusList'
 import {
   BitstringStatus,
+  BitstringStatusListEntryCredentialStatus,
   CheckStatusIndexArgs,
   CreateStatusListArgs,
   StatusListResult,
@@ -22,16 +42,37 @@ import {
 
 import { assertValidProofType, ensureDate, getAssertedProperty, getAssertedValue, getAssertedValues } from '../utils'
 import { BitstringStatusListCredential } from '../types/BitstringStatusList'
-import { BitstreamStatusList, BitstringStatusPurpose, createStatusListCredential } from '@4sure-tech/vc-bitstring-status-lists'
+import {
+  BitstreamStatusList,
+  BitstringStatusListCredentialUnsigned,
+  BitstringStatusPurpose,
+  createStatusListCredential,
+} from '@4sure-tech/vc-bitstring-status-lists'
+import { BitstringStatusListEntity, IBitstringStatusListEntryEntity, IStatusListEntryEntity, StatusListEntity } from '@sphereon/ssi-sdk.data-store'
+import { IVcdmCredentialPlugin } from '@sphereon/ssi-sdk.credential-vcdm'
 
 export const DEFAULT_LIST_LENGTH = 131072 // W3C spec minimum
 export const DEFAULT_PROOF_FORMAT = 'lds' as CredentialProofFormat
 export const DEFAULT_STATUS_PURPOSE: BitstringStatusPurpose = 'revocation'
 
+/**
+ * Implementation of the IStatusList interface for W3C Bitstring Status Lists
+ *
+ * This class handles the creation, updating, and verification of bitstring status lists
+ * according to the W3C Bitstring Status List specification. It supports multiple
+ * status purposes (revocation, suspension, etc.) and various proof formats.
+ */
 export class BitstringStatusListImplementation implements IStatusList {
+  /**
+   * Creates a new bitstring status list with the specified configuration
+   *
+   * @param args - Configuration for the new status list including issuer, purpose, and size
+   * @param context - Veramo agent context for credential operations
+   * @returns Promise resolving to the created status list details
+   */
   async createNewStatusList(
     args: CreateStatusListArgs,
-    context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
+    context: IAgentContext<IVcdmCredentialPlugin & IIdentifierResolution>,
   ): Promise<StatusListResult> {
     if (!args.bitstringStatusList) {
       throw new Error('BitstringStatusList options are required for type BitstringStatusList')
@@ -40,30 +81,37 @@ export class BitstringStatusListImplementation implements IStatusList {
     const length = args?.length ?? DEFAULT_LIST_LENGTH
     const proofFormat: CredentialProofFormat = args?.proofFormat ?? DEFAULT_PROOF_FORMAT
     assertValidProofType(StatusListType.BitstringStatusList, proofFormat)
-    const veramoProofFormat: VeramoProofFormat = proofFormat as VeramoProofFormat
 
     const { issuer, id } = args
     const correlationId = getAssertedValue('correlationId', args.correlationId)
     const { statusPurpose, bitsPerStatus, validFrom, validUntil, ttl } = args.bitstringStatusList
+
+    const unsignedCredential: BitstringStatusListCredentialUnsigned = await createStatusListCredential({
+      id,
+      issuer,
+      statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
+      validFrom: ensureDate(validFrom),
+      validUntil: ensureDate(validUntil),
+      ttl,
+    })
     const statusListCredential = await this.createVerifiableCredential(
       {
-        ...args,
-        proofFormat: veramoProofFormat,
-        statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
-        validFrom: ensureDate(validFrom),
-        validUntil: ensureDate(validUntil),
-        ttl,
+        unsignedCredential,
+        id,
+        issuer,
+        proofFormat,
+        keyRef: args.keyRef,
       },
       context,
     )
 
     return {
-      encodedList: statusListCredential.credentialSubject.encodedList,
-      statusListCredential: statusListCredential,
+      encodedList: unsignedCredential.credentialSubject.encodedList,
+      statusListCredential,
       bitstringStatusList: {
         statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
-        ...(statusListCredential.validFrom && { validFrom: new Date(statusListCredential.validFrom) }),
-        ...(statusListCredential.validUntil && { validUntil: new Date(statusListCredential.validUntil) }),
+        ...(unsignedCredential.validFrom && { validFrom: new Date(unsignedCredential.validFrom) }),
+        ...(unsignedCredential.validUntil && { validUntil: new Date(unsignedCredential.validUntil) }),
         ttl,
         bitsPerStatus,
       },
@@ -77,12 +125,19 @@ export class BitstringStatusListImplementation implements IStatusList {
     }
   }
 
+  /**
+   * Updates the status of a specific credential in an existing status list
+   *
+   * @param args - Update parameters including the status list credential, index, and new value
+   * @param context - Veramo agent context for credential operations
+   * @returns Promise resolving to the updated status list details
+   */
   async updateStatusListIndex(
     args: UpdateStatusListIndexArgs,
-    context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
+    context: IAgentContext<IVcdmCredentialPlugin & IIdentifierResolution>,
   ): Promise<StatusListResult> {
     if (!args.bitsPerStatus || args.bitsPerStatus < 1) {
-      return Promise.reject('bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (updateStatusListIndex)')
+      return Promise.reject(Error('bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (updateStatusListIndex)'))
     }
 
     const credential = args.statusListCredential
@@ -105,74 +160,92 @@ export class BitstringStatusListImplementation implements IStatusList {
     const validUntil = uniform.validUntil ? new Date(uniform.validUntil) : undefined
     const ttl = credSubject.ttl
 
+    const unsignedCredential: BitstringStatusListCredentialUnsigned = await createStatusListCredential({
+      id,
+      issuer,
+      statusList,
+      statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
+      validFrom: ensureDate(validFrom),
+      validUntil: ensureDate(validUntil),
+      ttl,
+    })
+
     const updatedCredential = await this.createVerifiableCredential(
       {
-        ...args,
+        unsignedCredential,
         id,
         issuer,
-        statusList,
-        proofFormat: proofFormat,
-        statusPurpose,
-        ttl,
-        validFrom,
-        validUntil,
+        proofFormat,
+        keyRef: args.keyRef,
       },
       context,
     )
 
     return {
       statusListCredential: updatedCredential,
-      encodedList: updatedCredential.credentialSubject.encodedList,
+      encodedList: unsignedCredential.credentialSubject.encodedList,
       bitstringStatusList: {
         statusPurpose,
-        ...(updatedCredential.validFrom && { validFrom: new Date(updatedCredential.validFrom) }),
-        ...(updatedCredential.validUntil && { validUntil: new Date(updatedCredential.validUntil) }),
+        ...(unsignedCredential.validFrom && { validFrom: new Date(unsignedCredential.validFrom) }),
+        ...(unsignedCredential.validUntil && { validUntil: new Date(unsignedCredential.validUntil) }),
         bitsPerStatus: args.bitsPerStatus,
         ttl,
       },
       length: statusList.getLength(),
       type: StatusListType.BitstringStatusList,
-      proofFormat: proofFormat,
+      proofFormat,
       id,
       issuer,
       statuslistContentType: this.buildContentType(proofFormat),
     }
   }
 
+  /**
+   * Updates a status list by decoding an encoded list, modifying it, and re-encoding
+   *
+   * @param args - Update parameters including encoded list, index, and new value
+   * @param context - Veramo agent context for credential operations
+   * @returns Promise resolving to the updated status list details
+   */
   async updateStatusListFromEncodedList(
     args: UpdateStatusListFromEncodedListArgs,
-    context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
+    context: IAgentContext<IVcdmCredentialPlugin & IIdentifierResolution>,
   ): Promise<StatusListResult> {
     if (!args.bitstringStatusList) {
       throw new Error('bitstringStatusList options required for type BitstringStatusList')
     }
 
     if (args.bitstringStatusList.bitsPerStatus < 1) {
-      return Promise.reject('bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (updateStatusListFromEncodedList)')
+      return Promise.reject(Error('bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (updateStatusListFromEncodedList)'))
     }
 
     const { statusPurpose, bitsPerStatus, ttl, validFrom, validUntil } = args.bitstringStatusList
 
     const proofFormat: CredentialProofFormat = args?.proofFormat ?? DEFAULT_PROOF_FORMAT
     assertValidProofType(StatusListType.BitstringStatusList, proofFormat)
-    const veramoProofFormat: VeramoProofFormat = proofFormat as VeramoProofFormat
 
     const { issuer, id } = getAssertedValues(args)
     const statusList: BitstreamStatusList = await BitstreamStatusList.decode({ encodedList: args.encodedList, statusSize: bitsPerStatus })
     const index = typeof args.statusListIndex === 'number' ? args.statusListIndex : parseInt(args.statusListIndex)
     statusList.setStatus(index, args.value)
 
+    const unsignedCredential: BitstringStatusListCredentialUnsigned = await createStatusListCredential({
+      id,
+      issuer,
+      statusList,
+      statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
+      validFrom: ensureDate(validFrom),
+      validUntil: ensureDate(validUntil),
+      ttl,
+    })
+
     const credential = await this.createVerifiableCredential(
       {
+        unsignedCredential,
         id,
         issuer,
-        statusList,
-        proofFormat: veramoProofFormat,
+        proofFormat,
         keyRef: args.keyRef,
-        statusPurpose,
-        validFrom: ensureDate(validFrom),
-        validUntil: ensureDate(validUntil),
-        ttl,
       },
       context,
     )
@@ -180,34 +253,38 @@ export class BitstringStatusListImplementation implements IStatusList {
     return {
       type: StatusListType.BitstringStatusList,
       statusListCredential: credential,
-      encodedList: credential.credentialSubject.encodedList,
+      encodedList: unsignedCredential.credentialSubject.encodedList,
       bitstringStatusList: {
         statusPurpose,
         bitsPerStatus,
-        ...(credential.validFrom && { validFrom: new Date(credential.validFrom) }),
-        ...(credential.validUntil && { validUntil: new Date(credential.validUntil) }),
+        ...(unsignedCredential.validFrom && { validFrom: new Date(unsignedCredential.validFrom) }),
+        ...(unsignedCredential.validUntil && { validUntil: new Date(unsignedCredential.validUntil) }),
         ttl,
       },
       length: statusList.getLength(),
       proofFormat: args.proofFormat ?? 'lds',
-      id: id,
-      issuer: issuer,
+      id,
+      issuer,
       statuslistContentType: this.buildContentType(proofFormat),
     }
   }
 
+  /**
+   * Checks the status of a specific credential by its index in the status list
+   *
+   * @param args - Check parameters including the status list credential and index
+   * @returns Promise resolving to the status value at the specified index
+   */
   async checkStatusIndex(args: CheckStatusIndexArgs): Promise<BitstringStatus> {
     if (!args.bitsPerStatus || args.bitsPerStatus < 1) {
-      return Promise.reject('bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (checkStatusIndex)')
+      return Promise.reject(Error('bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (checkStatusIndex)'))
     }
 
     const uniform = CredentialMapper.toUniformCredential(args.statusListCredential)
     const { credentialSubject } = uniform
     const encodedList = getAssertedProperty('encodedList', credentialSubject)
 
-    const statusSize = args.bitsPerStatus
-    const statusList = await BitstreamStatusList.decode({ encodedList, statusSize })
-
+    const statusList = await BitstreamStatusList.decode({ encodedList, statusSize: args.bitsPerStatus })
     const numIndex = typeof args.statusListIndex === 'number' ? args.statusListIndex : parseInt(args.statusListIndex)
     if (statusList.getLength() <= numIndex) {
       throw new Error(`Status list index out of bounds, has ${statusList.getLength()} entries, requested ${numIndex}`)
@@ -215,17 +292,23 @@ export class BitstringStatusListImplementation implements IStatusList {
     return statusList.getStatus(numIndex)
   }
 
-  async toStatusListDetails(args: ToStatusListDetailsArgs): Promise<StatusListResult> {
+  /**
+   * Converts a status list credential payload to detailed status list information
+   *
+   * @param args - Conversion parameters including the status list payload
+   * @returns Promise resolving to detailed status list information
+   */
+  async toStatusListDetails(args: ToStatusListDetailsArgs): Promise<StatusListResult & IBitstringStatusListImplementationResult> {
     const { statusListPayload, bitsPerStatus } = args
     if (!bitsPerStatus || bitsPerStatus < 1) {
-      return Promise.reject('bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (toStatusListDetails)')
+      return Promise.reject(Error('bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (toStatusListDetails)'))
     }
 
     const uniform = CredentialMapper.toUniformCredential(statusListPayload)
     const { issuer, credentialSubject } = uniform
     const id = getAssertedValue('id', uniform.id)
     const encodedList = getAssertedProperty('encodedList', credentialSubject)
-    const proofFormat: CredentialProofFormat = CredentialMapper.detectDocumentType(statusListPayload) === DocumentFormat.JWT ? 'jwt' : 'lds'
+    const proofFormat: CredentialProofFormat = CredentialMapper.detectDocumentType(statusListPayload) === DocumentFormat.JWT ? 'vc+jwt' : 'lds'
     const credSubject = Array.isArray(credentialSubject) ? credentialSubject[0] : credentialSubject
     const statusPurpose = getAssertedProperty('statusPurpose', credSubject)
     const validFrom = uniform.validFrom ? new Date(uniform.validFrom) : undefined
@@ -234,6 +317,7 @@ export class BitstringStatusListImplementation implements IStatusList {
     const statuslistLength: number = BitstreamStatusList.getStatusListLength(encodedList, bitsPerStatus)
 
     return {
+      // Base implementation fields
       id,
       encodedList,
       issuer,
@@ -242,56 +326,115 @@ export class BitstringStatusListImplementation implements IStatusList {
       length: statuslistLength,
       statusListCredential: statusListPayload,
       statuslistContentType: this.buildContentType(proofFormat),
+      correlationId: args.correlationId, // FIXME these do not need to be inside the impl
+      driverType: args.driverType, // FIXME these do not need to be inside the impl
+
+      // Flattened Bitstring-specific fields
+      statusPurpose,
+      bitsPerStatus,
+      ...(validFrom && { validFrom }),
+      ...(validUntil && { validUntil }),
+      ...(ttl && { ttl }),
+
+      // Legacy nested structure for backward compatibility
       bitstringStatusList: {
         statusPurpose,
         bitsPerStatus,
-        validFrom,
-        validUntil,
-        ttl,
+        ...(validFrom && { validFrom }),
+        ...(validUntil && { validUntil }),
+        ...(ttl && { ttl }),
       },
+
+      // Optional fields from args
       ...(args.correlationId && { correlationId: args.correlationId }),
       ...(args.driverType && { driverType: args.driverType }),
     }
   }
 
+  /**
+   * Creates a credential status entry for a specific credential in a status list
+   *
+   * @param args - Parameters including the status list, entry details, and index
+   * @returns Promise resolving to the credential status entry
+   */
+  async createCredentialStatus(args: {
+    statusList: StatusListEntity
+    statusListEntry: IStatusListEntryEntity | IBitstringStatusListEntryEntity
+    statusListIndex: number
+  }): Promise<BitstringStatusListEntryCredentialStatus> {
+    const { statusList, statusListEntry, statusListIndex } = args
+
+    // Type guard to ensure we have a bitstring entry
+    const isBitstringEntry = (entry: IStatusListEntryEntity | IBitstringStatusListEntryEntity): entry is IBitstringStatusListEntryEntity => {
+      return 'statusPurpose' in entry
+    }
+
+    if (!isBitstringEntry(statusListEntry)) {
+      throw new Error('Expected bitstring status list entry for bitstring status list')
+    }
+
+    // Cast to BitstringStatusListEntity to access specific properties
+    const bitstringStatusList = statusList as BitstringStatusListEntity
+
+    return {
+      id: `${statusList.id}#${statusListIndex}`,
+      type: 'BitstringStatusListEntry',
+      statusPurpose: statusListEntry.statusPurpose,
+      statusListIndex: '' + statusListIndex,
+      statusListCredential: statusList.id,
+      bitsPerStatus: bitstringStatusList.bitsPerStatus,
+    } satisfies BitstringStatusListEntryCredentialStatus
+  }
+
+  /**
+   * Creates a signed verifiable credential from an unsigned status list credential
+   *
+   * @param args - Parameters including the unsigned credential and signing details
+   * @param context - Veramo agent context for credential operations
+   * @returns Promise resolving to the signed credential
+   */
   private async createVerifiableCredential(
     args: {
+      unsignedCredential: BitstringStatusListCredentialUnsigned
       id: string
       issuer: string | IIssuer
-      statusList?: BitstreamStatusList
-      proofFormat: VeramoProofFormat
-      statusPurpose: BitstringStatusPurpose
-      validFrom?: Date
-      validUntil?: Date
-      ttl?: number
+      proofFormat: CredentialProofFormat
       keyRef?: string
     },
-    context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
+    context: IAgentContext<IVcdmCredentialPlugin & IIdentifierResolution>,
   ): Promise<BitstringStatusListCredential> {
+    const { unsignedCredential, issuer, proofFormat, keyRef } = args
+
     const identifier = await context.agent.identifierManagedGet({
-      identifier: typeof args.issuer === 'string' ? args.issuer : args.issuer.id,
+      identifier: typeof issuer === 'string' ? issuer : issuer.id,
       vmRelationship: 'assertionMethod',
       offlineWhenNoDIDRegistered: true,
     })
 
-    const unsignedCredential = await createStatusListCredential(args)
-
     const verifiableCredential = await context.agent.createVerifiableCredential({
       credential: unsignedCredential,
-      keyRef: args.keyRef ?? identifier.kmsKeyRef,
-      proofFormat: args.proofFormat,
+      keyRef: keyRef ?? identifier.kmsKeyRef,
+      proofFormat,
       fetchRemoteContexts: true,
     })
 
     return CredentialMapper.toWrappedVerifiableCredential(verifiableCredential as StatusListCredential).original as BitstringStatusListCredential
   }
 
-  private buildContentType(proofFormat: CredentialProofFormat | undefined) {
+  /**
+   * Builds the appropriate content type string for a given proof format
+   *
+   * @param proofFormat - The proof format to build content type for
+   * @returns The corresponding content type string
+   */
+  private buildContentType(proofFormat: CredentialProofFormat | undefined): string {
     switch (proofFormat) {
       case 'jwt':
-        return `application/statuslist+jwt`
+        return 'application/statuslist+jwt'
       case 'cbor':
-        return `application/statuslist+cwt`
+        return 'application/statuslist+cwt'
+      case 'vc+jwt':
+        return 'application/statuslist+vc+jwt'
       case 'lds':
         return 'application/statuslist+ld+json'
       default: