@sphereon/ssi-sdk.vc-status-list 0.32.1-feature.IATAB2B.52.190 → 0.32.1-feature.MWALL.715.121

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sphereon/ssi-sdk.vc-status-list",
   "description": "Sphereon SSI-SDK plugin for Status List management, like StatusList2021.",
-  "version": "0.32.1-feature.IATAB2B.52.190+ba7b1c04",
+  "version": "0.32.1-feature.MWALL.715.121+57a299ff",
   "source": "src/index.ts",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,23 +10,14 @@
     "build:clean": "tsc --build --clean && tsc --build"
   },
   "dependencies": {
-    "@sd-jwt/core": "^0.7.2",
-    "@sd-jwt/jwt-status-list": "^0.9.1",
-    "@sd-jwt/sd-jwt-vc": "^0.7.2",
-    "@sphereon/kmp-cbor": "0.2.0-SNAPSHOT.25",
-    "@sphereon/oid4vci-common": "0.16.1-feature.IATAB2B.52.345",
-    "@sphereon/ssi-sdk-ext.did-utils": "0.27.0",
-    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.27.0",
-    "@sphereon/ssi-sdk-ext.jwt-service": "0.27.0",
-    "@sphereon/ssi-types": "0.32.1-feature.IATAB2B.52.190+ba7b1c04",
+    "@sphereon/ssi-sdk-ext.did-utils": "0.27.1-next.14",
+    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.27.1-next.14",
+    "@sphereon/ssi-types": "0.32.1-feature.MWALL.715.121+57a299ff",
     "@sphereon/vc-status-list": "7.0.0-next.0",
     "@veramo/core": "4.2.0",
     "@veramo/credential-status": "4.2.0",
-    "base64url": "^3.0.1",
     "credential-status": "^2.0.6",
     "debug": "^4.3.5",
-    "jwt-decode": "^4.0.0",
-    "pako": "^2.1.0",
     "typeorm": "^0.3.20",
     "uint8arrays": "^3.1.1"
   },
@@ -35,8 +26,6 @@
     "@babel/core": "^7.24.9",
     "@babel/preset-env": "^7.24.8",
     "@babel/preset-typescript": "^7.24.7",
-    "@types/pako": "2.0.3",
-    "@veramo/key-manager": "4.2.0",
     "typescript": "5.4.2"
   },
   "files": [
@@ -58,5 +47,5 @@
     "StatusList2021"
   ],
   "nx": {},
-  "gitHead": "ba7b1c04da999658e9172c86331bc0d0da784562"
+  "gitHead": "57a299ff462f52b69fdcc5400cca68323cf10e64"
 }

package/src/functions.ts

@@ -2,42 +2,40 @@ import { IIdentifierResolution } from '@sphereon/ssi-sdk-ext.identifier-resoluti
 import {
   CredentialMapper,
   DocumentFormat,
-  ProofFormat,
-  StatusListCredential,
+  IIssuer,
+  OriginalVerifiableCredential,
   StatusListDriverType,
   StatusListType,
   StatusPurpose2021,
 } from '@sphereon/ssi-types'
-import { CredentialStatus, DIDDocument, IAgentContext, ICredentialPlugin, ProofFormat as VeramoProofFormat } from '@veramo/core'
 
-import { checkStatus } from '@sphereon/vc-status-list'
+import { checkStatus, StatusList } from '@sphereon/vc-status-list'
+import { CredentialStatus, DIDDocument, IAgentContext, ICredentialPlugin, ProofFormat } from '@veramo/core'
 import { CredentialJwtOrJSON, StatusMethod } from 'credential-status'
 import {
   CreateNewStatusListFuncArgs,
-  Status2021,
   StatusList2021ToVerifiableCredentialArgs,
+  StatusListDetails,
   StatusListResult,
-  StatusOAuth,
   UpdateStatusListFromEncodedListArgs,
-  UpdateStatusListIndexArgs,
+  UpdateStatusListFromStatusListCredentialArgs,
 } from './types'
-import { assertValidProofType, determineStatusListType, getAssertedValue, getAssertedValues } from './utils'
-import { getStatusListImplementation } from './impl/StatusListFactory'
 
-export async function fetchStatusListCredential(args: { statusListCredential: string }): Promise<StatusListCredential> {
+export async function fetchStatusListCredential(args: { statusListCredential: string }): Promise<OriginalVerifiableCredential> {
   const url = getAssertedValue('statusListCredential', args.statusListCredential)
   try {
     const response = await fetch(url)
     if (!response.ok) {
-      throw Error(`Fetching status list ${url} resulted in an error: ${response.status} : ${response.statusText}`)
+      const error = `Fetching status list ${url} resulted in an error: ${response.status} : ${response.statusText}`
+      throw Error(error)
     }
     const responseAsText = await response.text()
     if (responseAsText.trim().startsWith('{')) {
-      return JSON.parse(responseAsText) as StatusListCredential
+      return JSON.parse(responseAsText) as OriginalVerifiableCredential
     }
-    return responseAsText as StatusListCredential
+    return responseAsText as OriginalVerifiableCredential
   } catch (error) {
-    console.error(`Fetching status list ${url} resulted in an unexpected error: ${error instanceof Error ? error.message : JSON.stringify(error)}`)
+    console.log(`Fetching status list ${url} resulted in an unexpected error: ${error instanceof Error ? error.message : JSON.stringify(error)}`)
     throw error
   }
 }
@@ -54,7 +52,7 @@ export function statusPluginStatusFunction(args: {
     const result = await checkStatusForCredential({
       ...args,
       documentLoader: args.documentLoader,
-      credential: credential as StatusListCredential,
+      credential: credential as OriginalVerifiableCredential,
       errorUnknownListType: args.errorUnknownListType,
     })
 
@@ -77,7 +75,7 @@ export function vcLibCheckStatusFunction(args: {
 }) {
   const { mandatoryCredentialStatus, verifyStatusListCredential, verifyMatchingIssuers, errorUnknownListType } = args
   return (args: {
-    credential: StatusListCredential
+    credential: OriginalVerifiableCredential
     documentLoader: any
     suite: any
   }): Promise<{
@@ -95,7 +93,7 @@ export function vcLibCheckStatusFunction(args: {
 }
 
 export async function checkStatusForCredential(args: {
-  credential: StatusListCredential
+  credential: OriginalVerifiableCredential
   documentLoader: any
   suite: any
   mandatoryCredentialStatus?: boolean
@@ -134,7 +132,7 @@ export async function simpleCheckStatusFromStatusListUrl(args: {
   type?: StatusListType | 'StatusList2021Entry'
   id?: string
   statusListIndex: string
-}): Promise<number | Status2021 | StatusOAuth> {
+}): Promise<boolean> {
   return checkStatusIndexFromStatusListCredential({
     ...args,
     statusListCredential: await fetchStatusListCredential(args),
@@ -142,97 +140,163 @@ export async function simpleCheckStatusFromStatusListUrl(args: {
 }
 
 export async function checkStatusIndexFromStatusListCredential(args: {
-  statusListCredential: StatusListCredential
+  statusListCredential: OriginalVerifiableCredential
   statusPurpose?: StatusPurpose2021
   type?: StatusListType | 'StatusList2021Entry'
   id?: string
   statusListIndex: string | number
-}): Promise<number | Status2021 | StatusOAuth> {
-  const statusListType: StatusListType = determineStatusListType(args.statusListCredential)
-  const implementation = getStatusListImplementation(statusListType)
-  return implementation.checkStatusIndex(args)
+}): Promise<boolean> {
+  const requestedType = getAssertedStatusListType(args.type?.replace('Entry', '') as StatusListType)
+  const uniform = CredentialMapper.toUniformCredential(args.statusListCredential)
+  const { issuer, type, credentialSubject, id } = uniform
+  getAssertedValue('issuer', issuer) // We are only checking the value here
+  getAssertedValue('credentialSubject', credentialSubject)
+  if (args.statusPurpose && 'statusPurpose' in credentialSubject) {
+    if (args.statusPurpose !== credentialSubject.statusPurpose) {
+      throw Error(
+        `Status purpose in StatusList credential with id ${id} and value ${credentialSubject.statusPurpose} does not match supplied purpose: ${args.statusPurpose}`,
+      )
+    }
+  } else if (args.id && args.id !== id) {
+    throw Error(`Status list id ${id} did not match required supplied id: ${args.id}`)
+  }
+  if (!type || !(type.includes(requestedType) || type.includes(requestedType + 'Credential'))) {
+    throw Error(`Credential type ${JSON.stringify(type)} does not contain requested type ${requestedType}`)
+  }
+  // @ts-ignore
+  const encodedList = getAssertedValue('encodedList', credentialSubject['encodedList'])
+
+  const statusList = await StatusList.decode({ encodedList })
+  const status = statusList.getStatus(typeof args.statusListIndex === 'number' ? args.statusListIndex : Number.parseInt(args.statusListIndex))
+  return status
 }
 
 export async function createNewStatusList(
   args: CreateNewStatusListFuncArgs,
   context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
 ): Promise<StatusListResult> {
-  const { type } = getAssertedValues(args)
-  const implementation = getStatusListImplementation(type)
-  return implementation.createNewStatusList(args, context)
+  const length = args?.length ?? 250000
+  const proofFormat = args?.proofFormat ?? 'lds'
+  const { issuer, type, id } = getAssertedValues(args)
+  const correlationId = getAssertedValue('correlationId', args.correlationId)
+
+  const list = new StatusList({ length })
+  const encodedList = await list.encode()
+  const statusPurpose = args.statusPurpose ?? 'revocation'
+  const statusListCredential = await statusList2021ToVerifiableCredential(
+    {
+      ...args,
+      type,
+      proofFormat,
+      encodedList,
+    },
+    context,
+  )
+
+  return {
+    encodedList,
+    statusListCredential,
+    length,
+    type,
+    proofFormat,
+    id,
+    correlationId,
+    issuer,
+    statusPurpose,
+    indexingDirection: 'rightToLeft',
+  } as StatusListResult
 }
 
 export async function updateStatusIndexFromStatusListCredential(
-  args: UpdateStatusListIndexArgs,
+  args: UpdateStatusListFromStatusListCredentialArgs,
   context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
-): Promise<StatusListResult> {
-  const credential = getAssertedValue('statusListCredential', args.statusListCredential)
-  const statusListType: StatusListType = determineStatusListType(credential)
-  const implementation = getStatusListImplementation(statusListType)
-  return implementation.updateStatusListIndex(args, context)
+): Promise<StatusListDetails> {
+  return updateStatusListIndexFromEncodedList(
+    {
+      ...(await statusListCredentialToDetails(args)),
+      statusListIndex: args.statusListIndex,
+      value: args.value,
+    },
+    context,
+  )
 }
 
-// Keeping helper function for backward compatibility
 export async function statusListCredentialToDetails(args: {
-  statusListCredential: StatusListCredential
+  statusListCredential: OriginalVerifiableCredential
   correlationId?: string
   driverType?: StatusListDriverType
-}): Promise<StatusListResult> {
+}): Promise<StatusListDetails> {
   const credential = getAssertedValue('statusListCredential', args.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?
+  const uniform = CredentialMapper.toUniformCredential(credential)
+  const { issuer, type, credentialSubject } = uniform
+  if (!type.includes('StatusList2021Credential')) {
+    throw Error('StatusList2021Credential type should be present in the Verifiable Credential')
   }
-  if (!statusListType) {
-    const uniform = CredentialMapper.toUniformCredential(credential)
-    const type = uniform.type.find((t) => t.includes('StatusList2021') || t.includes('OAuth2StatusList'))
-    if (!type) {
-      throw new Error('Invalid status list credential type')
-    }
-    statusListType = type.replace('Credential', '') as StatusListType
+  const id = getAssertedValue('id', uniform.id)
+  // @ts-ignore
+  const { encodedList, statusPurpose } = credentialSubject
+  const proofFormat: ProofFormat = CredentialMapper.detectDocumentType(credential) === DocumentFormat.JWT ? 'jwt' : 'lds'
+  return {
+    id,
+    encodedList,
+    issuer,
+    type: StatusListType.StatusList2021,
+    proofFormat,
+    indexingDirection: 'rightToLeft',
+    length: (await StatusList.decode({ encodedList })).length,
+    statusPurpose,
+    statusListCredential: credential,
+    ...(args.correlationId && { correlationId: args.correlationId }),
+    ...(args.driverType && { driverType: args.driverType }),
   }
-
-  const implementation = getStatusListImplementation(statusListType)
-  return await implementation.toStatusListDetails({
-    statusListPayload: credential,
-    correlationId: args.correlationId,
-    driverType: args.driverType,
-  })
 }
 
 export async function updateStatusListIndexFromEncodedList(
   args: UpdateStatusListFromEncodedListArgs,
   context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
-): Promise<StatusListResult> {
-  const { type } = getAssertedValue('type', args)
-  const implementation = getStatusListImplementation(type!)
-  return implementation.updateStatusListFromEncodedList(args, context)
+): Promise<StatusListDetails> {
+  const { issuer, type, id } = getAssertedValues(args)
+  const proofFormat = args?.proofFormat ?? 'lds'
+  const origEncodedList = getAssertedValue('encodedList', args.encodedList)
+  const index = getAssertedValue('index', typeof args.statusListIndex === 'number' ? args.statusListIndex : Number.parseInt(args.statusListIndex))
+  const value = getAssertedValue('value', args.value)
+  const statusPurpose = getAssertedValue('statusPurpose', args.statusPurpose)
+
+  const statusList = await StatusList.decode({ encodedList: origEncodedList })
+  statusList.setStatus(index, value)
+  const encodedList = await statusList.encode()
+  const statusListCredential = await statusList2021ToVerifiableCredential(
+    {
+      ...args,
+      type,
+      proofFormat,
+      encodedList,
+    },
+    context,
+  )
+  return {
+    encodedList,
+    statusListCredential,
+    length: statusList.length - 1,
+    type,
+    proofFormat,
+    id,
+    issuer,
+    statusPurpose,
+    indexingDirection: 'rightToLeft',
+  }
 }
 
 export async function statusList2021ToVerifiableCredential(
   args: StatusList2021ToVerifiableCredentialArgs,
   context: IAgentContext<ICredentialPlugin & IIdentifierResolution>,
-): Promise<StatusListCredential> {
+): Promise<OriginalVerifiableCredential> {
   const { issuer, id, type } = getAssertedValues(args)
   const identifier = await context.agent.identifierManagedGet({
     identifier: typeof issuer === 'string' ? issuer : issuer.id,
     vmRelationship: 'assertionMethod',
     offlineWhenNoDIDRegistered: true, // FIXME Fix identifier resolution for EBSI
   })
-  const proofFormat: ProofFormat = args?.proofFormat ?? 'lds'
-  assertValidProofType(StatusListType.StatusList2021, proofFormat)
-  const veramoProofFormat: VeramoProofFormat = proofFormat as VeramoProofFormat
-
   const encodedList = getAssertedValue('encodedList', args.encodedList)
   const statusPurpose = getAssertedValue('statusPurpose', args.statusPurpose)
   const credential = {
@@ -252,9 +316,31 @@ export async function statusList2021ToVerifiableCredential(
   const verifiableCredential = await context.agent.createVerifiableCredential({
     credential,
     keyRef: identifier.kmsKeyRef,
-    proofFormat: veramoProofFormat,
+    proofFormat: args.proofFormat ?? 'lds',
     fetchRemoteContexts: true,
   })
 
-  return CredentialMapper.toWrappedVerifiableCredential(verifiableCredential as StatusListCredential).original as StatusListCredential
+  return CredentialMapper.toWrappedVerifiableCredential(verifiableCredential as OriginalVerifiableCredential).original
+}
+
+function getAssertedStatusListType(type?: StatusListType) {
+  const assertedType = type ?? StatusListType.StatusList2021
+  if (assertedType !== StatusListType.StatusList2021) {
+    throw Error(`StatusList type ${assertedType} is not supported (yet)`)
+  }
+  return assertedType
+}
+
+function getAssertedValue<T>(name: string, value: T): NonNullable<T> {
+  if (value === undefined || value === null) {
+    throw Error(`Missing required ${name} value`)
+  }
+  return value
+}
+
+function getAssertedValues(args: { issuer: string | IIssuer; id: string; type?: StatusListType }) {
+  const type = getAssertedStatusListType(args?.type)
+  const id = getAssertedValue('id', args.id)
+  const issuer = getAssertedValue('issuer', args.issuer)
+  return { id, issuer, type }
 }

package/src/types/index.ts

@@ -4,9 +4,8 @@ import {
   ICredentialStatus,
   IIssuer,
   IVerifiableCredential,
+  OriginalVerifiableCredential,
   OrPromise,
-  ProofFormat,
-  StatusListCredential,
   StatusListCredentialIdMode,
   StatusListDriverType,
   StatusListIndexingDirection,
@@ -19,104 +18,58 @@ import {
   ICredentialIssuer,
   ICredentialPlugin,
   ICredentialVerifier,
-  IKeyManager,
   IPluginMethodMap,
+  ProofFormat,
 } from '@veramo/core'
 import { DataSource } from 'typeorm'
-import { BitsPerStatus } from '@sd-jwt/jwt-status-list/dist'
-import { SdJwtVcPayload } from '@sd-jwt/sd-jwt-vc'
-import { StatusListOpts } from '@sphereon/oid4vci-common'
-
-export enum StatusOAuth {
-  Valid = 0,
-  Invalid = 1,
-  Suspended = 2,
-}
-
-export enum Status2021 {
-  Valid = 0,
-  Invalid = 1,
-}
-
-export type StatusList2021Args = {
-  indexingDirection: StatusListIndexingDirection
-  statusPurpose?: StatusPurpose2021
-  // todo: validFrom and validUntil
-}
 
-export type OAuthStatusListArgs = {
-  bitsPerStatus?: BitsPerStatus
-  expiresAt?: Date
-}
-
-export type BaseCreateNewStatusListArgs = {
-  type: StatusListType
-  id: string
-  issuer: string | IIssuer
-  correlationId?: string
+export interface CreateNewStatusListFuncArgs extends Omit<StatusList2021ToVerifiableCredentialArgs, 'encodedList'> {
+  correlationId: string
   length?: number
-  proofFormat?: ProofFormat
-  keyRef?: string
-  statusList2021?: StatusList2021Args
-  oauthStatusList?: OAuthStatusListArgs
 }
 
-export type UpdateStatusList2021Args = {
-  statusPurpose: StatusPurpose2021
+export interface UpdateStatusListFromEncodedListArgs extends StatusList2021ToVerifiableCredentialArgs {
+  statusListIndex: number | string
+  value: boolean
 }
 
-export type UpdateOAuthStatusListArgs = {
-  bitsPerStatus: BitsPerStatus
-  expiresAt?: Date
+export interface UpdateStatusListFromStatusListCredentialArgs {
+  statusListCredential: OriginalVerifiableCredential
+  keyRef?: string
+  statusListIndex: number | string
+  value: boolean
 }
 
-export interface UpdateStatusListFromEncodedListArgs {
+export interface StatusList2021ToVerifiableCredentialArgs {
+  issuer: string | IIssuer
+  id: string
   type?: StatusListType
-  statusListIndex: number | string
-  value: boolean
+  statusPurpose: StatusPurpose2021
+  encodedList: string
   proofFormat?: ProofFormat
   keyRef?: string
-  correlationId?: string
-  encodedList: string
-  issuer: string | IIssuer
-  id: string
-  statusList2021?: UpdateStatusList2021Args
-  oauthStatusList?: UpdateOAuthStatusListArgs
-}
 
-export interface UpdateStatusListFromStatusListCredentialArgs {
-  statusListCredential: StatusListCredential // | CompactJWT
-  keyRef?: string
-  statusListIndex: number | string
-  value: number | Status2021 | StatusOAuth
+  // todo: validFrom and validUntil
 }
 
-export interface StatusListResult {
+export interface StatusListDetails {
   encodedList: string
-  statusListCredential: StatusListCredential
   length: number
   type: StatusListType
   proofFormat: ProofFormat
+  statusPurpose: StatusPurpose2021
   id: string
-  statuslistContentType: string
   issuer: string | IIssuer
-  statusList2021?: StatusList2021Details
-  oauthStatusList?: OAuthStatusDetails
-
+  indexingDirection: StatusListIndexingDirection
+  statusListCredential: OriginalVerifiableCredential
   // These cannot be deduced from the VC, so they are present when callers pass in these values as params
   correlationId?: string
   driverType?: StatusListDriverType
   credentialIdMode?: StatusListCredentialIdMode
 }
 
-interface StatusList2021Details {
-  indexingDirection: StatusListIndexingDirection
-  statusPurpose?: StatusPurpose2021
-}
-
-interface OAuthStatusDetails {
-  bitsPerStatus?: BitsPerStatus
-  expiresAt?: Date
+export interface StatusListResult extends StatusListDetails {
+  statusListCredential: OriginalVerifiableCredential
 }
 
 export interface StatusList2021EntryCredentialStatus extends ICredentialStatus {
@@ -126,54 +79,6 @@ export interface StatusList2021EntryCredentialStatus extends ICredentialStatus {
   statusListCredential: string
 }
 
-export interface StatusListOAuthEntryCredentialStatus extends ICredentialStatus {
-  type: 'OAuthStatusListEntry'
-  bitsPerStatus: number
-  statusListIndex: string
-  statusListCredential: string
-  expiresAt?: Date
-}
-
-export interface StatusList2021ToVerifiableCredentialArgs {
-  issuer: string | IIssuer
-  id: string
-  type?: StatusListType
-  proofFormat?: ProofFormat
-  keyRef?: string
-  encodedList: string
-  statusPurpose: StatusPurpose2021
-}
-
-export interface CreateStatusListArgs {
-  issuer: string | IIssuer
-  id: string
-  proofFormat?: ProofFormat
-  keyRef?: string
-  correlationId?: string
-  length?: number
-  statusList2021?: StatusList2021Args
-  oauthStatusList?: OAuthStatusListArgs
-}
-
-export interface UpdateStatusListIndexArgs {
-  statusListCredential: StatusListCredential // | CompactJWT
-  statusListIndex: number | string
-  value: number | Status2021 | StatusOAuth
-  keyRef?: string
-  expiresAt?: Date
-}
-
-export interface CheckStatusIndexArgs {
-  statusListCredential: StatusListCredential // | CompactJWT
-  statusListIndex: string | number
-}
-
-export interface ToStatusListDetailsArgs {
-  statusListPayload: StatusListCredential
-  correlationId?: string
-  driverType?: StatusListDriverType
-}
-
 /**
  * The interface definition for a plugin that can add statuslist info to a credential
  *
@@ -190,7 +95,7 @@ export interface IStatusListPlugin extends IPluginMethodMap {
    *
    * @returns - The details of the newly created status list
    */
-  slCreateStatusList(args: CreateNewStatusListArgs, context: IRequiredContext): Promise<StatusListResult>
+  slCreateStatusList(args: CreateNewStatusListArgs, context: IRequiredContext): Promise<StatusListDetails>
 
   /**
    * Ensures status list info like index and list id is added to a credential
@@ -204,36 +109,25 @@ export interface IStatusListPlugin extends IPluginMethodMap {
    */
   slAddStatusToCredential(args: IAddStatusToCredentialArgs, context: IRequiredContext): Promise<CredentialWithStatusSupport>
 
-  slAddStatusToSdJwtCredential(args: IAddStatusToSdJwtCredentialArgs, context: IRequiredContext): Promise<SdJwtVcPayload>
-
   /**
    * Get the status list using the configured driver for the SL. Normally a correlationId or id should suffice. Optionally accepts a dbName/datasource
    * @param args
    * @param context
    */
-  slGetStatusList(args: GetStatusListArgs, context: IRequiredContext): Promise<StatusListResult>
-}
-
-export type CreateNewStatusListFuncArgs = BaseCreateNewStatusListArgs
-
-export type CreateNewStatusListArgs = BaseCreateNewStatusListArgs & {
-  dataSource?: OrPromise<DataSource>
-  dbName?: string
-  isDefault?: boolean
+  slGetStatusList(args: GetStatusListArgs, context: IRequiredContext): Promise<StatusListDetails>
 }
 
 export type IAddStatusToCredentialArgs = Omit<IIssueCredentialStatusOpts, 'dataSource'> & {
   credential: CredentialWithStatusSupport
 }
 
-export type IAddStatusToSdJwtCredentialArgs = Omit<IIssueCredentialStatusOpts, 'dataSource'> & {
-  credential: SdJwtVcPayload
-}
-
 export interface IIssueCredentialStatusOpts {
   dataSource?: DataSource
-  statusListOpts?: Array<StatusListOpts>
+
   credentialId?: string // An id to use for the credential. Normally should be set as the crdential.id value
+  statusListId?: string // Explicit status list to use. Determines the id from the credentialStatus object in the VC itself or uses the default otherwise
+  statusListIndex?: number | string
+  statusEntryCorrelationId?: string // An id to use for correlation. Can be the credential id, but also a business identifier. Will only be used for lookups/management
   value?: string
 }
 
@@ -244,12 +138,13 @@ export type GetStatusListArgs = {
   dbName?: string
 }
 
-export type CredentialWithStatusSupport = ICredential | CredentialPayload | IVerifiableCredential
-
-export type SignedStatusListData = {
-  statusListCredential: StatusListCredential
-  encodedList: string
+export type CreateNewStatusListArgs = CreateNewStatusListFuncArgs & {
+  dataSource?: OrPromise<DataSource>
+  dbName?: string
+  isDefault?: boolean
 }
 
+export type CredentialWithStatusSupport = ICredential | CredentialPayload | IVerifiableCredential
+
 export type IRequiredPlugins = ICredentialPlugin & IIdentifierResolution
-export type IRequiredContext = IAgentContext<ICredentialIssuer & ICredentialVerifier & IIdentifierResolution & IKeyManager & ICredentialPlugin>
+export type IRequiredContext = IAgentContext<ICredentialIssuer & ICredentialVerifier & IIdentifierResolution>

package/dist/impl/IStatusList.d.ts

@@ -1,26 +0,0 @@
-import { IAgentContext, ICredentialPlugin } from '@veramo/core';
-import { IIdentifierResolution } from '@sphereon/ssi-sdk-ext.identifier-resolution';
-import { CheckStatusIndexArgs, CreateStatusListArgs, Status2021, StatusListResult, StatusOAuth, ToStatusListDetailsArgs, UpdateStatusListFromEncodedListArgs, UpdateStatusListIndexArgs } from '../types';
-export interface IStatusList {
-    /**
-     * Creates a new status list of the specific type
-     */
-    createNewStatusList(args: CreateStatusListArgs, context: IAgentContext<ICredentialPlugin & IIdentifierResolution>): Promise<StatusListResult>;
-    /**
-     * Updates a status at the given index in the status list
-     */
-    updateStatusListIndex(args: UpdateStatusListIndexArgs, context: IAgentContext<ICredentialPlugin & IIdentifierResolution>): Promise<StatusListResult>;
-    /**
-     * Updates a status list using a base64 encoded list of statuses
-     */
-    updateStatusListFromEncodedList(args: UpdateStatusListFromEncodedListArgs, context: IAgentContext<ICredentialPlugin & IIdentifierResolution>): Promise<StatusListResult>;
-    /**
-     * Checks the status at a given index in the status list
-     */
-    checkStatusIndex(args: CheckStatusIndexArgs): Promise<number | Status2021 | StatusOAuth>;
-    /**
-     * Collects the status list details
-     */
-    toStatusListDetails(args: ToStatusListDetailsArgs): Promise<StatusListResult>;
-}
-//# sourceMappingURL=IStatusList.d.ts.map