@trustvc/trustvc 1.4.4 → 1.4.6

package/dist/cjs/core/endorsement-chain/helpers.js

@@ -55,8 +55,8 @@ const mergeTransfersV5 = /* @__PURE__ */ __name((transferEvents) => {
     if (groupedEvents.length === 1) return groupedEvents;
     if (groupedEvents.length > 1) {
       const { owner, holder } = getHolderOwner(groupedEvents);
-      const base = groupedEvents[0];
       const type = identifyEventTypeFromLogs(groupedEvents);
+      const base = groupedEvents.find((event) => event.type === type) ?? groupedEvents[0];
       return [{ ...base, owner, holder, type }];
     }
     throw new Error("Invalid hash, update your configuration");

package/dist/esm/core/endorsement-chain/helpers.js

@@ -53,8 +53,8 @@ const mergeTransfersV5 = /* @__PURE__ */ __name((transferEvents) => {
     if (groupedEvents.length === 1) return groupedEvents;
     if (groupedEvents.length > 1) {
       const { owner, holder } = getHolderOwner(groupedEvents);
-      const base = groupedEvents[0];
       const type = identifyEventTypeFromLogs(groupedEvents);
+      const base = groupedEvents.find((event) => event.type === type) ?? groupedEvents[0];
       return [{ ...base, owner, holder, type }];
     }
     throw new Error("Invalid hash, update your configuration");

package/dist/types/core/decrypt.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Decrypts a message that was encrypted using the ChaCha20 algorithm.
+ *
+ * This function takes an encrypted message (in base64 format), converts it back to a buffer,
+ * and decrypts it using the ChaCha20 stream cipher. The decryption key is processed to ensure it's
+ * 32 bytes in length, and the nonce (initialization vector) is either provided or generated as 12 bytes.
+ * @param {string} encryptedMessage - The encrypted message to be decrypted, in base64 format.
+ * @param {string} key - The decryption key, which will be processed into a 32-byte key.
+ * @param {string} [nonce] - (Optional) A 12-byte nonce used during the encryption process. If not provided, one will be generated.
+ * @returns {string} - The decrypted message in UTF-8 format.
+ * @throws {Error} - Throws if the decryption process encounters any issues.
+ */
 declare function decrypt(encryptedMessage: string, key: string, nonce?: string): string;
 
 export { decrypt };

package/dist/types/core/documentBuilder.d.ts

@@ -1,22 +1,46 @@
 import { PrivateKeyPair } from '@trustvc/w3c-issuer';
 import { VerifiableCredential, SignedVerifiableCredential } from '@trustvc/w3c-vc';
 
+/**
+ * Configuration for a W3C Verifiable Document using a Bitstring Status List.
+ * @property {string} url - A Verifiable Credential (VC) representing the Bitstring Status List,
+ * typically used for revocation or suspension checks.
+ * @property {number} index - The position within the Bitstring Status List that corresponds
+ * to the credential's status.
+ * @property {string} [purpose] - (Optional) The intended use or role of this status entry.
+ */
 interface W3CVerifiableDocumentConfig {
     url: string;
     index: number;
     purpose?: string;
 }
+/**
+ * Configuration for W3C Transferable Records, including blockchain details and token registry information.
+ * @property {string} chain - The name of the blockchain network (e.g., "Ethereum", "Polygon").
+ * @property {number} chainId - The unique identifier of the blockchain network.
+ * @property {string} tokenRegistry - The smart contract address of the token registry.
+ * @property {string} rpcProviderUrl - The RPC endpoint URL for interacting with the blockchain.
+ */
 interface W3CTransferableRecordsConfig {
     chain: string;
     chainId: number;
     tokenRegistry: string;
     rpcProviderUrl: string;
 }
+/**
+ * Configuration for the rendering method used in a Verifiable Credential document.
+ * @property {string} id - A unique identifier for the rendering method, typically a URL or URI.
+ * @property {string} type - The type of the renderer, which specifies the method of rendering (e.g., 'EMBEDDED_RENDERER').
+ * @property {string} templateName - The name of the template to be used for rendering, e.g., 'BILL_OF_LADING'.
+ */
 interface RenderMethod {
     id: string;
     type: string;
     templateName: string;
 }
+/**
+ * Main class responsible for building, configuring, and signing documents with credential statuses.
+ */
 declare class DocumentBuilder {
     private document;
     private documentType;
@@ -25,6 +49,11 @@ declare class DocumentBuilder {
     private rpcProviderUrl;
     private requiredFields;
     private isSigned;
+    /**
+     * Constructor to initialize the document builder.
+     * @param {Partial<VerifiableCredential>} input - The input document.
+     * @param {string} [documentType] - The type of the document (default is "w3c").
+     */
     constructor(input: Partial<VerifiableCredential>, documentType?: string);
     credentialSubject(subject: Partial<VerifiableCredential>): this;
     credentialStatus(config: W3CTransferableRecordsConfig | W3CVerifiableDocumentConfig): this;

package/dist/types/core/encrypt.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Encrypts a message using the ChaCha20 encryption algorithm with a given key and nonce.
+ *
+ * This function takes a plaintext message, converts it to a buffer, and encrypts it using
+ * the ChaCha20 stream cipher. The encryption key is processed to ensure it's 32 bytes in length,
+ * and the nonce (initialization vector) is either provided or generated as 12 bytes.
+ * @param {string} message - The plaintext message to be encrypted.
+ * @param {string} key - The encryption key, which will be processed into a 32-byte key.
+ * @param {string} [nonce] - (Optional) A 12-byte nonce to be used for the encryption. If not provided, one will be generated.
+ * @returns {string} - The encrypted message in base64 format.
+ * @throws {Error} - Throws if the encryption process encounters any issues.
+ */
 declare function encrypt(message: string, key: string, nonce?: string): string;
 
 export { encrypt };

package/dist/types/core/endorsement-chain/useEndorsementChain.d.ts

@@ -19,6 +19,11 @@ interface TitleEscrowVersionParams {
     versionInterface: string;
     provider: Provider | ethers.Provider;
 }
+/**
+ * To provide (tokenRegistryAddress and tokenId) or (titleEscrowAddress)
+ * @param {TitleEscrowVersionParams} params - TitleEscrowVersionParams
+ * @returns {Promise<boolean>} - return true if titleEscrow matches supportInterface
+ */
 declare const isTitleEscrowVersion: ({ tokenRegistryAddress, tokenId, titleEscrowAddress, versionInterface, provider, }: TitleEscrowVersionParams) => Promise<boolean>;
 declare const fetchEndorsementChain: (tokenRegistryAddress: string, tokenId: string, provider: Provider | ethers.Provider, keyId?: string) => Promise<EndorsementChain>;
 

package/dist/types/core/verify.d.ts

@@ -6,9 +6,30 @@ type VerificationBuilderOptions = {
     documentLoader?: DocumentLoader;
 };
 interface VerifyDocumentParams {
+    /**
+     * @deprecated
+     * Use { rpcProviderUrl?: string, documentLoader?: DocumentLoader } object instead
+     */
     (document: DocumentsToVerify | SignedVerifiableCredential, options: string): Promise<VerificationFragment[]>;
     (document: DocumentsToVerify | SignedVerifiableCredential, options?: VerificationBuilderOptions): Promise<VerificationFragment[]>;
 }
+/**
+ * Asynchronously verifies a document (OpenAttestation or W3C Verifiable Credential) using a specified Ethereum-compatible JSON-RPC provider.
+ *
+ * This function builds a verification process that can handle both OpenAttestation documents and W3C Verifiable Credentials.
+ * For OpenAttestation, it uses OpenAttestation's verifiers and DID identity proof. For W3C Verifiable Credentials,
+ * it verifies signatures, credential status, and issuer identity.
+ *
+ * The function takes an Ethereum-compatible JSON-RPC provider URL, which allows the user to specify the network
+ * (e.g., Ethereum, Polygon) for DID resolution and verification tasks.
+ * @param {DocumentsToVerify | SignedVerifiableCredential} document - The document to be verified, either an OpenAttestation document or a W3C Verifiable Credential.
+ * @param {VerificationBuilderOptions} options - The options object containing the provider URL and document loader.
+ * @param {string} options.rpcProviderUrl - The Ethereum-compatible JSON-RPC provider URL (e.g., Infura, Alchemy, Polygon, etc.) to resolve DIDs and verify credentials.
+ * @param {DocumentLoader} options.documentLoader - The document loader to be used for loading JSON-LD contexts.
+ * @returns {Promise<VerificationFragment[]>} - A promise that resolves to an array of verification fragments,
+ *                                              detailing the results of various verification checks such as
+ *                                              signature integrity, credential status, issuer identity, etc.
+ */
 declare const verifyDocument: VerifyDocumentParams;
 
 export { verifyDocument };

package/dist/types/open-attestation/verify.d.ts

@@ -1,5 +1,16 @@
 import { v2, v3 } from '@tradetrust-tt/tradetrust';
 
+/**
+ * Asynchronously verifies the signature of an OpenAttestation wrapped document.
+ *
+ * This function checks if the provided document is of type v2, v3, or v4,
+ * and then verifies its signature for validity. It returns a boolean indicating
+ * whether the signature is valid. If the document type is not recognized,
+ * it will return false.
+ * @param {v2.WrappedDocument | v3.WrappedDocument} document - The OpenAttestation document to be verified.
+ * @returns {Promise<boolean>} - A promise that resolves to `true` if the document's signature is valid,
+ *                               and `false` if the document type is not recognized or if the signature is invalid.
+ */
 declare const verifyOASignature: (document: v2.WrappedDocument | v3.WrappedDocument) => Promise<boolean>;
 
 export { verifyOASignature };

package/dist/types/open-attestation/wrap.d.ts

@@ -1,9 +1,50 @@
 import { OpenAttestationDocument, WrappedDocument, v2 } from '@tradetrust-tt/tradetrust';
 export { __unsafe__use__it__at__your__own__risks__wrapDocument as wrapOADocumentV3, __unsafe__use__it__at__your__own__risks__wrapDocuments as wrapOADocumentsV3 } from '@tradetrust-tt/tradetrust';
 
+/**
+ * Asynchronously wraps a V2 OpenAttestation document.
+ *
+ * This function takes a OpenAttestation document and wraps it using the OpenAttestation
+ * library's `wrapOADocument` function. The function will throw any errors encountered during
+ * the wrapping process, as handled by the OpenAttestation library.
+ * @param {v2.OpenAttestationDocument} document - The OpenAttestation document to be wrapped.
+ * @returns {Promise<v2.WrappedDocument>} - A promise that resolves to the wrapped document.
+ * @throws {Error} - Any errors thrown by the `wrapOADocument` function will propagate naturally.
+ */
 declare const wrapOADocumentV2: <T extends v2.OpenAttestationDocument>(document: T) => Promise<v2.WrappedDocument<T>>;
+/**
+ * Asynchronously wraps multiple V2 OpenAttestation documents.
+ *
+ * Similar to the `wrapOADocumentV2` function, this function takes an array of OpenAttestation
+ * documents and wraps them using the OpenAttestation library's `wrapOADocuments` function. The
+ * function will throw any errors encountered during the wrapping process, as handled by the
+ * OpenAttestation library.
+ * @param {v2.OpenAttestationDocument[]} documents - The OpenAttestation documents to be wrapped.
+ * @returns {Promise<v2.WrappedDocument[]>} - A promise that resolves to the wrapped documents.
+ * @throws {Error} - Any errors thrown by the `wrapOADocuments` function will propagate naturally.
+ */
 declare const wrapOADocumentsV2: <T extends v2.OpenAttestationDocument>(documents: T[]) => Promise<v2.WrappedDocument<T>[]>;
+/**
+ * Asynchronously wraps a v2 / v3 OpenAttestation document.
+ *
+ * This function takes an OpenAttestation document and validates its version before wrapping it
+ * using the OpenAttestation library's `wrapOADocument` function. The function will throw any errors
+ * encountered during the wrapping process, as handled by the OpenAttestation library.
+ * @param {OpenAttestationDocument} document - The OpenAttestation document to be wrapped.
+ * @returns {Promise<WrappedDocument>} - A promise that resolves to the wrapped document.
+ * @throws {Error} - Any errors thrown by the `wrapOADocument` function will propagate naturally.
+ */
 declare function wrapOADocument<T extends OpenAttestationDocument>(document: T): Promise<WrappedDocument<T>>;
+/**
+ * Asynchronously wraps multiple v2 / v3 OpenAttestation documents.
+ *
+ * This function takes an array of OpenAttestation documents and validates their versions before wrapping them
+ * using the OpenAttestation library's `wrapOADocuments` function. The function will throw any errors
+ * encountered during the wrapping process, as handled by the OpenAttestation library.
+ * @param {OpenAttestationDocument[]} documents - The OpenAttestation documents to be wrapped.
+ * @returns {Promise<WrappedDocument[]>} - A promise that resolves to the wrapped documents.
+ * @throws {Error} - Any errors thrown by the `wrapOADocuments` function will propagate naturally.
+ */
 declare function wrapOADocuments<T extends OpenAttestationDocument>(documents: T[]): Promise<WrappedDocument<T>[]>;
 
 export { wrapOADocument, wrapOADocumentV2, wrapOADocuments, wrapOADocumentsV2 };

package/dist/types/utils/stringUtils/index.d.ts

@@ -1,5 +1,30 @@
+/**
+ * Converts a string into a Uint8Array.
+ *
+ * This function takes a string input and uses the `Uint8Array` API to encode it into a
+ * Uint8Array, which is suitable for binary operations like encryption.
+ * @param {string} str - The string to be converted into a Uint8Array.
+ * @returns {Uint8Array} - The encoded Uint8Array representation of the input string.
+ */
 declare function stringToUint8Array(str: string): Uint8Array;
+/**
+ * Generates a 32-byte key by hashing the input string.
+ *
+ * This function uses the SHAKE256 hash function to generate a 128-bit (32-byte) key
+ * from the given input string. SHAKE256 is a cryptographic hash function that produces
+ * variable-length output.
+ * @param {string} input - The input string to be hashed into a 32-byte key.
+ * @returns {string} - A 32-byte hash of the input string, suitable for use as an encryption key.
+ */
 declare function generate32ByteKey(input: string): string;
+/**
+ * Generates a 12-byte nonce by hashing the input string.
+ *
+ * This function uses the SHAKE256 hash function to generate a 48-bit (12-byte) nonce
+ * from the given input string. The nonce is used as an initialization vector in encryption.
+ * @param {string} input - The input string to be hashed into a 12-byte nonce.
+ * @returns {string} - A 12-byte hash of the input string, suitable for use as a nonce.
+ */
 declare function generate12ByteNonce(input: string): string;
 
 export { generate12ByteNonce, generate32ByteKey, stringToUint8Array };

package/dist/types/w3c/sign.d.ts

@@ -1,6 +1,13 @@
 import { RawVerifiableCredential, SigningResult } from '@trustvc/w3c-vc';
 import { PrivateKeyPair } from '@trustvc/w3c-issuer';
 
+/**
+ * Signs a W3C Verifiable Credential using the provided cryptographic suite and key pair.
+ * @param {RawVerifiableCredential} credential - The verifiable credential object that needs to be signed.
+ * @param {PrivateKeyPair} keyPair - The private and public key pair used for signing the credential.
+ * @param {string} [cryptoSuite='BbsBlsSignature2020'] - The cryptographic suite to be used for signing (default is 'BbsBlsSignature2020').
+ * @returns {Promise<SigningResult>} A promise that resolves to the result of the signing operation, which includes the signed credential.
+ */
 declare const signW3C: (credential: RawVerifiableCredential, keyPair: PrivateKeyPair, cryptoSuite?: string) => Promise<SigningResult>;
 
 export { signW3C };

package/dist/types/w3c/verify.d.ts

@@ -1,5 +1,12 @@
 import { SignedVerifiableCredential, DocumentLoader, VerificationResult } from '@trustvc/w3c-vc';
 
+/**
+ * Verifies the signature of a W3C Verifiable Credential.
+ * @param {SignedVerifiableCredential} credential - The signed verifiable credential that needs to be verified.
+ * @param {object} options - Optional value
+ * @param {DocumentLoader} options.documentLoader - The document loader to be used for loading JSON-LD contexts / did.
+ * @returns {Promise<VerificationResult>} A promise that resolves to the verification result, indicating whether the credential is valid.
+ */
 declare const verifyW3CSignature: (credential: SignedVerifiableCredential, options?: {
     documentLoader?: DocumentLoader;
 }) => Promise<VerificationResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustvc/trustvc",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "description": "TrustVC library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",