gdc-common-utils-ts 1.0.4 → 1.0.7

package/dist/utils/did.js

@@ -0,0 +1,123 @@
+// crypto-ts/utils/did.ts
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+/**
+ * Generates a DID Service ID fragment from a selector object.
+ * The format is always `#<section>:<format>:<resourceType>:<action>`.
+ *
+ * This utility's only job is to correctly assemble the string. It contains no
+ * conditional logic about DID types, as that is handled by the data layer.
+ *
+ * @param selector The structured object containing the endpoint parts.
+ * @returns The formatted service ID fragment string.
+ */
+export function generateServiceId(selector) {
+    // Canonical casing:
+    // - `section`, `format`, `resourceType` are matched case-insensitively by the backend router,
+    //   and lowercasing them makes DID Document lookup deterministic across SDKs.
+    // - `action` is kept as-is (future actions may be case-sensitive identifiers).
+    const parts = [
+        selector.section?.toLowerCase(),
+        selector.format?.toLowerCase(),
+        selector.resourceType?.toLowerCase(),
+        selector.action,
+    ];
+    return `#${parts.filter(p => p).join(':')}`;
+}
+/**
+ * Normalizes a did:web string to a canonical format to prevent resolution errors
+ * due to case sensitivity in the path component of the underlying URL.
+ *
+ * The rule is:
+ * - All segments are lowercased, EXCEPT the final segment.
+ * - If the final segment represents a `system|code` pair (e.g., for a role),
+ *   the `system` part is lowercased, but the `code` is preserved as-is.
+ * - If the final segment is a unique identifier (like a Tax ID), it is preserved as-is.
+ *
+ * @param did The did:web string to normalize.
+ * @returns The canonicalized did:web string.
+ */
+export function normalizeDidWeb(did) {
+    const parts = did.split(':');
+    if (parts[0] !== 'did' || parts[1] !== 'web' || parts.length < 3) {
+        // Not a valid did:web, return as is.
+        return did;
+    }
+    // Lowercase all parts except the very last one.
+    const lowercasedParts = parts.slice(0, -1).map(part => part.toLowerCase());
+    let lastPart = parts[parts.length - 1];
+    // Special handling for the last part if it contains a role descriptor.
+    if (lastPart.includes('|')) {
+        const [system, ...codeParts] = lastPart.split('|');
+        const code = codeParts.join('|'); // Re-join in case the code itself has a pipe.
+        lastPart = `${system.toLowerCase()}|${code}`;
+    }
+    return [...lowercasedParts, lastPart].join(':');
+}
+/**
+* Encodes a hostname according to did:web spec (percent-encodes port colons).
+* @param apiUrl The full base URL of the API.
+* @returns The percent-encoded hostname.
+*/
+function getEncodedHost(apiUrl) {
+    try {
+        const parsedUrl = new URL(apiUrl);
+        return parsedUrl.host.replace(':', '%3A');
+    }
+    catch (e) {
+        console.error(`[getEncodedHost] Invalid apiUrl provided: ${apiUrl}`);
+        return 'localhost'; // Fallback
+    }
+}
+/**
+* Creates the deterministic "hosted" did:web for a tenant (Organization).
+*
+* @param hostDidWeb The DID of the host (e.g., 'did:web:host.example.com').
+* @param tenantAlternateName The alternate name of the tenant (e.g., 'acme').
+* @param context An object containing jurisdiction, version, and sector.
+* @returns The tenant's full, correctly formatted hosted did:web.
+*          Example: 'did:web:host.example.com:acme:cds-es:v1:health-care'
+*/
+export function createHostedDidWeb(hostDidWeb, tenantAlternateName, context) {
+    const hostPart = hostDidWeb.replace(/^did:web:/, '');
+    // The path in a did:web uses colons as separators.
+    const didPath = `cds-${context.jurisdiction}:${context.version}:${context.sector}`;
+    return `did:web:${hostPart}:${tenantAlternateName}:${didPath}`;
+}
+/**
+ * Builds the canonical details (URL and did:web URN) for a hosted DID.
+ * This is the single source of truth for constructing hosted identifiers in the app.
+ *
+ * @param options An object with the components of the DID.
+ * @param options.host The provider's domain (e.g., 'provider.com').
+ * @param options.alternateName The tenant's identifier (e.g., 'acme').
+ * @param options.jurisdiction The legal jurisdiction (defaults to 'ES').
+ * @param options.sector The business sector (defaults to 'health-care').
+ * @returns An object with the full URL (with trailing /) and the canonical did:web.
+ */
+export function buildHostedDidDetails({ host, alternateName, jurisdiction = 'ES', sector = 'health-care', }) {
+    // 1. Build the path part of the DID/URL.
+    const pathPart = `${alternateName}/cds-${jurisdiction}/v1/${sector}`;
+    // 2. Build the full URL, ensuring a trailing slash.
+    const url = `https://${host}/${pathPart}/`;
+    // 3. Build the canonical did:web, replacing / with :.
+    const hostAndPath = `${host}/${pathPart}`;
+    const did = `did:web:${hostAndPath.replace(/\//g, ':')}`;
+    return { did, url };
+}
+/**
+* Converts a did:web identifier into a full HTTPS or HTTP base URL with a trailing slash.
+* It correctly decodes percent-encoded ports for local development.
+* @param did The did:web string (e.g., 'did:web:example.com' or 'did:web:localhost%3A3000:acme:cds-es:v1:health-care').
+* @returns The full base URL (e.g., 'https://example.com/acme/cds-es/v1/health-care/').
+*/
+export function getBaseUrlFromDidWeb(did) {
+    const didParts = did.replace(/^did:web:/, '').split(':');
+    const domainPart = didParts[0];
+    const pathParts = didParts.slice(1);
+    const decodedDomain = decodeURIComponent(domainPart);
+    const protocol = decodedDomain.startsWith('localhost') ? 'http' : 'https';
+    const path = pathParts.join('/').replace(/cds-(es|us|gb)/, (match, p1) => `cds-${p1.toUpperCase()}`);
+    // Ensure a trailing slash for the base URL, without double slashes when no path is present.
+    const normalizedPath = path ? `${path}/` : '';
+    return `${protocol}://${decodedDomain}/${normalizedPath}`;
+}

package/dist/utils/format-converter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Normalizes a FHIR resource or Bundle into an array of entries.
+ */
+export declare const convertResourceDataToArrayOfDataEntries: (inputData: any, requestPath: string, webDomain: string) => any[];
+/**
+ * Converts a resource or a FHIR Bundle to a JSON:API Primary Document.
+ */
+export declare const convertResourceOrBundleToPrimaryDoc: (resourceData: any, specification: string, webDomain: string, requestPath: string) => any;
+/**
+ * Converts a JSON:API Primary Document back to a FHIR Bundle.
+ */
+export declare const convertPrimaryDocToBundleFHIR: (primaryDocument: any, bundleType: string) => any;
+/**
+ * Converts a FHIR Bundle containing one or more OperationOutcome entries into a
+ * compliant JSON:API Error Document. Each error entry in the bundle is mapped
+ * to a corresponding error object in the JSON:API `errors` array.
+ *
+ * @param errorBundle The FHIR Bundle representing the error(s).
+ * @returns A JSON:API document with a top-level `errors` array.
+ */
+export declare const convertFhirErrorBundleToJsonApiError: (errorBundle: any) => any;

package/dist/utils/format-converter.js

@@ -0,0 +1,109 @@
+// crypto-ts/utils/format-converter.ts
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { safelyJoinUrl } from "./url.js";
+/**
+ * Normalizes a FHIR resource or Bundle into an array of entries.
+ */
+export const convertResourceDataToArrayOfDataEntries = (inputData, requestPath, webDomain) => {
+    if (inputData.resourceType) { // It is FHIR data
+        if (inputData.resourceType === 'Bundle') {
+            return inputData.entry || [];
+        }
+        else {
+            const resourceIdentifier = inputData.id || (inputData.identifier && inputData.identifier[0]?.value) || "";
+            const fullUrl = safelyJoinUrl(webDomain, safelyJoinUrl(requestPath, resourceIdentifier));
+            return [{ fullUrl, resource: inputData }];
+        }
+    }
+    else { // Assume it's already a JSON:API-like object
+        const resourceIdentifier = inputData.id || "";
+        // const fullUrl = safelyJoinUrl(webDomain, safelyJoinUrl(requestPath, resourceIdentifier));
+        return [inputData];
+    }
+};
+/**
+ * Converts a resource or a FHIR Bundle to a JSON:API Primary Document.
+ */
+export const convertResourceOrBundleToPrimaryDoc = (resourceData, specification, webDomain, requestPath) => {
+    const entries = convertResourceDataToArrayOfDataEntries(resourceData, requestPath, webDomain);
+    // Handle FHIR entry structure vs. JSON:API data structure
+    const data = entries.map(entry => {
+        if (entry.resource) { // It's a FHIR entry
+            return {
+                type: `${specification}.${entry.resource.resourceType}`,
+                id: entry.resource.id,
+                attributes: { ...entry.resource }
+            };
+        }
+        return entry; // Assumes it's already a JSON:API resource object
+    });
+    return { data };
+};
+/**
+ * Converts a JSON:API Primary Document back to a FHIR Bundle.
+ */
+export const convertPrimaryDocToBundleFHIR = (primaryDocument, bundleType) => {
+    const entries = [];
+    if (primaryDocument.data) {
+        entries.push(...primaryDocument.data.map((jsonApiResourceObject) => ({
+            // fullUrl might need to be reconstructed based on context
+            resource: jsonApiResourceObject.attributes || jsonApiResourceObject
+        })));
+    }
+    if (primaryDocument.errors) {
+        entries.push(...primaryDocument.errors.map((errorObject) => ({
+            resource: {
+                resourceType: 'OperationOutcome',
+                id: errorObject.id,
+                issue: [{
+                        code: errorObject.status,
+                        severity: 'error',
+                        details: { text: errorObject.detail },
+                    }]
+            }
+        })));
+    }
+    return {
+        entry: entries,
+        resourceType: 'Bundle',
+        total: primaryDocument.data ? primaryDocument.data.length : 0,
+        type: bundleType
+    };
+};
+/**
+ * Converts a FHIR Bundle containing one or more OperationOutcome entries into a
+ * compliant JSON:API Error Document. Each error entry in the bundle is mapped
+ * to a corresponding error object in the JSON:API `errors` array.
+ *
+ * @param errorBundle The FHIR Bundle representing the error(s).
+ * @returns A JSON:API document with a top-level `errors` array.
+ */
+export const convertFhirErrorBundleToJsonApiError = (errorBundle) => {
+    if (!errorBundle.entry || errorBundle.entry.length === 0) {
+        return {
+            errors: [{
+                    status: '500',
+                    title: 'Unknown Error',
+                    detail: 'An unspecified error occurred and the error bundle was malformed or empty.'
+                }]
+        };
+    }
+    const errorObjects = errorBundle.entry.map((entry) => {
+        const resource = entry.resource || {};
+        const issue = resource.issue ? resource.issue[0] : {};
+        const title = issue.details?.text || 'Processing Error';
+        return {
+            id: resource.id,
+            status: entry.response?.status?.toString() || '500',
+            code: issue.code || 'processing-error',
+            title: title,
+            detail: issue.diagnostics || 'An error occurred while processing the request.',
+            meta: {
+                severity: issue.severity || 'error'
+            }
+        };
+    });
+    return {
+        errors: errorObjects
+    };
+};

package/dist/utils/index.js

@@ -0,0 +1,13 @@
+export * from './actor.js';
+export * from './base-convert.js';
+export * from './baseN.js';
+export * from './bundle.js';
+export * from './content.js';
+export * from './did.js';
+export * from './format-converter.js';
+export * from './jwt.js';
+export * from './manager-error.js';
+export * from './multibase58.js';
+export * from './multibasehash.js';
+export * from './normalize.js';
+export * from './object-convert.js';

package/dist/utils/jwt.d.ts

@@ -0,0 +1,52 @@
+import { DataCompactJWT, JwtCompactParts } from '../models/jwt';
+/**
+ * Splits a compact JWT string into its three parts.
+ * @param compactToken The compact JWT string.
+ * @returns A PartsJWT object or undefined if the format is invalid.
+ */
+export declare function getPartsJWT(compactToken: string | undefined): JwtCompactParts | undefined;
+/**
+ * Decodes the Base64Url header of a JWT into a JSON object.
+ * @param headerB64Url The Base64Url-encoded header string.
+ * @returns A JSON object representing the header claims.
+ */
+export declare function decodeHeader(headerB64Url: string): any;
+/**
+ * Decodes the payload of a JWT, decompressing it if necessary.
+ * @param payloadB64Url The Base64Url-encoded payload string.
+ * @param isDeflated True if the payload is compressed with DEFLATE.
+ * @returns The decoded payload as a JSON object.
+ */
+export declare function decodePayload(payloadB64Url: string, isDeflated?: boolean): Promise<object>;
+/**
+ * Fully decodes a compact JWT into a `DataCompactJWT` object with JSON headers and payload.
+ * @returns A (compact) JWT object or undefined if parsing fails.
+ */
+export declare function getDataJWT(compactJWT: string | undefined): Promise<DataCompactJWT | undefined>;
+/**
+ * Encodes a JSON object into a Base64Url string.
+ * @param header The header object.
+ * @returns The encoded string.
+ */
+export declare function encodeHeader(header: object): string;
+/**
+ * Encodes a JSON object into a Base64Url payload, compressing it if required.
+ * @param payload The payload object.
+ * @param deflate True to compress the payload with DEFLATE.
+ * @returns The encoded string.
+ */
+export declare function encodePayload(payload: object, deflate?: boolean): Promise<string>;
+/**
+ * Encodes a signature byte array into a Base64Url string.
+ * @param signatureBytes The signature bytes.
+ * @returns The encoded string, or an empty string if no signature is provided.
+ */
+export declare function encodeSignature(signatureBytes?: Uint8Array): string;
+/**
+ * Assembles a header, payload, and signature into a compact JWT string.
+ * @param header The header object.
+ * @param payload The payload object.
+ * @param signatureBytes The optional signature.
+ * @returns A compact JWT string.
+ */
+export declare function compactJWT(header: object, payload: object, signatureBytes?: Uint8Array): Promise<string>;

package/dist/utils/jwt.js

@@ -0,0 +1,153 @@
+// crypto-ts/utils/jwt.ts
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+// Use `import * as pako` to ensure compatibility with CommonJS/ESM module resolution.
+// This resolves a stubborn TypeScript error (`esModuleInterop`) during testing.
+import * as pako from 'pako';
+import { Content } from './content.js';
+// --- JWT Parsing and Decoding ---
+/**
+ * Splits a compact JWT string into its three parts.
+ * @param compactToken The compact JWT string.
+ * @returns A PartsJWT object or undefined if the format is invalid.
+ */
+export function getPartsJWT(compactToken) {
+    if (!compactToken) {
+        return undefined;
+    }
+    const parts = compactToken.split('.');
+    if (parts.length !== 3) {
+        return undefined;
+    }
+    return {
+        protected: parts[0],
+        payload: parts[1],
+        signature: parts[2],
+    };
+}
+/**
+ * Decodes the Base64Url header of a JWT into a JSON object.
+ * @param headerB64Url The Base64Url-encoded header string.
+ * @returns A JSON object representing the header claims.
+ */
+export function decodeHeader(headerB64Url) {
+    try {
+        const headerBytes = Content.base64ToBytes(headerB64Url);
+        const headerString = Content.bytesToStringASCII(headerBytes);
+        return JSON.parse(headerString);
+    }
+    catch (e) {
+        console.error(`Cannot decode JWT header: ${e}`);
+        return {};
+    }
+}
+/**
+ * Decodes the payload of a JWT, decompressing it if necessary.
+ * @param payloadB64Url The Base64Url-encoded payload string.
+ * @param isDeflated True if the payload is compressed with DEFLATE.
+ * @returns The decoded payload as a JSON object.
+ */
+export async function decodePayload(payloadB64Url, isDeflated) {
+    try {
+        let payloadBytes = Content.base64ToBytes(payloadB64Url);
+        if (isDeflated) {
+            payloadBytes = pako.inflate(payloadBytes);
+        }
+        // CRITICAL: The output of a decompression library like pako is a raw binary
+        // stream. It is NOT guaranteed to be valid UTF-8. Using the strict
+        // `bytesToStringUTF8` can fail. `bytesToStringASCII` is a more permissive
+        // decoder that is robust enough to handle this binary data and convert it
+        // to a string that can be safely parsed by `JSON.parse()`.
+        const payloadString = Content.bytesToStringASCII(payloadBytes);
+        return JSON.parse(payloadString);
+    }
+    catch (e) {
+        console.error(`Cannot decode JWT payload: ${e}`);
+        return {};
+    }
+}
+/**
+ * Fully decodes a compact JWT into a `DataCompactJWT` object with JSON headers and payload.
+ * @returns A (compact) JWT object or undefined if parsing fails.
+ */
+export async function getDataJWT(compactJWT) {
+    const parts = getPartsJWT(compactJWT);
+    if (!parts) {
+        return undefined;
+    }
+    const header = decodeHeader(parts.protected);
+    const isDeflated = header.zip === 'DEF';
+    const payload = await decodePayload(parts.payload, isDeflated);
+    return {
+        protected: header,
+        payload,
+        signature: parts.signature ? Content.base64ToBytes(parts.signature) : undefined,
+    };
+}
+// --- JWT Creation and Encoding ---
+/**
+ * Encodes a JSON object into a Base64Url string.
+ * @param header The header object.
+ * @returns The encoded string.
+ */
+export function encodeHeader(header) {
+    try {
+        return Content.objectToRawBase64UrlSafe(header);
+    }
+    catch (e) {
+        console.warn('Cannot encode JWT header', e);
+        return '';
+    }
+}
+/**
+ * Encodes a JSON object into a Base64Url payload, compressing it if required.
+ * @param payload The payload object.
+ * @param deflate True to compress the payload with DEFLATE.
+ * @returns The encoded string.
+ */
+export async function encodePayload(payload, deflate) {
+    try {
+        // CRITICAL: When creating a payload, we start with a JSON string, which IS
+        // valid UTF-8. We must use the strict `stringToBytesUTF8` encoder to ensure
+        // standards compliance.
+        let payloadBytes = Content.stringToBytesUTF8(JSON.stringify(payload));
+        if (deflate) {
+            payloadBytes = pako.deflate(payloadBytes);
+        }
+        return Content.bytesToRawBase64UrlSafe(payloadBytes);
+    }
+    catch (e) {
+        console.warn('Cannot encode JWT payload', e);
+        return '';
+    }
+}
+/**
+ * Encodes a signature byte array into a Base64Url string.
+ * @param signatureBytes The signature bytes.
+ * @returns The encoded string, or an empty string if no signature is provided.
+ */
+export function encodeSignature(signatureBytes) {
+    if (!signatureBytes || signatureBytes.length < 1) {
+        return '';
+    }
+    try {
+        return Content.bytesToRawBase64UrlSafe(signatureBytes);
+    }
+    catch (e) {
+        console.warn('Cannot encode JWT signature', e);
+        return '';
+    }
+}
+/**
+ * Assembles a header, payload, and signature into a compact JWT string.
+ * @param header The header object.
+ * @param payload The payload object.
+ * @param signatureBytes The optional signature.
+ * @returns A compact JWT string.
+ */
+export async function compactJWT(header, payload, signatureBytes) {
+    const encodedHeader = encodeHeader(header);
+    const isDeflated = header.zip === 'DEF';
+    const encodedPayload = await encodePayload(payload, isDeflated);
+    const encodedSignature = encodeSignature(signatureBytes);
+    return `${encodedHeader}.${encodedPayload}.${encodedSignature}`;
+}

package/dist/utils/manager-error.d.ts

@@ -0,0 +1,15 @@
+import { IssueTypeCode } from "../models/issue";
+/**
+ * A custom error class used to propagate specific operational failures from deep
+ * within the manager's logic to the central error handler.
+ * It carries the necessary information to build a well-formed ErrorEntry.
+ */
+export declare class ManagerError extends Error {
+    readonly code: IssueTypeCode;
+    readonly status: string;
+    /**
+     * @param message The diagnostic message for the error.
+     * @param code The classification of the error, from which the HTTP status will be derived.
+     */
+    constructor(message: string, code: IssueTypeCode);
+}

package/dist/utils/manager-error.js

@@ -0,0 +1,23 @@
+// src/utils/manager-error.ts
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { IssueTypeToHttpStatus } from "../models/issue.js";
+/**
+ * A custom error class used to propagate specific operational failures from deep
+ * within the manager's logic to the central error handler.
+ * It carries the necessary information to build a well-formed ErrorEntry.
+ */
+export class ManagerError extends Error {
+    code;
+    status; // This is a string
+    /**
+     * @param message The diagnostic message for the error.
+     * @param code The classification of the error, from which the HTTP status will be derived.
+     */
+    constructor(message, code) {
+        super(message);
+        this.name = 'ManagerError';
+        this.code = code;
+        // Automatically derive the HTTP status string from the issue code.
+        this.status = IssueTypeToHttpStatus[code] || '500';
+    }
+}

package/dist/utils/multibase58.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Encode bytes into multibase base58btc string (prefixed with 'z').
+ * Equivalent to multiformats base58btc.encode.
+ */
+export declare function encodeMultibase58btc(data: Uint8Array): string;
+/**
+ * Decode a multibase base58btc string (must start with 'z').
+ * Equivalent to multiformats base58btc.decode.
+ */
+export declare function decodeMultibase58btc(multibaseStr: string): Uint8Array;
+export declare function encodeHexToMultibase58btc(hexStr: string): string;
+export declare function decodeMultibase58btcToHex(b58str: string): string;
+export declare function decodeMultibase58btcToUUID(b58str: string): string;

package/dist/utils/multibase58.js

@@ -0,0 +1,40 @@
+// crypto-ts/crypto-ts/utils/multibase58.ts
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+import baseX from "base-x";
+const BASE58_BTC_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const base58btc = baseX(BASE58_BTC_ALPHABET);
+/**
+ * Encode bytes into multibase base58btc string (prefixed with 'z').
+ * Equivalent to multiformats base58btc.encode.
+ */
+export function encodeMultibase58btc(data) {
+    return "z" + base58btc.encode(Buffer.from(data));
+}
+/**
+ * Decode a multibase base58btc string (must start with 'z').
+ * Equivalent to multiformats base58btc.decode.
+ */
+export function decodeMultibase58btc(multibaseStr) {
+    if (!multibaseStr.startsWith("z")) {
+        throw new Error("Invalid multibase58btc string: missing 'z' prefix");
+    }
+    return new Uint8Array(base58btc.decode(multibaseStr.slice(1)));
+}
+// HEX ➜ multibase base58btc (quita guiones si los hay)
+export function encodeHexToMultibase58btc(hexStr) {
+    const hexClean = hexStr.replace(/-/g, "").toLowerCase();
+    if (!/^[0-9a-f]{32}$/i.test(hexClean))
+        throw new Error("Invalid 16-byte hex string");
+    const bytes = new Uint8Array(hexClean.match(/.{1,2}/g).map(b => parseInt(b, 16)));
+    return encodeMultibase58btc(bytes);
+}
+// multibase base58btc ➜ hex (no hyppens)
+export function decodeMultibase58btcToHex(b58str) {
+    const bytes = decodeMultibase58btc(b58str);
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, "0")).join("");
+}
+// multibase base58btc ➜ UUID (with hyppens)
+export function decodeMultibase58btcToUUID(b58str) {
+    const hex = decodeMultibase58btcToHex(b58str);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/dist/utils/multibasehash.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Encodes input into multibase(base58btc(multihash(sha384))).
+ * - Multihash prefix: 0x15 0x30
+ *   - 0x15: code for SHA-384
+ *   - 0x30: length of SHA-384 = 48 bytes
+ * - Multibase prefix: 'z'
+ */
+export declare function encodeMultibaseSha384(input: string | Uint8Array): string;

package/{src/utils/multibasehash.ts → dist/utils/multibasehash.js}

@@ -1,13 +1,10 @@
 // Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
-
 // Use explicit .js subpaths to satisfy package exports in Metro/Node ESM.
 import { sha384 } from '@noble/hashes/sha2.js';
 import { utf8ToBytes } from '@noble/hashes/utils.js';
 import baseX from 'base-x';
-
 const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 const base58btc = baseX(BASE58_ALPHABET);
-
 /**
  * Encodes input into multibase(base58btc(multihash(sha384))).
  * - Multihash prefix: 0x15 0x30
@@ -15,14 +12,12 @@ const base58btc = baseX(BASE58_ALPHABET);
  *   - 0x30: length of SHA-384 = 48 bytes
  * - Multibase prefix: 'z'
  */
-export function encodeMultibaseSha384(input: string | Uint8Array): string {
-  const bytes = typeof input === 'string' ? utf8ToBytes(input) : input;
-  const hashBytes = sha384(bytes);
-
-  const multihashBytes = new Uint8Array(2 + hashBytes.length);
-  multihashBytes[0] = 0x15; // SHA-384 code
-  multihashBytes[1] = 0x30; // length = 48
-  multihashBytes.set(hashBytes, 2);
-
-  return 'z' + base58btc.encode(multihashBytes);
+export function encodeMultibaseSha384(input) {
+    const bytes = typeof input === 'string' ? utf8ToBytes(input) : input;
+    const hashBytes = sha384(bytes);
+    const multihashBytes = new Uint8Array(2 + hashBytes.length);
+    multihashBytes[0] = 0x15; // SHA-384 code
+    multihashBytes[1] = 0x30; // length = 48
+    multihashBytes.set(hashBytes, 2);
+    return 'z' + base58btc.encode(multihashBytes);
 }

package/dist/utils/normalize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Normalizes an object for hashing by excluding a standard set of volatile properties.
+ * This function is based on the original `normalizeAndSerializeObject` from the backend utils.
+ *
+ * @param obj The object to normalize.
+ * @returns A stable, canonical JSON string of the object's core properties.
+ */
+export declare function normalizeObject(obj: object): string;
+/**
+ * Normalizes a DIDComm payload specifically for generating the `payload.id` (version hash).
+ * According to the defined architecture, this specifically excludes `id` and `meta`.
+ *
+ * @param payload The DIDComm payload object.
+ * @returns A stable JSON string representation of the payload's core content.
+ */
+export declare function normalizeDidcommPayloadForId(payload: object): string;