@trustvc/trustvc 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/core/fragments/document-status/w3cCredentialStatus.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var w3cVc = require('@trustvc/w3c-vc');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const w3cCredentialStatus = {
+  skip: /* @__PURE__ */ __name(async () => {
+    return {
+      type: "DOCUMENT_STATUS",
+      name: "W3CCredentialStatus",
+      reason: {
+        code: 0,
+        codeString: "SKIPPED",
+        message: `Document does not have a valid credentialStatus or type.`
+      },
+      status: "SKIPPED"
+    };
+  }, "skip"),
+  test: /* @__PURE__ */ __name((document) => {
+    const doc = document;
+    return doc.credentialStatus?.type === "StatusList2021Entry";
+  }, "test"),
+  verify: /* @__PURE__ */ __name(async (document) => {
+    const doc = document;
+    const verificationResult = await w3cVc.verifyCredentialStatus(doc.credentialStatus);
+    if (verificationResult.error) {
+      return {
+        type: "DOCUMENT_STATUS",
+        name: "W3CCredentialStatus",
+        reason: {
+          message: verificationResult.error
+        },
+        status: "ERROR"
+      };
+    } else if (verificationResult.status === true) {
+      return {
+        type: "DOCUMENT_STATUS",
+        name: "W3CCredentialStatus",
+        data: false,
+        status: "INVALID"
+      };
+    } else {
+      return {
+        type: "DOCUMENT_STATUS",
+        name: "W3CCredentialStatus",
+        data: true,
+        status: "VALID"
+      };
+    }
+  }, "verify")
+};
+
+exports.w3cCredentialStatus = w3cCredentialStatus;

package/dist/core/fragments/issuer-identity/w3cIssuerIdentity.d.mts

@@ -0,0 +1,5 @@
+import { Verifier, VerificationFragment } from '@tradetrust-tt/tt-verify';
+
+declare const w3cIssuerIdentity: Verifier<VerificationFragment>;
+
+export { w3cIssuerIdentity };

package/dist/core/fragments/issuer-identity/w3cIssuerIdentity.d.ts

@@ -0,0 +1,5 @@
+import { Verifier, VerificationFragment } from '@tradetrust-tt/tt-verify';
+
+declare const w3cIssuerIdentity: Verifier<VerificationFragment>;
+
+export { w3cIssuerIdentity };

package/dist/core/fragments/issuer-identity/w3cIssuerIdentity.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var didResolver = require('did-resolver');
+var webDidResolver = require('web-did-resolver');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const checkDidWebResolve = /* @__PURE__ */ __name(async (did) => {
+  try {
+    const resolver = new didResolver.Resolver({
+      ...webDidResolver.getResolver()
+    });
+    const didDocument = await resolver.resolve(did);
+    if (!didDocument || !didDocument.didDocument) {
+      throw new Error(`Failed to resolve DID: ${did}`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}, "checkDidWebResolve");
+const w3cIssuerIdentity = {
+  skip: /* @__PURE__ */ __name(async () => {
+    return {
+      type: "ISSUER_IDENTITY",
+      name: "W3CIssuerIdentity",
+      reason: {
+        code: 0,
+        codeString: "SKIPPED",
+        message: `Document has no issuer field.`
+      },
+      status: "SKIPPED"
+    };
+  }, "skip"),
+  test: /* @__PURE__ */ __name((document) => {
+    const doc = document;
+    return Boolean(doc.issuer);
+  }, "test"),
+  verify: /* @__PURE__ */ __name(async (document) => {
+    const doc = document;
+    if (doc.proof?.verificationMethod?.split("#")[0] !== doc.issuer) {
+      return {
+        type: "ISSUER_IDENTITY",
+        name: "W3CIssuerIdentity",
+        data: false,
+        reason: {
+          message: `Issuer and verification method do not match.`
+        },
+        status: "INVALID"
+      };
+    }
+    const resolutionResult = await checkDidWebResolve(doc.issuer);
+    if (resolutionResult) {
+      return {
+        type: "ISSUER_IDENTITY",
+        name: "W3CIssuerIdentity",
+        data: true,
+        status: "VALID"
+      };
+    } else {
+      return {
+        type: "ISSUER_IDENTITY",
+        name: "W3CIssuerIdentity",
+        data: false,
+        reason: {
+          message: `The DID cannot be resolved.`
+        },
+        status: "INVALID"
+      };
+    }
+  }, "verify")
+};
+
+exports.w3cIssuerIdentity = w3cIssuerIdentity;

package/dist/core/index.d.mts

@@ -0,0 +1,5 @@
+export { verifyDocument } from './verify.mjs';
+export { encrypt } from './encrypt.mjs';
+export { decrypt } from './decrypt.mjs';
+import '@tradetrust-tt/tt-verify';
+import '@trustvc/w3c-vc';

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export { verifyDocument } from './verify.js';
+export { encrypt } from './encrypt.js';
+export { decrypt } from './decrypt.js';
+import '@tradetrust-tt/tt-verify';
+import '@trustvc/w3c-vc';

package/dist/core/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var verify = require('./verify');
+var encrypt = require('./encrypt');
+var decrypt = require('./decrypt');
+
+
+
+Object.keys(verify).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return verify[k]; }
+	});
+});
+Object.keys(encrypt).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return encrypt[k]; }
+	});
+});
+Object.keys(decrypt).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return decrypt[k]; }
+	});
+});

package/dist/core/verify.d.mts

@@ -0,0 +1,6 @@
+import { DocumentsToVerify, VerificationFragment } from '@tradetrust-tt/tt-verify';
+import { SignedVerifiableCredential } from '@trustvc/w3c-vc';
+
+declare const verifyDocument: (document: DocumentsToVerify | SignedVerifiableCredential, rpcProviderUrl: string) => Promise<VerificationFragment[]>;
+
+export { verifyDocument };

package/dist/core/verify.d.ts

@@ -0,0 +1,6 @@
+import { DocumentsToVerify, VerificationFragment } from '@tradetrust-tt/tt-verify';
+import { SignedVerifiableCredential } from '@trustvc/w3c-vc';
+
+declare const verifyDocument: (document: DocumentsToVerify | SignedVerifiableCredential, rpcProviderUrl: string) => Promise<VerificationFragment[]>;
+
+export { verifyDocument };

package/dist/core/verify.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var tradetrust = require('@tradetrust-tt/tradetrust');
+var ttVerify = require('@tradetrust-tt/tt-verify');
+var ethers = require('ethers');
+var w3cSignatureIntegrity = require('./fragments/document-integrity/w3cSignatureIntegrity');
+var transferableRecordVerifier = require('./fragments/document-status/transferableRecords/transferableRecordVerifier');
+var w3cCredentialStatus = require('./fragments/document-status/w3cCredentialStatus');
+var w3cIssuerIdentity = require('./fragments/issuer-identity/w3cIssuerIdentity');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const verifyDocument = /* @__PURE__ */ __name(async (document, rpcProviderUrl) => {
+  if (tradetrust.utils.isWrappedV2Document(document) || tradetrust.utils.isWrappedV3Document(document)) {
+    const verify = ttVerify.verificationBuilder(
+      [...ttVerify.openAttestationVerifiers, ttVerify.openAttestationDidIdentityProof],
+      {
+        provider: new ethers.ethers.providers.JsonRpcProvider(rpcProviderUrl)
+        // Use user-provided provider URL
+      }
+    );
+    return verify(document);
+  } else {
+    const verify = ttVerify.verificationBuilder(
+      [
+        w3cSignatureIntegrity.w3cSignatureIntegrity,
+        w3cCredentialStatus.w3cCredentialStatus,
+        w3cIssuerIdentity.w3cIssuerIdentity,
+        transferableRecordVerifier.credentialStatusTransferableRecordVerifier
+      ],
+      {
+        provider: new ethers.ethers.providers.JsonRpcProvider(rpcProviderUrl)
+        // Use user-provided provider URL
+      }
+    );
+    return verify(document);
+  }
+}, "verifyDocument");
+
+exports.verifyDocument = verifyDocument;

package/dist/esm/config.js

@@ -0,0 +1,3 @@
+const DEFAULT_KEY = "4d5a4e3f2f6d2b0a1f2e9b8f8a3c7a0b8d4f5c2e7b1a1c3f2e7b8c2d5a4f7e3e";
+
+export { DEFAULT_KEY };

package/dist/esm/core/decrypt.js

@@ -0,0 +1,20 @@
+import { DEFAULT_KEY } from '../config';
+import { generate32ByteKey, generate12ByteNonce, stringToUint8Array } from '../utils/stringUtils';
+import { Chacha20 } from 'ts-chacha20';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function decrypt(encryptedMessage, key, nonce) {
+  key = key.length > 0 ? key : DEFAULT_KEY;
+  key = generate32ByteKey(key);
+  nonce = generate12ByteNonce(nonce ?? "");
+  const keyBuffer = stringToUint8Array(key);
+  const nonceBuffer = stringToUint8Array(nonce);
+  const chacha20 = new Chacha20(keyBuffer, nonceBuffer);
+  const encryptedBuffer = new Uint8Array(Buffer.from(encryptedMessage, "hex"));
+  const decrypted = chacha20.decrypt(encryptedBuffer);
+  return Buffer.from(decrypted).toString("utf-8");
+}
+__name(decrypt, "decrypt");
+
+export { decrypt };

package/dist/esm/core/encrypt.js

@@ -0,0 +1,20 @@
+import { DEFAULT_KEY } from '../config';
+import { generate32ByteKey, generate12ByteNonce, stringToUint8Array } from '../utils/stringUtils';
+import { Chacha20 } from 'ts-chacha20';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function encrypt(message, key, nonce) {
+  key = key.length > 0 ? key : DEFAULT_KEY;
+  key = generate32ByteKey(key);
+  nonce = generate12ByteNonce(nonce ?? "");
+  const keyBuffer = stringToUint8Array(key);
+  const nonceBuffer = stringToUint8Array(nonce);
+  const chacha20 = new Chacha20(keyBuffer, nonceBuffer);
+  const messageBuffer = stringToUint8Array(message);
+  const encrypted = chacha20.encrypt(messageBuffer);
+  return Buffer.from(encrypted).toString("hex");
+}
+__name(encrypt, "encrypt");
+
+export { encrypt };

package/dist/esm/core/fragments/document-integrity/w3cSignatureIntegrity.js

@@ -0,0 +1,46 @@
+import { verifyW3CSignature } from '../../..';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const w3cSignatureIntegrity = {
+  skip: /* @__PURE__ */ __name(async () => {
+    return {
+      type: "DOCUMENT_INTEGRITY",
+      name: "W3CSignatureIntegrity",
+      reason: {
+        code: 0,
+        codeString: "SKIPPED",
+        message: `Document either has no proof or proof.type is not 'BbsBlsSignature2020'.`
+      },
+      status: "SKIPPED"
+    };
+  }, "skip"),
+  test: /* @__PURE__ */ __name((document) => {
+    const doc = document;
+    return doc.proof?.type === "BbsBlsSignature2020";
+  }, "test"),
+  verify: /* @__PURE__ */ __name(async (document) => {
+    const doc = document;
+    const verificationResult = await verifyW3CSignature(doc);
+    if (verificationResult.verified) {
+      return {
+        type: "DOCUMENT_INTEGRITY",
+        name: "W3CSignatureIntegrity",
+        data: true,
+        status: "VALID"
+      };
+    } else {
+      return {
+        type: "DOCUMENT_INTEGRITY",
+        name: "W3CSignatureIntegrity",
+        data: false,
+        reason: {
+          message: verificationResult.error
+        },
+        status: "INVALID"
+      };
+    }
+  }, "verify")
+};
+
+export { w3cSignatureIntegrity };

package/dist/esm/core/fragments/document-status/transferableRecords/transferableRecordVerifier.js

@@ -0,0 +1,105 @@
+import { OpenAttestationEthereumTokenRegistryStatusCode, CodedError, ValidTokenRegistryStatus } from '@tradetrust-tt/tt-verify';
+import * as w3cVC from '@trustvc/w3c-vc';
+import { isTokenMintedOnRegistry } from './utils';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const TRANSFERABLE_RECORDS_TYPE = "TransferableRecords";
+const type = "DOCUMENT_STATUS";
+const name = TRANSFERABLE_RECORDS_TYPE;
+const verify = /* @__PURE__ */ __name(async (document, options) => {
+  let signedDocument;
+  let tokenId;
+  if (w3cVC.isSignedDocument(document)) {
+    signedDocument = document;
+    tokenId = "0x" + signedDocument?.credentialStatus?.tokenId;
+  }
+  const credentialStatus = signedDocument?.credentialStatus;
+  if (!credentialStatus?.tokenRegistry) {
+    throw new CodedError(
+      "Document's credentialStatus does not have tokenRegistry",
+      OpenAttestationEthereumTokenRegistryStatusCode.UNRECOGNIZED_DOCUMENT,
+      OpenAttestationEthereumTokenRegistryStatusCode[OpenAttestationEthereumTokenRegistryStatusCode.UNRECOGNIZED_DOCUMENT]
+    );
+  }
+  if (!credentialStatus?.tokenNetwork || !credentialStatus?.tokenNetwork?.chainId) {
+    throw new CodedError(
+      "Document's credentialStatus does not have tokenNetwork.chainId",
+      OpenAttestationEthereumTokenRegistryStatusCode.UNRECOGNIZED_DOCUMENT,
+      OpenAttestationEthereumTokenRegistryStatusCode[OpenAttestationEthereumTokenRegistryStatusCode.UNRECOGNIZED_DOCUMENT]
+    );
+  }
+  const { provider } = options;
+  const mintStatus = await isTokenMintedOnRegistry({
+    tokenRegistryAddress: credentialStatus?.tokenRegistry,
+    tokenId,
+    provider
+  });
+  const result = {
+    name,
+    type,
+    status: "INVALID",
+    data: {
+      tokenRegistry: credentialStatus.tokenRegistry
+    }
+  };
+  if (ValidTokenRegistryStatus.guard(mintStatus)) {
+    result.status = "VALID";
+  } else {
+    result.reason = mintStatus.reason;
+  }
+  return result;
+}, "verify");
+const skip = /* @__PURE__ */ __name(async () => {
+  return {
+    status: "SKIPPED",
+    type,
+    name,
+    reason: {
+      code: OpenAttestationEthereumTokenRegistryStatusCode.SKIPPED,
+      codeString: OpenAttestationEthereumTokenRegistryStatusCode[OpenAttestationEthereumTokenRegistryStatusCode.SKIPPED],
+      message: `Document does not have TransferableRecords status`
+    }
+  };
+}, "skip");
+const test = /* @__PURE__ */ __name((document) => {
+  if (document?.credentialStatus?.type === TRANSFERABLE_RECORDS_TYPE) {
+    return true;
+  }
+  return false;
+}, "test");
+const credentialStatusTransferableRecordVerifier = {
+  skip,
+  test,
+  verify: /* @__PURE__ */ __name(async (...args) => {
+    try {
+      return await verify(...args);
+    } catch (e) {
+      if (e instanceof CodedError) {
+        const err = {
+          name,
+          type,
+          status: "ERROR",
+          reason: {
+            code: e.code,
+            codeString: e.codeString,
+            message: e.message
+          }
+        };
+        return err;
+      }
+      return {
+        name,
+        type,
+        status: "ERROR",
+        reason: {
+          code: OpenAttestationEthereumTokenRegistryStatusCode.UNEXPECTED_ERROR,
+          codeString: OpenAttestationEthereumTokenRegistryStatusCode[OpenAttestationEthereumTokenRegistryStatusCode.UNEXPECTED_ERROR],
+          message: e instanceof Error ? e.message : "An unexpected error occurred"
+        }
+      };
+    }
+  }, "verify")
+};
+
+export { TRANSFERABLE_RECORDS_TYPE, credentialStatusTransferableRecordVerifier };

package/dist/esm/core/fragments/document-status/transferableRecords/transferableRecordVerifier.types.js

@@ -0,0 +1 @@
+

package/dist/esm/core/fragments/document-status/transferableRecords/utils.js

@@ -0,0 +1,72 @@
+import { CodedError, OpenAttestationEthereumTokenRegistryStatusCode } from '@tradetrust-tt/tt-verify';
+import { TradeTrustToken__factory } from '@tradetrust-tt/token-registry/dist/contracts';
+import { errors, constants } from 'ethers';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isNonExistentToken = /* @__PURE__ */ __name((error) => {
+  const message = error.message;
+  if (!message) {
+    return error.data && error.data.slice(0, 10) === "0x7e273289";
+  }
+  return message.includes("owner query for nonexistent token");
+}, "isNonExistentToken");
+const isMissingTokenRegistry = /* @__PURE__ */ __name((error) => {
+  return !error.reason && error.method?.toLowerCase() === "ownerOf(uint256)".toLowerCase() && error.code === errors.CALL_EXCEPTION;
+}, "isMissingTokenRegistry");
+const decodeError = /* @__PURE__ */ __name((error) => {
+  const reason = error.reason && Array.isArray(error.reason) ? error.reason[0] : error.reason ?? "";
+  switch (true) {
+    case isNonExistentToken(error):
+      return `Document has not been issued under token registry`;
+    case isMissingTokenRegistry(error):
+      return `Token registry is not found`;
+    case (reason.toLowerCase() === "ENS name not configured".toLowerCase() && error.code === errors.UNSUPPORTED_OPERATION):
+      return "ENS name is not configured";
+    case (reason.toLowerCase() === "invalid address".toLowerCase() && error.code === errors.INVALID_ARGUMENT):
+      return `Invalid token registry address`;
+    case error.code === errors.INVALID_ARGUMENT:
+      return `Invalid contract arguments`;
+    case error.code === errors.SERVER_ERROR:
+    case error.code === errors.NETWORK_ERROR:
+      throw new CodedError(
+        "Unable to connect to the network, please try again later",
+        OpenAttestationEthereumTokenRegistryStatusCode.SERVER_ERROR,
+        OpenAttestationEthereumTokenRegistryStatusCode[OpenAttestationEthereumTokenRegistryStatusCode.SERVER_ERROR]
+      );
+    default:
+      throw error;
+  }
+}, "decodeError");
+const isTokenMintedOnRegistry = /* @__PURE__ */ __name(async ({
+  tokenRegistryAddress,
+  tokenId,
+  provider
+}) => {
+  try {
+    const tokenRegistryContract = TradeTrustToken__factory.connect(tokenRegistryAddress, provider);
+    const minted = await tokenRegistryContract.ownerOf(tokenId).then((owner) => owner !== constants.AddressZero);
+    return minted ? { minted, address: tokenRegistryAddress } : {
+      minted,
+      address: tokenRegistryAddress,
+      reason: {
+        code: OpenAttestationEthereumTokenRegistryStatusCode.DOCUMENT_NOT_MINTED,
+        codeString: OpenAttestationEthereumTokenRegistryStatusCode[OpenAttestationEthereumTokenRegistryStatusCode.DOCUMENT_NOT_MINTED],
+        message: `Document ${tokenId} has not been issued under contract ${tokenRegistryAddress}`
+      }
+    };
+  } catch (error) {
+    return {
+      minted: false,
+      address: tokenRegistryAddress,
+      reason: {
+        message: decodeError(error),
+        // message: (error as Error).message,
+        code: OpenAttestationEthereumTokenRegistryStatusCode.DOCUMENT_NOT_MINTED,
+        codeString: OpenAttestationEthereumTokenRegistryStatusCode[OpenAttestationEthereumTokenRegistryStatusCode.DOCUMENT_NOT_MINTED]
+      }
+    };
+  }
+}, "isTokenMintedOnRegistry");
+
+export { decodeError, isTokenMintedOnRegistry };

package/dist/esm/core/fragments/document-status/w3cCredentialStatus.js

@@ -0,0 +1,52 @@
+import { verifyCredentialStatus } from '@trustvc/w3c-vc';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const w3cCredentialStatus = {
+  skip: /* @__PURE__ */ __name(async () => {
+    return {
+      type: "DOCUMENT_STATUS",
+      name: "W3CCredentialStatus",
+      reason: {
+        code: 0,
+        codeString: "SKIPPED",
+        message: `Document does not have a valid credentialStatus or type.`
+      },
+      status: "SKIPPED"
+    };
+  }, "skip"),
+  test: /* @__PURE__ */ __name((document) => {
+    const doc = document;
+    return doc.credentialStatus?.type === "StatusList2021Entry";
+  }, "test"),
+  verify: /* @__PURE__ */ __name(async (document) => {
+    const doc = document;
+    const verificationResult = await verifyCredentialStatus(doc.credentialStatus);
+    if (verificationResult.error) {
+      return {
+        type: "DOCUMENT_STATUS",
+        name: "W3CCredentialStatus",
+        reason: {
+          message: verificationResult.error
+        },
+        status: "ERROR"
+      };
+    } else if (verificationResult.status === true) {
+      return {
+        type: "DOCUMENT_STATUS",
+        name: "W3CCredentialStatus",
+        data: false,
+        status: "INVALID"
+      };
+    } else {
+      return {
+        type: "DOCUMENT_STATUS",
+        name: "W3CCredentialStatus",
+        data: true,
+        status: "VALID"
+      };
+    }
+  }, "verify")
+};
+
+export { w3cCredentialStatus };

package/dist/esm/core/fragments/issuer-identity/w3cIssuerIdentity.js

@@ -0,0 +1,72 @@
+import { Resolver } from 'did-resolver';
+import { getResolver } from 'web-did-resolver';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const checkDidWebResolve = /* @__PURE__ */ __name(async (did) => {
+  try {
+    const resolver = new Resolver({
+      ...getResolver()
+    });
+    const didDocument = await resolver.resolve(did);
+    if (!didDocument || !didDocument.didDocument) {
+      throw new Error(`Failed to resolve DID: ${did}`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}, "checkDidWebResolve");
+const w3cIssuerIdentity = {
+  skip: /* @__PURE__ */ __name(async () => {
+    return {
+      type: "ISSUER_IDENTITY",
+      name: "W3CIssuerIdentity",
+      reason: {
+        code: 0,
+        codeString: "SKIPPED",
+        message: `Document has no issuer field.`
+      },
+      status: "SKIPPED"
+    };
+  }, "skip"),
+  test: /* @__PURE__ */ __name((document) => {
+    const doc = document;
+    return Boolean(doc.issuer);
+  }, "test"),
+  verify: /* @__PURE__ */ __name(async (document) => {
+    const doc = document;
+    if (doc.proof?.verificationMethod?.split("#")[0] !== doc.issuer) {
+      return {
+        type: "ISSUER_IDENTITY",
+        name: "W3CIssuerIdentity",
+        data: false,
+        reason: {
+          message: `Issuer and verification method do not match.`
+        },
+        status: "INVALID"
+      };
+    }
+    const resolutionResult = await checkDidWebResolve(doc.issuer);
+    if (resolutionResult) {
+      return {
+        type: "ISSUER_IDENTITY",
+        name: "W3CIssuerIdentity",
+        data: true,
+        status: "VALID"
+      };
+    } else {
+      return {
+        type: "ISSUER_IDENTITY",
+        name: "W3CIssuerIdentity",
+        data: false,
+        reason: {
+          message: `The DID cannot be resolved.`
+        },
+        status: "INVALID"
+      };
+    }
+  }, "verify")
+};
+
+export { w3cIssuerIdentity };

package/dist/esm/core/index.js

@@ -0,0 +1,3 @@
+export * from './verify';
+export * from './encrypt';
+export * from './decrypt';