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

package/dist/index.cjs

@@ -61,7 +61,7 @@ var Status2021 = /* @__PURE__ */ function(Status20212) {
 }({});
 
 // src/functions.ts
-var import_ssi_types6 = require("@sphereon/ssi-types");
+var import_ssi_types7 = require("@sphereon/ssi-types");
 var import_vc_status_list2 = require("@sphereon/vc-status-list");
 
 // src/utils.ts
@@ -108,8 +108,7 @@ var ValidProofTypeMap = /* @__PURE__ */ new Map([
     import_ssi_types.StatusListType.StatusList2021,
     [
       "jwt",
-      "lds",
-      "EthereumEip712Signature2021"
+      "lds"
     ]
   ],
   [
@@ -652,6 +651,9 @@ var OAuthStatusListImplementation = class {
     if (index < 0 || index >= statusList.statusList.length) {
       throw new Error("Status list index out of bounds");
     }
+    if (typeof value !== "number") {
+      throw new Error("Status list values should be of type number");
+    }
     statusList.setStatus(index, value);
     const { statusListCredential: signedCredential, encodedList } = await this.createSignedStatusList(proofFormat, context, statusList, issuer, id, expiresAt, keyRef);
     return {
@@ -708,7 +710,7 @@ var OAuthStatusListImplementation = class {
     const { statusList } = proofFormat === "jwt" ? decodeStatusListJWT(statusListCredential) : decodeStatusListCWT(statusListCredential);
     const index = typeof statusListIndex === "number" ? statusListIndex : parseInt(statusListIndex);
     if (index < 0 || index >= statusList.statusList.length) {
-      throw new Error("Status list index out of bounds");
+      throw new Error(`Status list index out of bounds, has ${statusList.statusList.length} items, requested ${index}`);
     }
     return statusList.getStatus(index);
   }
@@ -755,7 +757,274 @@ var OAuthStatusListImplementation = class {
 };
 
 // src/impl/StatusListFactory.ts
+var import_ssi_types6 = require("@sphereon/ssi-types");
+
+// src/impl/BitstringStatusListImplementation.ts
 var import_ssi_types5 = require("@sphereon/ssi-types");
+var import_vc_bitstring_status_list = require("@digitalbazaar/vc-bitstring-status-list");
+var DEFAULT_LIST_LENGTH3 = 131072;
+var DEFAULT_PROOF_FORMAT3 = "lds";
+var DEFAULT_STATUS_SIZE = 1;
+var DEFAULT_STATUS_PURPOSE = "revocation";
+var BitstringStatusListImplementation = class {
+  static {
+    __name(this, "BitstringStatusListImplementation");
+  }
+  async createNewStatusList(args, context) {
+    if (!args.bitstringStatusList) {
+      throw new Error("BitstringStatusList options are required for type BitstringStatusList");
+    }
+    const length = args?.length ?? DEFAULT_LIST_LENGTH3;
+    const proofFormat = args?.proofFormat ?? DEFAULT_PROOF_FORMAT3;
+    assertValidProofType(import_ssi_types5.StatusListType.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 (0, import_vc_bitstring_status_list.createList)({
+      length
+    });
+    const encodedList = await list.encode();
+    const statusListCredential = await this.createVerifiableCredential({
+      ...args,
+      encodedList,
+      proofFormat: veramoProofFormat,
+      statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
+      statusSize: statusSize ?? DEFAULT_STATUS_SIZE,
+      statusMessage,
+      ttl
+    }, context);
+    return {
+      encodedList,
+      statusListCredential,
+      bitstringStatusList: {
+        statusPurpose: statusPurpose ?? DEFAULT_STATUS_PURPOSE,
+        ttl
+      },
+      length,
+      type: import_ssi_types5.StatusListType.BitstringStatusList,
+      proofFormat,
+      id,
+      correlationId,
+      issuer,
+      statuslistContentType: this.buildContentType(proofFormat)
+    };
+  }
+  async updateStatusListIndex(args, context) {
+    const credential = args.statusListCredential;
+    const uniform = import_ssi_types5.CredentialMapper.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 (0, import_vc_bitstring_status_list.decodeList)({
+      encodedList: origEncodedList
+    });
+    statusList.setStatus(index, args.value != 0);
+    const encodedList = await statusList.encode();
+    const proofFormat = import_ssi_types5.CredentialMapper.detectDocumentType(credential) === import_ssi_types5.DocumentFormat.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 updatedCredential = await this.createVerifiableCredential({
+      ...args,
+      id,
+      issuer,
+      encodedList,
+      proofFormat,
+      statusPurpose,
+      ttl,
+      validFrom,
+      validUntil
+    }, context);
+    return {
+      statusListCredential: updatedCredential,
+      encodedList,
+      bitstringStatusList: {
+        statusPurpose,
+        validFrom,
+        validUntil,
+        ttl
+      },
+      length: statusList.length - 1,
+      type: import_ssi_types5.StatusListType.BitstringStatusList,
+      proofFormat,
+      id,
+      issuer,
+      statuslistContentType: this.buildContentType(proofFormat)
+    };
+  }
+  async updateStatusListFromEncodedList(args, context) {
+    if (!args.bitstringStatusList) {
+      throw new Error("bitstringStatusList options required for type BitstringStatusList");
+    }
+    const proofFormat = args?.proofFormat ?? DEFAULT_PROOF_FORMAT3;
+    assertValidProofType(import_ssi_types5.StatusListType.BitstringStatusList, proofFormat);
+    const veramoProofFormat = proofFormat;
+    const { issuer, id } = getAssertedValues(args);
+    const statusList = await (0, import_vc_bitstring_status_list.decodeList)({
+      encodedList: args.encodedList
+    });
+    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({
+      id,
+      issuer,
+      encodedList: newEncodedList,
+      proofFormat: veramoProofFormat,
+      keyRef: args.keyRef,
+      statusPurpose,
+      statusSize,
+      statusMessage,
+      validFrom,
+      validUntil,
+      ttl
+    }, context);
+    return {
+      type: import_ssi_types5.StatusListType.BitstringStatusList,
+      statusListCredential: credential,
+      encodedList: newEncodedList,
+      bitstringStatusList: {
+        statusPurpose,
+        validFrom,
+        validUntil,
+        ttl
+      },
+      length: statusList.length,
+      proofFormat: args.proofFormat ?? "lds",
+      id,
+      issuer,
+      statuslistContentType: this.buildContentType(proofFormat)
+    };
+  }
+  async checkStatusIndex(args) {
+    const uniform = import_ssi_types5.CredentialMapper.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 (0, import_vc_bitstring_status_list.decodeList)({
+      encodedList
+    });
+    if (statusList.length <= numIndex) {
+      throw new Error(`Status list index out of bounds, has ${messageList.length} messages, requested ${numIndex}`);
+    }
+    const value = statusList.getStatus(numIndex);
+    return {
+      index: numIndex,
+      status: hexIndex,
+      message: statusMessage?.message,
+      set: value
+    };
+  }
+  async toStatusListDetails(args) {
+    const { statusListPayload } = args;
+    const uniform = import_ssi_types5.CredentialMapper.toUniformCredential(statusListPayload);
+    const { issuer, credentialSubject } = uniform;
+    const id = getAssertedValue("id", uniform.id);
+    const encodedList = getAssertedProperty("encodedList", credentialSubject);
+    const proofFormat = import_ssi_types5.CredentialMapper.detectDocumentType(statusListPayload) === import_ssi_types5.DocumentFormat.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 (0, import_vc_bitstring_status_list.decodeList)({
+      encodedList
+    });
+    return {
+      id,
+      encodedList,
+      issuer,
+      type: import_ssi_types5.StatusListType.BitstringStatusList,
+      proofFormat,
+      length: list.length,
+      statusListCredential: statusListPayload,
+      statuslistContentType: this.buildContentType(proofFormat),
+      bitstringStatusList: {
+        statusPurpose,
+        validFrom,
+        validUntil,
+        ttl
+      },
+      ...args.correlationId && {
+        correlationId: args.correlationId
+      },
+      ...args.driverType && {
+        driverType: args.driverType
+      }
+    };
+  }
+  async createVerifiableCredential(args, context) {
+    const identifier = await context.agent.identifierManagedGet({
+      identifier: typeof args.issuer === "string" ? args.issuer : args.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,
+      fetchRemoteContexts: true
+    });
+    return import_ssi_types5.CredentialMapper.toWrappedVerifiableCredential(verifiableCredential).original;
+  }
+  buildContentType(proofFormat) {
+    switch (proofFormat) {
+      case "jwt":
+        return `application/statuslist+jwt`;
+      case "cbor":
+        return `application/statuslist+cwt`;
+      case "lds":
+        return "application/statuslist+ld+json";
+      default:
+        throw Error(`Unsupported content type '${proofFormat}' for status lists`);
+    }
+  }
+};
+
+// src/impl/StatusListFactory.ts
 var StatusListFactory = class _StatusListFactory {
   static {
     __name(this, "StatusListFactory");
@@ -764,8 +1033,9 @@ var StatusListFactory = class _StatusListFactory {
   implementations;
   constructor() {
     this.implementations = /* @__PURE__ */ new Map();
-    this.implementations.set(import_ssi_types5.StatusListType.StatusList2021, new StatusList2021Implementation());
-    this.implementations.set(import_ssi_types5.StatusListType.OAuthStatusList, new OAuthStatusListImplementation());
+    this.implementations.set(import_ssi_types6.StatusListType.StatusList2021, new StatusList2021Implementation());
+    this.implementations.set(import_ssi_types6.StatusListType.OAuthStatusList, new OAuthStatusListImplementation());
+    this.implementations.set(import_ssi_types6.StatusListType.BitstringStatusList, new BitstringStatusListImplementation());
   }
   static getInstance() {
     if (!_StatusListFactory.instance) {
@@ -838,7 +1108,7 @@ __name(vcLibCheckStatusFunction, "vcLibCheckStatusFunction");
 async function checkStatusForCredential(args) {
   const verifyStatusListCredential = args.verifyStatusListCredential ?? true;
   const verifyMatchingIssuers = args.verifyMatchingIssuers ?? true;
-  const uniform = import_ssi_types6.CredentialMapper.toUniformCredential(args.credential);
+  const uniform = import_ssi_types7.CredentialMapper.toUniformCredential(args.credential);
   if (!("credentialStatus" in uniform) || !uniform.credentialStatus) {
     if (args.mandatoryCredentialStatus) {
       const error = "No credential status object found in the Verifiable Credential and it is mandatory";
@@ -853,7 +1123,7 @@ async function checkStatusForCredential(args) {
     };
   }
   if ("credentialStatus" in uniform && uniform.credentialStatus) {
-    if (uniform.credentialStatus.type === "StatusList2021Entry") {
+    if (uniform.credentialStatus.type === "StatusList2021Entry" || uniform.credentialStatus.type === "BitstringStatusListEntry") {
       return (0, import_vc_status_list2.checkStatus)({
         ...args,
         verifyStatusListCredential,
@@ -904,19 +1174,19 @@ __name(updateStatusIndexFromStatusListCredential, "updateStatusIndexFromStatusLi
 async function statusListCredentialToDetails(args) {
   const credential = getAssertedValue("statusListCredential", args.statusListCredential);
   let statusListType;
-  const documentFormat = import_ssi_types6.CredentialMapper.detectDocumentType(credential);
-  if (documentFormat === import_ssi_types6.DocumentFormat.JWT) {
+  const documentFormat = import_ssi_types7.CredentialMapper.detectDocumentType(credential);
+  if (documentFormat === import_ssi_types7.DocumentFormat.JWT) {
     const [header] = credential.split(".");
     const decodedHeader = JSON.parse(Buffer.from(header, "base64").toString());
     if (decodedHeader.typ === "statuslist+jwt") {
-      statusListType = import_ssi_types6.StatusListType.OAuthStatusList;
+      statusListType = import_ssi_types7.StatusListType.OAuthStatusList;
     }
-  } else if (documentFormat === import_ssi_types6.DocumentFormat.MSO_MDOC) {
-    statusListType = import_ssi_types6.StatusListType.OAuthStatusList;
+  } else if (documentFormat === import_ssi_types7.DocumentFormat.MSO_MDOC) {
+    statusListType = import_ssi_types7.StatusListType.OAuthStatusList;
   }
   if (!statusListType) {
-    const uniform = import_ssi_types6.CredentialMapper.toUniformCredential(credential);
-    const type = uniform.type.find((t) => t.includes("StatusList2021") || t.includes("OAuth2StatusList"));
+    const uniform = import_ssi_types7.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");
     }
@@ -944,7 +1214,7 @@ async function statusList2021ToVerifiableCredential(args, context) {
     offlineWhenNoDIDRegistered: true
   });
   const proofFormat = args?.proofFormat ?? "lds";
-  assertValidProofType(import_ssi_types6.StatusListType.StatusList2021, proofFormat);
+  assertValidProofType(import_ssi_types7.StatusListType.StatusList2021, proofFormat);
   const veramoProofFormat = proofFormat;
   const encodedList = getAssertedValue("encodedList", args.encodedList);
   const statusPurpose = getAssertedValue("statusPurpose", args.statusPurpose);
@@ -973,7 +1243,7 @@ async function statusList2021ToVerifiableCredential(args, context) {
     proofFormat: veramoProofFormat,
     fetchRemoteContexts: true
   });
-  return import_ssi_types6.CredentialMapper.toWrappedVerifiableCredential(verifiableCredential).original;
+  return import_ssi_types7.CredentialMapper.toWrappedVerifiableCredential(verifiableCredential).original;
 }
 __name(statusList2021ToVerifiableCredential, "statusList2021ToVerifiableCredential");
 //# sourceMappingURL=index.cjs.map