@dignetwork/dig-sdk 0.0.1-alpha.2

package/dist/DigNetwork/DigNetwork.js

@@ -0,0 +1,222 @@
+"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.DigNetwork = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cli_progress_1 = require("cli-progress");
+const DigPeer_1 = require("./DigPeer");
+const deltaUtils_1 = require("../utils/deltaUtils");
+const hashUtils_1 = require("../utils/hashUtils");
+const blockchain_1 = require("../blockchain");
+const config_1 = require("../utils/config");
+class DigNetwork {
+    constructor(storeId) {
+        this.dataStore = blockchain_1.DataStore.from(storeId);
+        this.serverCoin = new blockchain_1.ServerCoin(storeId);
+        this.storeDir = path.resolve(config_1.DIG_FOLDER_PATH, "stores", storeId);
+        this.peerBlacklist = new Map(); // Initialize empty map for blacklists
+    }
+    async uploadPreflight(digPeer) {
+        // Preflight check is handled internally by PropagationServer if needed
+        const { lastUploadedHash, generationIndex } = await digPeer.propagationServer.getUploadDetails();
+        const rootHistory = await this.dataStore.getLocalRootHistory();
+        if (!rootHistory || rootHistory.length === 0) {
+            throw new Error("No root hashes found. Please commit your changes first.");
+        }
+        const lastLocalRootHash = rootHistory[rootHistory.length - 1].root_hash;
+        const localGenerationIndex = rootHistory.length - 1;
+        // Handle conditions based on the upload details
+        if (lastUploadedHash !== lastLocalRootHash &&
+            generationIndex === localGenerationIndex) {
+            throw new Error("The repository seems to be corrupted. Please pull the latest changes before pushing.");
+        }
+        if (lastUploadedHash === lastLocalRootHash &&
+            generationIndex === localGenerationIndex) {
+            throw new Error("No changes detected. Skipping push.");
+        }
+        if (lastUploadedHash !== lastLocalRootHash &&
+            generationIndex > localGenerationIndex) {
+            throw new Error("Remote repository is ahead of the local repository. Please pull the latest changes before pushing.");
+        }
+        return { generationIndex, lastLocalRootHash };
+    }
+    // Uploads the store to a specific peer
+    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;
+        }
+        await this.runProgressBar(filesToUpload.length, "Store Data", async (progress) => {
+            for (const filePath of filesToUpload) {
+                console.log(`Uploading ${filePath}...`);
+                const relativePath = path
+                    .relative(this.storeDir, filePath)
+                    .replace(/\\/g, "/");
+                await digPeer.propagationServer.pushFile(filePath, relativePath);
+                progress.increment();
+            }
+        });
+    }
+    static async subscribeToStore(storeId) {
+        fs.mkdirSync(path.join(config_1.DIG_FOLDER_PATH, "stores", storeId), {
+            recursive: true,
+        });
+        const digNetwork = new DigNetwork(storeId);
+        await digNetwork.downloadFiles(true);
+    }
+    static unsubscribeFromStore(storeId) {
+        fs.rmdirSync(path.join(config_1.DIG_FOLDER_PATH, "stores", storeId), { recursive: true });
+        fs.unlinkSync(path.join(config_1.DIG_FOLDER_PATH, "stores", storeId + ".json"));
+    }
+    // Downloads files from the network based on the manifest
+    async downloadFiles(forceDownload = false, renderProgressBar = true) {
+        try {
+            const rootHistory = await this.dataStore.getRootHistory();
+            if (!rootHistory.length)
+                throw new Error("No roots found in rootHistory. Cannot proceed with file download.");
+            await this.downloadHeightFile(forceDownload);
+            const localManifestPath = path.join(this.storeDir, "manifest.dat");
+            const localManifestHashes = fs.existsSync(localManifestPath)
+                ? fs.readFileSync(localManifestPath, "utf-8").trim().split("\n")
+                : [];
+            const progressBar = renderProgressBar
+                ? new cli_progress_1.MultiBar({
+                    clearOnComplete: false,
+                    hideCursor: true,
+                    format: "Syncing Store | {bar} | {percentage}%",
+                    noTTYOutput: true,
+                }, cli_progress_1.Presets.shades_classic)
+                : null;
+            const progress = progressBar
+                ? progressBar.create(rootHistory.length, 0)
+                : null;
+            const newRootHashes = [];
+            for (let i = 0; i < rootHistory.length; i++) {
+                const { root_hash: rootHash } = rootHistory[i];
+                const datFilePath = path.join(this.storeDir, `${rootHash}.dat`);
+                await this.downloadFileFromPeers(`${rootHash}.dat`, datFilePath, forceDownload);
+                const datFileContent = JSON.parse(fs.readFileSync(datFilePath, "utf-8"));
+                if (datFileContent.root !== rootHash)
+                    throw new Error("Root hash mismatch");
+                for (const file of Object.keys(datFileContent.files)) {
+                    const filePath = (0, hashUtils_1.getFilePathFromSha256)(datFileContent.files[file].sha256, path.join(this.storeDir, "data"));
+                    const isInDataDir = filePath.startsWith(path.join(this.storeDir, "data"));
+                    await this.downloadFileFromPeers((0, hashUtils_1.getFilePathFromSha256)(datFileContent.files[file].sha256, "data"), filePath, forceDownload || !isInDataDir);
+                }
+                if (localManifestHashes[i] !== rootHash)
+                    newRootHashes.push(rootHash);
+                progress?.increment();
+            }
+            if (newRootHashes.length)
+                fs.appendFileSync(localManifestPath, newRootHashes.join("\n") + "\n");
+            await this.downloadManifestFile(forceDownload);
+            progressBar?.stop();
+            console.log("Syncing store complete.");
+        }
+        catch (error) {
+            console.trace(error);
+            throw error;
+        }
+    }
+    // Fetches available peers for the store
+    async fetchAvailablePeers() {
+        //const publicIp: string | null | undefined =
+        //   await nconfManager.getConfigValue("publicIp");
+        const peers = await this.serverCoin.sampleCurrentEpoch(10, Array.from(this.peerBlacklist.keys()));
+        return peers.map((ip) => new DigPeer_1.DigPeer(ip, this.dataStore.StoreId));
+    }
+    async downloadHeightFile(forceDownload) {
+        const heightFilePath = path.join(this.storeDir, "height.json");
+        await this.downloadFileFromPeers("height.json", heightFilePath, forceDownload);
+    }
+    async downloadManifestFile(forceDownload) {
+        const heightFilePath = path.join(this.storeDir, "manifest.dat");
+        await this.downloadFileFromPeers("manifest.dat", heightFilePath, forceDownload);
+    }
+    async downloadFileFromPeers(dataPath, filePath, overwrite) {
+        let digPeers = await this.fetchAvailablePeers();
+        while (true) {
+            if (!overwrite && fs.existsSync(filePath))
+                return;
+            const blacklist = this.peerBlacklist.get(dataPath) || new Set();
+            for (const digPeer of digPeers) {
+                if (blacklist.has(digPeer.IpAddress))
+                    continue;
+                try {
+                    // Create directory if it doesn't exist
+                    const directory = path.dirname(filePath);
+                    if (!fs.existsSync(directory)) {
+                        fs.mkdirSync(directory, { recursive: true });
+                    }
+                    // Stream the file data directly to the file system
+                    const fileStream = fs.createWriteStream(filePath);
+                    // Start streaming the data from the peer
+                    const peerStream = await digPeer.propagationServer.streamStoreData(dataPath);
+                    // Pipe the peer stream directly to the file system
+                    await new Promise((resolve, reject) => {
+                        peerStream.pipe(fileStream);
+                        peerStream.on("end", resolve);
+                        peerStream.on("error", reject);
+                        fileStream.on("error", reject);
+                    });
+                    if (process.env.DIG_DEBUG === "1") {
+                        console.log(`Downloaded ${dataPath} from ${digPeer.IpAddress}`);
+                    }
+                    return; // Exit the method if download succeeds
+                }
+                catch (error) {
+                    console.warn(`Failed to download ${dataPath} from ${digPeer.IpAddress}, blacklisting peer and trying next...`);
+                    blacklist.add(digPeer.IpAddress);
+                }
+            }
+            this.peerBlacklist.set(dataPath, blacklist);
+            if (blacklist.size >= digPeers.length) {
+                if (process.env.DIG_DEBUG === "1") {
+                    console.warn(`All peers blacklisted for ${dataPath}. Refreshing peers...`);
+                }
+                digPeers = await this.fetchAvailablePeers();
+                if (!digPeers.length) {
+                    throw new Error(`Failed to download ${dataPath}: no peers available.`);
+                }
+            }
+        }
+    }
+    async runProgressBar(total, name, task) {
+        // Using 'any' to work around TypeScript issues
+        const multiBar = new cli_progress_1.MultiBar({
+            clearOnComplete: false,
+            hideCursor: true,
+            format: "{bar} | {percentage}% | {name}",
+            noTTYOutput: true,
+        }, cli_progress_1.Presets.shades_classic);
+        const progress = multiBar.create(total, 0, { name });
+        await task(progress).finally(() => multiBar.stop());
+    }
+}
+exports.DigNetwork = DigNetwork;

package/dist/DigNetwork/DigPeer.d.ts

@@ -0,0 +1,19 @@
+import { ContentServer } from "./ContentServer";
+import { PropagationServer } from "./PropagationServer";
+import { IncentiveServer } from "./IncentiveServer";
+export declare class DigPeer {
+    private ipAddress;
+    private storeId;
+    private _contentServer;
+    private _propagationServer;
+    private _incentiveServer;
+    constructor(ipAddress: string, storeId: string);
+    get contentServer(): ContentServer;
+    get propagationServer(): PropagationServer;
+    get incentiveServer(): IncentiveServer;
+    get IpAddress(): string;
+    validateStore(rootHash: string, keys: string[]): Promise<boolean>;
+    isSynced(): Promise<boolean>;
+    sendPayment(walletName: string, amount: bigint): Promise<void>;
+}
+//# sourceMappingURL=DigPeer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DigPeer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigPeer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAcpD,qBAAa,OAAO;IAClB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,kBAAkB,CAAoB;IAC9C,OAAO,CAAC,gBAAgB,CAAkB;gBAE9B,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAS9C,IAAW,aAAa,IAAI,aAAa,CAExC;IAGD,IAAW,iBAAiB,IAAI,iBAAiB,CAEhD;IAGD,IAAW,eAAe,IAAI,eAAe,CAE5C;IAED,IAAW,SAAS,IAAI,MAAM,CAE7B;IAEY,aAAa,CACxB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,OAAO,CAAC;IA8GN,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAyB5B,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAmC5E"}

package/dist/DigNetwork/DigPeer.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigPeer = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const ContentServer_1 = require("./ContentServer");
+const PropagationServer_1 = require("./PropagationServer");
+const IncentiveServer_1 = require("./IncentiveServer");
+const blockchain_1 = require("../blockchain");
+const DataIntegrityTree_1 = require("../DataIntegrityTree");
+const datalayer_driver_1 = require("datalayer-driver");
+const blockchain_2 = require("../blockchain");
+const blockchain_3 = require("../blockchain");
+const coins_1 = require("../blockchain/coins");
+class DigPeer {
+    constructor(ipAddress, storeId) {
+        this.ipAddress = ipAddress;
+        this.storeId = storeId;
+        this._contentServer = new ContentServer_1.ContentServer(ipAddress, storeId);
+        this._propagationServer = new PropagationServer_1.PropagationServer(ipAddress, storeId);
+        this._incentiveServer = new IncentiveServer_1.IncentiveServer(ipAddress);
+    }
+    // Getter for ContentServer
+    get contentServer() {
+        return this._contentServer;
+    }
+    // Getter for PropagationServer
+    get propagationServer() {
+        return this._propagationServer;
+    }
+    // Getter for IncentiveServer
+    get incentiveServer() {
+        return this._incentiveServer;
+    }
+    get IpAddress() {
+        return this.ipAddress;
+    }
+    async validateStore(rootHash, keys) {
+        console.log(`Validating store ${this.storeId} on peer ${this.ipAddress}...`);
+        try {
+            const dataStore = blockchain_1.DataStore.from(this.storeId);
+            // Fetch the root history from the propagation server
+            const rootHistory = await dataStore.getRootHistory();
+            if (rootHistory.length === 0) {
+                console.error("No root history found for the store.");
+                return false;
+            }
+            // Fetch the manifest.dat file content from the propagation server
+            const manifestContent = await this.propagationServer.getStoreData("manifest.dat");
+            const manifestHashes = manifestContent
+                .split("\n")
+                .filter(Boolean);
+            // Ensure all hashes in root history are present in the manifest in the same order
+            for (let i = 0; i < rootHistory.length; i++) {
+                if (rootHistory[i].root_hash !== manifestHashes[i]) {
+                    console.error(`Hash mismatch at index ${i}: manifest hash ${manifestHashes[i]} does not match root history hash ${rootHistory[i].root_hash}`);
+                    return false;
+                }
+            }
+            console.log("Manifest file validated.");
+            // Fetch the .dat file content for the specified root hash from the content server
+            const datFileContent = JSON.parse(await this.propagationServer.getStoreData(`${rootHash}.dat`));
+            if (datFileContent.root !== rootHash) {
+                console.error(`Root hash in .dat file does not match: ${datFileContent.root} !== ${rootHash}`);
+                return false;
+            }
+            let filesIntegrityIntact = true;
+            // Validate SHA256 hashes of the specified keys using streamStoreKey
+            for (const key of keys) {
+                const fileData = datFileContent.files[key];
+                if (!fileData) {
+                    console.error(`File key ${key} not found in .dat file.`);
+                    filesIntegrityIntact = false;
+                    continue;
+                }
+                // Stream the file from the propagation server and calculate the SHA256 hash on the fly
+                const hash = crypto_1.default.createHash("sha256");
+                const fileStream = await this.contentServer.streamKey(Buffer.from(key, "hex").toString("utf-8"));
+                await new Promise((resolve, reject) => {
+                    fileStream.on("data", (chunk) => {
+                        hash.update(chunk); // Update the hash with each chunk of data
+                    });
+                    fileStream.on("end", () => {
+                        const calculatedHash = hash.digest("hex");
+                        // Compare the calculated hash with the expected hash
+                        if (calculatedHash !== fileData.sha256) {
+                            console.error(`File ${key} failed SHA256 validation.`);
+                            filesIntegrityIntact = false;
+                        }
+                        resolve();
+                    });
+                    fileStream.on("error", (err) => {
+                        console.error(`Failed to stream file ${key}: ${err.message}`);
+                        reject(err);
+                    });
+                });
+                // Perform tree integrity validation using the datFileContent and the root hash
+                const treeCheck = DataIntegrityTree_1.DataIntegrityTree.validateKeyIntegrityWithForeignTree(key, fileData.sha256, datFileContent, rootHash);
+                if (!treeCheck) {
+                    console.error(`Tree validation failed for file ${key}.`);
+                    filesIntegrityIntact = false;
+                }
+            }
+            if (!filesIntegrityIntact) {
+                console.error("Store Corrupted: Data failed SHA256 validation.");
+                return false;
+            }
+            console.log("Store validation successful.");
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to validate store: ${error.message}`);
+            return false;
+        }
+    }
+    async isSynced() {
+        try {
+            // Fetch the root history from the propagation server
+            const dataStore = blockchain_1.DataStore.from(this.storeId);
+            const rootHistory = await dataStore.getRootHistory();
+            if (rootHistory.length === 0) {
+                console.error("No root history found for the store.");
+                return false;
+            }
+            // Fetch the manifest.dat file content from the content server
+            const manifestContent = await this.propagationServer.getStoreData("manifest.dat");
+            const manifestHashes = manifestContent
+                .split("\n")
+                .filter(Boolean);
+            // Compare lengths of root history and manifest
+            return rootHistory.length === manifestHashes.length;
+        }
+        catch (error) {
+            console.error(`Failed to check sync status: ${error.message}`);
+            return false;
+        }
+    }
+    async sendPayment(walletName, amount) {
+        const paymentAddress = await this.contentServer.getPaymentAddress();
+        console.log(`Sending ${amount} Mojos to ${paymentAddress}...`);
+        const fee = BigInt(1000);
+        const wallet = await blockchain_3.Wallet.load(walletName);
+        const publicSyntheticKey = await wallet.getPublicSyntheticKey();
+        const peer = await blockchain_2.FullNodePeer.connect();
+        const coins = await (0, coins_1.selectUnspentCoins)(peer, amount, fee, [], walletName);
+        const paymentAddressPuzzleHash = (0, datalayer_driver_1.addressToPuzzleHash)(paymentAddress);
+        const outputs = [
+            {
+                puzzleHash: paymentAddressPuzzleHash,
+                amount: amount,
+            },
+        ];
+        const coinSpends = await (0, datalayer_driver_1.sendXch)(publicSyntheticKey, coins, outputs, fee);
+        const sig = (0, datalayer_driver_1.signCoinSpends)(coinSpends, [await wallet.getPrivateSyntheticKey()], false);
+        const err = await peer.broadcastSpend(coinSpends, [sig]);
+        if (err) {
+            throw new Error(err);
+        }
+        await blockchain_2.FullNodePeer.waitForConfirmation((0, datalayer_driver_1.getCoinId)(coins[0]));
+    }
+}
+exports.DigPeer = DigPeer;

package/dist/DigNetwork/IncentiveServer.d.ts

@@ -0,0 +1,13 @@
+import { IncentiveProgramData } from "../types";
+export declare class IncentiveServer {
+    private ipAddress;
+    private port;
+    constructor(ipAddress: string);
+    createIncentiveProgram(data: IncentiveProgramData): Promise<void>;
+    updateIncentiveProgram(data: IncentiveProgramData): Promise<void>;
+    deleteIncentiveProgram(storeId: string): Promise<void>;
+    getAllIncentivePrograms(): Promise<IncentiveProgramData[]>;
+    getIncentiveProgram(storeId: string): Promise<IncentiveProgramData>;
+    private makeRequest;
+}
+//# sourceMappingURL=IncentiveServer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IncentiveServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/IncentiveServer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAgB;gBAEhB,SAAS,EAAE,MAAM;IAKhB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAOjE,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAOjE,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOtD,uBAAuB,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAO1D,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;YAOlE,WAAW;CA6C1B"}

package/dist/DigNetwork/IncentiveServer.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncentiveServer = void 0;
+const https_1 = __importDefault(require("https"));
+const url_1 = require("url");
+class IncentiveServer {
+    constructor(ipAddress) {
+        this.port = 4160;
+        this.ipAddress = ipAddress;
+    }
+    // Method to create a new incentive program
+    async createIncentiveProgram(data) {
+        const url = `https://${this.ipAddress}:${this.port}/incentive`;
+        await this.makeRequest(url, "POST", data);
+    }
+    // Method to update an existing incentive program
+    async updateIncentiveProgram(data) {
+        const url = `https://${this.ipAddress}:${this.port}/incentive`;
+        await this.makeRequest(url, "PUT", data);
+    }
+    // Method to delete an incentive program by storeId
+    async deleteIncentiveProgram(storeId) {
+        const url = `https://${this.ipAddress}:${this.port}/incentive`;
+        await this.makeRequest(url, "DELETE", { storeId });
+    }
+    // Method to get all incentive programs
+    async getAllIncentivePrograms() {
+        const url = `https://${this.ipAddress}:${this.port}/incentive`;
+        return this.makeRequest(url, "GET");
+    }
+    // Method to get a specific incentive program by storeId
+    async getIncentiveProgram(storeId) {
+        const url = `https://${this.ipAddress}:${this.port}/incentive/${storeId}`;
+        return this.makeRequest(url, "GET");
+    }
+    // Helper method to handle the HTTPS request
+    async makeRequest(url, method, data) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port,
+                path: urlObj.pathname + urlObj.search,
+                method: method,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            };
+            const req = https_1.default.request(options, (res) => {
+                let responseData = "";
+                res.on("data", (chunk) => {
+                    responseData += chunk;
+                });
+                res.on("end", () => {
+                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(responseData ? JSON.parse(responseData) : undefined);
+                    }
+                    else {
+                        reject(new Error(`Request failed with status ${res.statusCode}: ${res.statusMessage}`));
+                    }
+                });
+            });
+            req.on("error", (err) => {
+                reject(err);
+            });
+            if (data) {
+                req.write(JSON.stringify(data));
+            }
+            req.end();
+        });
+    }
+}
+exports.IncentiveServer = IncentiveServer;

package/dist/DigNetwork/PropagationServer.d.ts

@@ -0,0 +1,41 @@
+import { Readable } from "stream";
+export declare class PropagationServer {
+    private ipAddress;
+    private storeId;
+    private static certPath;
+    private static keyPath;
+    private static readonly port;
+    private static readonly maxRetries;
+    private static readonly initialDelay;
+    private static readonly maxDelay;
+    private static readonly delayMultiplier;
+    constructor(ipAddress: string, storeId: string);
+    pushFile(filePath: string, relativePath: string): Promise<void>;
+    subscribeToStore(): Promise<void>;
+    unsubscribeFromStore(): Promise<void>;
+    getStoreStatus(): Promise<any>;
+    streamStoreData(dataPath: string): Promise<Readable>;
+    getStoreData(dataPath: string): Promise<string>;
+    getStatus(): Promise<{
+        synced: boolean;
+    }>;
+    headStore(): Promise<boolean>;
+    isStoreSynced(): Promise<boolean>;
+    getUploadDetails(): Promise<{
+        nonce: string;
+        lastUploadedHash: string;
+        generationIndex: number;
+        username: string;
+        password: string;
+    }>;
+    private postRequest;
+    private fetchUploadDetails;
+    private uploadFileDirect;
+    private retryOperation;
+    private fetch;
+    private head;
+    private fetchJson;
+    private createReadStreamWithRetries;
+    private createReadStream;
+}
+//# sourceMappingURL=PropagationServer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PropagationServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/PropagationServer.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAGlC,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAQ;IACpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAK;IACvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAQ;IAC5C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAS;IACzC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAO;gBAElC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAYjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB/D,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC;IAQrC,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAK9B,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAMpD,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/C,SAAS,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;IAOzC,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAM7B,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC;IAMjC,gBAAgB,IAAI,OAAO,CAAC;QACvC,KAAK,EAAE,MAAM,CAAC;QACd,gBAAgB,EAAE,MAAM,CAAC;QACzB,eAAe,EAAE,MAAM,CAAC;QACxB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;YAmBY,WAAW;YAyCX,kBAAkB;YA0ElB,gBAAgB;YAgEhB,cAAc;YAiCd,KAAK;YAmDL,IAAI;YAgCJ,SAAS;YAuCT,2BAA2B;YAiC3B,gBAAgB;CAyC/B"}