neozipkit 0.2.1 → 0.3.0

package/dist/shared/components/CertificateOTS.d.ts

@@ -1,15 +0,0 @@
-import ZipEntry from '../ZipEntry';
-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;

package/dist/shared/components/CertificateOTS.js

@@ -1,116 +0,0 @@
-"use strict";
-// ======================================
-//	CertificateOTS.ts
-//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
-// ======================================
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = CertificateTemplate;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const Headers_1 = require("../constants/Headers");
-/**
- * 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
- */
-function CertificateTemplate(attestStr, zipFile, hashDigest, needsUpdateMsg, attestationValues, zipEntries, narrow) {
-    // Load the HTML template
-    let templatePath;
-    try {
-        // Try to find the template from the package root
-        templatePath = path_1.default.resolve(process.cwd(), 'assets/templates/certificate.html');
-        if (!fs_1.default.existsSync(templatePath)) {
-            // If not found in current working directory, try relative to this file
-            templatePath = path_1.default.resolve(__dirname, '../../assets/templates/certificate.html');
-        }
-        if (!fs_1.default.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_1.default.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 === Headers_1.TIMESTAMP_METADATA) {
-            stampEntry = entry;
-        }
-        else if (entry.filename === Headers_1.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/dist/shared/components/FileSys.d.ts

@@ -1,2 +0,0 @@
-export declare function outputToFile(fileName: string, buffer: Buffer, dirPath: string, overwrite: boolean, never: boolean, fileAttr: number): boolean;
-export declare function makeDir(folder: string): void;

package/dist/shared/components/FileSys.js

@@ -1,113 +0,0 @@
-"use strict";
-// ======================================
-//	FileSys.ts
-//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
-// ======================================
-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.outputToFile = outputToFile;
-exports.makeDir = makeDir;
-const fs = __importStar(require("fs"));
-const pth = __importStar(require("path"));
-const Errors_1 = __importDefault(require("../constants/Errors"));
-// Output a buffer to a file
-function outputToFile(fileName, buffer, dirPath, overwrite, never, fileAttr) {
-    // 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
-function makeDir(folder) {
-    console.log('mkDir: ', folder);
-    // Sync - make directories tree
-    function mkdirSync(fpath) {
-        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_1.default.FILE_IN_THE_WAY.replace("%s", resolvedPath);
-        });
-    }
-    mkdirSync(folder);
-}
-;

package/dist/shared/components/HashAccumulator.d.ts

@@ -1,55 +0,0 @@
-/**
- * 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;
-    private xorResult;
-    /**
-     * Creates a new HashAccumulator instance
-     * Initializes empty hash array and zero-filled XOR buffer
-     */
-    constructor();
-    /**
-     * 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): void;
-    /**
-     * Gets the accumulated XOR of all added hashes
-     * @returns Hex string of XOR result
-     */
-    xorHash(): string;
-    /**
-     * 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;
-    /**
-     * Gets the number of hashes accumulated
-     * @returns Number of accumulated hashes
-     */
-    leafCount(): number;
-    /**
-     * Resets the accumulator to initial state
-     * Clears hash array and zeroes XOR buffer
-     */
-    clear(): void;
-    /**
-     * 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;
-    }[]): string | null;
-}

package/dist/shared/components/HashAccumulator.js

@@ -1,100 +0,0 @@
-"use strict";
-// ======================================
-//  HashAccumulator.ts
-// ======================================
-Object.defineProperty(exports, "__esModule", { value: true });
-const merkleTree_1 = require("./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
- * ```
- */
-class HashAccumulator {
-    /**
-     * 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) {
-        // 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() {
-        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() {
-        let merkleRoot = null;
-        if (this.hashes.length > 0) {
-            const tree = new merkleTree_1.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() {
-        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) {
-        const accumulator = new HashAccumulator();
-        // Combine all hashes
-        for (const result of results) {
-            if (result.merkleRoot) {
-                accumulator.addHash(result.merkleRoot);
-            }
-        }
-        return accumulator.merkleRoot();
-    }
-}
-exports.default = HashAccumulator;

package/dist/shared/components/ZipCrypto.d.ts

@@ -1,3 +0,0 @@
-export declare function sha256(data: Buffer): string;
-export declare function encrypter(data: Buffer | null, checkByte: number, pwd: string): Buffer | null;
-export declare function decrypter(pwd: string | Buffer): Function;

package/dist/shared/components/ZipCrypto.js

@@ -1,78 +0,0 @@
-// ======================================
-//	ZipCrypto.ts
-//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
-// ======================================
-// Zip Cryptography Routines
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha256 = sha256;
-exports.encrypter = encrypter;
-exports.decrypter = decrypter;
-const crypto_1 = require("crypto");
-const Util_1 = require("./Util");
-const Headers_1 = require("../constants/Headers");
-// Return the SHA256 hash of a buffer
-function sha256(data) {
-    const hash = (0, crypto_1.createHash)('sha256');
-    return hash
-        .update(data)
-        .digest('hex');
-}
-class InitKeys {
-    constructor(pw) {
-        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) {
-        this.keys[0] = (0, Util_1.crc32update)(this.keys[0], byteValue);
-        this.keys[1] = ((this.keys[1] + (this.keys[0] & 0xff)) * 0x08088405 + 1) >>> 0;
-        this.keys[2] = (0, Util_1.crc32update)(this.keys[2], this.keys[1] >>> 24);
-        return byteValue;
-    }
-    next() {
-        const k = (this.keys[2] | 2) >>> 0; // key
-        return ((0, Util_1.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) {
-    const keys = new InitKeys(pwd);
-    return function (data, result, pos = 0) {
-        // 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
-function encrypter(data, checkByte, pwd) {
-    if (!data)
-        return null;
-    const _encrypter = make_encrypter(pwd);
-    const salt = (0, crypto_1.randomFillSync)(Buffer.alloc(Headers_1.ENCRYPT_HDR_SIZE));
-    salt[Headers_1.ENCRYPT_HDR_SIZE - 1] = checkByte;
-    // create encryption header
-    const result = Buffer.alloc(data.length + Headers_1.ENCRYPT_HDR_SIZE);
-    _encrypter(salt, result);
-    // encode content
-    return _encrypter(data, result, Headers_1.ENCRYPT_HDR_SIZE);
-}
-// Return the decrypter function
-function decrypter(pwd) {
-    const keys = new InitKeys(pwd);
-    return function (data) {
-        for (let i = 0; i < data.length; i++) {
-            data[i] = keys.updateKeys(data[i] ^ keys.next());
-        }
-        return data;
-    };
-}

package/dist/shared/components/merkleTree.d.ts

@@ -1,66 +0,0 @@
-/**
- * Configuration options for Merkle tree construction
- */
-interface MerkleTreeOptions {
-    hashLeaves: boolean;
-    sortLeaves: boolean;
-    sortPairs: boolean;
-    duplicateOdd: boolean;
-}
-/**
- * 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 declare class MerkleTree {
-    private leaves;
-    private layers;
-    private options;
-    /**
-     * 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>);
-    /**
-     * Computes SHA-256 hash of input data
-     * @param data - Data to hash
-     * @returns Buffer containing hash
-     */
-    private hash;
-    /**
-     * 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;
-    /**
-     * Builds the Merkle tree by creating successive layers of hashes
-     * @param nodes - Array of nodes in current layer
-     */
-    private createHashes;
-    /**
-     * Gets the root hash of the Merkle tree
-     * @returns Buffer containing root hash
-     */
-    getRoot(): Buffer;
-    /**
-     * 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
-     */
-    getProof(leaf: Buffer): 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
-     */
-    verify(proof: Buffer[], targetHash: Buffer, root: Buffer): boolean;
-}
-export {};

package/dist/shared/components/merkleTree.js

@@ -1,136 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MerkleTree = void 0;
-const crypto_1 = require("crypto");
-/**
- * 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.
- */
-class MerkleTree {
-    /**
-     * 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, options = {}) {
-        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
-     */
-    hash(data) {
-        return (0, crypto_1.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
-     */
-    combinedHash(left, right) {
-        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
-     */
-    createHashes(nodes) {
-        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
-     */
-    getRoot() {
-        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
-     */
-    getProof(leaf) {
-        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;
-        }, []);
-    }
-    /**
-     * 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
-     */
-    verify(proof, targetHash, root) {
-        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);
-    }
-}
-exports.MerkleTree = MerkleTree;