@dignetwork/dig-sdk 0.0.1-alpha.5 → 0.0.1-alpha.52

package/dist/DigNetwork/DigNetwork.js

@@ -28,10 +28,13 @@ 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");
+const util_1 = require("util");
+const DataIntegrityTree_1 = require("../DataIntegrityTree");
+const rename = (0, util_1.promisify)(fs.rename);
+const unlink = (0, util_1.promisify)(fs.unlink);
 class DigNetwork {
     constructor(storeId) {
         this.dataStore = blockchain_1.DataStore.from(storeId);
@@ -39,83 +42,6 @@ class DigNetwork {
         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 };
-    }
-    async uploadStoreHead(digPeer) {
-        // First make sure that the remote store is up to date.
-        const rootHistory = await this.dataStore.getRootHistory();
-        const localManifestHashes = await this.dataStore.getManifestHashes();
-        const remoteManifestFile = await digPeer.propagationServer.getStoreData("manifest.dat");
-        const remoteManifestHashes = remoteManifestFile.split("\n").filter(Boolean);
-        const onChainRootHashes = rootHistory.map((root) => root.root_hash);
-        // Check that remote manifest is one behind on-chain root hashes
-        if (remoteManifestHashes.length !== onChainRootHashes.length - 1) {
-            throw new Error("Remote manifest should be one behind the on-chain root. Cannot push head.");
-        }
-        // Compare each remote manifest hash with the corresponding on-chain root hash
-        for (let i = 0; i < remoteManifestHashes.length; i++) {
-            if (remoteManifestHashes[i] !== onChainRootHashes[i]) {
-                throw new Error(`Remote manifest does not match on-chain root at index ${i}. Cannot push head.`);
-            }
-        }
-        // Get the files for the latest local manifest hash
-        const filesToUpload = await this.dataStore.getFileSetForRootHash(localManifestHashes[localManifestHashes.length - 1]);
-        if (!filesToUpload.length) {
-            console.log("No files to upload.");
-            return;
-        }
-        // Upload files to the remote peer with a progress bar
-        await this.runProgressBar(filesToUpload.length, "Store Data", async (progress) => {
-            for (const filePath of filesToUpload) {
-                const relativePath = path
-                    .relative(this.storeDir, filePath)
-                    .replace(/\\/g, "/");
-                await digPeer.propagationServer.pushFile(filePath, relativePath);
-                progress.increment();
-            }
-        });
-    }
-    // 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) {
-                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,
@@ -123,60 +49,128 @@ class DigNetwork {
         const digNetwork = new DigNetwork(storeId);
         await digNetwork.downloadFiles(true);
     }
+    static async findPeerWithStoreKey(storeId, rootHash, key, intialBlackList = []) {
+        const peerBlackList = intialBlackList;
+        const serverCoin = new blockchain_1.ServerCoin(storeId);
+        let peerIp = null;
+        // Keep sampling peers until an empty array is returned
+        while (true) {
+            try {
+                // Sample a peer from the current epoch
+                const digPeers = await serverCoin.sampleCurrentEpoch(1, peerBlackList);
+                // If no peers are returned, break out of the loop
+                if (digPeers.length === 0) {
+                    console.log("No more peers found.");
+                    break;
+                }
+                peerIp = digPeers[0];
+                const digPeer = new DigPeer_1.DigPeer(peerIp, storeId);
+                // Try to fetch the head store information
+                const storeResponse = await digPeer.contentServer.headStore({
+                    hasRootHash: rootHash,
+                });
+                // If the peer has the correct root hash, check if key is required
+                if (storeResponse.headers?.["x-has-roothash"] === "true") {
+                    console.log(`Found Peer at ${peerIp} for storeId: ${storeId}, root hash ${rootHash}`);
+                    // If no key is provided, return the peer
+                    if (!key) {
+                        return digPeer;
+                    }
+                    // If key is provided, check if the peer has it
+                    const keyResponse = await digPeer.contentServer.headKey(key);
+                    if (keyResponse.headers?.["x-key-exists"] === "true") {
+                        return digPeer;
+                    }
+                }
+                // Add peer to blacklist if it doesn't meet criteria
+                peerBlackList.push(peerIp);
+            }
+            catch (error) {
+                console.error(`Error connecting to DIG Peer ${peerIp}. Resampling...`);
+                if (peerIp) {
+                    peerBlackList.push(peerIp); // Add to blacklist if error occurs
+                }
+            }
+        }
+        // Return null if no valid peer was found
+        return null;
+    }
     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, skipData = false) {
+    async downloadFiles(skipData = false) {
+        console.log("Starting file download process...");
+        let peerBlackList = [];
+        let selectedPeer = null;
         try {
             const rootHistory = await this.dataStore.getRootHistory();
-            if (!rootHistory.length)
+            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");
-                if (!skipData) {
-                    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);
+            }
+            await this.downloadHeightFile(true);
+            // Filter out rootInfo entries where the .dat file already exists
+            const rootHistoryFiltered = rootHistory
+                .filter((item) => item.timestamp !== undefined)
+                .filter((item) => !fs.existsSync(`${this.storeDir}/${item.root_hash}.dat`))
+                // Reverse to download the latest first
+                .reverse();
+            if (!rootHistoryFiltered.length) {
+                console.log("All root hashes already exist locally. No need for download.");
+                return;
+            }
+            // Process filtered rootHistory sequentially
+            for (const rootInfo of rootHistoryFiltered) {
+                while (true) {
+                    try {
+                        selectedPeer = await DigNetwork.findPeerWithStoreKey(this.dataStore.StoreId, rootInfo.root_hash, undefined, peerBlackList);
+                        if (!selectedPeer) {
+                            console.error(`No peer found with root hash ${rootInfo.root_hash}. Skipping download.`);
+                            break; // Exit loop if no more peers are found
+                        }
+                        const rootResponse = await selectedPeer.propagationServer.getStoreData(`${rootInfo.root_hash}.dat`);
+                        const root = JSON.parse(rootResponse);
+                        if (!skipData) {
+                            // Sequential file download
+                            for (const [storeKey, file] of Object.entries(root.files)) {
+                                const filePath = (0, hashUtils_1.getFilePathFromSha256)(file.sha256, `${this.storeDir}/data`);
+                                console.log(`Downloading file with sha256: ${file.sha256}...`);
+                                await selectedPeer.downloadData(this.dataStore.StoreId, `data/${file.sha256.match(/.{1,2}/g).join("/")}`);
+                                const integrityCheck = await DataIntegrityTree_1.DataIntegrityTree.validateKeyIntegrityWithForeignTree(storeKey, file.sha256, root, rootInfo.root_hash, `${this.storeDir}/data`);
+                                if (integrityCheck) {
+                                    console.log(`\x1b[32mIntegrity check passed for file with sha256: ${file.sha256}.\x1b[0m`);
+                                    continue;
+                                }
+                                console.error(`\x1b[31mIntegrity check failed for file with sha256: ${file.sha256}.\x1b[0m`);
+                                await unlink(filePath);
+                                throw new Error(`Store Integrity check failed. Syncing file from another peer.`);
+                            }
+                        }
+                        fs.writeFileSync(`${this.storeDir}/${rootInfo.root_hash}.dat`, rootResponse);
+                        peerBlackList = []; // Clear the blacklist upon successful download
+                        // Break out of the retry loop if the download succeeds
+                        break;
+                    }
+                    catch (error) {
+                        console.error(`Error downloading from peer. Retrying with another peer.`, error);
+                        if (selectedPeer) {
+                            peerBlackList.push(selectedPeer.IpAddress); // Add peer to blacklist and try again
+                        }
                     }
                 }
-                if (localManifestHashes[i] !== rootHash)
-                    newRootHashes.push(rootHash);
-                progress?.increment();
+                // Only process the first root hash so other stores can sync the latest.
+                // This has an effect where the latest roothash will always be synced first, even if new ones come in.
+                // Then it will backfill historical roothashes
+                break;
             }
-            if (newRootHashes.length)
-                fs.appendFileSync(localManifestPath, newRootHashes.join("\n") + "\n");
-            await this.downloadManifestFile(forceDownload);
-            progressBar?.stop();
             console.log("Syncing store complete.");
         }
         catch (error) {
+            if (selectedPeer) {
+                peerBlackList.push(selectedPeer.IpAddress);
+            }
             console.trace(error);
             throw error;
         }
@@ -192,62 +186,33 @@ class DigNetwork {
         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();
+        const tempFilePath = `${filePath}.tmp`;
         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}`);
-                    }
+                    if (blacklist.has(digPeer.IpAddress))
+                        continue;
+                    await digPeer.downloadData(this.dataStore.StoreId, dataPath);
                     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.`);
+                    // Clean up the temp file in case of failure
+                    if (fs.existsSync(tempFilePath)) {
+                        await unlink(tempFilePath);
+                    }
                 }
             }
         }
     }
     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 +222,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.d.ts

@@ -1,6 +1,7 @@
 import { ContentServer } from "./ContentServer";
 import { PropagationServer } from "./PropagationServer";
 import { IncentiveServer } from "./IncentiveServer";
+import { Output } from "@dignetwork/datalayer-driver";
 export declare class DigPeer {
     private ipAddress;
     private storeId;
@@ -12,8 +13,12 @@ export declare class DigPeer {
     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>;
+    static sendEqualBulkPayments(walletName: string, addresses: string[], totalAmount: bigint, memos: Buffer[]): Promise<void>;
+    static sendBulkPayments(walletName: string, outputs: Output[]): Promise<void>;
+    sendPayment(walletName: string, amount: bigint, memos?: Buffer[]): Promise<void>;
+    static createPaymentHint(storeId: Buffer): Buffer;
+    syncStore(): Promise<void>;
+    pushStoreRoot(storeId: string, rootHash: string): Promise<void>;
+    downloadData(storeId: string, dataPath: string): Promise<void>;
 }
 //# sourceMappingURL=DigPeer.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"DigPeer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigPeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAKpD,OAAO,EAKL,MAAM,EACP,MAAM,8BAA8B,CAAC;AAUtC,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;WAEa,qBAAqB,CACjC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EAAE,EACnB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,IAAI,CAAC;WAuBI,gBAAgB,CAClC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,IAAI,CAAC;IAwCH,WAAW,CACtB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,MAAM,EAAO,GACnB,OAAO,CAAC,IAAI,CAAC;WAYF,iBAAiB,CAAC,OAAO,EAAE,MAAM;IAqBlC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAU1B,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyB/D,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA4C5E"}

package/dist/DigNetwork/DigPeer.js

@@ -4,16 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigPeer = void 0;
+const path_1 = __importDefault(require("path"));
 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 fs_1 = __importDefault(require("fs"));
+const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
 const blockchain_2 = require("../blockchain");
 const blockchain_3 = require("../blockchain");
 const coins_1 = require("../blockchain/coins");
+const config_1 = require("../utils/config");
+const util_1 = require("util");
+const rename = (0, util_1.promisify)(fs_1.default.rename);
+const unlink = (0, util_1.promisify)(fs_1.default.unlink);
 class DigPeer {
     constructor(ipAddress, storeId) {
         this.ipAddress = ipAddress;
@@ -37,122 +42,31 @@ class DigPeer {
     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;
-        }
+    static sendEqualBulkPayments(walletName, addresses, totalAmount, memos) {
+        // Use a Set to ensure unique addresses
+        const uniqueAddresses = Array.from(new Set(addresses));
+        // Convert unique addresses to puzzle hashes
+        const puzzleHashes = uniqueAddresses.map((address) => (0, datalayer_driver_1.addressToPuzzleHash)(address));
+        // Calculate amount per puzzle hash
+        const amountPerPuzzleHash = totalAmount / BigInt(puzzleHashes.length);
+        // Create outputs array
+        const outputs = puzzleHashes.map((puzzleHash) => ({
+            puzzleHash,
+            amount: amountPerPuzzleHash,
+            memos,
+        }));
+        // Call the sendBulkPayments function with the generated outputs
+        return DigPeer.sendBulkPayments(walletName, outputs);
     }
-    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);
+    static async sendBulkPayments(walletName, outputs) {
+        const feePerCondition = BigInt(1000);
+        const totalFee = feePerCondition * BigInt(outputs.length);
         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 totalAmount = outputs.reduce((acc, output) => acc + output.amount, BigInt(0));
+        const coins = await (0, coins_1.selectUnspentCoins)(peer, totalAmount, totalFee, [], walletName);
+        const coinSpends = await (0, datalayer_driver_1.sendXch)(publicSyntheticKey, coins, outputs, totalFee);
         const sig = (0, datalayer_driver_1.signCoinSpends)(coinSpends, [await wallet.getPrivateSyntheticKey()], false);
         const err = await peer.broadcastSpend(coinSpends, [sig]);
         if (err) {
@@ -160,5 +74,93 @@ class DigPeer {
         }
         await blockchain_2.FullNodePeer.waitForConfirmation((0, datalayer_driver_1.getCoinId)(coins[0]));
     }
+    async sendPayment(walletName, amount, memos = []) {
+        const paymentAddress = await this.contentServer.getPaymentAddress();
+        const paymentAddressPuzzleHash = (0, datalayer_driver_1.addressToPuzzleHash)(paymentAddress);
+        const output = {
+            puzzleHash: paymentAddressPuzzleHash,
+            amount,
+            memos,
+        };
+        return DigPeer.sendBulkPayments(walletName, [output]);
+    }
+    static createPaymentHint(storeId) {
+        // Ensure the input is a 32-byte buffer
+        if (!Buffer.isBuffer(storeId) || storeId.length !== 32) {
+            throw new Error("Invalid input. Must be a 32-byte buffer.");
+        }
+        // Define the seed
+        const seed = "digpayment";
+        // Combine the seed and the original buffer
+        const combinedBuffer = Buffer.concat([Buffer.from(seed), storeId]);
+        // Apply SHA-256 hash to the combined buffer
+        const hash = crypto_1.default.createHash("sha256");
+        hash.update(combinedBuffer);
+        const transformedBuffer = hash.digest();
+        // Return the 32-byte hash as a hex string
+        return transformedBuffer;
+    }
+    async syncStore() {
+        const dataStore = blockchain_1.DataStore.from(this.storeId);
+        const rootHistory = await dataStore.getRootHistory();
+        rootHistory
+            .filter((root) => root.synced)
+            .forEach((item) => {
+            this.pushStoreRoot(this.storeId, item.root_hash);
+        });
+    }
+    async pushStoreRoot(storeId, rootHash) {
+        const dataStore = blockchain_1.DataStore.from(storeId);
+        const alreadySynced = await this.contentServer.hasRootHash(rootHash);
+        if (alreadySynced) {
+            console.log(`Root hash ${rootHash} already synced.`);
+            return;
+        }
+        const tree = await dataStore.Tree.serialize(rootHash);
+        // @ts-ignore
+        tree.files.forEach(async (file) => {
+            await dataStore.Tree.verifyKeyIntegrity(file.sha256, rootHash);
+            console.log(`Pushing file ${file.key} to ${this.IpAddress}`);
+            const dataPath = path_1.default.join("data", file.sha256.match(/.{1,2}/g).join("/"));
+            const fileLocation = path_1.default.join(config_1.STORE_PATH, storeId, dataPath);
+            await this.propagationServer.pushFile(fileLocation, dataPath);
+        });
+    }
+    async downloadData(storeId, dataPath) {
+        const filePath = path_1.default.join(config_1.STORE_PATH, storeId, dataPath);
+        const tempFilePath = `${filePath}.tmp`;
+        try {
+            const headStoreResponse = await this.propagationServer.headStore();
+            if (!headStoreResponse.success) {
+                throw new Error("Data not accessible from store.");
+            }
+            const directory = path_1.default.dirname(tempFilePath);
+            if (!fs_1.default.existsSync(directory)) {
+                fs_1.default.mkdirSync(directory, { recursive: true });
+            }
+            const fileStream = fs_1.default.createWriteStream(tempFilePath);
+            const dataStream = await this.propagationServer.streamStoreData(dataPath);
+            await new Promise((resolve, reject) => {
+                dataStream.pipe(fileStream);
+                dataStream.on("end", resolve);
+                dataStream.on("error", reject);
+                fileStream.on("error", reject);
+            });
+            await rename(tempFilePath, filePath);
+            console.log(`Downloaded ${dataPath} from ${this.IpAddress}`);
+        }
+        catch (error) {
+            console.error(`Failed to download data: ${error.message}`);
+            if (fs_1.default.existsSync(tempFilePath)) {
+                await unlink(tempFilePath);
+            }
+            // Check if directory is empty and remove it if it is
+            const directory = path_1.default.dirname(tempFilePath);
+            if (fs_1.default.existsSync(directory) && fs_1.default.readdirSync(directory).length === 0) {
+                fs_1.default.rmdirSync(directory);
+                console.log(`Removed empty directory: ${directory}`);
+            }
+        }
+    }
 }
 exports.DigPeer = DigPeer;