neozipkit 0.1.1

package/dist/server/platform/servercomponents/ZipKitOTS.js

@@ -0,0 +1,271 @@
+// ======================================
+//	ZipKitOTS.ts
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+// ZipKit OpenTimestamps Routines
+"use server";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyTimestamp = verifyTimestamp;
+exports.createTimestamp = createTimestamp;
+exports.deserializeOts = deserializeOts;
+exports.parseVerifyResult = parseVerifyResult;
+const moment_timezone_1 = __importDefault(require("moment-timezone"));
+if (global._bitcore)
+    delete global._bitcore;
+let OTSInstance = null;
+async function getOTS() {
+    if (!OTSInstance) {
+        OTSInstance = (await Promise.resolve().then(() => __importStar(require('opentimestamps')))).default;
+    }
+    return OTSInstance;
+}
+/**
+ * Verifies a timestamp proof against a file hash
+ *
+ * @param hashDigest - SHA-256 hash digest of the file or merkle root (hex string)
+ * @param otsData - The OpenTimestamps proof data
+ * @returns Promise with verification result or null on critical failure
+ *
+ * @example
+ * // Verify a timestamp proof
+ * const hashDigest = "8a9d..."; // SHA-256 digest in hex format
+ * const result = await verifyTimestamp(hashDigest, otsBuffer);
+ *
+ * if (result) {
+ *   if (result.error) {
+ *     console.error("Verification failed:", result.error);
+ *   } else {
+ *     console.log("Verification succeeded:", result.verified);
+ *
+ *     if (result.upgradedOts) {
+ *       // Save the upgraded timestamp
+ *     }
+ *   }
+ * }
+ */
+async function verifyTimestamp(hashDigest, ots) {
+    if (!hashDigest || !ots) {
+        console.error('verifyTimestamp - Invalid parameters');
+        return null;
+    }
+    const tsResult = {
+        merkleRoot: hashDigest,
+        ots: ots,
+        verified: false,
+        results: null,
+        error: null,
+        attestations: null,
+        upgradedOts: null,
+    };
+    try {
+        const OpenTimestamps = await getOTS();
+        // Convert the base64 string to a Buffer
+        // const _otsBuffer = Buffer.from(ots, 'base64');
+        const _otsBuffer = Buffer.from(ots);
+        const detachedOts = OpenTimestamps.DetachedTimestampFile.deserialize(_otsBuffer);
+        const digest = Buffer.from(hashDigest, 'hex');
+        const hashOts = OpenTimestamps.DetachedTimestampFile.fromHash(new OpenTimestamps.Ops.OpSHA256(), digest);
+        // Check if the MetaStamp should be upgraded
+        const upgrade = await OpenTimestamps.upgrade(detachedOts);
+        if (upgrade) {
+            console.log('verifyTimestamp === Timestamp should be upgraded!');
+            tsResult.upgradedOts = detachedOts.serializeToBytes();
+        }
+        // Verify the MetaStamp
+        tsResult.results = await OpenTimestamps.verify(detachedOts, hashOts, {
+            ignoreBitcoinNode: true, // Don't check for local Bitcoin node
+            timeout: 5000
+        });
+        var _attest = [];
+        detachedOts.timestamp.allAttestations().forEach((attestation) => {
+            if (attestation instanceof OpenTimestamps.Notary.UnknownAttestation) {
+                console.log('Unknown attestation type');
+            }
+            else {
+                // console.log(attestation);
+                _attest.push(attestation);
+            }
+        });
+        tsResult.attestations = JSON.stringify(_attest);
+        // Check if the results show a verified timestamp
+        if (Object.keys(tsResult.results).length < 1) {
+            tsResult.results = null;
+            tsResult.verified = false;
+        }
+        else {
+            tsResult.verified = true;
+        }
+        console.log('verifyTimestamp === tsResult: ', tsResult);
+        return tsResult;
+    }
+    catch (error) {
+        let errMsg = error?.message || 'Timestamp Verification Failed!';
+        if (errMsg.indexOf('ESOCKETTIMEDOUT') != -1) {
+            errMsg = 'Server timed out, Try again in a few minutes.';
+        }
+        else if (errMsg.indexOf('502') != -1) {
+            errMsg = 'Server failed to respond, Try again in a few minutes.';
+        }
+        else if (errMsg.indexOf('ECONNRESET') != -1) {
+            errMsg = 'Server connection reset, Try again in a few minutes.';
+        }
+        return { error: errMsg };
+    }
+}
+/**
+ * Creates a timestamp proof for a file hash using OpenTimestamps
+ *
+ * @param hashDigest - SHA-256 hash digest of the file or merkle root (hex string)
+ * @returns Promise containing the OpenTimestamps proof or null on failure
+ *
+ * @example
+ * // Create a timestamp for a file hash
+ * const hashDigest = "8a9d..."; // SHA-256 digest in hex format
+ * const timestampProof = await createTimestamp(hashDigest);
+ *
+ * if (timestampProof) {
+ *   // Save the timestamp proof to storage
+ * }
+ */
+async function createTimestamp(hashDigest) {
+    if (!hashDigest)
+        return null;
+    try {
+        const OpenTimestamps = await getOTS();
+        // Convert hex string to Buffer
+        const hashBuffer = Buffer.from(hashDigest, 'hex');
+        // Create detached timestamp file
+        const detached = OpenTimestamps.DetachedTimestampFile.fromHash(new OpenTimestamps.Ops.OpSHA256(), hashBuffer);
+        // Create the timestamp
+        await OpenTimestamps.stamp(detached);
+        // Return the serialized timestamp
+        return Buffer.from(detached.serializeToBytes());
+    }
+    catch (error) {
+        console.error('Error creating timestamp:', error);
+        throw new Error('Error creating timestamp');
+    }
+}
+/**
+ * Deserializes timestamp metadata to extract attestation information
+ * Used for generating timestamp certificates and displaying verification details
+ *
+ * @param tsResult - Timestamp verification result to deserialize
+ * @returns JSON string of deserialized data or null on failure
+ */
+async function deserializeOts(tsResult) {
+    let result = {
+        attestStr: null,
+        needsUpdateMsg: null,
+        attestationValues: [],
+    };
+    for (const chain in tsResult.results) {
+        let _results = tsResult.results[chain];
+        const _attestDate = (0, moment_timezone_1.default)(_results.timestamp * 1000).tz(moment_timezone_1.default.tz.guess()).format('MM-DD-YYYY hh:mma z');
+        const blockchain = chain.charAt(0).toUpperCase() + chain.slice(1);
+        result.attestStr = `<b>${blockchain} block ${_results.height}</b> attests existence as of <b>${_attestDate}</b>`;
+    }
+    ;
+    let timestamp = tsResult.ots;
+    if (tsResult.upgradedOts != null) {
+        result.needsUpdateMsg = "This Zip file requires updated Timestamp Metadata!";
+        // Use the updated timestamp metadata
+        timestamp = tsResult.upgradedOts;
+    }
+    // Extract the attestation values from the timestamp metadata
+    if (!timestamp)
+        return null;
+    const OpenTimestamps = await getOTS();
+    const detached = OpenTimestamps.DetachedTimestampFile.deserialize(Buffer.from(timestamp));
+    const infoResult = OpenTimestamps.info(detached);
+    // Extract all transaction IDs using a regular expression
+    const transactionIdMatches = [...infoResult.matchAll(/transaction id ([a-f0-9]+)/gi)];
+    const transactionIds = transactionIdMatches.map(match => match[1]);
+    // Extract the value inside the parentheses using a regular expression
+    const blockHeightMatches = [...infoResult.matchAll(/verify BitcoinBlockHeaderAttestation\((\d+)\)/g)];
+    const blockHeights = blockHeightMatches.map(match => match[1]);
+    // Extract all values after "block merkle root" using a regular expression
+    const merkleRootMatches = [...infoResult.matchAll(/block merkle root ([a-f0-9]+)/gi)];
+    const merkleRoots = merkleRootMatches.map(match => match[1]);
+    // Group the values in a loop
+    result.attestationValues = [];
+    if (transactionIds.length === blockHeights.length && transactionIds.length === merkleRoots.length) {
+        for (let i = 0; i < transactionIds.length; i++) {
+            result.attestationValues.push({
+                blockHeight: blockHeights[i],
+                transactionId: transactionIds[i],
+                merkleRoot: merkleRoots[i]
+            });
+        }
+        // Sort the grouped values by blockHeight in ascending order
+        result.attestationValues.sort((a, b) => a.blockHeight - b.blockHeight);
+    }
+    return JSON.stringify(result);
+}
+// Parse the verifyResult into a TimestampInfo object
+async function parseVerifyResult(verifyResult) {
+    let tsInfo = {
+        message: '',
+        results: [],
+        attestDate: null,
+        attestHeight: null,
+        submittedUri: null,
+        otsUpgraded: false
+    };
+    for (const chain in verifyResult?.results) {
+        let _results = verifyResult.results[chain];
+        const _date = (0, moment_timezone_1.default)(_results.timestamp * 1000)
+            .tz('UTC')
+            .format('MM-DD-YYYY hh:mma z');
+        const _blockchain = chain.charAt(0).toUpperCase() + chain.slice(1);
+        tsInfo.message = 'Validated - ' + _blockchain + ' block ' + _results.height + ' attests existence as of ' + _date;
+        if (tsInfo.attestHeight == null) {
+            tsInfo.attestDate = new Date(_results.timestamp * 1000);
+            tsInfo.attestHeight = _results.height;
+        }
+        tsInfo.results.push(tsInfo.message);
+    }
+    ;
+    if (verifyResult?.upgradedOts) {
+        tsInfo.otsUpgraded = true;
+        tsInfo.results.push('Notice: Please select "Upgrade Timestamp" to save the upgraded timestamp.');
+    }
+    return tsInfo;
+}

package/dist/shared/ZipEntry.d.ts

@@ -0,0 +1,131 @@
+import { ZipFileEntry, FileData } from './types';
+/**
+ * Class representing a single entry (file or directory) within a ZIP archive
+ */
+export default class ZipEntry implements ZipFileEntry {
+    debug: boolean;
+    verMadeBy: number;
+    verExtract: number;
+    bitFlags: number;
+    cmpMethod: number;
+    timeDateDOS: number;
+    crc: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    volNumber: number;
+    intFileAttr: number;
+    extFileAttr: number;
+    localHdrOffset: number;
+    filename: string;
+    extraField: Buffer | null;
+    comment: string | null;
+    fileBuffer: Buffer | null;
+    cmpData: Buffer | null;
+    isEncrypted: boolean;
+    isStrongEncrypt: boolean;
+    encryptHdr: Buffer | null;
+    lastModTimeDate: number;
+    decrypt: Function | null;
+    isUpdated: boolean;
+    isDirectory: boolean;
+    isMetaData: boolean;
+    platform: string | null;
+    universalTime: number | null;
+    uid: number | null;
+    gid: number | null;
+    sha256: string | null;
+    fileData?: FileData;
+    /**
+     * Creates a new ZIP entry
+     * @param fname - Name of the file within the ZIP
+     * @param comment - Optional comment for this entry
+     * @param debug - Enable debug logging
+     */
+    constructor(fname: string | null, comment?: string | null, debug?: boolean);
+    isMSDOS: boolean;
+    isUnixLike: boolean;
+    isMacOS: boolean;
+    isLinux: boolean;
+    VER_MADE_BY: number;
+    /**
+     * Reads ZIP entry data from a central directory buffer
+     * @param data - Buffer containing central directory entry data
+     * @returns Buffer positioned at start of next entry
+     * @throws Error if central directory entry is invalid
+     */
+    readZipEntry(data: Buffer): Buffer;
+    /**
+     * Checks if the filename contains characters that require Unicode handling
+     * @returns true if the filename contains non-ASCII characters or special characters
+     */
+    needsUnicodeHandling(): boolean;
+    /**
+     * Adds UTF-8 Unicode Path field to a buffer
+     * @param buffer - The buffer to write to
+     * @param offset - The offset in the buffer to start writing
+     * @returns The new offset after writing
+     */
+    private addUnicodePathField;
+    /**
+     * Creates a local header for this ZIP entry
+     * @returns Buffer containing the local header data
+     */
+    createLocalHdr(): Buffer;
+    /**
+     * Creates a central directory entry for this ZIP entry
+     * @returns Buffer containing the central directory entry data
+     */
+    centralDirEntry(): Buffer;
+    /**
+     * Sets the DOS date/time for this entry
+     * @param date - Date to convert to DOS format
+     * @returns number - DOS format date/time
+     */
+    setDateTime(date: Date): number;
+    /**
+     * Converts DOS date/time to JavaScript Date
+     * @param timeStamp - DOS format date/time
+     * @returns Date object or null if timestamp is 0
+     */
+    parseDateTime(timeStamp: number): Date | null;
+    /**
+     * Formats the entry's date in local format
+     * @returns String in MM/DD/YYYY format or "--/--/----" if no date
+     */
+    toLocalDateString(): string;
+    /**
+     * Formats the entry's time
+     * @returns String in HH:MM format or "--:--" if no time
+     */
+    toTimeString(): string;
+    /**
+     * Formats the entry's date and time in local format
+     * @returns String like "Jan 01, 2024 13:45:30" or "--/--/-- --:--" if no date/time
+     */
+    toFormattedDateString(): string;
+    /**
+     * Formats the entry's date and time in UTC
+     * @returns String like "Jan 01, 2024 13:45:30 UTC" or "--/--/-- --:--" if no date/time
+     */
+    toFormattedUTCDateString(): string;
+    /**
+     * Converts compression method code to human-readable string
+     * @returns String describing the compression method
+     */
+    cmpMethodToString(): string;
+    /**
+     * Converts file system code to human-readable string
+     * @returns String describing the file system
+     */
+    fileSystemToString(): string;
+    /**
+     * Converts MS-DOS file attributes to string representation
+     * @returns String like "----" where R=readonly, H=hidden, S=system, A=archive
+     */
+    private dosAttributesToString;
+    /**
+     * Outputs detailed information about this entry for debugging
+     * Includes compression, encryption, timestamps, and extra fields
+     */
+    showVerboseInfo(): void;
+}