@dignetwork/dig-sdk 0.0.1-alpha.4 → 0.0.1-alpha.6

package/dist/DataIntegrityTree/DataIntegrityTree.d.ts

@@ -0,0 +1,160 @@
+import { MerkleTree } from "merkletreejs";
+import { Readable } from "stream";
+export interface DataIntegrityTreeOptions {
+    storeDir?: string;
+    storageMode?: "local" | "unified";
+    rootHash?: string;
+    disableInitialize?: boolean;
+}
+/**
+ * DataStoreManager class to manage Merkle tree operations.
+ */
+declare class DataIntegrityTree {
+    private storeId;
+    private storeBaseDir;
+    private storeDir;
+    private dataDir;
+    files: Map<string, {
+        hash: string;
+        sha256: string;
+    }>;
+    private tree;
+    constructor(storeId: string, options?: DataIntegrityTreeOptions);
+    static from(storeId: string, options: DataIntegrityTreeOptions): DataIntegrityTree;
+    /**
+     * Load the manifest file.
+     * @private
+     */
+    private _loadManifest;
+    /**
+     * Load the latest tree from the manifest file.
+     * @private
+     */
+    private _loadLatestTree;
+    /**
+     * Save a binary stream to the store's data directory.
+     * @param sha256 - The SHA-256 hash of the buffer.
+     * @returns The write stream for the file.
+     */
+    private _createWriteStream;
+    /**
+     * Stream file from one path to another.
+     * @param src - The source file path.
+     * @param dest - The destination file path.
+     */
+    private _streamFile;
+    /**
+     * Upsert a key with a binary stream to the Merkle tree.
+     * Compresses the file, calculates the SHA-256 of the uncompressed file, and stores it.
+     * @param readStream - The binary data stream.
+     * @param key - The hexadecimal key for the binary data.
+     */
+    upsertKey(readStream: Readable, key: string): Promise<void>;
+    /**
+     * Delete a key from the Merkle tree.
+     * @param key - The hexadecimal key to delete.
+     */
+    deleteKey(key: string): void;
+    /**
+     * List all keys in the Merkle tree.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The list of keys.
+     */
+    listKeys(rootHash?: string | null): string[];
+    /**
+     * Rebuild the Merkle tree from the current files.
+     * @private
+     */
+    private _rebuildTree;
+    /**
+     * Get the root of the Merkle tree.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The Merkle root.
+     */
+    getRoot(): string;
+    /**
+     * Serialize the Merkle tree to a JSON object.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The serialized Merkle tree.
+     */
+    serialize(rootHash?: string | null): object;
+    /**
+     * Deserialize a JSON object to a Merkle tree.
+     * @param rootHash - The root hash of the tree.
+     * @returns The deserialized Merkle tree.
+     */
+    deserializeTree(rootHash: string): MerkleTree;
+    private appendRootHashToManifest;
+    /**
+     * Commit the current state of the Merkle tree.
+     */
+    commit(): string | undefined;
+    /**
+     * Clear pending changes and revert to the latest committed state.
+     */
+    clearPendingRoot(): void;
+    /**
+     * Check if a file exists for a given key.
+     * @param hexKey - The hexadecimal key of the file.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns A boolean indicating if the file exists.
+     */
+    hasKey(hexKey: string, rootHash?: string | null): boolean;
+    /**
+     * Get a readable stream for a file based on its key, with decompression.
+     * @param hexKey - The hexadecimal key of the file.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The readable stream for the file.
+     */
+    getValueStream(hexKey: string, rootHash?: string | null): Readable;
+    /**
+     * Delete all leaves from the Merkle tree.
+     */
+    deleteAllLeaves(): void;
+    getSHA256(hexKey: string, rootHash?: string): string | undefined;
+    /**
+     * Get a proof for a file based on its key and SHA-256 hash.
+     * @param hexKey - The hexadecimal key of the file.
+     * @param sha256 - The SHA-256 hash of the file.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The proof for the file as a hex string.
+     */
+    getProof(hexKey: string, sha256: string, rootHash?: string | null): string;
+    /**
+     * Verify a proof for a file against the Merkle tree.
+     * @param proofObjectHex - The proof object as a hex string.
+     * @param sha256 - The SHA-256 hash of the file.
+     * @returns True if the proof is valid, false otherwise.
+     */
+    verifyProof(proofObjectHex: string, sha256: string): boolean;
+    /**
+     * Get the difference between two Merkle tree roots.
+     * @param rootHash1 - The first root hash.
+     * @param rootHash2 - The second root hash.
+     * @returns An object containing the added and deleted keys and their SHA-256 hashes.
+     */
+    getRootDiff(rootHash1: string, rootHash2: string): {
+        added: Map<string, string>;
+        deleted: Map<string, string>;
+    };
+    /**
+     * Verify the integrity of a file based on its SHA-256 hash and check if it is in the specified Merkle root.
+     * @param sha256 - The SHA-256 hash of the file.
+     * @param root - The root hash to check against.
+     * @returns True if the file integrity is verified and it is in the Merkle root, false otherwise.
+     */
+    verifyKeyIntegrity(sha256: string, rootHash: string): Promise<boolean>;
+    /**
+     * Static method to validate key integrity using a foreign Merkle tree.
+     * Verifies if a given SHA-256 hash for a key exists within the foreign tree and checks if the root hash matches.
+     *
+     * @param key - The hexadecimal key of the file.
+     * @param sha256 - The SHA-256 hash of the file.
+     * @param serializedTree - The foreign serialized Merkle tree.
+     * @param expectedRootHash - The expected root hash of the Merkle tree.
+     * @returns A boolean indicating if the SHA-256 is present in the foreign tree and the root hash matches.
+     */
+    static validateKeyIntegrityWithForeignTree(key: string, sha256: string, serializedTree: object, expectedRootHash: string): boolean;
+}
+export { DataIntegrityTree };
+//# sourceMappingURL=DataIntegrityTree.d.ts.map

package/dist/DataIntegrityTree/DataIntegrityTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataIntegrityTree.d.ts","sourceRoot":"","sources":["../../src/DataIntegrityTree/DataIntegrityTree.ts"],"names":[],"mappings":"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"}

package/dist/DataIntegrityTree/DataIntegrityTree.js

@@ -0,0 +1,648 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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.DataIntegrityTree = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const zlib = __importStar(require("zlib"));
+const crypto_js_1 = require("crypto-js");
+const merkletreejs_1 = require("merkletreejs");
+const util_1 = require("util");
+const DataLayerError_1 = __importDefault(require("./DataLayerError"));
+const unlink = (0, util_1.promisify)(fs.unlink);
+/**
+ * Convert a string to hexadecimal representation.
+ * @param str - The input string.
+ * @returns The hexadecimal representation of the input string.
+ */
+const toHex = (str) => {
+    return Buffer.from(str).toString("hex");
+};
+/**
+ * Remove empty directories recursively.
+ * @param dir - The directory path.
+ */
+const removeEmptyDirectories = (dir) => {
+    if (fs.existsSync(dir)) {
+        const files = fs.readdirSync(dir);
+        if (files.length === 0) {
+            fs.rmdirSync(dir);
+            const parentDir = path.dirname(dir);
+            removeEmptyDirectories(parentDir);
+        }
+    }
+};
+/**
+ * Check if a string is a valid hexadecimal string.
+ * @param str - The string to validate.
+ * @returns True if the string is a valid hex string, false otherwise.
+ */
+const isHexString = (str) => {
+    return /^[0-9a-fA-F]+$/.test(str) && str.length % 2 === 0;
+};
+/**
+ * DataStoreManager class to manage Merkle tree operations.
+ */
+class DataIntegrityTree {
+    constructor(storeId, options = {}) {
+        if (!isHexString(storeId) || storeId.length !== 64) {
+            throw new Error("storeId must be a 64 char hex string");
+        }
+        this.storeId = storeId;
+        this.storeBaseDir = options.storeDir || "./";
+        if (!fs.existsSync(this.storeBaseDir)) {
+            fs.mkdirSync(this.storeBaseDir, { recursive: true });
+        }
+        if (options.storageMode === "unified") {
+            this.dataDir = path.join(this.storeBaseDir, "data");
+        }
+        else {
+            this.dataDir = path.join(this.storeBaseDir, this.storeId, "data");
+        }
+        this.storeDir = path.join(this.storeBaseDir, this.storeId);
+        if (!fs.existsSync(this.storeDir)) {
+            fs.mkdirSync(this.storeDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+        }
+        this.files = new Map();
+        if (options.rootHash) {
+            const manifest = this._loadManifest();
+            if (manifest.includes(options.rootHash)) {
+                this.tree = this.deserializeTree(options.rootHash);
+            }
+            else {
+                throw new DataLayerError_1.default(404, `Root hash ${options.rootHash} not found`);
+            }
+        }
+        else {
+            this.tree = this._loadLatestTree();
+        }
+        // Commit the empty Merkle tree immediately upon creation
+        if (!options.disableInitialize && this.tree.getLeafCount() === 0) {
+            this.commit();
+        }
+    }
+    static from(storeId, options) {
+        return new DataIntegrityTree(storeId, { ...options, disableInitialize: true });
+    }
+    /**
+     * Load the manifest file.
+     * @private
+     */
+    _loadManifest() {
+        const manifestPath = path.join(this.storeDir, "manifest.dat");
+        if (fs.existsSync(manifestPath)) {
+            return fs.readFileSync(manifestPath, "utf8").trim().split("\n");
+        }
+        return [];
+    }
+    /**
+     * Load the latest tree from the manifest file.
+     * @private
+     */
+    _loadLatestTree() {
+        const manifest = this._loadManifest();
+        if (manifest.length > 0) {
+            const latestRootHash = manifest[manifest.length - 1];
+            return this.deserializeTree(latestRootHash);
+        }
+        else {
+            return new merkletreejs_1.MerkleTree([], crypto_js_1.SHA256, { sortPairs: true });
+        }
+    }
+    /**
+     * Save a binary stream to the store's data directory.
+     * @param sha256 - The SHA-256 hash of the buffer.
+     * @returns The write stream for the file.
+     */
+    _createWriteStream(sha256) {
+        const subDirs = sha256.match(/.{1,2}/g) || [];
+        const fileDir = path.join(this.dataDir, ...subDirs.slice(0, -1));
+        const fileName = subDirs[subDirs.length - 1];
+        const fileSavePath = path.join(fileDir, fileName);
+        if (!fs.existsSync(fileDir)) {
+            fs.mkdirSync(fileDir, { recursive: true });
+        }
+        return fs.createWriteStream(fileSavePath);
+    }
+    /**
+     * Stream file from one path to another.
+     * @param src - The source file path.
+     * @param dest - The destination file path.
+     */
+    async _streamFile(src, dest) {
+        return new Promise((resolve, reject) => {
+            const readStream = fs.createReadStream(src);
+            const writeStream = fs.createWriteStream(dest);
+            readStream.pipe(writeStream);
+            writeStream.on("finish", resolve);
+            writeStream.on("error", reject);
+            readStream.on("error", reject);
+        });
+    }
+    /**
+     * Upsert a key with a binary stream to the Merkle tree.
+     * Compresses the file, calculates the SHA-256 of the uncompressed file, and stores it.
+     * @param readStream - The binary data stream.
+     * @param key - The hexadecimal key for the binary data.
+     */
+    async upsertKey(readStream, key) {
+        if (!isHexString(key)) {
+            throw new Error(`key must be a valid hex string: ${key}`);
+        }
+        const uncompressedHash = crypto.createHash("sha256");
+        const gzip = zlib.createGzip();
+        let sha256;
+        const tempDir = path.join(this.storeDir, "tmp");
+        if (!fs.existsSync(tempDir)) {
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+        const tempFilePath = path.join(tempDir, `${crypto.randomUUID()}.gz`);
+        return new Promise((resolve, reject) => {
+            const tempWriteStream = fs.createWriteStream(tempFilePath);
+            readStream.on("data", (chunk) => {
+                uncompressedHash.update(chunk);
+            });
+            readStream.pipe(gzip).pipe(tempWriteStream);
+            tempWriteStream.on("finish", async () => {
+                sha256 = uncompressedHash.digest("hex");
+                const finalWriteStream = this._createWriteStream(sha256);
+                const finalPath = finalWriteStream.path;
+                // Ensure the directory exists before copying the file
+                const finalDir = path.dirname(finalPath);
+                if (!fs.existsSync(finalDir)) {
+                    fs.mkdirSync(finalDir, { recursive: true });
+                }
+                try {
+                    await this._streamFile(tempFilePath, finalPath);
+                    await unlink(tempFilePath);
+                    const combinedHash = crypto
+                        .createHash("sha256")
+                        .update(`${key}/${sha256}`)
+                        .digest("hex");
+                    if (Array.from(this.files.values()).some((file) => file.hash === combinedHash)) {
+                        console.log(`No changes detected for key: ${key}`);
+                        return resolve();
+                    }
+                    if (this.files.has(key)) {
+                        this.deleteKey(key);
+                    }
+                    console.log(`Inserted key: ${key}`);
+                    this.files.set(key, {
+                        hash: combinedHash,
+                        sha256: sha256,
+                    });
+                    this._rebuildTree();
+                    resolve();
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            tempWriteStream.on("error", (err) => {
+                reject(err);
+            });
+            readStream.on("error", (err) => {
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Delete a key from the Merkle tree.
+     * @param key - The hexadecimal key to delete.
+     */
+    deleteKey(key) {
+        if (!isHexString(key)) {
+            throw new Error("key must be a valid hex string");
+        }
+        if (this.files.has(key)) {
+            this.files.delete(key);
+            this._rebuildTree();
+            console.log(`Deleted key: ${key}`);
+        }
+    }
+    /**
+     * List all keys in the Merkle tree.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The list of keys.
+     */
+    listKeys(rootHash = null) {
+        if (rootHash && !isHexString(rootHash)) {
+            throw new Error("rootHash must be a valid hex string");
+        }
+        if (rootHash) {
+            const tree = this.deserializeTree(rootHash);
+            // @ts-ignore
+            return Array.from(tree.files.keys());
+        }
+        return Array.from(this.files.keys());
+    }
+    /**
+     * Rebuild the Merkle tree from the current files.
+     * @private
+     */
+    _rebuildTree() {
+        const leaves = Array.from(this.files.values()).map(({ hash }) => Buffer.from(hash, "hex"));
+        this.tree = new merkletreejs_1.MerkleTree(leaves, crypto_js_1.SHA256, { sortPairs: true });
+    }
+    /**
+     * Get the root of the Merkle tree.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The Merkle root.
+     */
+    getRoot() {
+        return this.tree.getRoot().toString("hex");
+    }
+    /**
+     * Serialize the Merkle tree to a JSON object.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The serialized Merkle tree.
+     */
+    serialize(rootHash = null) {
+        if (rootHash && !isHexString(rootHash)) {
+            throw new Error("rootHash must be a valid hex string");
+        }
+        if (rootHash) {
+            const tree = this.deserializeTree(rootHash);
+            return {
+                root: tree.getRoot().toString("hex"),
+                leaves: tree.getLeaves().map((leaf) => leaf.toString("hex")),
+                // @ts-ignore
+                files: Object.fromEntries(tree.files),
+            };
+        }
+        return {
+            root: this.getRoot(),
+            leaves: this.tree.getLeaves().map((leaf) => leaf.toString("hex")),
+            files: Object.fromEntries(this.files),
+        };
+    }
+    /**
+     * Deserialize a JSON object to a Merkle tree.
+     * @param rootHash - The root hash of the tree.
+     * @returns The deserialized Merkle tree.
+     */
+    deserializeTree(rootHash) {
+        if (!isHexString(rootHash)) {
+            throw new Error("rootHash must be a valid hex string");
+        }
+        const treeFilePath = path.join(this.storeDir, `${rootHash}.dat`);
+        if (!fs.existsSync(treeFilePath)) {
+            throw new Error(`Tree file ${treeFilePath} does not exist`);
+        }
+        const data = JSON.parse(fs.readFileSync(treeFilePath, "utf8"));
+        const leaves = data.leaves.map((leaf) => Buffer.from(leaf, "hex"));
+        const tree = new merkletreejs_1.MerkleTree(leaves, crypto_js_1.SHA256, { sortPairs: true });
+        // @ts-ignore
+        tree.files = new Map(Object.entries(data.files).map(([key, value]) => [
+            key,
+            { hash: value.hash, sha256: value.sha256 },
+        ]));
+        // @ts-ignore
+        this.files = tree.files;
+        return tree;
+    }
+    appendRootHashToManifest(rootHash) {
+        const manifestPath = path.join(this.storeDir, "manifest.dat");
+        // Read the current manifest file
+        const manifestContent = fs.existsSync(manifestPath)
+            ? fs.readFileSync(manifestPath, "utf-8").trim().split("\n")
+            : [];
+        // Check if the last entry is the same as the rootHash to avoid duplicates
+        const latestRootHash = manifestContent.length > 0 ? manifestContent[manifestContent.length - 1] : null;
+        if (latestRootHash !== rootHash) {
+            // Append the new rootHash if it is not the same as the last one
+            fs.appendFileSync(manifestPath, `${rootHash}\n`);
+        }
+        else {
+            console.log(`Root hash ${rootHash} is already at the end of the file. Skipping append.`);
+        }
+    }
+    /**
+     * Commit the current state of the Merkle tree.
+     */
+    commit() {
+        const emptyRootHash = "0000000000000000000000000000000000000000000000000000000000000000";
+        const rootHash = this.tree.getLeafCount() === 0 ? emptyRootHash : this.getRoot();
+        const manifest = this._loadManifest();
+        const latestRootHash = manifest.length > 0 ? manifest[manifest.length - 1] : null;
+        if (rootHash === latestRootHash && rootHash !== emptyRootHash) {
+            console.log("No changes to commit. Aborting commit.");
+            return undefined;
+        }
+        this.appendRootHashToManifest(rootHash);
+        const treeFilePath = path.join(this.storeDir, `${rootHash}.dat`);
+        if (!fs.existsSync(path.dirname(treeFilePath))) {
+            fs.mkdirSync(path.dirname(treeFilePath), { recursive: true });
+        }
+        const serializedTree = this.serialize();
+        if (rootHash === emptyRootHash) {
+            serializedTree.root = emptyRootHash;
+        }
+        fs.writeFileSync(treeFilePath, JSON.stringify(serializedTree));
+        console.log(`Committed new root`);
+        console.log(this.tree.toString());
+        return rootHash;
+    }
+    /**
+     * Clear pending changes and revert to the latest committed state.
+     */
+    clearPendingRoot() {
+        this.tree = this._loadLatestTree();
+    }
+    /**
+     * Check if a file exists for a given key.
+     * @param hexKey - The hexadecimal key of the file.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns A boolean indicating if the file exists.
+     */
+    hasKey(hexKey, rootHash = null) {
+        if (!isHexString(hexKey)) {
+            throw new Error("key must be a valid hex string");
+        }
+        if (rootHash && !isHexString(rootHash)) {
+            throw new Error("rootHash must be a valid hex string");
+        }
+        let sha256;
+        if (rootHash) {
+            const tree = this.deserializeTree(rootHash);
+            // @ts-ignore
+            sha256 = tree.files.get(hexKey)?.sha256;
+        }
+        else {
+            sha256 = this.files.get(hexKey)?.sha256;
+        }
+        if (!sha256) {
+            return false;
+        }
+        const filePath = path.join(this.dataDir, sha256.match(/.{1,2}/g).join("/"));
+        // Check if the file exists at the calculated path
+        return fs.existsSync(filePath);
+    }
+    /**
+     * Get a readable stream for a file based on its key, with decompression.
+     * @param hexKey - The hexadecimal key of the file.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The readable stream for the file.
+     */
+    getValueStream(hexKey, rootHash = null) {
+        if (!isHexString(hexKey)) {
+            throw new Error("key must be a valid hex string");
+        }
+        if (rootHash && !isHexString(rootHash)) {
+            throw new Error("rootHash must be a valid hex string");
+        }
+        let sha256;
+        if (rootHash) {
+            const tree = this.deserializeTree(rootHash);
+            // @ts-ignore
+            sha256 = tree.files.get(hexKey)?.sha256;
+        }
+        else {
+            sha256 = this.files.get(hexKey)?.sha256;
+        }
+        if (!sha256) {
+            throw new Error(`File with key ${hexKey} not found.`);
+        }
+        const filePath = path.join(this.dataDir, sha256.match(/.{1,2}/g).join("/"));
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File at path ${filePath} does not exist`);
+        }
+        // Create a read stream and pipe it through a decompression stream using the same algorithm (gzip)
+        const readStream = fs.createReadStream(filePath);
+        const decompressStream = zlib.createGunzip();
+        // Return the combined stream as a generic Readable stream
+        return readStream.pipe(decompressStream);
+    }
+    /**
+     * Delete all leaves from the Merkle tree.
+     */
+    deleteAllLeaves() {
+        this.files.clear();
+        this._rebuildTree();
+    }
+    getSHA256(hexKey, rootHash) {
+        if (!rootHash) {
+            return this.files.get(hexKey)?.sha256;
+        }
+        const tree = this.deserializeTree(rootHash);
+        // @ts-ignore
+        return tree.files.get(hexKey)?.sha256;
+    }
+    /**
+     * Get a proof for a file based on its key and SHA-256 hash.
+     * @param hexKey - The hexadecimal key of the file.
+     * @param sha256 - The SHA-256 hash of the file.
+     * @param rootHash - The root hash of the tree. Defaults to the latest root hash.
+     * @returns The proof for the file as a hex string.
+     */
+    getProof(hexKey, sha256, rootHash = null) {
+        if (!isHexString(hexKey)) {
+            throw new Error("key must be a valid hex string");
+        }
+        if (!isHexString(sha256)) {
+            throw new Error("sha256 must be a valid hex string");
+        }
+        if (rootHash && !isHexString(rootHash)) {
+            throw new Error("rootHash must be a valid hex string");
+        }
+        if (!rootHash) {
+            const manifest = this._loadManifest();
+            rootHash = manifest[manifest.length - 1];
+        }
+        const tree = this.deserializeTree(rootHash);
+        const combinedHash = (0, crypto_js_1.SHA256)(`${hexKey}/${sha256}`).toString();
+        const leaf = Buffer.from(combinedHash, "hex");
+        const proof = tree.getProof(leaf);
+        // Convert the proof to a single hex string
+        const proofHex = proof.map((p) => p.data.toString("hex")).join("");
+        // Create an object with the key, rootHash, and proofHex
+        const proofObject = {
+            key: hexKey,
+            rootHash: rootHash,
+            proof: proofHex,
+        };
+        // Convert the proofObject to JSON and then to a hex string
+        const proofObjectHex = Buffer.from(JSON.stringify(proofObject)).toString("hex");
+        return proofObjectHex;
+    }
+    /**
+     * Verify a proof for a file against the Merkle tree.
+     * @param proofObjectHex - The proof object as a hex string.
+     * @param sha256 - The SHA-256 hash of the file.
+     * @returns True if the proof is valid, false otherwise.
+     */
+    verifyProof(proofObjectHex, sha256) {
+        if (!isHexString(proofObjectHex)) {
+            throw new Error("proofObjectHex must be a valid hex string");
+        }
+        if (!isHexString(sha256)) {
+            throw new Error("sha256 must be a valid hex string");
+        }
+        // Convert the proofObjectHex back to a proof object
+        const proofObject = JSON.parse(Buffer.from(proofObjectHex, "hex").toString("utf8"));
+        const { key, rootHash, proof } = proofObject;
+        const tree = this.deserializeTree(rootHash);
+        const combinedHash = (0, crypto_js_1.SHA256)(`${key}/${sha256}`).toString();
+        const leaf = Buffer.from(combinedHash, "hex");
+        // Convert the proofHex string back to the proof array
+        const proofBufferArray = [];
+        for (let i = 0; i < proof.length; i += 64) {
+            proofBufferArray.push(Buffer.from(proof.slice(i, i + 64), "hex"));
+        }
+        const proofArray = proofBufferArray.map((data) => ({ data }));
+        return tree.verify(proofArray, leaf, Buffer.from(rootHash, "hex"));
+    }
+    /**
+     * Get the difference between two Merkle tree roots.
+     * @param rootHash1 - The first root hash.
+     * @param rootHash2 - The second root hash.
+     * @returns An object containing the added and deleted keys and their SHA-256 hashes.
+     */
+    getRootDiff(rootHash1, rootHash2) {
+        if (!isHexString(rootHash1) || !isHexString(rootHash2)) {
+            throw new Error("rootHash1 and rootHash2 must be valid hex strings");
+        }
+        const tree1 = this.deserializeTree(rootHash1);
+        const tree2 = this.deserializeTree(rootHash2);
+        // @ts-ignore
+        const files1 = tree1.files;
+        // @ts-ignore
+        const files2 = tree2.files;
+        const added = new Map();
+        const deleted = new Map();
+        files1.forEach((value, key) => {
+            if (!files2.has(key)) {
+                deleted.set(key, value.sha256);
+            }
+        });
+        files2.forEach((value, key) => {
+            if (!files1.has(key)) {
+                added.set(key, value.sha256);
+            }
+        });
+        return { added, deleted };
+    }
+    /**
+     * Verify the integrity of a file based on its SHA-256 hash and check if it is in the specified Merkle root.
+     * @param sha256 - The SHA-256 hash of the file.
+     * @param root - The root hash to check against.
+     * @returns True if the file integrity is verified and it is in the Merkle root, false otherwise.
+     */
+    async verifyKeyIntegrity(sha256, rootHash) {
+        if (!isHexString(sha256)) {
+            throw new Error("sha256 must be a valid hex string");
+        }
+        if (!isHexString(rootHash)) {
+            throw new Error("rootHash must be a valid hex string");
+        }
+        const filePath = path.join(this.dataDir, sha256.match(/.{1,2}/g).join("/"));
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File at path ${filePath} does not exist`);
+        }
+        const compressedReadStream = fs.createReadStream(filePath);
+        const decompressStream = zlib.createGunzip();
+        const hash = crypto.createHash("sha256");
+        return new Promise((resolve, reject) => {
+            compressedReadStream.pipe(decompressStream);
+            decompressStream.on("data", (chunk) => {
+                hash.update(chunk);
+            });
+            decompressStream.on("end", () => {
+                const uncompressedSha256 = hash.digest("hex");
+                const isValid = uncompressedSha256 === sha256;
+                console.log(`SHA-256 of uncompressed file: ${uncompressedSha256}`);
+                if (!isValid) {
+                    return resolve(false);
+                }
+                const tree = this.deserializeTree(rootHash);
+                const combinedHash = crypto
+                    .createHash("sha256")
+                    .update(`${toHex(sha256)}/${sha256}`)
+                    .digest("hex");
+                const leaf = Buffer.from(combinedHash, "hex");
+                const isInTree = tree.getLeafIndex(leaf) !== -1;
+                resolve(isInTree);
+            });
+            decompressStream.on("error", (err) => {
+                reject(err);
+            });
+            compressedReadStream.on("error", (err) => {
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Static method to validate key integrity using a foreign Merkle tree.
+     * Verifies if a given SHA-256 hash for a key exists within the foreign tree and checks if the root hash matches.
+     *
+     * @param key - The hexadecimal key of the file.
+     * @param sha256 - The SHA-256 hash of the file.
+     * @param serializedTree - The foreign serialized Merkle tree.
+     * @param expectedRootHash - The expected root hash of the Merkle tree.
+     * @returns A boolean indicating if the SHA-256 is present in the foreign tree and the root hash matches.
+     */
+    static validateKeyIntegrityWithForeignTree(key, sha256, serializedTree, expectedRootHash) {
+        if (!isHexString(key)) {
+            throw new Error("key must be a valid hex string");
+        }
+        if (!isHexString(sha256)) {
+            throw new Error("sha256 must be a valid hex string");
+        }
+        if (!isHexString(expectedRootHash)) {
+            throw new Error("expectedRootHash must be a valid hex string");
+        }
+        // Deserialize the foreign tree
+        const leaves = serializedTree.leaves.map((leaf) => Buffer.from(leaf, "hex"));
+        const tree = new merkletreejs_1.MerkleTree(leaves, crypto_js_1.SHA256, { sortPairs: true });
+        // Verify that the deserialized tree's root matches the expected root hash
+        const treeRootHash = tree.getRoot().toString("hex");
+        if (treeRootHash !== expectedRootHash) {
+            console.warn(`Expected root hash ${expectedRootHash}, but got ${treeRootHash}`);
+            return false;
+        }
+        // Rebuild the files map from the serialized tree
+        // @ts-ignore
+        tree.files = new Map(Object.entries(serializedTree.files).map(([key, value]) => [
+            key,
+            { hash: value.hash, sha256: value.sha256 },
+        ]));
+        // Check if the SHA-256 exists in the foreign tree's files
+        const combinedHash = crypto
+            .createHash("sha256")
+            .update(`${toHex(key)}/${sha256}`)
+            .digest("hex");
+        const leaf = Buffer.from(combinedHash, "hex");
+        const isInTree = tree.getLeafIndex(leaf) !== -1;
+        return isInTree;
+    }
+}
+exports.DataIntegrityTree = DataIntegrityTree;

package/dist/DataIntegrityTree/DataLayerError.d.ts

@@ -0,0 +1,6 @@
+declare class DataLayerError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+}
+export default DataLayerError;
+//# sourceMappingURL=DataLayerError.d.ts.map

package/dist/DataIntegrityTree/DataLayerError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataLayerError.d.ts","sourceRoot":"","sources":["../../src/DataIntegrityTree/DataLayerError.ts"],"names":[],"mappings":"AAAA,cAAM,cAAe,SAAQ,KAAK;IAC9B,IAAI,EAAE,MAAM,CAAC;gBAED,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAe1C;AAED,eAAe,cAAc,CAAC"}

package/dist/DataIntegrityTree/DataLayerError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DataLayerError extends Error {
+    constructor(code, message) {
+        // Call the parent constructor with the message
+        super(message);
+        // Set the name of the error to the class name
+        this.name = this.constructor.name;
+        // Assign the custom code
+        this.code = code;
+        // Capture the stack trace (if available in the environment)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+exports.default = DataLayerError;

package/dist/DataIntegrityTree/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataIntegrityTree';
+//# sourceMappingURL=index.d.ts.map

package/dist/DataIntegrityTree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/DataIntegrityTree/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/DataIntegrityTree/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DataIntegrityTree"), exports);

package/dist/DigNetwork/DigNetwork.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;gBAEpC,OAAO,EAAE,MAAM;YAOb,eAAe;IA8ChB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAsDhD,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;WA+BrC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQtD,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQ5C,aAAa,CACxB,aAAa,GAAE,OAAe,EAC9B,iBAAiB,GAAE,OAAc,EACjC,QAAQ,GAAE,OAAe,GACxB,OAAO,CAAC,IAAI,CAAC;YAqFF,mBAAmB;YAWnB,kBAAkB;YASlB,oBAAoB;YASpB,qBAAqB;YAuErB,cAAc;CAuB7B"}
+{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;gBAEpC,OAAO,EAAE,MAAM;YAOb,eAAe;IA8ChB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAsDhD,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;WA6BrC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQtD,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQ5C,aAAa,CACxB,aAAa,GAAE,OAAe,EAC9B,iBAAiB,GAAE,OAAc,EACjC,QAAQ,GAAE,OAAe,GACxB,OAAO,CAAC,IAAI,CAAC;YAqFF,mBAAmB;YAWnB,kBAAkB;YASlB,oBAAoB;YASpB,qBAAqB;YAuErB,cAAc;CAoB7B"}

package/dist/DigNetwork/DigNetwork.js

@@ -101,7 +101,6 @@ class DigNetwork {
     async uploadStore(digPeer) {
         const { generationIndex } = await this.uploadPreflight(digPeer);
         const filesToUpload = await (0, deltaUtils_1.getDeltaFiles)(this.dataStore.StoreId, generationIndex, path.resolve(config_1.DIG_FOLDER_PATH, "stores"));
-        console.log(filesToUpload);
         if (!filesToUpload.length) {
             console.log("No files to upload.");
             return;
@@ -246,8 +245,6 @@ class DigNetwork {
     }
     async runProgressBar(total, name, task) {
         // Using 'any' to work around TypeScript issues
-        const oldConsoleLog = console.log;
-        console.log = () => { }; // Suppress console.log output
         const multiBar = new cli_progress_1.MultiBar({
             clearOnComplete: false,
             hideCursor: true,
@@ -257,7 +254,6 @@ class DigNetwork {
         const progress = multiBar.create(total, 0, { name });
         await task(progress).finally(() => {
             multiBar.stop();
-            console.log = oldConsoleLog; // Restore console.log
         });
     }
 }

package/dist/DigNetwork/DigPeer.js

@@ -9,7 +9,7 @@ const ContentServer_1 = require("./ContentServer");
 const PropagationServer_1 = require("./PropagationServer");
 const IncentiveServer_1 = require("./IncentiveServer");
 const blockchain_1 = require("../blockchain");
-const data_integrity_tree_1 = require("@dignetwork/data-integrity-tree");
+const DataIntegrityTree_1 = require("../DataIntegrityTree");
 const datalayer_driver_1 = require("datalayer-driver");
 const blockchain_2 = require("../blockchain");
 const blockchain_3 = require("../blockchain");
@@ -97,7 +97,7 @@ class DigPeer {
                     });
                 });
                 // Perform tree integrity validation using the datFileContent and the root hash
-                const treeCheck = data_integrity_tree_1.DataIntegrityTree.validateKeyIntegrityWithForeignTree(key, fileData.sha256, datFileContent, rootHash);
+                const treeCheck = DataIntegrityTree_1.DataIntegrityTree.validateKeyIntegrityWithForeignTree(key, fileData.sha256, datFileContent, rootHash);
                 if (!treeCheck) {
                     console.error(`Tree validation failed for file ${key}.`);
                     filesIntegrityIntact = false;

package/dist/blockchain/DataStore.d.ts

@@ -1,6 +1,6 @@
 import { DataStore as DataStoreDriver, DataStoreMetadata } from "datalayer-driver";
 import { RootHistoryItem } from "../types";
-import { DataIntegrityTree, DataIntegrityTreeOptions } from "@dignetwork/data-integrity-tree";
+import { DataIntegrityTree, DataIntegrityTreeOptions } from "../DataIntegrityTree";
 import { CreateStoreUserInputs } from "../types";
 export declare class DataStore {
     private storeId;

package/dist/blockchain/DataStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataStore.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStore.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,SAAS,IAAI,eAAe,EAE5B,iBAAiB,EAIlB,MAAM,kBAAkB,CAAC;AAY1B,OAAO,EAAE,eAAe,EAAW,MAAM,UAAU,CAAC;AAGpD,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AASjD,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAAoB;gBAEpB,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,wBAAwB;IAiB/D,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,IAAI,IAAI,iBAAiB,CAEnC;IAEM,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;IAIlB,SAAS,IAAI,MAAM;WAMN,cAAc,IAAI,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;WAOtD,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS;WAK1C,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;WAYnC,MAAM,CACxB,MAAM,GAAE,qBAA0B,GACjC,OAAO,CAAC,SAAS,CAAC;mBAyCA,IAAI;IA4FzB;;;OAGG;IACU,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAK5C;;;OAGG;WACiB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAIxD;;;;OAIG;mBACkB,mBAAmB;WAqB1B,YAAY,IAAI,SAAS,EAAE;IAW5B,aAAa,IAAI,OAAO,CAAC;QACpC,WAAW,EAAE,eAAe,CAAC;QAC7B,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IAyGW,iBAAiB,IAAI,OAAO,CAAC;QACxC,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;YA0BY,iBAAiB;IAYlB,cAAc,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAsB5C,mBAAmB,IAAI,OAAO,CAAC,eAAe,EAAE,GAAG,SAAS,CAAC;IAiB7D,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IA+E5B,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAKzC,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAgB5B,uBAAuB,CAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,OAAO,CAAC;IAkBN,cAAc,CACzB,QAAQ,EAAE,iBAAiB,GAC1B,OAAO,CAAC,eAAe,CAAC;IA+Cd,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAiChE,iBAAiB,IAAI,MAAM,EAAE;CAUrC"}
+{"version":3,"file":"DataStore.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStore.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,SAAS,IAAI,eAAe,EAE5B,iBAAiB,EAIlB,MAAM,kBAAkB,CAAC;AAY1B,OAAO,EAAE,eAAe,EAAW,MAAM,UAAU,CAAC;AAGpD,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AASjD,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAAoB;gBAEpB,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,wBAAwB;IAiB/D,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,IAAI,IAAI,iBAAiB,CAEnC;IAEM,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;IAIlB,SAAS,IAAI,MAAM;WAMN,cAAc,IAAI,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;WAOtD,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS;WAK1C,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;WAYnC,MAAM,CACxB,MAAM,GAAE,qBAA0B,GACjC,OAAO,CAAC,SAAS,CAAC;mBAyCA,IAAI;IA4FzB;;;OAGG;IACU,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAK5C;;;OAGG;WACiB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAIxD;;;;OAIG;mBACkB,mBAAmB;WAqB1B,YAAY,IAAI,SAAS,EAAE;IAW5B,aAAa,IAAI,OAAO,CAAC;QACpC,WAAW,EAAE,eAAe,CAAC;QAC7B,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IAyGW,iBAAiB,IAAI,OAAO,CAAC;QACxC,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;YA0BY,iBAAiB;IAYlB,cAAc,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAsB5C,mBAAmB,IAAI,OAAO,CAAC,eAAe,EAAE,GAAG,SAAS,CAAC;IAiB7D,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IA+E5B,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAKzC,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAgB5B,uBAAuB,CAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,OAAO,CAAC;IAkBN,cAAc,CACzB,QAAQ,EAAE,iBAAiB,GAC1B,OAAO,CAAC,eAAe,CAAC;IA+Cd,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAiChE,iBAAiB,IAAI,MAAM,EAAE;CAUrC"}

package/dist/blockchain/DataStore.js

@@ -14,7 +14,7 @@ const config_1 = require("../utils/config");
 const coins_1 = require("./coins");
 const utils_1 = require("../utils");
 const hashUtils_1 = require("../utils/hashUtils");
-const data_integrity_tree_1 = require("@dignetwork/data-integrity-tree");
+const DataIntegrityTree_1 = require("../DataIntegrityTree");
 const prompts_1 = require("../prompts");
 const FileCache_1 = require("../utils/FileCache");
 const DataStoreSerializer_1 = require("./DataStoreSerializer");
@@ -33,7 +33,7 @@ class DataStore {
                 storeDir: config_1.STORE_PATH,
             };
         }
-        this.tree = new data_integrity_tree_1.DataIntegrityTree(storeId, _options);
+        this.tree = new DataIntegrityTree_1.DataIntegrityTree(storeId, _options);
     }
     get StoreId() {
         return this.storeId;

package/dist/blockchain/FullNodePeer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAmBxC,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAC3E,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAA0B;IAChE,OAAO,CAAC,IAAI,CAAO;IAQnB,OAAO;WAIa,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5C,OAAO,CAAC,MAAM,CAAC,eAAe;IAiB9B,OAAO,CAAC,MAAM,CAAC,gBAAgB;mBAOV,eAAe;mBAkDf,UAAU;IAyB/B,OAAO,CAAC,MAAM,CAAC,eAAe;mBA4BT,WAAW;IAgGzB,OAAO,IAAI,IAAI;WAIF,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAwBpB"}
+{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAmBxC,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAC3E,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAA0B;IAChE,OAAO,CAAC,IAAI,CAAO;IAQnB,OAAO;WAIa,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5C,OAAO,CAAC,MAAM,CAAC,eAAe;IAiB9B,OAAO,CAAC,MAAM,CAAC,gBAAgB;mBAOV,eAAe;mBAkDf,UAAU;IAyB/B,OAAO,CAAC,MAAM,CAAC,eAAe;mBA8CT,WAAW;IAgGzB,OAAO,IAAI,IAAI;WAIF,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAwBpB"}

package/dist/blockchain/FullNodePeer.js

@@ -107,17 +107,35 @@ class FullNodePeer {
         }
         return FullNodePeer.memoizedFetchNewPeerIPs();
     }
-    static createPeerProxy(peer, certFile, keyFile) {
+    static createPeerProxy(peer) {
         return new Proxy(peer, {
             get: (target, prop) => {
                 const originalMethod = target[prop];
                 if (typeof originalMethod === "function") {
                     return async (...args) => {
+                        let timeoutId;
+                        // Start the timeout to forget the peer after 1 minute
+                        const timeoutPromise = new Promise((_, reject) => {
+                            timeoutId = setTimeout(() => {
+                                FullNodePeer.cachedPeer = null;
+                                reject(new Error("Operation timed out. Reconnecting to a new peer."));
+                            }, 60000); // 1 minute
+                        });
                         try {
-                            return await originalMethod.apply(target, args);
+                            // Run the original method and race it against the timeout
+                            const result = await Promise.race([
+                                originalMethod.apply(target, args),
+                                timeoutPromise,
+                            ]);
+                            // Clear the timeout if the operation succeeded
+                            if (timeoutId) {
+                                clearTimeout(timeoutId);
+                            }
+                            return result;
                         }
                         catch (error) {
-                            if (error.message.includes("WebSocket")) {
+                            // If the error is WebSocket-related or timeout, reset the peer
+                            if (error.message.includes("WebSocket") || error.message.includes("Operation timed out")) {
                                 FullNodePeer.cachedPeer = null;
                                 const newPeer = await FullNodePeer.getBestPeer();
                                 return newPeer[prop](...args);
@@ -149,7 +167,7 @@ class FullNodePeer {
             if (ip) {
                 try {
                     const peer = await datalayer_driver_1.Peer.new(`${ip}:${FULLNODE_PORT}`, false, certFile, keyFile);
-                    return FullNodePeer.createPeerProxy(peer, certFile, keyFile);
+                    return FullNodePeer.createPeerProxy(peer);
                 }
                 catch (error) {
                     console.error(`Failed to create peer for IP ${ip}: ${error.message}`);

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from './blockchain';
 export * from './DigNetwork';
 export * from './utils';
-export * from '@dignetwork/data-integrity-tree';
+export * from './DataIntegrityTree';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -17,4 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./blockchain"), exports);
 __exportStar(require("./DigNetwork"), exports);
 __exportStar(require("./utils"), exports);
-__exportStar(require("@dignetwork/data-integrity-tree"), exports);
+__exportStar(require("./DataIntegrityTree"), exports);

package/dist/utils/directoryUtils.d.ts

@@ -1,4 +1,4 @@
-import { DataIntegrityTree } from "@dignetwork/data-integrity-tree";
+import { DataIntegrityTree } from "../DataIntegrityTree";
 /**
  * Recursively add all files in a directory to the Merkle tree, skipping the .dig, .git folders, and files in .gitignore.
  * @param datalayer - The DataStoreManager instance.

package/dist/utils/directoryUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directoryUtils.d.ts","sourceRoot":"","sources":["../../src/utils/directoryUtils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,cACZ,iBAAiB,WACnB,MAAM,YACN,MAAM,KACd,OAAO,CAAC,IAAI,CAmCd,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,eAAgB,MAAM,KAAG,MAiBxD,CAAC"}
+{"version":3,"file":"directoryUtils.d.ts","sourceRoot":"","sources":["../../src/utils/directoryUtils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,cACZ,iBAAiB,WACnB,MAAM,YACN,MAAM,KACd,OAAO,CAAC,IAAI,CAmCd,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,eAAgB,MAAM,KAAG,MAiBxD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/dig-sdk",
-  "version": "0.0.1-alpha.4",
+  "version": "0.0.1-alpha.6",
   "description": "",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -25,7 +25,6 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@dignetwork/data-integrity-tree": "^0.0.22",
     "bip39": "^3.1.0",
     "chia-bls": "^1.0.2",
     "chia-config-loader": "^1.0.1",