neozipkit 0.1.1

package/src/shared/components/merkleTree.ts

@@ -0,0 +1,162 @@
+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/constants/Errors.ts

@@ -0,0 +1,82 @@
+// ======================================
+//	Errors.ts
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+// Error messages
+
+export default {
+    /* Header error messages */
+    INVALID_LOC: "Invalid LOC header (bad signature)",
+    INVALID_CEN: "Invalid CEN header (bad signature)",
+    INVALID_END: "Invalid END header (bad signature)",
+
+    /* ZipEntry error messages*/
+    NO_DATA: "Nothing to decompress",
+    FILE_IN_THE_WAY: "There is a file in the way: %s",
+    UNKNOWN_METHOD: "Invalid/unsupported compression method",
+
+    /* Encryption Errors */
+    STRONG_ENCRYPT_UNSUPPORTED: "Strong Encryption is not supported",
+
+    /* Timestamp error messages */
+    INVALID_TIMESTAMP: "Invalid timestamp",
+    TIMESTAMP_FAILED: "Failed to create the timestamp",
+
+    /* Inflater error messages */
+    AVAIL_DATA: "inflate::Available inflate data did not terminate",
+    INVALID_DISTANCE: "inflate::Invalid literal/length or distance code in fixed or dynamic block",
+    TO_MANY_CODES: "inflate::Dynamic block code description: too many length or distance codes",
+    INVALID_REPEAT_LEN: "inflate::Dynamic block code description: repeat more than specified lengths",
+    INVALID_REPEAT_FIRST: "inflate::Dynamic block code description: repeat lengths with no first length",
+    INCOMPLETE_CODES: "inflate::Dynamic block code description: code lengths codes incomplete",
+    INVALID_DYN_DISTANCE: "inflate::Dynamic block code description: invalid distance code lengths",
+    INVALID_CODES_LEN: "inflate::Dynamic block code description: invalid literal/length code lengths",
+    INVALID_STORE_BLOCK: "inflate::Stored block length did not match one's complement",
+    INVALID_BLOCK_TYPE: "inflate::Invalid block type (type == 3)",
+
+    /* Extract error messages */
+    INVALID_CMP_DATA_LENGTH: "Compressed data length does not match the expected length",
+    EXTRACT_FAILED: "Failed to extract file",
+    INVALID_CRC: "CRC32 checksum does not match the expected value",
+    UNKNOWN_SHA256: "The SHA-256 hash has not been saved",
+    INVALID_SHA256: "The SHA-256 hash does not match the expected value",
+
+    /* NEO-ZIP error messages */
+    CANT_EXTRACT_FILE: "Could not extract the file",
+    CANT_OVERRIDE: "Target file already exists",
+    NO_ZIP: "No zip file was loaded",
+    NO_ENTRY: "Entry doesn't exist",
+    DIRECTORY_CONTENT_ERROR: "A directory cannot have content",
+    FILE_NOT_FOUND: "File not found: %s",
+    NOT_IMPLEMENTED: "Not implemented",
+    INVALID_FILENAME: "Invalid filename",
+    INVALID_FORMAT: "Invalid or unsupported zip format. No END header found",
+
+    // NeoZipKit error messages
+    NO_STREAM_SUPPORT: "Streams are not supported in this environment",
+    NO_BLOB_SUPPORT: "Blobs are not supported in this environment",
+    NO_FILE_READER_SUPPORT: "FileReader is not supported in this environment",
+
+    // Create Zip error messages
+    NO_FILES: "No files added, Zip file not created",
+
+    DATATYPE_STRING_UNSUPPORTED: "The String type is not supported by this platform.",
+    DATATYPE_ARRAY_UNSUPPORTED: "The Array type is not supported by this platform.",
+    DATATYPE_BUFFER_UNSUPPORTED: "The Buffer type is not supported by this platform.",
+    DATATYPE_BLOB_UNSUPPORTED: "The Blob type is not supported by this platform.",
+    DATATYPE_U8ARRAY_UNSUPPORTED: "The uint8Array type is not supported by this platform.",
+    DATATYPE_ARRAYBUFFER_UNSUPPORTED: "The ArrayBuffer type is not supported by this platform.",
+    DATATYPE_UNSUPPORTED: "Unsupported input type.",
+
+    COMPRESS_FAILED: 'Failed to compress data',
+    COMPRESSION_ERROR: 'Error occurred during compression',
+    DECOMPRESSION_ERROR: 'Error occurred during decompression',
+
+    ENCRYPT_FAILED: 'Encryption failed',
+
+    // Certificate error messages
+    CERTIFICATE_OTS_BAD: 'Unable to create OTS certificate, bad OTS timestamp',
+    CERTIFICATE_OTS_FAILED: 'Failed to create OTS certificate',
+};
+
+

package/src/shared/constants/Headers.ts

@@ -0,0 +1,203 @@
+// ======================================
+//	Headers.ts
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+// Zip File Format Constants
+
+export const LOCAL_FILE_HEADER = 'PK\x03\x04';
+export const CENTRAL_FILE_HEADER = 'PK\x01\x02';
+export const CENTRAL_DIRECTORY_END = 'PK\x05\x06';
+export const ZIP64_CENTRAL_DIRECTORY_LOCATOR = 'PK\x06\x07';
+export const ZIP64_CENTRAL_DIRECTORY_END = 'PK\x06\x06';
+export const DATA_DESCRIPTOR = 'PK\x07\x08';
+
+export const TIMESTAMP_SUBMITTED = 'META-INF/TS-SUBMIT.OTS';
+export const TIMESTAMP_METADATA = 'META-INF/TIMESTAMP.OTS';
+export const TOKENIZED_METADATA = 'META-INF/NZIP.TOKEN';
+
+// Local file header
+export const LOCAL_HDR = {
+  SIZE:       30,     // LOC header size in bytes
+  SIGNATURE:  0x04034b50,  // "PK\003\004"
+  VER_EXTRACT: 4,     // version needed to extract
+  FLAGS:       6,     // general purpose bit flag
+  COMPRESSION: 8,     // compression method
+  TIMEDATE_DOS: 10,   // modification time (2 bytes time, 2 bytes date)
+  CRC:        14,     // uncompressed file crc-32 value
+  CMP_SIZE:   18,     // compressed size
+  UNCMP_SIZE: 22,     // uncompressed size
+  FNAME_LEN:  26,     // filename length
+  EXTRA_LEN:  28      // extra field length
+};
+export const ENCRYPT_HDR_SIZE = 12;
+
+// Data descriptor
+export const DATA_DESC = {
+  SIGNATURE:  0x08074b50,  // "PK\007\008"
+  SIZE:       16,     // EXT header size in bytes
+  CRC:        4,      // uncompressed file crc-32 value (offset)
+  CMP_SIZE:   8,      // compressed size (offset)
+  UNCMP_SIZE: 12      // uncompressed size
+};
+
+// The central directory file header 
+export const CENTRAL_DIR = {
+  SIZE:       46,     // Central directory header size
+  SIGNATURE:  0x02014b50,  // "PK\001\002"
+  VER_MADE:   4,      // version made by
+  VER_EXT:    6,      // version needed to extract
+  FLAGS:      8,      // encrypt, decrypt flags
+  CMP_METHOD: 10,    // compression method
+  TIMEDATE_DOS: 12,     // DOS modification time (2 bytes time, 2 bytes date)
+  CRC:        16,     // uncompressed file crc-32 value
+  CMP_SIZE:   20,     // compressed size
+  UNCMP_SIZE: 24,     // uncompressed size
+  FNAME_LEN:  28,     // filename length
+  EXTRA_LEN:  30,     // extra field length
+  COMMENT_LEN: 32,    // file comment length
+  DISK_NUM:   34,     // volume number start
+  INT_FILE_ATTR: 36,  // internal file attributes
+  EXT_FILE_ATTR: 38,  // external file attributes (host system dependent)
+  LOCAL_HDR_OFFSET: 42 // LOC header offset
+};
+
+// The Zip central directory Locator
+export const CENTRAL_END = {
+  SIZE:       22,         // END header size
+  SIGNATURE:  0x06054b50, // "PK\005\006"
+  VOL_NUM:        4,      // number of this disk
+  VOLDIR_START:   6,      // number of the volume/disk with start of the Central Directory
+  VOL_ENTRIES:    8,      // number of entries on this volume/disk
+  TOTAL_ENTRIES:  10,     // total number of entries on this disk
+  CENTRAL_DIR_SIZE: 12,   // central directory size in bytes
+  CENTRAL_DIR_OFFSET: 16, // offset of first CEN header
+  ZIP_COMMENT_LEN: 20     // zip file comment length
+};
+
+// Zip64 Central Directory Entry
+export const ZIP64_CENTRAL_DIR = {
+  SIGNATURE:  0x06064b50,  // zip64 signature, "PK\006\006"
+  SIZE:       56,     // zip64 record minimum size
+  LEAD:       12,     // leading bytes at the start of the record, not counted by the value stored in ZIP64SIZE
+  SIZE_FIELD:  4,     // zip64 size of the central directory record
+  VER_MADEBY: 12,     // zip64 version made by
+  VER_NEEDED: 14,     // zip64 version needed to extract
+  VOL_NUM:    16,     // zip64 number of this disk
+  VOLDIR_START: 20,  // number of the disk with the start of the record directory
+  VOL_ENTRIES:  24,  // number of entries on this disk
+  TOTAL_ENTRIES: 32,  // total number of entries
+  CENTRAL_DIR_SIZE: 40, // zip64 central directory size in bytes
+  CENTRAL_DIR_OFFSET: 48, // offset of start of central directory with respect to the starting disk number
+  EXTRA_FIELD:   56   // extensible data sector
+};
+
+// Zip64 Central directory locator
+export const ZIP64_CENTRAL_END = {
+  SIZE:       20,         // zip64 END header size
+  SIGNATURE:  0x07064b50, // zip64 Locator signature, "PK\006\007"
+  VOL_NUM:    4,          // number of the disk with the start of the zip64
+  CENTRAL_DIR_OFFSET: 8,  // relative offset of the zip64 end of central directory
+  TOTAL_DISKS: 16         // total number of disks
+};
+
+// Compression methods
+export const CMP_METHOD = {
+  STORED:           0,  // no compression
+  SHRUNK:           1,  // shrunk
+  REDUCED1:         2,  // reduced with compression factor 1
+  REDUCED2:         3,  // reduced with compression factor 2
+  REDUCED3:         4,  // reduced with compression factor 3
+  REDUCED4:         5,  // reduced with compression factor 4
+  IMPLODED:         6,  // imploded
+  DEFLATED:         8,  // deflated
+  ENHANCED_DEFLATE: 9,  // enhanced deflated
+  BZIP2:            12, //  compressed using BZIP2
+  LZMA:             14, // LZMA
+  IBM_TERSE:        18, // compressed using IBM TERSE
+  IBM_LZ77:         19, // IBM LZ77
+  ZSTD:             93, // Zstandard compression
+  AES_ENCRYPT:      99  // WinZIP AES encryption method
+};
+
+// General purpose bit flag
+export const GP_FLAG = {
+  ENCRYPTED:      1,    // Bit 0: encrypted file
+  COMPRESSION1:   2,    // Bit 1, compression option
+  COMPRESSION2:   4,    // Bit 2, compression option
+  DATA_DESC:      8,    // Bit 3, data descriptor 
+  ENHANCED_DEFLATE: 16, // Bit 4, enhanced deflating
+  PATCHED:        32,   // Bit 5, indicates that the file is compressed patched data.
+  STRONG_ENCRYPT: 64,   // Bit 6, strong encryption (patented)
+                        // Bits 7-10: Currently unused.
+  EFS:            2048, // Bit 11: Language encoding flag (EFS)
+                        // Bit 12: Reserved by PKWARE for enhanced compression.
+                        // Bit 13: encrypted the Central Directory (patented).
+                        // Bits 14-15: Reserved by PKWARE.
+  MASK:           4096, // mask header values
+};
+
+// 4.5 Extensible data fields
+export const EXTENSIBLE_DATA_FIELDS = {
+  ID:              0,
+  SIZE:            2,
+};
+
+// Header IDs
+export const HDR_ID = {
+  ZIP64:           0x0001,
+  AVINFO:          0x0007,
+  PFS:             0x0008,
+  OS2:             0x0009,
+  NTFS:            0x000a,
+  OPENVMS:         0x000c,
+  UNIX:            0x000d,
+  FORK:            0x000e,
+  PATCH:           0x000f,
+  x509PKCS7:       0x0014,
+  x509CERT_IDF:    0x0015,
+  x509CERT_IDC:    0x0016,
+  STRONG_ENC:      0x0017,
+  RECORD_MGT:      0x0018,
+  x509PKCS7RL:     0x0019,
+  IBM1:            0x0065,
+  IBM2:            0x0066,
+  SHA256:          0x014E,    // SHA256 "N\01" with 64 bytes (256 bit) of SHA256 hash data
+  POSZIP:          0x4690,    // POSZIP 4690
+  UNV_TIME:        0x5455,    // Universal Time (UT) (32-bit) 5 data bytes
+  UID_GID:         0x7875,    // Unix UID/GID (any size)
+  UNICODE_PATH:    0x7075,    // Info-ZIP Unicode Path Extra Field
+};
+
+// File System
+export const FILE_SYSTEM = {
+  MSDOS:           0,   // MS-DOS and OS/2 (FAT / VFAT / FAT32 file systems)
+  AMIGA:           1,   // Amiga
+  OPENVMS:         2,   // OpenVMS
+  UNIX:            3,   // UNIX
+  VM_CMS:          4,   // VM/CMS
+  ATARI:           5,   // Atari ST
+  OS2:             6,   // OS/2 H.P.F.S.
+  MAC:             7,   // Macintosh
+  CP_M:            9,   // CP/M
+  NTFS:            10,  // Windows NTFS
+  MVS:             11,  // MVS (OS/390 - Z/OS)
+  VSE:             12,  // VSE
+  ACORN:           13,  // Acorn Risc
+  VFAT:            14,  // VFAT
+  ALTMVS:          15,  // Alternate MVS
+  BEOS:            16,  // BeOS
+  TANDEM:          17,  // Tandem
+  OS400:           18,  // OS/400
+  DARWIN:          19   // Apple OS/X (Darwin)
+};
+
+// DOS File Attributes
+export const DOS_FILE_ATTR = {
+  READONLY:        0x01,
+  HIDDEN:          0x02,
+  SYSTEM:          0x04,
+  VOLUME:          0x08,
+  DIRECTORY:       0x10,
+  ARCHIVE:         0x20
+};
+

package/src/shared/types/index.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,23 @@
+/**
+ * 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

@@ -0,0 +1,8 @@
+// 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>;
+  }
+} 

package/src/shared/types.ts

@@ -0,0 +1,43 @@
+import { VERSION } from './version';
+
+export interface FileData {
+  name: string;
+  size: number;
+  lastModified: number;
+  arrayBuffer(): Promise<ArrayBuffer>;
+}
+
+export interface FileReader extends EventTarget {
+  readAsArrayBuffer(blob: Blob): void;
+  onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+  onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+  result: string | ArrayBuffer | null;
+  error: Error | null;
+}
+
+export interface ZipFileEntry {
+  filename: string;
+  comment?: string | null;
+  fileData?: FileData;
+  fileBuffer?: Buffer | null;
+  isDirectory: boolean;
+  isMetaData: boolean;
+  isEncrypted: boolean;
+  sha256?: string | null;
+}
+
+export interface AttestationValue {
+  blockHeight: number;
+  transactionId: string;
+  merkleRoot: string;
+}
+
+export interface NeoZipKitInfo {
+  version: string;
+  releaseDate: string;
+}
+
+export const NEOZIPKIT_INFO: NeoZipKitInfo = {
+  version: VERSION.number,
+  releaseDate: VERSION.date
+};

package/src/shared/version.ts

@@ -0,0 +1,4 @@
+export const VERSION = {
+  number: '0.1.51',
+  date: '04-17-2025'
+}; 

package/src/types/index.ts

@@ -0,0 +1,25 @@
+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/types/modules.d.ts

@@ -0,0 +1,22 @@
+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/types/opentimestamps.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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
+  };
+}