@idos-network/credentials 1.1.0

package/src/builder/builder.test.ts

@@ -0,0 +1,407 @@
+import { Ed25519VerificationKey2020 } from "@digitalbazaar/ed25519-verification-key-2020";
+import crypto from "node:crypto";
+import { describe, expect, it } from "vitest";
+import { ZodError } from "zod";
+
+import { buildCredential, buildFaceIdCredential } from ".";
+import { fileToBase85 } from "../utils";
+import { verifyCredential } from "./verifier";
+
+describe("verifiableCredentials", () => {
+  describe("face-scan-id", () => {
+    it("should raise an error if the fields are invalid", async () => {
+      expect.assertions(4); // catch
+
+      const id = "z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3";
+      const issuer = "https://vc-issuers.cool.id/idos";
+
+      const validKey = await Ed25519VerificationKey2020.generate({
+        id: `${issuer}/keys/1`,
+        controller: `${issuer}/issuers/1`,
+      });
+
+      try {
+        await buildFaceIdCredential(
+          {
+            id: `${issuer}/credentials/${id}`,
+            level: "human",
+            issued: new Date("2022-01-01"),
+            approvedAt: new Date("2022-01-01"),
+            expirationDate: new Date("2030-01-01"),
+          },
+          {
+            // @ts-expect-error
+            id: `uuid:${id}`,
+          },
+          validKey,
+        );
+      } catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+        const zodError = error as ZodError;
+        expect(zodError.issues).toHaveLength(1);
+
+        const faceSignUserId = zodError.issues.find((error) => error.path[0] === "faceSignUserId");
+        expect(faceSignUserId).toBeDefined();
+        expect(faceSignUserId?.message).toContain(
+          "Invalid input: expected string, received undefined",
+        );
+      }
+    });
+
+    it("should create and verify a verifiable vc", async () => {
+      const id = "z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3";
+      const issuer = "https://vc-issuers.cool.id/idos";
+      const issuer2 = "https://vc-issuers.cool.id/idos2";
+
+      const validKey = await Ed25519VerificationKey2020.generate({
+        id: `${issuer}/keys/1`,
+        controller: `${issuer}/issuers/1`,
+      });
+
+      const anotherKey = await Ed25519VerificationKey2020.generate({
+        id: `${issuer2}/keys/1`,
+        controller: `${issuer2}/issuers/1`,
+      });
+
+      const faceSignUserId = crypto.randomUUID();
+
+      const data = await buildFaceIdCredential(
+        {
+          id: `${issuer}/credentials/${id}`,
+          level: "human",
+          issued: new Date("2022-01-01"),
+          approvedAt: new Date("2022-01-01"),
+          expirationDate: new Date("2030-01-01"),
+        },
+        {
+          faceSignUserId,
+        },
+        validKey,
+      );
+
+      // Check if residential address is properly prefixed
+      expect(data.credentialSubject.faceSignUserId).toBe(faceSignUserId);
+
+      // Check if proof is properly constructed
+      expect(data.proof.proofPurpose).toBe("assertionMethod");
+      expect(data.proof.type).toBe("Ed25519Signature2020");
+      expect(data.proof.verificationMethod).toBe("https://vc-issuers.cool.id/idos/keys/1");
+
+      const allowedIssuers = [anotherKey, validKey];
+
+      const [verified, validResults] = await verifyCredential(data, allowedIssuers);
+      expect(verified).toBe(true);
+
+      const validResultsArray = validResults.values().toArray();
+      expect(validResultsArray).toHaveLength(2);
+      expect(validResultsArray[0].verified).toBe(false);
+      expect(validResultsArray[1].verified).toBe(true);
+    });
+
+    it("tempered VCs will be rejected", async () => {
+      const id = "z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3";
+      const issuer = "https://vc-issuers.cool.id/idos";
+
+      const validKey = await Ed25519VerificationKey2020.generate({
+        id: `${issuer}/keys/1`,
+        controller: `${issuer}/issuers/1`,
+      });
+
+      const faceSignUserId = crypto.randomUUID();
+      const faceSignUserId2 = crypto.randomUUID();
+
+      const data = await buildFaceIdCredential(
+        {
+          id: `${issuer}/credentials/${id}`,
+          level: "human",
+          issued: new Date("2022-01-01"),
+          approvedAt: new Date("2022-01-01"),
+          expirationDate: new Date("2030-01-01"),
+        },
+        {
+          faceSignUserId,
+        },
+        validKey,
+      );
+
+      // Check validity
+      const allowedIssuers = [validKey];
+      const [verified] = await verifyCredential(data, allowedIssuers);
+      expect(verified).toBe(true);
+
+      // Modify data
+      data.credentialSubject.faceSignUserId = faceSignUserId2;
+      const [verified2] = await verifyCredential(data, allowedIssuers);
+      expect(verified2).toBe(false);
+    });
+  });
+
+  describe("credentials", () => {
+    it("should raise an error if the fields are invalid", async () => {
+      expect.assertions(12); // catch
+
+      const id = "z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3";
+      const issuer = "https://vc-issuers.cool.id/idos";
+
+      const validKey = await Ed25519VerificationKey2020.generate({
+        id: `${issuer}/keys/1`,
+        controller: `${issuer}/issuers/1`,
+      });
+
+      try {
+        await buildCredential(
+          {
+            id: `${issuer}/credentials/${id}`,
+            level: "human",
+            issued: new Date("2022-01-01"),
+            approvedAt: new Date("2022-01-01"),
+            expirationDate: new Date("2030-01-01"),
+          },
+          {
+            id: `uuid:${id}`,
+            firstName: "John",
+            familyName: "Lennon",
+            // @ts-expect-error - This is a test, so the error is expected, since data is invalid
+            gender: "MALE",
+            email: "john.lennon@example.com",
+            phoneNumber: "+1234567890",
+            ssn: "203-456",
+            dateOfBirth: new Date("2025-02-30"),
+            placeOfBirth: "New York, NY",
+            idDocumentCountry: "DEU",
+            idDocumentNumber: "123456789",
+            idDocumentType: "PASSPORT",
+            idDocumentDateOfIssue: new Date("2022-01-01"),
+            idDocumentDateOfExpiry: new Date("2025-01-01"),
+            idDocumentFrontFile: Buffer.from("Front of ID document"),
+            residentialAddress: {
+              street: "Main St",
+              houseNumber: "123",
+              additionalAddressInfo: "Apt 1",
+              city: "New York",
+              postalCode: "10001",
+              country: "USA",
+              proofCategory: "Utility Bill",
+              proofDateOfIssue: new Date("2022-01-01"),
+              proofFile: Buffer.from("Proof of address"),
+            },
+          },
+          validKey,
+        );
+      } catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+        const zodError = error as ZodError;
+        expect(zodError.issues).toHaveLength(5);
+
+        // idDocumentCountry
+        const idDocumentCountryError = zodError.issues.find(
+          (error) => error.path[0] === "idDocumentCountry",
+        );
+        expect(idDocumentCountryError).toBeDefined();
+        expect(idDocumentCountryError?.message).toContain(
+          "Too big: expected string to have <=2 characters",
+        );
+
+        // selfieFile
+        const selfieFileError = zodError.issues.find((error) => error.path[0] === "selfieFile");
+        expect(selfieFileError).toBeDefined();
+        expect(selfieFileError?.message).toContain("expected Buffer, received undefined");
+
+        // residentialAddress country
+        const residentialAddressCountryError = zodError.issues.find(
+          (error) => error.path[0] === "residentialAddress",
+        );
+        expect(residentialAddressCountryError).toBeDefined();
+        expect(residentialAddressCountryError?.message).toContain(
+          "Too big: expected string to have <=2 characters",
+        );
+
+        // gender
+        const genderError = zodError.issues.find((error) => error.path[0] === "gender");
+        expect(genderError).toBeDefined();
+        expect(genderError?.message).toContain('Invalid option: expected one of "M"|"F"|"OTHER"');
+
+        // ssn
+        const ssnError = zodError.issues.find((error) => error.path[0] === "ssn");
+        expect(ssnError).toBeDefined();
+        expect(ssnError?.message).toContain("Too small: expected string to have >=9 characters");
+      }
+    });
+
+    it("test refinement (at least one of firstName or familyName must be provided)", async () => {
+      const id = "z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3";
+      const issuer = "https://vc-issuers.cool.id/idos";
+
+      const validKey = await Ed25519VerificationKey2020.generate({
+        id: `${issuer}/keys/1`,
+        controller: `${issuer}/issuers/1`,
+      });
+
+      expect.assertions(3); // catch
+
+      try {
+        await buildCredential(
+          {
+            id: `${issuer}/credentials/${id}`,
+            level: "human",
+            issued: new Date("2022-01-01"),
+            approvedAt: new Date("2022-01-01"),
+            expirationDate: new Date("2030-01-01"),
+          },
+          {
+            id: `uuid:${id}`,
+            ssn: "123456789",
+            firstName: "",
+            familyName: undefined,
+            gender: "M",
+            nationality: "US",
+            email: "john.lennon@example.com",
+            phoneNumber: "+1234567890",
+            dateOfBirth: new Date("1980-01-01"),
+            placeOfBirth: "New York, NY",
+            idDocumentCountry: "US",
+            idDocumentNumber: "123456789",
+            idDocumentType: "PASSPORT",
+            idDocumentDateOfIssue: new Date("2022-01-01"),
+            idDocumentDateOfExpiry: new Date("2025-01-01"),
+            idDocumentFrontFile: Buffer.from("Front of ID document"),
+            idDocumentBackFile: Buffer.from("Back of ID document"),
+            selfieFile: Buffer.from("Selfie"),
+          },
+          validKey,
+        );
+      } catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+        const zodError = error as ZodError;
+        expect(zodError.issues).toHaveLength(1);
+
+        const refinementError = zodError.issues.find(
+          (error) => error.message === "At least one of firstName or familyName must be provided",
+        );
+        expect(refinementError).toBeDefined();
+      }
+    });
+
+    it("should create and verify a verifiable vc", async () => {
+      const id = "z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3";
+      const issuer = "https://vc-issuers.cool.id/idos";
+      const issuer2 = "https://vc-issuers.cool.id/idos2";
+
+      const validKey = await Ed25519VerificationKey2020.generate({
+        id: `${issuer}/keys/1`,
+        controller: `${issuer}/issuers/1`,
+      });
+
+      const anotherKey = await Ed25519VerificationKey2020.generate({
+        id: `${issuer2}/keys/1`,
+        controller: `${issuer2}/issuers/1`,
+      });
+
+      const data = await buildCredential(
+        {
+          id: `${issuer}/credentials/${id}`,
+          level: "human",
+          issued: new Date("2022-01-01"),
+          approvedAt: new Date("2022-01-01"),
+          expirationDate: new Date("2030-01-01"),
+        },
+        {
+          id: `uuid:${id}`,
+          firstName: "John",
+          middleName: "Paul",
+          familyName: "Lennon",
+          ssn: "123456789",
+          gender: "M",
+          nationality: "US",
+          email: "john.lennon@example.com",
+          phoneNumber: "+1234567890",
+          dateOfBirth: new Date("1980-01-01"),
+          placeOfBirth: "New York, NY",
+          idDocumentCountry: "US",
+          idDocumentNumber: "123456789",
+          idDocumentType: "PASSPORT",
+          idDocumentDateOfIssue: new Date("2022-01-01"),
+          idDocumentDateOfExpiry: new Date("2025-01-01"),
+          idDocumentFrontFile: Buffer.from("Front of ID document"),
+          idDocumentBackFile: Buffer.from("Back of ID document"),
+          selfieFile: Buffer.from("Selfie"),
+          residentialAddress: {
+            street: "Main St",
+            houseNumber: "123",
+            additionalAddressInfo: "Apt 1",
+            region: "NY",
+            city: "New York",
+            postalCode: "10001",
+            country: "US",
+            proofCategory: "Utility Bill",
+            proofDateOfIssue: new Date("2022-01-01"),
+            proofFile: Buffer.from("Proof of address"),
+          },
+        },
+        validKey,
+      );
+
+      // Check if residential address is properly prefixed
+      expect(data.credentialSubject.residentialAddressStreet).toBe("Main St");
+      expect(data.credentialSubject.residentialAddressHouseNumber).toBe("123");
+      expect(data.credentialSubject.residentialAddressAdditionalAddressInfo).toBe("Apt 1");
+      expect(data.credentialSubject.residentialAddressCity).toBe("New York");
+      expect(data.credentialSubject.residentialAddressPostalCode).toBe("10001");
+      expect(data.credentialSubject.residentialAddressCountry).toBe("US");
+      expect(data.credentialSubject.residentialAddressRegion).toBe("NY");
+      expect(data.credentialSubject.residentialAddressProofCategory).toBe("Utility Bill");
+      expect(data.credentialSubject.residentialAddressProofDateOfIssue).toEqual(
+        new Date("2022-01-01").toISOString(),
+      );
+      expect(data.credentialSubject.residentialAddressProofFile).toEqual(
+        fileToBase85(Buffer.from("Proof of address")),
+      );
+
+      expect(data.credentialSubject.email).toBe("john.lennon@example.com");
+      expect(data.credentialSubject.phoneNumber).toBe("+1234567890");
+
+      // Check if proof is properly constructed
+      expect(data.proof.proofPurpose).toBe("assertionMethod");
+      expect(data.proof.type).toBe("Ed25519Signature2020");
+      expect(data.proof.verificationMethod).toBe("https://vc-issuers.cool.id/idos/keys/1");
+
+      const allowedIssuers = [anotherKey, validKey];
+
+      const [verified, validResults] = await verifyCredential(data, allowedIssuers);
+      expect(verified).toBe(true);
+
+      const validResultsArray = validResults.values().toArray();
+      expect(validResultsArray).toHaveLength(2);
+      expect(validResultsArray[0].verified).toBe(false);
+      expect(validResultsArray[1].verified).toBe(true);
+
+      // Invalid issuer
+      const invalidIssuers = [
+        {
+          // Just the wrong issuer
+          issuer: issuer2,
+          publicKeyMultibase: anotherKey.publicKeyMultibase,
+        },
+      ];
+
+      const [invalidVerified, invalidResults] = await verifyCredential(data, invalidIssuers);
+      expect(invalidVerified).toBe(false);
+
+      const invalidResultsArray = invalidResults.values().toArray();
+      expect(invalidResultsArray).toHaveLength(1);
+      expect(invalidResultsArray[0].verified).toBe(false);
+      expect(invalidResultsArray[0].error?.errors?.[0]?.message).toContain("not verify any proofs");
+
+      // Accepts issuer as issuer object
+      const validIssuer = [
+        {
+          issuer,
+          publicKeyMultibase: validKey.publicKeyMultibase,
+        },
+      ];
+
+      const [validIssuerVerified] = await verifyCredential(data, validIssuer);
+      expect(validIssuerVerified).toBe(true);
+    });
+  });
+});

package/src/builder/index.ts

@@ -0,0 +1,122 @@
+import { Ed25519Signature2020 } from "@digitalbazaar/ed25519-signature-2020";
+import * as vc from "@digitalbazaar/vc";
+
+import type { VerifyCredentialResult } from "./verifier";
+
+import {
+  type AvailableIssuerType,
+  type CredentialFields,
+  CredentialFieldsSchema,
+  type CredentialSubject,
+  type CredentialSubjectFaceId,
+  CredentialSubjectFaceIdSchema,
+  CredentialSubjectSchema,
+  type VerifiableCredential,
+  type VerifiableCredentialSubject,
+} from "../types";
+import { convertValues, issuerToKey } from "../utils";
+import {
+  CONTEXT_IDOS_CREDENTIAL,
+  CONTEXT_IDOS_CREDENTIAL_FACE_ID,
+  CONTEXT_IDOS_CREDENTIAL_SUBJECT,
+  CONTEXT_IDOS_SIGNATURE,
+  CONTEXT_V1,
+  defaultDocumentLoader,
+} from "./loader";
+import { verifyCredential } from "./verifier";
+
+export type Credential = VerifiableCredential<VerifiableCredentialSubject>;
+export type FaceIdCredential = VerifiableCredential<CredentialSubjectFaceId>;
+
+export type CredentialBuilder<TInput, TOutput = TInput> = (
+  fields: CredentialFields,
+  subject: TInput,
+  issuer: AvailableIssuerType,
+  validate?: boolean,
+) => Promise<VerifiableCredential<TOutput>>;
+
+export type CredentialConverter<TInput> = (
+  subject: TInput,
+  validate: boolean,
+  // oxlint-disable-next-line typescript/no-explicit-any -- any is needed here
+) => Record<string, any>;
+
+function genericCredentialBuilder<TInput, TOutput = TInput>(
+  credentialConverter: CredentialConverter<TInput>,
+): CredentialBuilder<TInput, TOutput> {
+  async function builder(
+    fields: CredentialFields,
+    subject: TInput,
+    issuer: AvailableIssuerType,
+    validate = true,
+  ) {
+    if (validate) {
+      // This raises an z.ZodError exception if the fields are invalid
+      CredentialFieldsSchema.parse(fields);
+    }
+
+    const credentialSubject = credentialConverter(subject, validate);
+
+    const key = await issuerToKey(issuer);
+
+    // Create credentials container
+    const credential = {
+      "@context": [CONTEXT_V1, CONTEXT_IDOS_CREDENTIAL, CONTEXT_IDOS_SIGNATURE],
+      type: ["VerifiableCredential"],
+      issuer: key.controller,
+      ...convertValues(fields),
+      credentialSubject,
+    };
+
+    const suite = new Ed25519Signature2020({ key });
+
+    return vc.issue<TOutput>({
+      credential,
+      suite,
+      documentLoader: defaultDocumentLoader,
+    });
+  }
+
+  return builder;
+}
+
+export const credentialSubjectConverter: CredentialConverter<CredentialSubject> = (
+  subject,
+  validate,
+) => {
+  if (validate) {
+    CredentialSubjectSchema.parse(subject);
+  }
+
+  const { residentialAddress, ...subjectData } = subject;
+  return {
+    "@context": CONTEXT_IDOS_CREDENTIAL_SUBJECT,
+    ...convertValues(subjectData),
+    ...(residentialAddress ? convertValues(residentialAddress, "residentialAddress") : {}),
+  };
+};
+
+export const credentialFaceIdSubjectConverter: CredentialConverter<CredentialSubjectFaceId> = (
+  subject,
+  validate,
+) => {
+  if (validate) {
+    CredentialSubjectFaceIdSchema.parse(subject);
+  }
+
+  return {
+    "@context": CONTEXT_IDOS_CREDENTIAL_FACE_ID,
+    ...convertValues(subject),
+  };
+};
+
+export const buildCredential: CredentialBuilder<CredentialSubject, VerifiableCredentialSubject> =
+  genericCredentialBuilder<CredentialSubject, VerifiableCredentialSubject>(
+    credentialSubjectConverter,
+  );
+
+export const buildFaceIdCredential: CredentialBuilder<CredentialSubjectFaceId> =
+  genericCredentialBuilder<CredentialSubjectFaceId>(credentialFaceIdSubjectConverter);
+
+export type { VerifyCredentialResult };
+export { verifyCredential };

package/src/builder/loader.ts

@@ -0,0 +1,76 @@
+import { type JsonLDDocumentLoaderInstance, JsonLdDocumentLoader } from "jsonld-document-loader";
+
+import ed25519Signature2020V1 from "../../assets/ed25519-signature-2020-v1.json";
+import idosCredentialSubjectFaceIdV1 from "../../assets/idos-credential-subject-face-id-v1.json";
+import idosCredentialSubjectV1 from "../../assets/idos-credential-subject-v1.json";
+import idosCredentialSubjectV2 from "../../assets/idos-credential-subject-v2.json";
+import idosCredentialsV1 from "../../assets/idos-credentials-v1.json";
+import v1 from "../../assets/v1.json";
+
+export const CONTEXT_V1 = "https://www.w3.org/2018/credentials/v1";
+export const CONTEXT_ED25519_SIGNATURE_2020_V1 = "https://w3id.org/security/suites/ed25519-2020/v1";
+
+// Check .github/workflow/pages.yml how those are deployed
+export const CONTEXT_IDOS_CREDENTIAL_V1 =
+  "https://idos-network.github.io/idos-sdk-js/credentials/idos-credentials-v1.json";
+export const CONTEXT_IDOS_CREDENTIAL_V1_SUBJECT =
+  "https://idos-network.github.io/idos-sdk-js/credentials/idos-credential-subject-v1.json";
+export const CONTEXT_IDOS_CREDENTIAL_V2_SUBJECT =
+  "https://idos-network.github.io/idos-sdk-js/credentials/idos-credential-subject-v2.json";
+
+export const CONTEXT_IDOS_CREDENTIAL_V1_FACE_ID =
+  "https://idos-network.github.io/idos-sdk-js/credentials/idos-credential-subject-face-id-v1.json";
+
+// Latest contexts for builder
+export const CONTEXT_IDOS_CREDENTIAL: string = CONTEXT_IDOS_CREDENTIAL_V1;
+export const CONTEXT_IDOS_CREDENTIAL_SUBJECT: string = CONTEXT_IDOS_CREDENTIAL_V2_SUBJECT;
+export const CONTEXT_IDOS_SIGNATURE: string = CONTEXT_ED25519_SIGNATURE_2020_V1;
+export const CONTEXT_IDOS_CREDENTIAL_FACE_ID: string = CONTEXT_IDOS_CREDENTIAL_V1_FACE_ID;
+
+export function buildDocumentLoader(): JsonLDDocumentLoaderInstance {
+  const loader = new JsonLdDocumentLoader();
+
+  loader.addStatic(CONTEXT_V1, v1);
+  loader.addStatic(CONTEXT_IDOS_CREDENTIAL_V1, idosCredentialsV1);
+  loader.addStatic(CONTEXT_ED25519_SIGNATURE_2020_V1, ed25519Signature2020V1);
+
+  // plus / basic + liveness credentials
+  loader.addStatic(CONTEXT_IDOS_CREDENTIAL_V1_SUBJECT, idosCredentialSubjectV1);
+  loader.addStatic(CONTEXT_IDOS_CREDENTIAL_V2_SUBJECT, idosCredentialSubjectV2);
+
+  // PoP
+  loader.addStatic(CONTEXT_IDOS_CREDENTIAL_V1_FACE_ID, idosCredentialSubjectFaceIdV1);
+
+  // DEPRECATED: Those should be removed
+  [
+    "1356fea6672d22deb07fedc5fa427478b2e1654c",
+    "346f14468348e4f3dd00039c89ce9bb49d88777c",
+    "1e8421744e037dfd7b0289cb39261c73ab6d643c",
+    "0049d2e93f8913c42398372e2bb65d92bed38ac0",
+  ].forEach((hash) => {
+    loader.addStatic(
+      `https://raw.githubusercontent.com/idos-network/idos-sdk-js/${hash}/packages/%40credentials/assets/idos-credentials-v1.json`,
+      idosCredentialsV1,
+    );
+    loader.addStatic(
+      `https://raw.githubusercontent.com/idos-network/idos-sdk-js/${hash}/packages/%40credentials/assets/idos-credential-subject-v1.json`,
+      idosCredentialSubjectV1,
+    );
+  });
+
+  // DEPRECATED: Those should be removed
+  ["1bc3503f5302a7e42777076445d5b05fec8db429"].forEach((hash) => {
+    loader.addStatic(
+      `https://raw.githubusercontent.com/idos-network/idos-sdk-js/${hash}/packages/issuer-sdk-js/assets/idos-credentials-v1.json`,
+      idosCredentialsV1,
+    );
+    loader.addStatic(
+      `https://raw.githubusercontent.com/idos-network/idos-sdk-js/${hash}/packages/issuer-sdk-js/assets/idos-credential-subject-v1.json`,
+      idosCredentialSubjectV1,
+    );
+  });
+
+  return loader.build();
+}
+
+export const defaultDocumentLoader: JsonLDDocumentLoaderInstance = buildDocumentLoader();

package/src/builder/verifier.ts

@@ -0,0 +1,55 @@
+import type { JsonLDDocumentLoaderInstance } from "jsonld-document-loader";
+
+import { Ed25519Signature2020 } from "@digitalbazaar/ed25519-signature-2020";
+import * as vc from "@digitalbazaar/vc";
+
+import type {
+  AvailableIssuerType,
+  VerifiableCredential,
+  VerifiableCredentialSubject,
+} from "../types";
+
+import { issuerToKey } from "../utils";
+import { defaultDocumentLoader } from "./loader";
+
+export type VerifyCredentialResult = [boolean, Map<AvailableIssuerType, vc.VerifyCredentialResult>];
+
+export async function verifyCredential<K = VerifiableCredentialSubject>(
+  credential: VerifiableCredential<K>,
+  issuers: AvailableIssuerType[],
+  customDocumentLoader?: JsonLDDocumentLoaderInstance,
+): Promise<VerifyCredentialResult> {
+  const resultsByIssuer: Map<AvailableIssuerType, vc.VerifyCredentialResult> = new Map();
+
+  for (const issuer of issuers) {
+    const publicKey = await issuerToKey(issuer);
+
+    const vcVerifyingSuite = new Ed25519Signature2020({
+      key: publicKey,
+      verificationMethod: publicKey.id,
+    });
+
+    const controller = {
+      "@context": "https://w3id.org/security/v2",
+      id: publicKey.controller,
+      assertionMethod: [publicKey.id],
+      authentication: [publicKey.id],
+    };
+
+    // Verify the signature
+    const verifyCredentialResult = await vc.verifyCredential<K>({
+      credential: credential,
+      suite: vcVerifyingSuite,
+      controller,
+      documentLoader: customDocumentLoader ?? defaultDocumentLoader,
+    });
+
+    resultsByIssuer.set(issuer, verifyCredentialResult);
+
+    if (verifyCredentialResult.verified) {
+      return [true, resultsByIssuer];
+    }
+  }
+
+  return [false, resultsByIssuer];
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+/* oxlint-disable */
+// This is just empty placeholder for main export