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

package/README.md

@@ -0,0 +1,138 @@
+# TrustVC
+
+## About
+TrustVC is a wrapper library that facilitates the signing and verification of TrustVC W3C [Verifiable Credentials (VC)](https://github.com/TrustVC/w3c/tree/alpha) 1.0.0-alpha, adhering to the W3C [VC](https://www.w3.org/TR/vc-data-model/) Data Model v1.1 and OpenAttestation [Verifiable Documents (VD)](https://github.com/Open-Attestation/open-attestation/tree/beta) v6.10.0-beta.
+
+
+## Functions
+### 1. **Signing**
+
+> Independent signing function for TrustVC W3C VC and OpenAttestation VD
+
+  1. OpenAttestation Signing (signOA), supporting only OA Schema [v4](https://github.com/Open-Attestation/open-attestation/tree/beta/src/4.0)
+    
+  > [!NOTE]
+  > Do not confuse OA Schema V4 with OA package version.
+
+```ts
+import { wrapOA, signOA } from '@trustvc/trustvc';
+
+const rawDocument = {
+  '@context': [
+    'https://www.w3.org/ns/credentials/v2',
+    'https://schemata.openattestation.com/com/openattestation/4.0/context.json',
+  ],
+  type: ['VerifiableCredential', 'OpenAttestationCredential'],
+  credentialSubject: {
+    id: '0x1234567890123456789012345678901234567890',
+    name: 'John Doe',
+    country: 'SG',
+  },
+  issuer: {
+    id: 'did:ethr:0xB26B4941941C51a4885E5B7D3A1B861E54405f90',
+    type: 'OpenAttestationIssuer',
+    name: 'Government Technology Agency of Singapore (GovTech)',
+    identityProof: { identityProofType: 'DNS-DID', identifier: 'example.openattestation.com' },
+  },
+}
+
+const wrappedDocument = await wrapOA(rawDocument);
+
+const signedWrappedDocument = await signOA(wrappedDocument, {
+  public: 'did:ethr:0xB26B4941941C51a4885E5B7D3A1B861E54405f90#controller',
+  private: '<privateKey>',
+});
+```
+
+  2. TrustVC W3C Signing (signW3C)
+
+```ts
+import { signW3C } from '@trustvc/trustvc';
+import { VerificationType } from '@trustvc/w3c-issuer';
+
+const rawDocument = {
+  '@context': [
+    'https://www.w3.org/2018/credentials/v1',
+    'https://w3c-ccg.github.io/citizenship-vocab/contexts/citizenship-v1.jsonld',
+    'https://w3id.org/security/bbs/v1',
+    'https://w3id.org/vc/status-list/2021/v1',
+  ],
+  credentialStatus: {
+    id: 'https://trustvc.github.io/did/credentials/statuslist/1#1',
+    type: 'StatusList2021Entry',
+    statusPurpose: 'revocation',
+    statusListIndex: '10',
+    statusListCredential: 'https://trustvc.github.io/did/credentials/statuslist/1',
+  },
+  credentialSubject: {
+    name: 'TrustVC',
+    birthDate: '2024-04-01T12:19:52Z',
+    type: ['PermanentResident', 'Person'],
+  },
+  expirationDate: '2029-12-03T12:19:52Z',
+  issuer: 'did:web:trustvc.github.io:did:1',
+  type: ['VerifiableCredential'],
+  issuanceDate: '2024-04-01T12:19:52Z'
+}
+
+const signingResult = await signW3C(rawDocument, {
+  id: 'did:web:trustvc.github.io:did:1#keys-1',
+  controller: 'did:web:trustvc.github.io:did:1',
+  type: VerificationType.Bls12381G2Key2020,
+  publicKeyBase58:
+    'oRfEeWFresvhRtXCkihZbxyoi2JER7gHTJ5psXhHsdCoU1MttRMi3Yp9b9fpjmKh7bMgfWKLESiK2YovRd8KGzJsGuamoAXfqDDVhckxuc9nmsJ84skCSTijKeU4pfAcxeJ',
+  privateKeyBase58: '<privateKeyBase58>',
+});
+```
+
+### 2. **Verifying**
+
+> Single verifying function to simplify the process
+
+  1. Verify
+
+```ts
+import { verifyDocument } from '@trustvc/trustvc';
+
+const signedDocument = {
+  '@context': [
+    'https://www.w3.org/2018/credentials/v1',
+    'https://w3c-ccg.github.io/citizenship-vocab/contexts/citizenship-v1.jsonld',
+    'https://w3id.org/security/bbs/v1',
+    'https://w3id.org/vc/status-list/2021/v1',
+  ],
+  credentialStatus: {
+    id: 'https://trustvc.github.io/did/credentials/statuslist/1#1',
+    type: 'StatusList2021Entry',
+    statusPurpose: 'revocation',
+    statusListIndex: '10',
+    statusListCredential: 'https://trustvc.github.io/did/credentials/statuslist/1',
+  },
+  credentialSubject: {
+    name: 'TrustVC',
+    birthDate: '2024-04-01T12:19:52Z',
+    type: ['PermanentResident', 'Person'],
+  },
+  expirationDate: '2029-12-03T12:19:52Z',
+  issuer: 'did:web:trustvc.github.io:did:1',
+  type: ['VerifiableCredential'],
+  issuanceDate: '2024-04-01T12:19:52Z',
+  proof: {
+    type: 'BbsBlsSignature2020',
+    created: '2024-10-14T04:11:49Z',
+    proofPurpose: 'assertionMethod',
+    proofValue:
+      'l79dlFQMowalep+WCFqgCvpVBcCAr0GDEFUV6S7gRVY/TQ+sp/wcwaT61PaD19rJYUHlKfzccE4m7waZyoLEkBLFiK2g54Q2i+CdtYBgDdkUDsoULSBMcH1MwGHwdjfXpldFNFrHFx/IAvLVniyeMQ==',
+    verificationMethod: 'did:web:trustvc.github.io:did:1#keys-1',
+  },
+}
+
+const resultFragments = await verifyDocument(signedDocument);
+```
+
+## Running the code
+```
+npm install
+npm run build
+npm run test
+```

package/dist/config.d.mts

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

package/dist/config.d.ts

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

package/dist/config.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const DEFAULT_KEY = "4d5a4e3f2f6d2b0a1f2e9b8f8a3c7a0b8d4f5c2e7b1a1c3f2e7b8c2d5a4f7e3e";
+
+exports.DEFAULT_KEY = DEFAULT_KEY;

package/dist/core/decrypt.d.mts

@@ -0,0 +1,3 @@
+declare function decrypt(encryptedMessage: string, key: string, nonce?: string): string;
+
+export { decrypt };

package/dist/core/decrypt.d.ts

@@ -0,0 +1,3 @@
+declare function decrypt(encryptedMessage: string, key: string, nonce?: string): string;
+
+export { decrypt };

package/dist/core/decrypt.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var config = require('../config');
+var stringUtils = require('../utils/stringUtils');
+var tsChacha20 = require('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 : config.DEFAULT_KEY;
+  key = stringUtils.generate32ByteKey(key);
+  nonce = stringUtils.generate12ByteNonce(nonce ?? "");
+  const keyBuffer = stringUtils.stringToUint8Array(key);
+  const nonceBuffer = stringUtils.stringToUint8Array(nonce);
+  const chacha20 = new tsChacha20.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");
+
+exports.decrypt = decrypt;

package/dist/core/encrypt.d.mts

@@ -0,0 +1,3 @@
+declare function encrypt(message: string, key: string, nonce?: string): string;
+
+export { encrypt };

package/dist/core/encrypt.d.ts

@@ -0,0 +1,3 @@
+declare function encrypt(message: string, key: string, nonce?: string): string;
+
+export { encrypt };

package/dist/core/encrypt.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var config = require('../config');
+var stringUtils = require('../utils/stringUtils');
+var tsChacha20 = require('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 : config.DEFAULT_KEY;
+  key = stringUtils.generate32ByteKey(key);
+  nonce = stringUtils.generate12ByteNonce(nonce ?? "");
+  const keyBuffer = stringUtils.stringToUint8Array(key);
+  const nonceBuffer = stringUtils.stringToUint8Array(nonce);
+  const chacha20 = new tsChacha20.Chacha20(keyBuffer, nonceBuffer);
+  const messageBuffer = stringUtils.stringToUint8Array(message);
+  const encrypted = chacha20.encrypt(messageBuffer);
+  return Buffer.from(encrypted).toString("hex");
+}
+__name(encrypt, "encrypt");
+
+exports.encrypt = encrypt;

package/dist/core/fragments/document-integrity/w3cSignatureIntegrity.d.mts

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

package/dist/core/fragments/document-integrity/w3cSignatureIntegrity.d.ts

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

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

@@ -0,0 +1,48 @@
+'use strict';
+
+var __ = require('../../..');
+
+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")
+};
+
+exports.w3cSignatureIntegrity = w3cSignatureIntegrity;

package/dist/core/fragments/document-status/transferableRecords/transferableRecordVerifier.d.mts

@@ -0,0 +1,7 @@
+import { VerifierType } from './transferableRecordVerifier.types.mjs';
+import '@tradetrust-tt/tt-verify';
+
+declare const TRANSFERABLE_RECORDS_TYPE = "TransferableRecords";
+declare const credentialStatusTransferableRecordVerifier: VerifierType;
+
+export { TRANSFERABLE_RECORDS_TYPE, credentialStatusTransferableRecordVerifier };

package/dist/core/fragments/document-status/transferableRecords/transferableRecordVerifier.d.ts

@@ -0,0 +1,7 @@
+import { VerifierType } from './transferableRecordVerifier.types.js';
+import '@tradetrust-tt/tt-verify';
+
+declare const TRANSFERABLE_RECORDS_TYPE = "TransferableRecords";
+declare const credentialStatusTransferableRecordVerifier: VerifierType;
+
+export { TRANSFERABLE_RECORDS_TYPE, credentialStatusTransferableRecordVerifier };

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

@@ -0,0 +1,128 @@
+'use strict';
+
+var ttVerify = require('@tradetrust-tt/tt-verify');
+var w3cVC = require('@trustvc/w3c-vc');
+var utils = require('./utils');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var w3cVC__namespace = /*#__PURE__*/_interopNamespace(w3cVC);
+
+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__namespace.isSignedDocument(document)) {
+    signedDocument = document;
+    tokenId = "0x" + signedDocument?.credentialStatus?.tokenId;
+  }
+  const credentialStatus = signedDocument?.credentialStatus;
+  if (!credentialStatus?.tokenRegistry) {
+    throw new ttVerify.CodedError(
+      "Document's credentialStatus does not have tokenRegistry",
+      ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.UNRECOGNIZED_DOCUMENT,
+      ttVerify.OpenAttestationEthereumTokenRegistryStatusCode[ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.UNRECOGNIZED_DOCUMENT]
+    );
+  }
+  if (!credentialStatus?.tokenNetwork || !credentialStatus?.tokenNetwork?.chainId) {
+    throw new ttVerify.CodedError(
+      "Document's credentialStatus does not have tokenNetwork.chainId",
+      ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.UNRECOGNIZED_DOCUMENT,
+      ttVerify.OpenAttestationEthereumTokenRegistryStatusCode[ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.UNRECOGNIZED_DOCUMENT]
+    );
+  }
+  const { provider } = options;
+  const mintStatus = await utils.isTokenMintedOnRegistry({
+    tokenRegistryAddress: credentialStatus?.tokenRegistry,
+    tokenId,
+    provider
+  });
+  const result = {
+    name,
+    type,
+    status: "INVALID",
+    data: {
+      tokenRegistry: credentialStatus.tokenRegistry
+    }
+  };
+  if (ttVerify.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: ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.SKIPPED,
+      codeString: ttVerify.OpenAttestationEthereumTokenRegistryStatusCode[ttVerify.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 ttVerify.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: ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.UNEXPECTED_ERROR,
+          codeString: ttVerify.OpenAttestationEthereumTokenRegistryStatusCode[ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.UNEXPECTED_ERROR],
+          message: e instanceof Error ? e.message : "An unexpected error occurred"
+        }
+      };
+    }
+  }, "verify")
+};
+
+exports.TRANSFERABLE_RECORDS_TYPE = TRANSFERABLE_RECORDS_TYPE;
+exports.credentialStatusTransferableRecordVerifier = credentialStatusTransferableRecordVerifier;

package/dist/core/fragments/document-status/transferableRecords/transferableRecordVerifier.types.d.mts

@@ -0,0 +1,30 @@
+import { OpenAttestationEthereumTokenRegistryStatusCode, VerificationFragment, ErrorVerificationFragment, Verifier } from '@tradetrust-tt/tt-verify';
+
+type TransferableRecordsErrorReason = {
+    code: OpenAttestationEthereumTokenRegistryStatusCode;
+    codeString: string;
+    message: string;
+};
+type TransferableRecordsResultFragment = VerificationFragment & {
+    status: 'VALID' | 'INVALID';
+    data: {
+        tokenRegistry: string;
+    };
+    reason?: TransferableRecordsErrorReason;
+};
+type TransferableRecordsErrorFragment = Omit<ErrorVerificationFragment<never>, 'data'> & {
+    data?: never;
+    reason: TransferableRecordsErrorReason;
+};
+type TransferableRecordsVerificationFragment = TransferableRecordsResultFragment | TransferableRecordsErrorFragment;
+type VerifierType = Verifier<TransferableRecordsVerificationFragment>;
+type TransferableRecordCredentialStatus = {
+    type: 'TransferableRecords';
+    tokenRegistry: string;
+    tokenNetwork: {
+        chainId: number;
+        name: string;
+    };
+};
+
+export type { TransferableRecordCredentialStatus, TransferableRecordsErrorFragment, TransferableRecordsErrorReason, TransferableRecordsResultFragment, TransferableRecordsVerificationFragment, VerifierType };

package/dist/core/fragments/document-status/transferableRecords/transferableRecordVerifier.types.d.ts

@@ -0,0 +1,30 @@
+import { OpenAttestationEthereumTokenRegistryStatusCode, VerificationFragment, ErrorVerificationFragment, Verifier } from '@tradetrust-tt/tt-verify';
+
+type TransferableRecordsErrorReason = {
+    code: OpenAttestationEthereumTokenRegistryStatusCode;
+    codeString: string;
+    message: string;
+};
+type TransferableRecordsResultFragment = VerificationFragment & {
+    status: 'VALID' | 'INVALID';
+    data: {
+        tokenRegistry: string;
+    };
+    reason?: TransferableRecordsErrorReason;
+};
+type TransferableRecordsErrorFragment = Omit<ErrorVerificationFragment<never>, 'data'> & {
+    data?: never;
+    reason: TransferableRecordsErrorReason;
+};
+type TransferableRecordsVerificationFragment = TransferableRecordsResultFragment | TransferableRecordsErrorFragment;
+type VerifierType = Verifier<TransferableRecordsVerificationFragment>;
+type TransferableRecordCredentialStatus = {
+    type: 'TransferableRecords';
+    tokenRegistry: string;
+    tokenNetwork: {
+        chainId: number;
+        name: string;
+    };
+};
+
+export type { TransferableRecordCredentialStatus, TransferableRecordsErrorFragment, TransferableRecordsErrorReason, TransferableRecordsResultFragment, TransferableRecordsVerificationFragment, VerifierType };

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

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/fragments/document-status/transferableRecords/utils.d.mts

@@ -0,0 +1,18 @@
+import { ValidTokenRegistryStatus, InvalidTokenRegistryStatus } from '@tradetrust-tt/tt-verify';
+import { providers, errors } from 'ethers';
+
+type EthersError = {
+    message?: string;
+    data?: string;
+    method?: string;
+    reason?: string;
+    code?: errors;
+};
+declare const decodeError: (error: EthersError) => "Document has not been issued under token registry" | "Token registry is not found" | "ENS name is not configured" | "Invalid token registry address" | "Invalid contract arguments";
+declare const isTokenMintedOnRegistry: ({ tokenRegistryAddress, tokenId, provider, }: {
+    tokenRegistryAddress: string;
+    tokenId: string;
+    provider: providers.Provider;
+}) => Promise<ValidTokenRegistryStatus | InvalidTokenRegistryStatus>;
+
+export { decodeError, isTokenMintedOnRegistry };

package/dist/core/fragments/document-status/transferableRecords/utils.d.ts

@@ -0,0 +1,18 @@
+import { ValidTokenRegistryStatus, InvalidTokenRegistryStatus } from '@tradetrust-tt/tt-verify';
+import { providers, errors } from 'ethers';
+
+type EthersError = {
+    message?: string;
+    data?: string;
+    method?: string;
+    reason?: string;
+    code?: errors;
+};
+declare const decodeError: (error: EthersError) => "Document has not been issued under token registry" | "Token registry is not found" | "ENS name is not configured" | "Invalid token registry address" | "Invalid contract arguments";
+declare const isTokenMintedOnRegistry: ({ tokenRegistryAddress, tokenId, provider, }: {
+    tokenRegistryAddress: string;
+    tokenId: string;
+    provider: providers.Provider;
+}) => Promise<ValidTokenRegistryStatus | InvalidTokenRegistryStatus>;
+
+export { decodeError, isTokenMintedOnRegistry };

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

@@ -0,0 +1,75 @@
+'use strict';
+
+var ttVerify = require('@tradetrust-tt/tt-verify');
+var contracts = require('@tradetrust-tt/token-registry/dist/contracts');
+var ethers = require('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 === ethers.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 === ethers.errors.UNSUPPORTED_OPERATION):
+      return "ENS name is not configured";
+    case (reason.toLowerCase() === "invalid address".toLowerCase() && error.code === ethers.errors.INVALID_ARGUMENT):
+      return `Invalid token registry address`;
+    case error.code === ethers.errors.INVALID_ARGUMENT:
+      return `Invalid contract arguments`;
+    case error.code === ethers.errors.SERVER_ERROR:
+    case error.code === ethers.errors.NETWORK_ERROR:
+      throw new ttVerify.CodedError(
+        "Unable to connect to the network, please try again later",
+        ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.SERVER_ERROR,
+        ttVerify.OpenAttestationEthereumTokenRegistryStatusCode[ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.SERVER_ERROR]
+      );
+    default:
+      throw error;
+  }
+}, "decodeError");
+const isTokenMintedOnRegistry = /* @__PURE__ */ __name(async ({
+  tokenRegistryAddress,
+  tokenId,
+  provider
+}) => {
+  try {
+    const tokenRegistryContract = contracts.TradeTrustToken__factory.connect(tokenRegistryAddress, provider);
+    const minted = await tokenRegistryContract.ownerOf(tokenId).then((owner) => owner !== ethers.constants.AddressZero);
+    return minted ? { minted, address: tokenRegistryAddress } : {
+      minted,
+      address: tokenRegistryAddress,
+      reason: {
+        code: ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.DOCUMENT_NOT_MINTED,
+        codeString: ttVerify.OpenAttestationEthereumTokenRegistryStatusCode[ttVerify.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: ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.DOCUMENT_NOT_MINTED,
+        codeString: ttVerify.OpenAttestationEthereumTokenRegistryStatusCode[ttVerify.OpenAttestationEthereumTokenRegistryStatusCode.DOCUMENT_NOT_MINTED]
+      }
+    };
+  }
+}, "isTokenMintedOnRegistry");
+
+exports.decodeError = decodeError;
+exports.isTokenMintedOnRegistry = isTokenMintedOnRegistry;

package/dist/core/fragments/document-status/w3cCredentialStatus.d.mts

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

package/dist/core/fragments/document-status/w3cCredentialStatus.d.ts

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