@dignetwork/dig-sdk 0.0.1-alpha.2

package/dist/utils/deltaUtils.js

@@ -0,0 +1,83 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeltaFiles = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const hashUtils_1 = require("./hashUtils");
+const getDeltaFiles = async (storeId, generationIndex = 0, directoryPath) => {
+    if (isNaN(generationIndex)) {
+        generationIndex = 0;
+    }
+    // Load manifest file
+    const manifestFilePath = path.join(directoryPath, storeId, "manifest.dat");
+    if (!fs.existsSync(manifestFilePath)) {
+        console.error("Manifest file not found", manifestFilePath);
+        return [];
+    }
+    const manifestHashes = fs
+        .readFileSync(manifestFilePath, "utf-8")
+        .split("\n")
+        .filter(Boolean);
+    console.log("");
+    console.log(`Uploading delta from generation ${generationIndex}`);
+    const filesInvolved = [];
+    // Include the height.dat file at the top of the directory
+    const heightDatFilePath = path.join(directoryPath, storeId, "height.json");
+    if (fs.existsSync(heightDatFilePath)) {
+        filesInvolved.push(heightDatFilePath);
+    }
+    // Collect files starting from generationIndex + 1
+    for (let i = generationIndex; i < manifestHashes.length; i++) {
+        const rootHash = manifestHashes[i];
+        const datFilePath = path.join(directoryPath, storeId, `${rootHash}.dat`);
+        if (!fs.existsSync(datFilePath)) {
+            console.error(`Data file for root hash ${rootHash} not found`);
+            return [];
+        }
+        const datFileContent = JSON.parse(fs.readFileSync(datFilePath, "utf-8"));
+        if (datFileContent.root !== rootHash) {
+            console.error(`Root hash in data file does not match: ${datFileContent.root} !== ${rootHash}`);
+            return [];
+        }
+        // Add the .dat file itself to the list of files involved
+        filesInvolved.push(datFilePath);
+        // Collect all files involved, ensuring correct paths
+        for (const file of Object.keys(datFileContent.files)) {
+            const filePath = (0, hashUtils_1.getFilePathFromSha256)(datFileContent.files[file].sha256, path.join(directoryPath, storeId, "data"));
+            filesInvolved.push(filePath);
+        }
+    }
+    if (process.env.DIG_DEBUG === "1") {
+        console.log("Files involved in the delta:");
+        console.table(filesInvolved);
+    }
+    // list the manifest file last, this actually
+    // helps with upload because by overriding the manifest file last, 
+    // the store can still be considered valid even when the upload is interrupted
+    filesInvolved.push(manifestFilePath);
+    return filesInvolved;
+};
+exports.getDeltaFiles = getDeltaFiles;

package/dist/utils/directoryUtils.d.ts

@@ -0,0 +1,15 @@
+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.
+ * @param dirPath - The directory path.
+ * @param baseDir - The base directory for relative paths.
+ */
+export declare const addDirectory: (datalayer: DataIntegrityTree, dirPath: string, baseDir?: string) => Promise<void>;
+/**
+ * Calculate the total size of the DIG_FOLDER_PATH
+ * @param folderPath - The path of the folder to calculate size.
+ * @returns The total size of the folder in bytes.
+ */
+export declare const calculateFolderSize: (folderPath: string) => bigint;
+//# sourceMappingURL=directoryUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"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/dist/utils/directoryUtils.js

@@ -0,0 +1,91 @@
+"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.calculateFolderSize = exports.addDirectory = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+/**
+ * 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.
+ * @param dirPath - The directory path.
+ * @param baseDir - The base directory for relative paths.
+ */
+const addDirectory = async (datalayer, dirPath, baseDir = dirPath) => {
+    const ig = (0, ignore_1.default)();
+    const gitignorePath = path.join(baseDir, ".gitignore");
+    // Load .gitignore rules if the file exists
+    if (fs.existsSync(gitignorePath)) {
+        const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+        ig.add(gitignoreContent);
+    }
+    const files = fs.readdirSync(dirPath);
+    for (const file of files) {
+        const filePath = path.join(dirPath, file);
+        const relativePath = path.relative(baseDir, filePath).replace(/\\/g, "/");
+        // Skip the .dig, .git folders and files or directories ignored by .gitignore
+        if (file === ".dig" || file === ".git" || ig.ignores(relativePath)) {
+            continue;
+        }
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            await (0, exports.addDirectory)(datalayer, filePath, baseDir);
+        }
+        else {
+            await new Promise((resolve, reject) => {
+                const stream = fs.createReadStream(filePath);
+                datalayer
+                    .upsertKey(stream, Buffer.from(relativePath).toString("hex"))
+                    .then(resolve)
+                    .catch(reject);
+            });
+        }
+    }
+};
+exports.addDirectory = addDirectory;
+/**
+ * Calculate the total size of the DIG_FOLDER_PATH
+ * @param folderPath - The path of the folder to calculate size.
+ * @returns The total size of the folder in bytes.
+ */
+const calculateFolderSize = (folderPath) => {
+    let totalSize = BigInt(0);
+    const files = fs.readdirSync(folderPath);
+    for (const file of files) {
+        const filePath = path.join(folderPath, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            totalSize += (0, exports.calculateFolderSize)(filePath);
+        }
+        else {
+            totalSize += BigInt(stat.size);
+        }
+    }
+    return totalSize;
+};
+exports.calculateFolderSize = calculateFolderSize;

package/dist/utils/encryption.d.ts

@@ -0,0 +1,8 @@
+export interface EncryptedData {
+    data: string;
+    nonce: string;
+    salt: string;
+}
+export declare const encryptData: (data: string) => EncryptedData;
+export declare const decryptData: (encryptedData: EncryptedData) => string;
+//# sourceMappingURL=encryption.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/utils/encryption.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAMD,eAAO,MAAM,WAAW,SAAU,MAAM,KAAG,aAW1C,CAAC;AAEF,eAAO,MAAM,WAAW,kBAAmB,aAAa,KAAG,MAY1D,CAAC"}

package/dist/utils/encryption.js

@@ -0,0 +1,55 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptData = exports.encryptData = void 0;
+// encryption.ts
+const crypto = __importStar(require("crypto"));
+const ALGORITHM = "aes-256-gcm";
+const generateKey = (salt) => {
+    return crypto.pbkdf2Sync("mnemonic-seed", salt, 100000, 32, "sha512");
+};
+const encryptData = (data) => {
+    const nonce = crypto.randomBytes(12).toString("hex");
+    const salt = crypto.randomBytes(16).toString("hex");
+    const key = generateKey(salt);
+    const cipher = crypto.createCipheriv(ALGORITHM, key, Buffer.from(nonce, "hex"));
+    let encrypted = cipher.update(data, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    const tag = cipher.getAuthTag().toString("hex");
+    return { data: encrypted + tag, nonce, salt };
+};
+exports.encryptData = encryptData;
+const decryptData = (encryptedData) => {
+    const { data, nonce, salt } = encryptedData;
+    const encryptedText = data.slice(0, -32);
+    const tag = Buffer.from(data.slice(-32), "hex");
+    const key = generateKey(salt);
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, Buffer.from(nonce, "hex"));
+    decipher.setAuthTag(tag);
+    let decrypted = decipher.update(encryptedText, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+};
+exports.decryptData = decryptData;

package/dist/utils/hashUtils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calculate the SHA-256 hash of a buffer using the crypto module.
+ * @param buffer - The buffer.
+ * @returns The SHA-256 hash of the buffer.
+ */
+export declare const calculateSHA256: (buffer: Buffer) => string;
+export declare const getFilePathFromSha256: (sha256: string, dataDir: string) => string;
+//# sourceMappingURL=hashUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashUtils.d.ts","sourceRoot":"","sources":["../../src/utils/hashUtils.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,eAAe,WAAY,MAAM,KAAG,MAIhD,CAAC;AAGF,eAAO,MAAM,qBAAqB,WACxB,MAAM,WACL,MAAM,KACd,MAEF,CAAC"}

package/dist/utils/hashUtils.js

@@ -0,0 +1,44 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilePathFromSha256 = exports.calculateSHA256 = void 0;
+const crypto = __importStar(require("crypto"));
+const path = __importStar(require("path"));
+/**
+ * Calculate the SHA-256 hash of a buffer using the crypto module.
+ * @param buffer - The buffer.
+ * @returns The SHA-256 hash of the buffer.
+ */
+const calculateSHA256 = (buffer) => {
+    const hash = crypto.createHash("sha256");
+    hash.update(buffer);
+    return hash.digest("hex");
+};
+exports.calculateSHA256 = calculateSHA256;
+// Helper function to derive file path from SHA256 hash
+const getFilePathFromSha256 = (sha256, dataDir) => {
+    return path.join(dataDir, sha256.match(/.{1,2}/g).join("/"));
+};
+exports.getFilePathFromSha256 = getFilePathFromSha256;

package/dist/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * from './config';
+export * from './connectionUtils';
+export * from './credentialsUtils';
+export * from './deltaUtils';
+export * from './directoryUtils';
+export * from './encryption';
+export * from './FileCache';
+export * from './hashUtils';
+export * from './NconfManager';
+export * from './network';
+export * from './spinnerUtils';
+export * from './ssl';
+export * from './validationUtils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,OAAO,CAAC;AACtB,cAAc,mBAAmB,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,29 @@
+"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("./config"), exports);
+__exportStar(require("./connectionUtils"), exports);
+__exportStar(require("./credentialsUtils"), exports);
+__exportStar(require("./deltaUtils"), exports);
+__exportStar(require("./directoryUtils"), exports);
+__exportStar(require("./encryption"), exports);
+__exportStar(require("./FileCache"), exports);
+__exportStar(require("./hashUtils"), exports);
+__exportStar(require("./NconfManager"), exports);
+__exportStar(require("./network"), exports);
+__exportStar(require("./spinnerUtils"), exports);
+__exportStar(require("./ssl"), exports);
+__exportStar(require("./validationUtils"), exports);

package/dist/utils/network.d.ts

@@ -0,0 +1,2 @@
+export declare const getPublicIpAddress: () => Promise<string | undefined>;
+//# sourceMappingURL=network.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../src/utils/network.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB,QAAa,OAAO,CAAC,MAAM,GAAG,SAAS,CA8BrE,CAAC"}

package/dist/utils/network.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicIpAddress = void 0;
+const superagent_1 = __importDefault(require("superagent"));
+const MAX_RETRIES = 5;
+const RETRY_DELAY = 2000; // in milliseconds
+const getPublicIpAddress = async () => {
+    const publicIp = process.env.PUBLIC_IP;
+    if (publicIp) {
+        console.log('Public IP address from env:', publicIp);
+        return publicIp;
+    }
+    let attempt = 0;
+    while (attempt < MAX_RETRIES) {
+        try {
+            const response = await superagent_1.default.get('https://api.datalayer.storage/user/v1/get_user_ip');
+            if (response.body && response.body.success) {
+                console.log('Public IP address:', response.body);
+                return response.body.ip_address;
+            }
+            else {
+                throw new Error('Failed to retrieve public IP address');
+            }
+        }
+        catch (error) {
+            attempt++;
+            console.error(`Error fetching public IP address (Attempt ${attempt}):`, error.message);
+            if (attempt >= MAX_RETRIES) {
+                throw new Error('Could not retrieve public IP address after several attempts');
+            }
+            await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY));
+        }
+    }
+};
+exports.getPublicIpAddress = getPublicIpAddress;

package/dist/utils/spinnerUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const waitForPromise: <T>(promiseFn: () => Promise<T>, spinnerText?: string, successText?: string, errorText?: string) => Promise<T>;
+//# sourceMappingURL=spinnerUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spinnerUtils.d.ts","sourceRoot":"","sources":["../../src/utils/spinnerUtils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,GAAU,CAAC,aACzB,MAAM,OAAO,CAAC,CAAC,CAAC,gBACd,MAAM,gBACN,MAAM,cACR,MAAM,KAChB,OAAO,CAAC,CAAC,CA8CX,CAAC"}

package/dist/utils/spinnerUtils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForPromise = void 0;
+const nanospinner_1 = require("nanospinner");
+const waitForPromise = async (promiseFn, spinnerText = "Processing...", successText = "OK!", errorText = "Error.") => {
+    const spinner = (0, nanospinner_1.createSpinner)(spinnerText).start();
+    // Store original console.log and console.error, and collect log messages
+    const originalConsoleLog = console.log;
+    const originalConsoleError = console.error;
+    let logMessages = [];
+    let errorMessages = [];
+    console.log = (...args) => {
+        logMessages.push(args.map(arg => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' '));
+    };
+    console.error = (...args) => {
+        errorMessages.push(args.map(arg => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' '));
+    };
+    try {
+        const result = await promiseFn();
+        if (result) {
+            spinner.success({ text: successText });
+        }
+        else {
+            throw new Error(errorText);
+        }
+        return result;
+    }
+    catch (error) {
+        spinner.error({ text: errorText });
+        // Print collected log messages and error messages on error
+        if (logMessages.length > 0) {
+            originalConsoleLog("\nCollected logs:");
+            logMessages.forEach((message) => originalConsoleLog(message));
+        }
+        if (errorMessages.length > 0) {
+            originalConsoleError("\nCollected errors:");
+            errorMessages.forEach((message) => originalConsoleError(message));
+        }
+        throw error;
+    }
+    finally {
+        // Restore the original console.log and console.error functions
+        console.log = originalConsoleLog;
+        console.error = originalConsoleError;
+    }
+};
+exports.waitForPromise = waitForPromise;

package/dist/utils/ssl.d.ts

@@ -0,0 +1,5 @@
+export declare const getOrCreateSSLCerts: () => {
+    certPath: string;
+    keyPath: string;
+};
+//# sourceMappingURL=ssl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ssl.d.ts","sourceRoot":"","sources":["../../src/utils/ssl.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB;;;CAqB/B,CAAC"}

package/dist/utils/ssl.js

@@ -0,0 +1,50 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrCreateSSLCerts = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chia_server_coin_1 = require("chia-server-coin");
+const config_1 = require("./config");
+const getOrCreateSSLCerts = () => {
+    const sslDir = path.join(config_1.USER_DIR_PATH, "ssl");
+    const certPath = path.join(sslDir, "client.cert");
+    const keyPath = path.join(sslDir, "client.key");
+    // Ensure the SSL directory exists
+    if (!fs.existsSync(sslDir)) {
+        fs.mkdirSync(sslDir, { recursive: true });
+    }
+    // Check if the certificate and key exist, if not, generate them
+    if (!fs.existsSync(certPath) || !fs.existsSync(keyPath)) {
+        new chia_server_coin_1.Tls(certPath, keyPath);
+        console.log("Client certificate and key generated successfully.");
+    }
+    // Return the paths to the cert and key files
+    return {
+        certPath,
+        keyPath,
+    };
+};
+exports.getOrCreateSSLCerts = getOrCreateSSLCerts;

package/dist/utils/validationUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Validates if the SHA256 hash of the decompressed file matches the provided hash.
+ *
+ * @param sha256 - The expected SHA256 hash of the decompressed file.
+ * @param dataDir - The root folder where the data files are stored.
+ * @returns A boolean indicating whether the decompressed file's hash matches the provided hash.
+ */
+export declare const validateFileSha256: (sha256: string, dataDir: string) => boolean;
+//# sourceMappingURL=validationUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validationUtils.d.ts","sourceRoot":"","sources":["../../src/utils/validationUtils.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,WACrB,MAAM,WACL,MAAM,KACd,OAoBF,CAAC"}

package/dist/utils/validationUtils.js

@@ -0,0 +1,55 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFileSha256 = void 0;
+const fs = __importStar(require("fs"));
+const zlib = __importStar(require("zlib"));
+const crypto = __importStar(require("crypto"));
+const hashUtils_1 = require("./hashUtils");
+/**
+ * Validates if the SHA256 hash of the decompressed file matches the provided hash.
+ *
+ * @param sha256 - The expected SHA256 hash of the decompressed file.
+ * @param dataDir - The root folder where the data files are stored.
+ * @returns A boolean indicating whether the decompressed file's hash matches the provided hash.
+ */
+const validateFileSha256 = (sha256, dataDir) => {
+    // Derive the file path from the SHA256 hash
+    const filePath = (0, hashUtils_1.getFilePathFromSha256)(sha256, dataDir);
+    if (!fs.existsSync(filePath)) {
+        return false;
+    }
+    // Read and decompress the file
+    const fileBuffer = fs.readFileSync(filePath);
+    const decompressedBuffer = zlib.gunzipSync(fileBuffer);
+    // Calculate the SHA256 hash of the decompressed content
+    const hash = crypto
+        .createHash("sha256")
+        .update(decompressedBuffer)
+        .digest("hex");
+    // Compare the calculated hash with the provided hash
+    return hash === sha256;
+};
+exports.validateFileSha256 = validateFileSha256;