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

package/dist/index.js

@@ -15,7 +15,7 @@ var Status2021 = /* @__PURE__ */ function(Status20212) {
 }({});
 
 // src/functions.ts
-import { CredentialMapper as CredentialMapper4, DocumentFormat as DocumentFormat4, StatusListType as StatusListType6 } from "@sphereon/ssi-types";
+import { CredentialMapper as CredentialMapper4, StatusListType as StatusListType6 } from "@sphereon/ssi-types";
 import { checkStatus } from "@sphereon/vc-status-list";
 
 // src/utils.ts
@@ -25,7 +25,8 @@ function getAssertedStatusListType(type) {
   const assertedType = type ?? StatusListType.StatusList2021;
   if (![
     StatusListType.StatusList2021,
-    StatusListType.OAuthStatusList
+    StatusListType.OAuthStatusList,
+    StatusListType.BitstringStatusList
   ].includes(assertedType)) {
     throw Error(`StatusList type ${assertedType} is not supported (yet)`);
   }
@@ -71,6 +72,13 @@ var ValidProofTypeMap = /* @__PURE__ */ new Map([
       "jwt",
       "cbor"
     ]
+  ],
+  [
+    StatusListType.BitstringStatusList,
+    [
+      "lds",
+      "vc+jwt"
+    ]
   ]
 ]);
 function assertValidProofType(type, proofFormat) {
@@ -84,29 +92,50 @@ function determineStatusListType(credential) {
   const proofFormat = determineProofFormat(credential);
   switch (proofFormat) {
     case "jwt":
-      const payload = jwtDecode(credential);
-      const keys = Object.keys(payload);
-      if (keys.includes("status_list")) {
-        return StatusListType.OAuthStatusList;
-      } else if (keys.includes("vc")) {
-        return StatusListType.StatusList2021;
-      }
-      break;
+      return determineJwtStatusListType(credential);
     case "lds":
-      const uniform = CredentialMapper.toUniformCredential(credential);
-      const type = uniform.type.find((t) => {
-        return Object.values(StatusListType).some((statusType) => t.includes(statusType));
-      });
-      if (!type) {
-        throw new Error("Invalid status list credential type");
-      }
-      return type.replace("Credential", "");
+      return determineLdsStatusListType(credential);
     case "cbor":
       return StatusListType.OAuthStatusList;
+    default:
+      throw new Error("Cannot determine status list type from credential payload");
   }
-  throw new Error("Cannot determine status list type from credential payload");
 }
 __name(determineStatusListType, "determineStatusListType");
+function determineJwtStatusListType(credential) {
+  const payload = jwtDecode(credential);
+  if ("status_list" in payload) {
+    return StatusListType.OAuthStatusList;
+  }
+  if ("credentialSubject" in payload) {
+    return getStatusListTypeFromSubject(payload.credentialSubject);
+  }
+  if ("vc" in payload && "credentialSubject" in payload.vc) {
+    return getStatusListTypeFromSubject(payload.vc.credentialSubject);
+  }
+  throw new Error("Invalid status list credential: credentialSubject not found");
+}
+__name(determineJwtStatusListType, "determineJwtStatusListType");
+function determineLdsStatusListType(credential) {
+  const uniform = CredentialMapper.toUniformCredential(credential);
+  const statusListType = uniform.type.find((type) => Object.values(StatusListType).some((statusType) => type.includes(statusType)));
+  if (!statusListType) {
+    throw new Error("Invalid status list credential type");
+  }
+  return statusListType.replace("Credential", "");
+}
+__name(determineLdsStatusListType, "determineLdsStatusListType");
+function getStatusListTypeFromSubject(credentialSubject) {
+  switch (credentialSubject.type) {
+    case "StatusList2021":
+      return StatusListType.StatusList2021;
+    case "BitstringStatusList":
+      return StatusListType.BitstringStatusList;
+    default:
+      throw new Error(`Unknown credential subject type: ${credentialSubject.type}`);
+  }
+}
+__name(getStatusListTypeFromSubject, "getStatusListTypeFromSubject");
 function determineProofFormat(credential) {
   const type = CredentialMapper.detectDocumentType(credential);
   switch (type) {
@@ -121,6 +150,26 @@ function determineProofFormat(credential) {
   }
 }
 __name(determineProofFormat, "determineProofFormat");
+function ensureDate(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "string") {
+    if (value.trim() === "") {
+      return void 0;
+    }
+    const date = new Date(value);
+    if (isNaN(date.getTime())) {
+      return void 0;
+    }
+    return date;
+  }
+  return void 0;
+}
+__name(ensureDate, "ensureDate");
 
 // src/impl/StatusList2021.ts
 import { CredentialMapper as CredentialMapper2, DocumentFormat as DocumentFormat2, StatusListType as StatusListType2 } from "@sphereon/ssi-types";
@@ -184,13 +233,14 @@ var StatusList2021Implementation = class {
       encodedList,
       proofFormat
     }, context);
+    if (!("statusPurpose" in credentialSubject)) {
+      return Promise.reject(Error("statusPurpose is required in credentialSubject for StatusList2021"));
+    }
     return {
       statusListCredential: updatedCredential,
       encodedList,
       statusList2021: {
-        ..."statusPurpose" in credentialSubject ? {
-          statusPurpose: credentialSubject.statusPurpose
-        } : {},
+        statusPurpose: credentialSubject.statusPurpose,
         indexingDirection: "rightToLeft"
       },
       length: statusList.length - 1,
@@ -213,7 +263,7 @@ var StatusList2021Implementation = class {
       encodedList: args.encodedList
     });
     const index = typeof args.statusListIndex === "number" ? args.statusListIndex : parseInt(args.statusListIndex);
-    statusList.setStatus(index, args.value);
+    statusList.setStatus(index, args.value !== 0);
     const newEncodedList = await statusList.encode();
     const credential = await this.createVerifiableCredential({
       id,
@@ -247,36 +297,88 @@ var StatusList2021Implementation = class {
     const status = statusList.getStatus(typeof args.statusListIndex === "number" ? args.statusListIndex : parseInt(args.statusListIndex));
     return status ? Status2021.Invalid : Status2021.Valid;
   }
-  async toStatusListDetails(args) {
-    const { statusListPayload } = args;
-    const uniform = CredentialMapper2.toUniformCredential(statusListPayload);
+  /**
+  * Performs the initial parsing of a StatusListCredential.
+  * This method handles expensive operations like JWT/CWT decoding once.
+  * It extracts all details available from the credential payload itself.
+  */
+  async extractCredentialDetails(credential) {
+    const uniform = CredentialMapper2.toUniformCredential(credential);
     const { issuer, credentialSubject } = uniform;
-    const id = getAssertedValue("id", uniform.id);
-    const encodedList = getAssertedProperty("encodedList", credentialSubject);
-    const proofFormat = CredentialMapper2.detectDocumentType(statusListPayload) === DocumentFormat2.JWT ? "jwt" : "lds";
-    const statusPurpose = getAssertedProperty("statusPurpose", credentialSubject);
-    const list = await StatusList.decode({
-      encodedList
-    });
+    const subject = Array.isArray(credentialSubject) ? credentialSubject[0] : credentialSubject;
     return {
-      id,
-      encodedList,
+      id: getAssertedValue("id", uniform.id),
       issuer,
-      type: StatusListType2.StatusList2021,
-      proofFormat,
-      length: list.length,
-      statusListCredential: statusListPayload,
-      statuslistContentType: this.buildContentType(proofFormat),
-      statusList2021: {
+      encodedList: getAssertedProperty("encodedList", subject)
+    };
+  }
+  async toStatusListDetails(args) {
+    if ("statusListCredential" in args) {
+      const { statusListCredential, correlationId, driverType } = args;
+      const uniform = CredentialMapper2.toUniformCredential(statusListCredential);
+      const { issuer, credentialSubject } = uniform;
+      const subject = Array.isArray(credentialSubject) ? credentialSubject[0] : credentialSubject;
+      const id = getAssertedValue("id", uniform.id);
+      const encodedList = getAssertedProperty("encodedList", subject);
+      const statusPurpose = getAssertedProperty("statusPurpose", subject);
+      const proofFormat = CredentialMapper2.detectDocumentType(statusListCredential) === DocumentFormat2.JWT ? "jwt" : "lds";
+      const list = await StatusList.decode({
+        encodedList
+      });
+      return {
+        id,
+        encodedList,
+        issuer,
+        type: StatusListType2.StatusList2021,
+        proofFormat,
+        length: list.length,
+        statusListCredential,
+        statuslistContentType: this.buildContentType(proofFormat),
+        correlationId,
+        driverType,
         indexingDirection: "rightToLeft",
-        statusPurpose
-      },
-      ...args.correlationId && {
-        correlationId: args.correlationId
-      },
-      ...args.driverType && {
-        driverType: args.driverType
-      }
+        statusPurpose,
+        statusList2021: {
+          indexingDirection: "rightToLeft",
+          statusPurpose
+        }
+      };
+    } else {
+      const { extractedDetails, statusListEntity } = args;
+      const statusList2021Entity = statusListEntity;
+      const proofFormat = CredentialMapper2.detectDocumentType(statusListEntity.statusListCredential) === DocumentFormat2.JWT ? "jwt" : "lds";
+      const list = await StatusList.decode({
+        encodedList: extractedDetails.encodedList
+      });
+      return {
+        id: extractedDetails.id,
+        encodedList: extractedDetails.encodedList,
+        issuer: extractedDetails.issuer,
+        type: StatusListType2.StatusList2021,
+        proofFormat,
+        length: list.length,
+        statusListCredential: statusListEntity.statusListCredential,
+        statuslistContentType: this.buildContentType(proofFormat),
+        correlationId: statusListEntity.correlationId,
+        driverType: statusListEntity.driverType,
+        indexingDirection: statusList2021Entity.indexingDirection,
+        statusPurpose: statusList2021Entity.statusPurpose,
+        statusList2021: {
+          indexingDirection: statusList2021Entity.indexingDirection,
+          statusPurpose: statusList2021Entity.statusPurpose
+        }
+      };
+    }
+  }
+  async createCredentialStatus(args) {
+    const { statusList, statusListIndex } = args;
+    const statusList2021 = statusList;
+    return {
+      id: `${statusList.id}#${statusListIndex}`,
+      type: "StatusList2021Entry",
+      statusPurpose: statusList2021.statusPurpose ?? "revocation",
+      statusListIndex: "" + statusListIndex,
+      statusListCredential: statusList.id
     };
   }
   async createVerifiableCredential(args, context) {
@@ -571,7 +673,8 @@ var OAuthStatusListImplementation = class {
     }
     const proofFormat = args?.proofFormat ?? DEFAULT_PROOF_FORMAT2;
     const { issuer, id, oauthStatusList, keyRef } = args;
-    const { bitsPerStatus, expiresAt } = oauthStatusList;
+    const { bitsPerStatus } = oauthStatusList;
+    const expiresAt = ensureDate(oauthStatusList.expiresAt);
     const length = args.length ?? DEFAULT_LIST_LENGTH2;
     const issuerString = typeof issuer === "string" ? issuer : issuer.id;
     const correlationId = getAssertedValue("correlationId", args.correlationId);
@@ -594,7 +697,8 @@ var OAuthStatusListImplementation = class {
     };
   }
   async updateStatusListIndex(args, context) {
-    const { statusListCredential, value, expiresAt, keyRef } = args;
+    const { statusListCredential, value, keyRef } = args;
+    const expiresAt = ensureDate(args.expiresAt);
     if (typeof statusListCredential !== "string") {
       return Promise.reject("statusListCredential in neither JWT nor CWT");
     }
@@ -630,12 +734,13 @@ var OAuthStatusListImplementation = class {
       throw new Error("OAuthStatusList options are required for type OAuthStatusList");
     }
     const { proofFormat, oauthStatusList, keyRef } = args;
-    const { bitsPerStatus, expiresAt } = oauthStatusList;
+    const { bitsPerStatus } = oauthStatusList;
+    const expiresAt = ensureDate(oauthStatusList.expiresAt);
     const { issuer, id } = getAssertedValues(args);
     const issuerString = typeof issuer === "string" ? issuer : issuer.id;
     const listToUpdate = StatusList4.decompressStatusList(args.encodedList, bitsPerStatus ?? DEFAULT_BITS_PER_STATUS);
     const index = typeof args.statusListIndex === "number" ? args.statusListIndex : parseInt(args.statusListIndex);
-    listToUpdate.setStatus(index, args.value ? 1 : 0);
+    listToUpdate.setStatus(index, args.value);
     const { statusListCredential, encodedList } = await this.createSignedStatusList(proofFormat ?? DEFAULT_PROOF_FORMAT2, context, listToUpdate, issuerString, id, expiresAt, keyRef);
     return {
       encodedList,
@@ -652,9 +757,6 @@ var OAuthStatusListImplementation = class {
       statuslistContentType: this.buildContentType(proofFormat)
     };
   }
-  buildContentType(proofFormat) {
-    return `application/statuslist+${proofFormat === "cbor" ? "cwt" : "jwt"}`;
-  }
   async checkStatusIndex(args) {
     const { statusListCredential, statusListIndex } = args;
     if (typeof statusListCredential !== "string") {
@@ -668,34 +770,101 @@ var OAuthStatusListImplementation = class {
     }
     return statusList.getStatus(index);
   }
-  async toStatusListDetails(args) {
-    const { statusListPayload } = args;
-    const proofFormat = determineProofFormat(statusListPayload);
-    const decoded = proofFormat === "jwt" ? decodeStatusListJWT(statusListPayload) : decodeStatusListCWT(statusListPayload);
-    const { statusList, issuer, id, exp } = decoded;
+  /**
+  * Performs the initial parsing of a StatusListCredential.
+  * This method handles expensive operations like JWT/CWT decoding once.
+  * It extracts all details available from the credential payload itself.
+  */
+  async extractCredentialDetails(credential) {
+    if (typeof credential !== "string") {
+      return Promise.reject("statusListCredential must be a JWT or CWT string");
+    }
+    const proofFormat = determineProofFormat(credential);
+    const decoded = proofFormat === "jwt" ? decodeStatusListJWT(credential) : decodeStatusListCWT(credential);
     return {
-      id,
-      encodedList: statusList.compressStatusList(),
-      issuer,
-      type: StatusListType3.OAuthStatusList,
-      proofFormat,
-      length: statusList.statusList.length,
-      statusListCredential: statusListPayload,
-      statuslistContentType: this.buildContentType(proofFormat),
-      oauthStatusList: {
-        bitsPerStatus: statusList.getBitsPerStatus(),
-        ...exp && {
-          expiresAt: new Date(exp * 1e3)
-        }
-      },
-      ...args.correlationId && {
-        correlationId: args.correlationId
-      },
-      ...args.driverType && {
-        driverType: args.driverType
+      id: decoded.id,
+      issuer: decoded.issuer,
+      encodedList: decoded.statusList.compressStatusList(),
+      decodedPayload: decoded
+    };
+  }
+  async toStatusListDetails(args) {
+    if ("statusListCredential" in args) {
+      const { statusListCredential, bitsPerStatus, correlationId, driverType } = args;
+      if (!bitsPerStatus || bitsPerStatus < 1) {
+        return Promise.reject(Error("bitsPerStatus must be set for OAuth status lists and must be 1 or higher"));
       }
+      const proofFormat = determineProofFormat(statusListCredential);
+      const decoded = proofFormat === "jwt" ? decodeStatusListJWT(statusListCredential) : decodeStatusListCWT(statusListCredential);
+      const { statusList, issuer, id, exp } = decoded;
+      const expiresAt = exp ? new Date(exp * 1e3) : void 0;
+      return {
+        id,
+        encodedList: statusList.compressStatusList(),
+        issuer,
+        type: StatusListType3.OAuthStatusList,
+        proofFormat,
+        length: statusList.statusList.length,
+        statusListCredential,
+        statuslistContentType: this.buildContentType(proofFormat),
+        correlationId,
+        driverType,
+        bitsPerStatus,
+        ...expiresAt && {
+          expiresAt
+        },
+        oauthStatusList: {
+          bitsPerStatus,
+          ...expiresAt && {
+            expiresAt
+          }
+        }
+      };
+    } else {
+      const { extractedDetails, statusListEntity } = args;
+      const oauthEntity = statusListEntity;
+      const decoded = extractedDetails.decodedPayload;
+      const proofFormat = determineProofFormat(statusListEntity.statusListCredential);
+      const expiresAt = decoded.exp ? new Date(decoded.exp * 1e3) : void 0;
+      return {
+        id: extractedDetails.id,
+        encodedList: extractedDetails.encodedList,
+        issuer: extractedDetails.issuer,
+        type: StatusListType3.OAuthStatusList,
+        proofFormat,
+        length: decoded.statusList.statusList.length,
+        statusListCredential: statusListEntity.statusListCredential,
+        statuslistContentType: this.buildContentType(proofFormat),
+        correlationId: statusListEntity.correlationId,
+        driverType: statusListEntity.driverType,
+        bitsPerStatus: oauthEntity.bitsPerStatus,
+        ...expiresAt && {
+          expiresAt
+        },
+        oauthStatusList: {
+          bitsPerStatus: oauthEntity.bitsPerStatus,
+          ...expiresAt && {
+            expiresAt
+          }
+        }
+      };
+    }
+  }
+  async createCredentialStatus(args) {
+    const { statusList, statusListIndex } = args;
+    const oauthStatusList = statusList;
+    return {
+      id: `${statusList.id}#${statusListIndex}`,
+      type: "OAuthStatusListEntry",
+      bitsPerStatus: oauthStatusList.bitsPerStatus,
+      statusListIndex: "" + statusListIndex,
+      statusListCredential: statusList.id,
+      expiresAt: oauthStatusList.expiresAt
     };
   }
+  buildContentType(proofFormat) {
+    return `application/statuslist+${proofFormat === "cbor" ? "cwt" : "jwt"}`;
+  }
   async createSignedStatusList(proofFormat, context, statusList, issuerString, id, expiresAt, keyRef) {
     switch (proofFormat) {
       case "jwt": {
@@ -715,15 +884,21 @@ import { StatusListType as StatusListType5 } from "@sphereon/ssi-types";
 
 // src/impl/BitstringStatusListImplementation.ts
 import { CredentialMapper as CredentialMapper3, DocumentFormat as DocumentFormat3, StatusListType as StatusListType4 } from "@sphereon/ssi-types";
-import { createList, decodeList } from "@digitalbazaar/vc-bitstring-status-list";
+import { BitstreamStatusList, createStatusListCredential } from "@4sure-tech/vc-bitstring-status-lists";
 var DEFAULT_LIST_LENGTH3 = 131072;
-var DEFAULT_PROOF_FORMAT3 = "lds";
-var DEFAULT_STATUS_SIZE = 1;
+var DEFAULT_PROOF_FORMAT3 = "vc+jwt";
 var DEFAULT_STATUS_PURPOSE = "revocation";
 var BitstringStatusListImplementation = class {
   static {
     __name(this, "BitstringStatusListImplementation");
   }
+  /**
+  * 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, context) {
     if (!args.bitstringStatusList) {
       throw new Error("BitstringStatusList options are required for type BitstringStatusList");
@@ -731,29 +906,37 @@ var BitstringStatusListImplementation = class {
     const length = args?.length ?? DEFAULT_LIST_LENGTH3;
     const proofFormat = args?.proofFormat ?? DEFAULT_PROOF_FORMAT3;
     assertValidProofType(StatusListType4.BitstringStatusList, proofFormat);
-    const veramoProofFormat = proofFormat;
     const { issuer, id } = args;
     const correlationId = getAssertedValue("correlationId", args.correlationId);
-    const { statusPurpose, statusSize, statusMessage, ttl } = args.bitstringStatusList;
-    const list = await createList({
-      length
-    });
-    const encodedList = await list.encode();
-    const statusListCredential = await this.createVerifiableCredential({
-      ...args,
-      encodedList,
-      proofFormat: veramoProofFormat,
+    const { statusPurpose, bitsPerStatus, validFrom, validUntil, ttl } = args.bitstringStatusList;
+    const unsignedCredential = await createStatusListCredential({
+      id,
+      issuer,
       statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
-      statusSize: statusSize ?? DEFAULT_STATUS_SIZE,
-      statusMessage,
+      validFrom: ensureDate(validFrom),
+      validUntil: ensureDate(validUntil),
       ttl
+    });
+    const statusListCredential = await this.createVerifiableCredential({
+      unsignedCredential,
+      id,
+      issuer,
+      proofFormat,
+      keyRef: args.keyRef
     }, context);
     return {
-      encodedList,
+      encodedList: unsignedCredential.credentialSubject.encodedList,
       statusListCredential,
       bitstringStatusList: {
         statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
-        ttl
+        ...unsignedCredential.validFrom && {
+          validFrom: new Date(unsignedCredential.validFrom)
+        },
+        ...unsignedCredential.validUntil && {
+          validUntil: new Date(unsignedCredential.validUntil)
+        },
+        ttl,
+        bitsPerStatus
       },
       length,
       type: StatusListType4.BitstringStatusList,
@@ -764,45 +947,66 @@ var BitstringStatusListImplementation = class {
       statuslistContentType: this.buildContentType(proofFormat)
     };
   }
+  /**
+  * 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, context) {
+    if (!args.bitsPerStatus || args.bitsPerStatus < 1) {
+      return Promise.reject(Error("bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (updateStatusListIndex)"));
+    }
     const credential = args.statusListCredential;
     const uniform = CredentialMapper3.toUniformCredential(credential);
     const { issuer, credentialSubject } = uniform;
     const id = getAssertedValue("id", uniform.id);
     const origEncodedList = getAssertedProperty("encodedList", credentialSubject);
     const index = typeof args.statusListIndex === "number" ? args.statusListIndex : parseInt(args.statusListIndex);
-    const statusList = await decodeList({
-      encodedList: origEncodedList
+    const statusList = await BitstreamStatusList.decode({
+      encodedList: origEncodedList,
+      statusSize: args.bitsPerStatus
     });
-    statusList.setStatus(index, args.value != 0);
-    const encodedList = await statusList.encode();
-    const proofFormat = CredentialMapper3.detectDocumentType(credential) === DocumentFormat3.JWT ? "jwt" : "lds";
+    const bitstringStatusId = args.value;
+    statusList.setStatus(index, bitstringStatusId);
+    const proofFormat = CredentialMapper3.detectDocumentType(credential) === DocumentFormat3.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) : void 0;
     const validUntil = uniform.validUntil ? new Date(uniform.validUntil) : void 0;
     const ttl = credSubject.ttl;
+    const unsignedCredential = 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,
-      encodedList,
       proofFormat,
-      statusPurpose,
-      ttl,
-      validFrom,
-      validUntil
+      keyRef: args.keyRef
     }, context);
     return {
       statusListCredential: updatedCredential,
-      encodedList,
+      encodedList: unsignedCredential.credentialSubject.encodedList,
       bitstringStatusList: {
         statusPurpose,
-        validFrom,
-        validUntil,
+        ...unsignedCredential.validFrom && {
+          validFrom: new Date(unsignedCredential.validFrom)
+        },
+        ...unsignedCredential.validUntil && {
+          validUntil: new Date(unsignedCredential.validUntil)
+        },
+        bitsPerStatus: args.bitsPerStatus,
         ttl
       },
-      length: statusList.length - 1,
+      length: statusList.getLength(),
       type: StatusListType4.BitstringStatusList,
       proofFormat,
       id,
@@ -810,166 +1014,262 @@ var BitstringStatusListImplementation = class {
       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, context) {
     if (!args.bitstringStatusList) {
       throw new Error("bitstringStatusList options required for type BitstringStatusList");
     }
+    if (args.bitstringStatusList.bitsPerStatus < 1) {
+      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 = args?.proofFormat ?? DEFAULT_PROOF_FORMAT3;
     assertValidProofType(StatusListType4.BitstringStatusList, proofFormat);
-    const veramoProofFormat = proofFormat;
     const { issuer, id } = getAssertedValues(args);
-    const statusList = await decodeList({
-      encodedList: args.encodedList
+    const statusList = 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 newEncodedList = await statusList.encode();
-    const { statusPurpose, statusSize, statusMessage, ttl, validFrom, validUntil } = args.bitstringStatusList;
-    const credential = await this.createVerifiableCredential({
+    const unsignedCredential = await createStatusListCredential({
       id,
       issuer,
-      encodedList: newEncodedList,
-      proofFormat: veramoProofFormat,
-      keyRef: args.keyRef,
-      statusPurpose,
-      statusSize,
-      statusMessage,
-      validFrom,
-      validUntil,
+      statusList,
+      statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
+      validFrom: ensureDate(validFrom),
+      validUntil: ensureDate(validUntil),
       ttl
+    });
+    const credential = await this.createVerifiableCredential({
+      unsignedCredential,
+      id,
+      issuer,
+      proofFormat,
+      keyRef: args.keyRef
     }, context);
     return {
       type: StatusListType4.BitstringStatusList,
       statusListCredential: credential,
-      encodedList: newEncodedList,
+      encodedList: unsignedCredential.credentialSubject.encodedList,
       bitstringStatusList: {
         statusPurpose,
-        validFrom,
-        validUntil,
+        bitsPerStatus,
+        ...unsignedCredential.validFrom && {
+          validFrom: new Date(unsignedCredential.validFrom)
+        },
+        ...unsignedCredential.validUntil && {
+          validUntil: new Date(unsignedCredential.validUntil)
+        },
         ttl
       },
-      length: statusList.length,
+      length: statusList.getLength(),
       proofFormat: args.proofFormat ?? "lds",
       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) {
+    if (!args.bitsPerStatus || args.bitsPerStatus < 1) {
+      return Promise.reject(Error("bitsPerStatus must be set for bitstring status lists and must be 1 or higher. (checkStatusIndex)"));
+    }
     const uniform = CredentialMapper3.toUniformCredential(args.statusListCredential);
     const { credentialSubject } = uniform;
     const encodedList = getAssertedProperty("encodedList", credentialSubject);
-    const subject = Array.isArray(credentialSubject) ? credentialSubject[0] : credentialSubject;
-    const messageList = subject.statusMessage;
-    const numIndex = typeof args.statusListIndex === "number" ? args.statusListIndex : parseInt(args.statusListIndex);
-    const hexIndex = `0x${numIndex.toString(16)}`;
-    const statusMessage = messageList.find((statMsg) => statMsg.status === hexIndex);
-    const statusList = await decodeList({
-      encodedList
+    const statusList = await BitstreamStatusList.decode({
+      encodedList,
+      statusSize: args.bitsPerStatus
     });
-    if (statusList.length <= numIndex) {
-      throw new Error(`Status list index out of bounds, has ${messageList.length} messages, requested ${numIndex}`);
+    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}`);
     }
-    const value = statusList.getStatus(numIndex);
-    return {
-      index: numIndex,
-      status: hexIndex,
-      message: statusMessage?.message,
-      set: value
-    };
+    return statusList.getStatus(numIndex);
   }
-  async toStatusListDetails(args) {
-    const { statusListPayload } = args;
-    const uniform = CredentialMapper3.toUniformCredential(statusListPayload);
+  /**
+  * Performs the initial parsing of a StatusListCredential.
+  * This method handles expensive operations like JWT/CWT decoding once.
+  * It extracts all details available from the credential payload itself.
+  */
+  async extractCredentialDetails(credential) {
+    const uniform = CredentialMapper3.toUniformCredential(credential);
     const { issuer, credentialSubject } = uniform;
-    const id = getAssertedValue("id", uniform.id);
-    const encodedList = getAssertedProperty("encodedList", credentialSubject);
-    const proofFormat = CredentialMapper3.detectDocumentType(statusListPayload) === DocumentFormat3.JWT ? "jwt" : "lds";
-    const credSubject = Array.isArray(credentialSubject) ? credentialSubject[0] : credentialSubject;
-    const statusPurpose = getAssertedProperty("statusPurpose", credSubject);
-    const validFrom = uniform.validFrom ? new Date(uniform.validFrom) : void 0;
-    const validUntil = uniform.validUntil ? new Date(uniform.validUntil) : void 0;
-    const ttl = credSubject.ttl;
-    const list = await decodeList({
-      encodedList
-    });
+    const subject = Array.isArray(credentialSubject) ? credentialSubject[0] : credentialSubject;
     return {
-      id,
-      encodedList,
+      id: getAssertedValue("id", uniform.id),
       issuer,
-      type: StatusListType4.BitstringStatusList,
-      proofFormat,
-      length: list.length,
-      statusListCredential: statusListPayload,
-      statuslistContentType: this.buildContentType(proofFormat),
-      bitstringStatusList: {
+      encodedList: getAssertedProperty("encodedList", subject)
+    };
+  }
+  async toStatusListDetails(args) {
+    if ("statusListCredential" in args) {
+      const { statusListCredential, bitsPerStatus, correlationId, driverType } = args;
+      if (!bitsPerStatus || bitsPerStatus < 1) {
+        return Promise.reject(Error("bitsPerStatus must be set for bitstring status lists and must be 1 or higher"));
+      }
+      const uniform = CredentialMapper3.toUniformCredential(statusListCredential);
+      const { issuer, credentialSubject } = uniform;
+      const subject = Array.isArray(credentialSubject) ? credentialSubject[0] : credentialSubject;
+      const id = getAssertedValue("id", uniform.id);
+      const encodedList = getAssertedProperty("encodedList", subject);
+      const statusPurpose = getAssertedProperty("statusPurpose", subject);
+      const validFrom = uniform.validFrom ? new Date(uniform.validFrom) : void 0;
+      const validUntil = uniform.validUntil ? new Date(uniform.validUntil) : void 0;
+      const ttl = subject.ttl;
+      const proofFormat = CredentialMapper3.detectDocumentType(statusListCredential) === DocumentFormat3.JWT ? "vc+jwt" : "lds";
+      const statuslistLength = BitstreamStatusList.getStatusListLength(encodedList, bitsPerStatus);
+      return {
+        id,
+        encodedList,
+        issuer,
+        type: StatusListType4.BitstringStatusList,
+        proofFormat,
+        length: statuslistLength,
+        statusListCredential,
+        statuslistContentType: this.buildContentType(proofFormat),
+        correlationId,
+        driverType,
         statusPurpose,
-        validFrom,
-        validUntil,
-        ttl
-      },
-      ...args.correlationId && {
-        correlationId: args.correlationId
-      },
-      ...args.driverType && {
-        driverType: args.driverType
+        bitsPerStatus,
+        ...validFrom && {
+          validFrom
+        },
+        ...validUntil && {
+          validUntil
+        },
+        ...ttl && {
+          ttl
+        },
+        bitstringStatusList: {
+          statusPurpose,
+          bitsPerStatus,
+          ...validFrom && {
+            validFrom
+          },
+          ...validUntil && {
+            validUntil
+          },
+          ...ttl && {
+            ttl
+          }
+        }
+      };
+    } else {
+      const { extractedDetails, statusListEntity } = args;
+      const bitstringEntity = statusListEntity;
+      if (!bitstringEntity.bitsPerStatus) {
+        return Promise.reject(Error("bitsPerStatus must be present for a bitstring status list"));
       }
+      const proofFormat = CredentialMapper3.detectDocumentType(statusListEntity.statusListCredential) === DocumentFormat3.JWT ? "vc+jwt" : "lds";
+      const statuslistLength = BitstreamStatusList.getStatusListLength(extractedDetails.encodedList, bitstringEntity.bitsPerStatus);
+      return {
+        id: extractedDetails.id,
+        encodedList: extractedDetails.encodedList,
+        issuer: extractedDetails.issuer,
+        type: StatusListType4.BitstringStatusList,
+        proofFormat,
+        length: statuslistLength,
+        statusListCredential: statusListEntity.statusListCredential,
+        statuslistContentType: this.buildContentType(proofFormat),
+        correlationId: statusListEntity.correlationId,
+        driverType: statusListEntity.driverType,
+        statusPurpose: bitstringEntity.statusPurpose,
+        bitsPerStatus: bitstringEntity.bitsPerStatus,
+        ...bitstringEntity.validFrom && {
+          validFrom: bitstringEntity.validFrom
+        },
+        ...bitstringEntity.validUntil && {
+          validUntil: bitstringEntity.validUntil
+        },
+        ...bitstringEntity.ttl && {
+          ttl: bitstringEntity.ttl
+        },
+        bitstringStatusList: {
+          statusPurpose: bitstringEntity.statusPurpose,
+          bitsPerStatus: bitstringEntity.bitsPerStatus,
+          ...bitstringEntity.validFrom && {
+            validFrom: bitstringEntity.validFrom
+          },
+          ...bitstringEntity.validUntil && {
+            validUntil: bitstringEntity.validUntil
+          },
+          ...bitstringEntity.ttl && {
+            ttl: bitstringEntity.ttl
+          }
+        }
+      };
+    }
+  }
+  /**
+  * 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) {
+    const { statusList, statusListEntry, statusListIndex } = args;
+    const bitstringStatusList = statusList;
+    const bitstringStatusListEntry = statusListEntry;
+    return {
+      id: `${statusList.id}#${statusListIndex}`,
+      type: "BitstringStatusListEntry",
+      statusPurpose: bitstringStatusListEntry.statusPurpose,
+      statusListIndex: "" + statusListIndex,
+      statusListCredential: statusList.id,
+      bitsPerStatus: bitstringStatusList.bitsPerStatus,
+      statusMessage: bitstringStatusListEntry.statusMessage,
+      statusReference: bitstringStatusListEntry.statusReference
     };
   }
+  /**
+  * 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
+  */
   async createVerifiableCredential(args, context) {
+    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 credentialSubject = {
-      id: args.id,
-      type: "BitstringStatusList",
-      statusPurpose: args.statusPurpose,
-      encodedList: args.encodedList
-    };
-    if (args.statusSize && args.statusSize > 1) {
-      credentialSubject.statusSize = args.statusSize;
-    }
-    if (args.statusMessage) {
-      credentialSubject.statusMessage = args.statusMessage;
-    }
-    if (args.validFrom) {
-      credentialSubject.validFrom = args.validFrom;
-    }
-    if (args.validUntil) {
-      credentialSubject.validUntil = args.validUntil;
-    }
-    if (args.ttl) {
-      credentialSubject.ttl = args.ttl;
-    }
-    const credential = {
-      "@context": [
-        "https://www.w3.org/2018/credentials/v1",
-        "https://www.w3.org/ns/credentials/status/v1"
-      ],
-      id: args.id,
-      issuer: args.issuer,
-      type: [
-        "VerifiableCredential",
-        "BitstringStatusListCredential"
-      ],
-      credentialSubject
-    };
     const verifiableCredential = await context.agent.createVerifiableCredential({
-      credential,
-      keyRef: args.keyRef ?? identifier.kmsKeyRef,
-      proofFormat: args.proofFormat,
+      credential: unsignedCredential,
+      keyRef: keyRef ?? identifier.kmsKeyRef,
+      proofFormat,
       fetchRemoteContexts: true
     });
     return CredentialMapper3.toWrappedVerifiableCredential(verifiableCredential).original;
   }
+  /**
+  * 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
+  */
   buildContentType(proofFormat) {
     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:
@@ -1125,35 +1425,35 @@ async function updateStatusIndexFromStatusListCredential(args, context) {
   return implementation.updateStatusListIndex(args, context);
 }
 __name(updateStatusIndexFromStatusListCredential, "updateStatusIndexFromStatusListCredential");
-async function statusListCredentialToDetails(args) {
-  const credential = getAssertedValue("statusListCredential", args.statusListCredential);
-  let statusListType;
-  const documentFormat = CredentialMapper4.detectDocumentType(credential);
-  if (documentFormat === DocumentFormat4.JWT) {
-    const [header] = credential.split(".");
-    const decodedHeader = JSON.parse(Buffer.from(header, "base64").toString());
-    if (decodedHeader.typ === "statuslist+jwt") {
-      statusListType = StatusListType6.OAuthStatusList;
-    }
-  } else if (documentFormat === DocumentFormat4.MSO_MDOC) {
-    statusListType = StatusListType6.OAuthStatusList;
-  }
-  if (!statusListType) {
-    const uniform = CredentialMapper4.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", "");
+async function extractCredentialDetails(statusListCredential) {
+  const statusListType = determineStatusListType(statusListCredential);
+  const implementation = getStatusListImplementation(statusListType);
+  return implementation.extractCredentialDetails(statusListCredential);
+}
+__name(extractCredentialDetails, "extractCredentialDetails");
+async function toStatusListDetails(args) {
+  if ("statusListCredential" in args) {
+    const statusListType = args.statusListType;
+    const implementation = getStatusListImplementation(statusListType);
+    return implementation.toStatusListDetails(args);
+  } else {
+    const statusListType = args.statusListEntity.type;
+    const implementation = getStatusListImplementation(statusListType);
+    return implementation.toStatusListDetails(args);
   }
+}
+__name(toStatusListDetails, "toStatusListDetails");
+async function createCredentialStatusFromStatusList(args) {
+  const { statusList, statusListEntry, statusListIndex } = args;
+  const statusListType = determineStatusListType(statusList.statusListCredential);
   const implementation = getStatusListImplementation(statusListType);
-  return await implementation.toStatusListDetails({
-    statusListPayload: credential,
-    correlationId: args.correlationId,
-    driverType: args.driverType
+  return implementation.createCredentialStatus({
+    statusList,
+    statusListEntry,
+    statusListIndex
   });
 }
-__name(statusListCredentialToDetails, "statusListCredentialToDetails");
+__name(createCredentialStatusFromStatusList, "createCredentialStatusFromStatusList");
 async function updateStatusListIndexFromEncodedList(args, context) {
   const { type } = getAssertedValue("type", args);
   const implementation = getStatusListImplementation(type);
@@ -1205,12 +1505,15 @@ export {
   StatusOAuth,
   checkStatusForCredential,
   checkStatusIndexFromStatusListCredential,
+  createCredentialStatusFromStatusList,
   createNewStatusList,
+  determineStatusListType,
+  extractCredentialDetails,
   fetchStatusListCredential,
   simpleCheckStatusFromStatusListUrl,
   statusList2021ToVerifiableCredential,
-  statusListCredentialToDetails,
   statusPluginStatusFunction,
+  toStatusListDetails,
   updateStatusIndexFromStatusListCredential,
   updateStatusListIndexFromEncodedList,
   vcLibCheckStatusFunction