neozipkit 0.2.1 → 0.3.0

package/src/shared/components/CertificateOTS.ts

@@ -1,132 +0,0 @@
-// ======================================
-//	CertificateOTS.ts
-//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
-// ======================================
-
-import fs from 'fs';
-import path from 'path';
-import ZipEntry from '../ZipEntry';
-
-import { 
-  TIMESTAMP_SUBMITTED,
-  TIMESTAMP_METADATA,
-} from '../constants/Headers';
-
-// Add this at the top of the file
-import type { AttestationValue } from '../types';
-
-/**
- * Generates a certificate HTML document based on timestamp information
- * 
- * @param attestStr - Attestation message
- * @param zipFile - Name of the zip file
- * @param hashDigest - Hash digest of the zip file
- * @param needsUpdateMsg - Message indicating if update is needed
- * @param attestationValues - Array of attestation values
- * @param zipEntries - Array of ZipEntry objects
- * @param narrow - Whether to use narrow layout
- * @returns Generated HTML certificate as string
- */
-export default function CertificateTemplate(
-  attestStr: string | null,
-  zipFile: string, 
-  hashDigest: string,
-  needsUpdateMsg: string,
-  attestationValues: AttestationValue[],
-  zipEntries: ZipEntry[],
-  narrow?: boolean
-): string {
-  // Load the HTML template
-  let templatePath;
-  try {
-    // Try to find the template from the package root
-    templatePath = path.resolve(process.cwd(), 'assets/templates/certificate.html');
-    if (!fs.existsSync(templatePath)) {
-      // If not found in current working directory, try relative to this file
-      templatePath = path.resolve(__dirname, '../../assets/templates/certificate.html');
-    }
-    
-    if (!fs.existsSync(templatePath)) {
-      throw new Error('Certificate template not found');
-    }
-  } catch (error) {
-    console.error('Error resolving template path:', error);
-    return '';
-  }
-
-  // Read the template file
-  let htmlTemplate;
-  try {
-    htmlTemplate = fs.readFileSync(templatePath, 'utf8');
-  } catch (error) {
-    console.error('Error reading template file:', error);
-    return '';
-  }
-
-  const updateWarning = needsUpdateMsg || '';
-
-  // Generate attestation HTML
-  let attestHTML = '';
-  if (attestationValues && attestationValues.length > 0) {
-    attestationValues.forEach((attest) => {
-      attestHTML += `
-        <div class="key-value-pair">
-          <div class="key">Block Height:</div>
-          <div class="value">${attest['blockHeight']}</div>
-        </div>
-        <div class="key-value-pair">
-          <div class="key">Transaction:</div>
-          <div class="value">${attest['transactionId']}</div>
-        </div>
-        <div class="key-value-pair">
-          <div class="key">Merkle Root:</div>
-          <div class="value">${attest['merkleRoot']}</div>
-        </div>
-        <br/>
-      `;
-    });
-  }
-
-  // Generate files table HTML
-  let stampEntry = null;
-  let files = [];
-  for (const entry of zipEntries) {
-    if (entry.filename === TIMESTAMP_METADATA) {
-      stampEntry = entry;
-    } else if (entry.filename === TIMESTAMP_SUBMITTED) {
-      if (stampEntry == null)
-        stampEntry = entry;
-    } else if (entry.sha256) {
-      let file = {
-        name: entry.filename,
-        size: entry.uncompressedSize.toString(),
-        date: entry.toFormattedUTCDateString(),
-        hash: entry.sha256,
-      }
-      files.push(file);
-    }
-  }
-
-  let filesTableHTML = '';
-  files.forEach((file) => {
-    filesTableHTML += `
-      <tr>
-        <td class="table-data1">${file.name}</td>
-        <td class="table-data">${file.size}</td>
-        <td class="table-data">${file.date}</td>
-        <td class="table-data">${file.hash}</td>
-      </tr>
-    `;
-  });
-
-  // Replace placeholders in the template
-  let html = htmlTemplate
-    .replace(/{{ATTEST_STR}}/g, attestStr || '')
-    .replace(/{{UPDATE_WARNING}}/g, needsUpdateMsg ? `<div class="warning">${needsUpdateMsg}</div>` : '')
-    .replace(/{{ZIP_FILE}}/g, zipFile)
-    .replace(/{{HASH_DIGEST}}/g, hashDigest)
-    .replace(/{{ATTESTATION_HTML}}/g, attestHTML)
-    .replace(/{{FILES_TABLE_HTML}}/g, filesTableHTML);
-
-  return html;
-}

package/src/shared/components/FileSys.ts

@@ -1,87 +0,0 @@
-// ======================================
-//	FileSys.ts
-//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
-// ======================================
-
-import * as fs from 'fs';
-import * as pth from 'path';
-
-import Errors from '../constants/Errors';
-
-// Output a buffer to a file
-export function outputToFile(
-  fileName: string, 
-  buffer: Buffer, 
-  dirPath: string,
-  overwrite: boolean, 
-  never: boolean, 
-  fileAttr: number)
-{
-  // get Unix file permissions
-  const _fattr = fileAttr ? (((fileAttr >>> 0) | 0) >> 16) & 0xfff : 0; 
-
-  const _path = dirPath ? dirPath + pth.sep + fileName : fileName;
-
-  if (fs.existsSync(_path)) {
-    console.log('File exists: ', _path);
-    if (never) 
-      return false;
-    if (!overwrite) {
-      console.log('Overwrite file: ', _path);
-      return false; // cannot overwrite
-    }
-
-    const stat = fs.statSync(_path);
-    if (stat.isDirectory())
-      return false;
-  }
-  
-  // Check if we need to create a new folder
-  const _folder = pth.dirname(_path);
-  if (!fs.existsSync(_folder)) {
-    makeDir(_folder);
-  }
-
-  var fd;
-  try {
-    fd = fs.openSync(_path, "w", 438); // 0666
-  } catch (e) {
-    fs.chmodSync(_path, 438);
-    fd = fs.openSync(_path, "w", 438);
-  }
-  if (fd) {
-    try {
-      fs.writeSync(fd, buffer, 0, buffer.length, 0);
-    } finally {
-      fs.closeSync(fd);
-    }
-  }
-
-  if (_fattr)
-    fs.chmodSync(_path, _fattr);
-
-  return true;
-}
-
-// Make directories tree for a given path
-export function makeDir(folder: string) {
-  console.log('mkDir: ', folder);
-
-  // Sync - make directories tree
-  function mkdirSync(fpath: string) {
-    let resolvedPath = fpath.split(pth.sep)[0];
-    fpath.split(pth.sep).forEach(function (name) {
-      if (!name || name.endsWith(":")) return;
-      resolvedPath += pth.sep + name;
-      var stat;
-      try {
-        stat = fs.statSync(resolvedPath);
-      } catch (e) {
-        fs.mkdirSync(resolvedPath);
-      }
-      if (stat && stat.isFile()) throw Errors.FILE_IN_THE_WAY.replace("%s", resolvedPath);
-    });
-  }
-
-  mkdirSync(folder);
-};

package/src/shared/components/HashAccumulator.ts

@@ -1,113 +0,0 @@
-// ======================================
-//  HashAccumulator.ts
-// ======================================
-
-import { MerkleTree } from './merkleTree';
-
-/**
- * Class for accumulating and combining SHA-256 hashes using both XOR and Merkle tree methods
- * 
- * Usage example:
- * ```typescript
- * const accumulator = new HashAccumulator();
- * accumulator.addHash('a1b2c3d4');
- * accumulator.addHash('12345678');
- * console.log(accumulator.xorHash()); // Outputs the accumulated XOR result
- * console.log(accumulator.merkleRoot()); // Outputs the accumulated Merkle root
- * ```
- */
-export default class HashAccumulator {
-  private hashes: Buffer[];        // Array of hash buffers for Merkle tree
-  private xorResult: Buffer;       // Running XOR of all hashes
-
-  /**
-   * Creates a new HashAccumulator instance
-   * Initializes empty hash array and zero-filled XOR buffer
-   */
-  constructor() {
-    this.hashes = [];
-    this.xorResult = Buffer.alloc(32, 0);
-  }
-
-  /**
-   * Adds a hash to both the XOR accumulation and hash array
-   * @param hash - Hash value as hex string or Buffer
-   * The hash must be 32 bytes (SHA-256)
-   */
-  addHash(hash: string | Buffer) {
-    // Convert hash to Buffer if it's a string
-    const hashBuffer = typeof hash === 'string' 
-      ? Buffer.from(hash, 'hex') 
-      : hash;
-
-    // Add to array for Merkle tree
-    this.hashes.push(hashBuffer);
-
-    // XOR accumulation
-    for (let i = 0; i < 32; i++) {
-      this.xorResult[i] ^= hashBuffer[i];
-    }
-  }
-
-  /**
-   * Gets the accumulated XOR of all added hashes
-   * @returns Hex string of XOR result
-   */
-  xorHash(): string {
-    return this.xorResult.toString('hex');
-  }
-
-  /**
-   * Creates a Merkle tree from accumulated hashes and returns the root
-   * @returns Hex string of Merkle root, or null if no hashes added
-   */
-  merkleRoot(): string | null {
-    let merkleRoot = null;
-    if (this.hashes.length > 0) {
-      const tree = new MerkleTree(this.hashes, {
-        hashLeaves: false, // Leaves are already hashed
-        sortLeaves: true,  // Sort leaves for consistent results
-        sortPairs: true,   // Sort pairs for consistent results
-        duplicateOdd: true // Duplicate odd leaf for balanced tree
-      });
-      merkleRoot = tree.getRoot().toString('hex');
-    }
-
-    return merkleRoot;
-  }
-
-  /**
-   * Gets the number of hashes accumulated
-   * @returns Number of accumulated hashes
-   */
-  leafCount(): number {
-    return this.hashes.length;
-  }
-
-  /**
-   * Resets the accumulator to initial state
-   * Clears hash array and zeroes XOR buffer
-   */
-  clear() {
-    this.hashes = [];
-    this.xorResult = Buffer.alloc(32, 0);
-  }
-
-  /**
-   * Combines multiple hash results into a single Merkle root
-   * @param results - Array of objects containing merkleRoot properties
-   * @returns Combined Merkle root as hex string, or null if no valid roots
-   */
-  static combineResults(results: { merkleRoot?: string }[]) {
-    const accumulator = new HashAccumulator();
-    
-    // Combine all hashes
-    for (const result of results) {
-      if (result.merkleRoot) {
-        accumulator.addHash(result.merkleRoot);
-      }
-    }
-
-    return accumulator.merkleRoot();
-  }
-}

package/src/shared/components/ZipCrypto.ts

@@ -1,91 +0,0 @@
-// ======================================
-//	ZipCrypto.ts
-//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
-// ======================================
-// Zip Cryptography Routines
-
-"use strict";
-
-import { createHash, randomFillSync } from 'crypto';
-
-import { crc32update, uMul } from './Util';
-import { ENCRYPT_HDR_SIZE } from '../constants/Headers';
-
-// Return the SHA256 hash of a buffer
-export function sha256(data: Buffer): string {
-  const hash = createHash('sha256');
-
-  return hash
-    .update(data)
-    .digest('hex');
-}
-
-class InitKeys {
-  private keys: Uint32Array;
-
-  constructor(pw: string | Buffer) {
-    this.keys = new Uint32Array([0x12345678, 0x23456789, 0x34567890]);
-    const pass = typeof pw === 'string' ? Buffer.from(pw) : pw;
-    for (let i = 0; i < pass.length; i++) {
-      this.updateKeys(pass[i]);
-    }
-  }
-
-  updateKeys(byteValue: number): number {
-    this.keys[0] = crc32update(this.keys[0], byteValue);
-    this.keys[1] = ((this.keys[1] + (this.keys[0] & 0xff)) * 0x08088405 + 1) >>> 0;
-    this.keys[2] = crc32update(this.keys[2], this.keys[1] >>> 24);
-    return byteValue;
-  }
-
-  next(): number {
-    const k = (this.keys[2] | 2) >>> 0; // key
-    return (uMul(k, k ^ 1) >> 8) & 0xff; // decode
-  }
-}
-
-// Return encrypting function, result and pos is here so we dont have to merge buffers later
-function make_encrypter(pwd: string | Buffer): Function {
-  const keys = new InitKeys(pwd);
-
-  return function (data: Buffer, result: Buffer, pos: number = 0): Buffer {
-    // result - we create new Buffer for results
-    if (!result) result = Buffer.alloc(data.length);
-    // process input data
-    for (let c of data) {
-      const k = keys.next(); // save key byte
-      result[pos++] = c ^ k; // save val
-      keys.updateKeys(c); // update keys with decoded byte
-    }
-    return result;
-  };
-}
-
-// Encrypt data with password and include a checkByte verification byte at the end
-export function encrypter(data: Buffer | null, checkByte: number, pwd: string): Buffer | null {
-  if (!data) return null;
-
-  const _encrypter = make_encrypter(pwd);
-
-  const salt = randomFillSync(Buffer.alloc(ENCRYPT_HDR_SIZE));
-  salt[ENCRYPT_HDR_SIZE - 1] = checkByte;
- 
-  // create encryption header
-  const result = Buffer.alloc(data.length + ENCRYPT_HDR_SIZE);
-  _encrypter(salt, result);
-
-  // encode content
-  return _encrypter(data, result, ENCRYPT_HDR_SIZE);
-}
-
-// Return the decrypter function
-export function decrypter(pwd: string | Buffer): Function {
-  const keys = new InitKeys(pwd);
-
-  return function (data: Buffer): Buffer {
-    for (let i=0; i<data.length; i++) {
-      data[i] = keys.updateKeys(data[i] ^ keys.next()); 
-    }
-    return data;
-  };
-}

package/src/shared/components/merkleTree.ts

@@ -1,162 +0,0 @@
-import { createHash } from 'crypto';
-
-/**
- * Configuration options for Merkle tree construction
- */
-interface MerkleTreeOptions {
-  hashLeaves: boolean;      // Whether to hash the leaf nodes before adding to tree
-  sortLeaves: boolean;      // Whether to sort leaf nodes for consistent trees
-  sortPairs: boolean;       // Whether to sort each pair before hashing
-  duplicateOdd: boolean;    // Whether to duplicate last leaf when odd number of leaves
-}
-
-/**
- * Implementation of a Merkle Tree (hash tree) using SHA-256
- * 
- * A Merkle tree is a binary tree where each non-leaf node is the hash of its two children.
- * This allows efficient verification of large datasets by only storing/transmitting the root hash
- * and generating proofs of inclusion for individual items.
- */
-export class MerkleTree {
-  private leaves: Buffer[];       // Leaf nodes (original data or hashes)
-  private layers: Buffer[][];     // All layers of the tree, from leaves to root
-  private options: MerkleTreeOptions;
-
-  /**
-   * Creates a new Merkle tree from an array of leaf nodes
-   * @param leaves - Array of leaf node data as Buffers
-   * @param options - Configuration options for tree construction
-   */
-  constructor(leaves: Buffer[], options: Partial<MerkleTreeOptions> = {}) {
-    this.options = {
-      hashLeaves: false,
-      sortLeaves: true,
-      sortPairs: true,
-      duplicateOdd: true,
-      ...options
-    };
-
-    // Process leaves according to options
-    this.leaves = leaves.map(leaf => {
-      if (this.options.hashLeaves) {
-        return this.hash(leaf);
-      }
-      return Buffer.isBuffer(leaf) ? leaf : Buffer.from(leaf);
-    });
-
-    if (this.options.sortLeaves) {
-      this.leaves.sort(Buffer.compare);
-    }
-
-    this.layers = [this.leaves];
-    this.createHashes(this.leaves);
-  }
-
-  /**
-   * Computes SHA-256 hash of input data
-   * @param data - Data to hash
-   * @returns Buffer containing hash
-   */
-  private hash(data: Buffer): Buffer {
-    return createHash('sha256').update(data).digest();
-  }
-
-  /**
-   * Combines two child hashes to create parent hash
-   * @param left - Left child hash
-   * @param right - Right child hash
-   * @returns Combined hash of children
-   */
-  private combinedHash(left: Buffer, right: Buffer): Buffer {
-    if (this.options.sortPairs && Buffer.compare(left, right) > 0) {
-      [left, right] = [right, left];
-    }
-    return this.hash(Buffer.concat([left, right]));
-  }
-
-  /**
-   * Builds the Merkle tree by creating successive layers of hashes
-   * @param nodes - Array of nodes in current layer
-   */
-  private createHashes(nodes: Buffer[]) {
-    while (nodes.length > 1) {
-      const layerIndex = this.layers.length;
-      this.layers.push([]);
-
-      // Process pairs of nodes
-      for (let i = 0; i < nodes.length - 1; i += 2) {
-        const left = nodes[i];
-        const right = nodes[i + 1];
-        const hash = this.combinedHash(left, right);
-        this.layers[layerIndex].push(hash);
-      }
-
-      // Handle odd number of nodes
-      if (nodes.length % 2 === 1) {
-        const last = nodes[nodes.length - 1];
-        if (this.options.duplicateOdd) {
-          // Duplicate the last node if odd
-          const hash = this.combinedHash(last, last);
-          this.layers[layerIndex].push(hash);
-        } else {
-          // Push last node up to next layer
-          this.layers[layerIndex].push(last);
-        }
-      }
-
-      nodes = this.layers[layerIndex];
-    }
-  }
-
-  /**
-   * Gets the root hash of the Merkle tree
-   * @returns Buffer containing root hash
-   */
-  public getRoot(): Buffer {
-    return this.layers[this.layers.length - 1][0];
-  }
-
-  /**
-   * Generates a proof of inclusion for a leaf node
-   * @param leaf - The leaf node to generate proof for
-   * @returns Array of sibling hashes needed to reconstruct root
-   * @throws Error if leaf not found in tree
-   */
-  public getProof(leaf: Buffer): Buffer[] {
-    let index = this.leaves.findIndex(item => item.equals(leaf));
-    if (index === -1) {
-      throw new Error('Leaf not found in tree');
-    }
-
-    return this.layers.reduce((proof, layer) => {
-      if (layer.length === 1) return proof;
-
-      const pairIndex = index % 2 === 0 ? index + 1 : index - 1;
-      if (pairIndex < layer.length) {
-        proof.push(layer[pairIndex]);
-      }
-
-      index = Math.floor(index / 2);
-      return proof;
-    }, [] as Buffer[]);
-  }
-
-  /**
-   * Verifies a proof of inclusion for a leaf node
-   * @param proof - Array of sibling hashes from getProof()
-   * @param targetHash - Hash of the leaf node being verified
-   * @param root - Expected root hash
-   * @returns boolean indicating if proof is valid
-   */
-  public verify(proof: Buffer[], targetHash: Buffer, root: Buffer): boolean {
-    let computedHash = targetHash;
-
-    for (const proofElement of proof) {
-      computedHash = Buffer.compare(computedHash, proofElement) <= 0
-        ? this.combinedHash(computedHash, proofElement)
-        : this.combinedHash(proofElement, computedHash);
-    }
-
-    return computedHash.equals(root);
-  }
-} 

package/src/shared/types/index.ts

@@ -1,25 +0,0 @@
-export interface FileData {
-  name: string;
-  size: number;
-  lastModified: number;
-  arrayBuffer(): Promise<ArrayBuffer>;
-}
-
-export interface ZipFileEntry {
-  fileData?: FileData;
-}
-
-export interface Support {
-  base64: boolean;
-  array: boolean;
-  string: boolean;
-  isNode: boolean;
-  buffer: boolean;
-  uint8array: boolean;
-  arrayBuffer: boolean;
-  blob: boolean;
-  streams: boolean;
-  fileReader: boolean;
-}
-
-// External module types are handled by installed @types packages 

package/src/shared/types/modules.d.ts

@@ -1,22 +0,0 @@
-declare module 'pako' {
-  export function deflateRaw(data: Uint8Array | Buffer, options?: any): Buffer;
-  export function inflateRaw(data: Uint8Array | Buffer): Buffer;
-}
-
-declare module 'opentimestamps' {
-  export class Ops {
-    static OpSHA256: any;
-  }
-  export class DetachedTimestampFile {
-    static fromHash(op: any, digest: Buffer): DetachedTimestampFile;
-    static deserialize(ots: Buffer): DetachedTimestampFile;
-    serializeToBytes(): Uint8Array;
-    timestamp?: {
-      allAttestations(): string[];
-    };
-  }
-  export function stamp(detached: DetachedTimestampFile[]): Promise<void>;
-  export function upgrade(ots: DetachedTimestampFile): Promise<boolean>;
-  export function verify(ots: DetachedTimestampFile, hash: DetachedTimestampFile, options?: any): Promise<any>;
-  export function info(detached: DetachedTimestampFile): string;
-} 

package/src/shared/types/opentimestamps.d.ts

@@ -1,23 +0,0 @@
-/**
- * Type declarations for OpenTimestamps module
- */
-declare module 'opentimestamps' {
-  namespace stamp {
-    function create(fileBuffer: Buffer): Promise<Buffer>;
-  }
-
-  namespace verify {
-    function verifyTimestamp(ots: Buffer, fileHash: Buffer): Promise<any>;
-  }
-
-  namespace utils {
-    function hexToBytes(hex: string): number[];
-    function bytesToHex(bytes: number[]): string;
-  }
-
-  export default {
-    stamp,
-    verify,
-    utils
-  };
-} 

package/src/shared/types.d.ts

@@ -1,8 +0,0 @@
-// Type declarations for modules without proper TypeScript support
-
-declare module 'opentimestamps' {
-  export default class OpenTimestamps {
-    static stamp(data: Buffer): Promise<any>;
-    static verify(timestamp: any, data: Buffer): Promise<boolean>;
-  }
-}