neozipkit 0.1.1 → 0.3.0

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

@@ -1,271 +0,0 @@
-// ======================================
-//	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/ZipKit.d.ts

@@ -1,249 +0,0 @@
-import ZipEntry from './ZipEntry';
-import Errors from './constants/Errors';
-import { LOCAL_HDR, ENCRYPT_HDR_SIZE, CMP_METHOD, CENTRAL_END, CENTRAL_DIR, ZIP64_CENTRAL_END, ZIP64_CENTRAL_DIR, GP_FLAG, TIMESTAMP_SUBMITTED, TIMESTAMP_METADATA, TOKENIZED_METADATA, LOCAL_FILE_HEADER, CENTRAL_FILE_HEADER, CENTRAL_DIRECTORY_END, HDR_ID } from './constants/Headers';
-export { ZipEntry, Errors, CMP_METHOD, TIMESTAMP_METADATA, TIMESTAMP_SUBMITTED, TOKENIZED_METADATA, LOCAL_HDR, ENCRYPT_HDR_SIZE, CENTRAL_END, CENTRAL_DIR, ZIP64_CENTRAL_END, ZIP64_CENTRAL_DIR, GP_FLAG, LOCAL_FILE_HEADER, CENTRAL_FILE_HEADER, CENTRAL_DIRECTORY_END, HDR_ID };
-/**
- * Options for compressing files in a ZIP archive
- */
-export interface CompressOptions {
-    level?: number;
-    password?: string | null;
-    useSHA256?: boolean;
-    useZstd?: boolean;
-}
-/**
- * Callbacks for ZIP file creation process
- */
-export interface CreateZipOptions {
-    onError?: (error: Error) => void;
-    onEntryDone?: (entry: ZipEntry, status: string) => void;
-    onReadEntryData?: (entry: ZipEntry) => Buffer;
-    onOutputBuffer?: (data: Buffer) => void;
-}
-/**
- * Main class for ZIP file operations including compression, extraction, and encryption
- */
-export default class ZipKit {
-    static readonly version: string;
-    static readonly releaseDate: string;
-    private inBuffer;
-    private zipEntries;
-    private sortName;
-    private centralDirSize;
-    private centralDirOffset;
-    private stampEntry;
-    zipComment: string | null;
-    static support: {
-        base64: boolean;
-        array: boolean;
-        string: boolean;
-        isNode: boolean;
-        buffer: boolean;
-        uint8array: boolean;
-        arrayBuffer: boolean;
-        blob: boolean;
-        streams: boolean;
-        fileReader: boolean;
-    };
-    /**
-     * Creates a new ZipKit instance
-     */
-    constructor();
-    /**
-     * Resets all ZIP-related data to initial state
-     */
-    resetZipData(): void;
-    /**
-     * Loads a ZIP file from a buffer
-     * @param inBuf - Buffer containing ZIP file data
-     */
-    loadZip(inBuf: Buffer): void;
-    /**
-     * Tests if data matches the CRC32 checksum
-     * @param entry - ZIP entry to check
-     * @param data - Data buffer to verify
-     * @returns boolean indicating if CRC matches
-     */
-    testCRC32(entry: ZipEntry, data: Buffer): boolean;
-    /**
-     * Tests if data matches the SHA256 hash
-     * @param entry - ZIP entry to check
-     * @param data - Data buffer to verify
-     * @returns boolean indicating if SHA256 matches
-     * @throws Error if entry has no SHA256 hash
-     */
-    testSHA256(entry: ZipEntry, data: Buffer): boolean;
-    /**
-     * Locates and parses the central end directory
-     * @param inBuffer - Buffer containing ZIP file data
-     * @returns Number of entries in ZIP file
-     * @throws Error if central directory is invalid
-     */
-    getCentralEnd(inBuffer: Buffer): number;
-    /**
-     * Creates the central end directory header
-     * @param centralDirSize - Size of central directory
-     * @param centralDirOffset - Offset to central directory
-     * @returns Buffer containing end directory header
-     */
-    centralEndHdr(centralDirSize: number, centralDirOffset: number): Buffer;
-    /**
-     * Reads and parses the ZIP file directory
-     * @param debug - Enable debug logging
-     * @returns Array of ZIP entries
-     */
-    getDirectory(debug?: boolean): ZipEntry[];
-    /**
-     * Gets a ZIP entry by filename
-     * @param fname - Filename to search for
-     * @returns ZipEntry if found, null otherwise
-     */
-    getZipEntry(fname: string): ZipEntry | null;
-    /**
-     * Creates a new ZIP entry
-     * @param fname - Filename for new entry
-     * @param comment - Optional entry comment
-     * @returns Created ZipEntry
-     */
-    createZipEntry(fname: string, comment?: string): ZipEntry;
-    /**
-     * Deletes an entry from the ZIP file
-     * @param fname - Filename to delete
-     * @returns boolean indicating if file was deleted
-     */
-    deleteFile(fname: string): boolean;
-    /**
-     * Parses local header and returns entry data
-     * @param entry - ZIP entry to parse
-     * @param withLocalHdrData - Include header in returned data
-     * @returns Buffer containing entry data
-     * @throws Error if header is invalid
-     */
-    parseLocalHeader(entry: ZipEntry, withLocalHdrData?: boolean): Buffer;
-    /**
-     * Copies an entry's data from source ZIP
-     * @param entry - Entry to copy
-     * @returns Buffer containing entry data with headers
-     */
-    copyEntry(entry: ZipEntry): Buffer;
-    /**
-     * Compresses data for a ZIP entry
-     * @param entry - ZIP entry to compress
-     * @param data - Data to compress
-     * @param options - Compression options
-     * @returns Buffer containing compressed data
-     */
-    compressData(entry: ZipEntry, data: Buffer, options?: CompressOptions): Promise<Buffer>;
-    /**
-     * Compresses data using deflate algorithm
-     * @param inbuf - Data to compress
-     * @param options - Compression options
-     * @returns Compressed data buffer
-     */
-    private deflate;
-    /**
-     * Compresses data using Zstandard (zstd) algorithm
-     * @param inbuf - Data to compress
-     * @param options - Compression options
-     * @returns Compressed data buffer
-     */
-    private zstdCompress;
-    /**
-     * Decompresses data using Zstandard (zstd) algorithm
-     * @param inbuf - Compressed data buffer
-     * @returns Decompressed data buffer
-     */
-    zstdDecompress(inbuf: Buffer): Promise<Buffer>;
-    /**
-     * Creates new Zip data file with the passed ZipEntries
-     * @param cmpOptions - Compression options
-     * @param zipOptions - Create ZIP options
-     * @returns Promise<number> - The offset of the last entry
-     */
-    createZipFileData(cmpOptions?: CompressOptions, zipOptions?: CreateZipOptions): Promise<number>;
-    /**
-     * Finishes Zip data file by adding any Metadata entries and the Central End Directory
-     * @param offset - The current offset in the zip data file
-     * @param onOutputBuffer - The callback function to output the data buffer
-     * @param metaEntry - The Metadata ZipEntry to add to the Zip file
-     */
-    finishZipFileData(offset: number, onOutputBuffer: (data: Buffer) => void, metaEntry?: ZipEntry): Promise<void>;
-    /**
-     * Unzips the data buffer using pako inflate method
-     * @param inbuf - Data buffer to inflate
-     * @returns Inflated data buffer
-     * @throws Error if extraction fails
-     */
-    inflate(inbuf: Buffer): Buffer;
-    /**
-     * Extracts the data from the ZipEntry and returns the data as a Buffer
-     * @param entry - ZIP entry to extract
-     * @param skipHashCheck - Whether to skip hash checking
-     * @returns Buffer containing extracted data or null if extraction fails
-     */
-    extract(entry: ZipEntry, skipHashCheck?: boolean): Promise<Buffer | null>;
-    /**
-     * Decrypts the entry data
-     * @param entry - ZIP entry to decrypt
-     * @param password - Password for decryption
-     * @returns Decrypted data buffer or null if decryption fails
-     */
-    decryptEntry(entry: ZipEntry, password: string): Buffer | null;
-    /**
-     * Checks if a filename is a blockchain metadata file that should be excluded from Merkle Root calculation
-     * @param filename - The filename to check
-     * @returns boolean - True if the file is a metadata file
-     */
-    private isMetadataFile;
-    /**
-     * Calculates the Merkle Root of the ZIP file
-     * Excludes blockchain metadata files (META-INF/*) to ensure consistent calculation
-     * @returns string - The Merkle Root of the ZIP file
-     */
-    getMerkleRoot(): string | null;
-    /**
-     * Checks if a ZIP file contains valid timestamp metadata
-     * @returns { merkleRoot: string | null, ots: Buffer | null }
-     * Returns the merkle root hash and timestamp metadata if found, null otherwise
-     */
-    checkForTimestamp(): string | null;
-    /**
-     * Gets the OTS from the timestamp metadata entry
-     * @returns Promise<Buffer | null> - The OTS from the timestamp metadata entry or null if not found
-     */
-    getOts(): Promise<Buffer | null>;
-    /**
-     * Creates a new timestamp metadata entry for the ZIP file
-     * Calculates merkle root from file hashes and obtains blockchain timestamp
-     * @returns Promise<ZipEntry | null> The created timestamp metadata entry or null if failed
-     */
-    createTimestampMetadataEntry(ots: Buffer | null): ZipEntry | null;
-    /**
-     * Sets the ZIP file comment
-     * @param msg - Comment to set
-     */
-    setZipComment(msg: string | null): void;
-    /**
-     * Gets the ZIP file comment
-     * @returns string | null - The ZIP file comment
-     */
-    getZipComment(): string | null;
-    /**
-     * Converts the compression method to a string
-     * @param cmpMethod - Compression method number
-     * @returns string - Compression method as a string
-     */
-    cmpMethodToString(cmpMethod: number): string;
-    /**
-     * Ensures ZIP entries are loaded
-     * @returns Array of ZIP entries
-     * @throws Error if no ZIP entries are loaded
-     */
-    private ensureZipEntries;
-    /**
-     * Ensures ZIP data buffer is loaded
-     * @returns Buffer containing ZIP data
-     * @throws Error if no ZIP data is loaded
-     */
-    private ensureBuffer;
-}