@dignetwork/dig-sdk 0.0.1-alpha.19 → 0.0.1-alpha.190

package/dist/DigNetwork/DigNetwork.d.ts

@@ -4,17 +4,23 @@ export declare class DigNetwork {
     private serverCoin;
     private storeDir;
     private peerBlacklist;
+    private static networkSyncMap;
     constructor(storeId: string);
-    private uploadPreflight;
-    uploadStoreHead(digPeer: DigPeer): Promise<void>;
-    uploadStore(digPeer: DigPeer): Promise<void>;
     static subscribeToStore(storeId: string): Promise<void>;
+    static getAllNetworkDataStoreIds(): string[];
+    static getUdiContent(udi: string): Promise<void>;
+    /**
+     * Find a peer that has the store key and root hash, using ranked peers first and searching in groups of 5.
+     *
+     * @param {string} storeId - The ID of the store.
+     * @param {string} rootHash - The root hash of the store.
+     * @param {string} [key] - Optional key to check for in the store.
+     * @returns {Promise<DigPeer | null>} - A valid peer or null if none found.
+     */
+    static findPeerWithStoreKey(storeId: string, rootHash: string, key?: string): Promise<DigPeer | null>;
     static unsubscribeFromStore(storeId: string): void;
-    downloadFiles(forceDownload?: boolean, renderProgressBar?: boolean, skipData?: boolean): Promise<void>;
-    private fetchAvailablePeers;
-    private downloadHeightFile;
-    private downloadManifestFile;
-    private downloadFileFromPeers;
-    private runProgressBar;
+    static pingNetworkOfUpdate(storeId: string, rootHash: string): Promise<void>;
+    syncStoreFromPeers(prioritizedPeer?: DigPeer, maxRootsToProcess?: number): Promise<void>;
+    fetchAvailablePeers(): Promise<DigPeer[]>;
 }
 //# sourceMappingURL=DigNetwork.d.ts.map

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;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"}
+{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,MAAM,CAAC,cAAc,CAAmC;gBAEpD,OAAO,EAAE,MAAM;WAOP,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQtD,yBAAyB,IAAI,MAAM,EAAE;WAI/B,aAAa,CAAC,GAAG,EAAE,MAAM;IAI7C;;;;;;;OAOG;WACiB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;WAsFZ,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;WAOrC,mBAAmB,CACrC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAcH,kBAAkB,CAC7B,eAAe,CAAC,EAAE,OAAO,EACzB,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC;IAqFH,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAUvD"}

package/dist/DigNetwork/DigNetwork.js

@@ -26,12 +26,10 @@ 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");
+const utils_1 = require("../utils");
 class DigNetwork {
     constructor(storeId) {
         this.dataStore = blockchain_1.DataStore.from(storeId);
@@ -39,88 +37,82 @@ 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"));
-        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,
         });
         const digNetwork = new DigNetwork(storeId);
-        await digNetwork.downloadFiles(true);
+        await digNetwork.syncStoreFromPeers();
+    }
+    static getAllNetworkDataStoreIds() {
+        throw new Error("Method not implemented.");
+    }
+    static async getUdiContent(udi) {
+        throw new Error("Method not implemented.");
+    }
+    /**
+     * Find a peer that has the store key and root hash, using ranked peers first and searching in groups of 5.
+     *
+     * @param {string} storeId - The ID of the store.
+     * @param {string} rootHash - The root hash of the store.
+     * @param {string} [key] - Optional key to check for in the store.
+     * @returns {Promise<DigPeer | null>} - A valid peer or null if none found.
+     */
+    static async findPeerWithStoreKey(storeId, rootHash, key) {
+        const serverCoin = new blockchain_1.ServerCoin(storeId);
+        try {
+            // Fetch all active peers for the current epoch
+            const digPeers = await serverCoin.getActiveEpochPeers();
+            // If no peers are returned, exit early
+            if (digPeers.length === 0) {
+                console.log("No peers found.");
+                return null;
+            }
+            // Initialize PeerRanker with the list of digPeers (IP addresses)
+            const peerRanker = new utils_1.PeerRanker(digPeers);
+            // Rank the peers based on latency and bandwidth
+            const rankedPeers = await peerRanker.rankPeers();
+            // If no peers are returned after ranking, exit early
+            if (rankedPeers.length === 0) {
+                console.log("No valid peers found after ranking.");
+                return null;
+            }
+            // Define the iterator function to process each peer
+            const iteratorFn = async (peerMetrics) => {
+                const peerIp = peerMetrics.ip;
+                try {
+                    const digPeer = new DigPeer_1.DigPeer(peerIp, storeId);
+                    // Wrap the store check with a 10-second timeout
+                    const { storeExists, rootHashExists } = await (0, utils_1.withTimeout)(digPeer.propagationServer.checkStoreExists(rootHash), 10000, `Timeout while checking store on peer ${peerIp}`);
+                    // Check if the store and root hash exist on the peer
+                    if (storeExists && rootHashExists) {
+                        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, wrap key check with a 10-second timeout
+                        const keyResponse = await (0, utils_1.withTimeout)(digPeer.contentServer.headKey(key, rootHash), 10000, `Timeout while checking key on peer ${peerIp}`);
+                        if (keyResponse.headers?.["x-key-exists"] === "true") {
+                            return digPeer;
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(`Error connecting to DIG Peer ${peerIp}:`, error.message);
+                }
+                // If the peer does not meet the criteria, return null
+                return null;
+            };
+            // Use Promise.race to return the first valid peer found
+            const validPeer = await Promise.race(rankedPeers.map((peer) => iteratorFn(peer)));
+            // Return the first valid peer or null if none is found
+            return validPeer || null;
+        }
+        catch (error) {
+            console.error("Error sampling peers:", error);
+            return null;
+        }
     }
     static unsubscribeFromStore(storeId) {
         fs.rmdirSync(path.join(config_1.DIG_FOLDER_PATH, "stores", storeId), {
@@ -128,57 +120,73 @@ class DigNetwork {
         });
         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) {
+    static async pingNetworkOfUpdate(storeId, rootHash) {
+        const serverCoin = new blockchain_1.ServerCoin(storeId);
+        // When an update is made, ping 10 network peers to pull updates from this store
+        const digPeers = await serverCoin.sampleCurrentEpoch(10);
+        for (const peer of digPeers) {
+            const digPeer = new DigPeer_1.DigPeer(peer, storeId);
+            await (0, utils_1.withTimeout)(digPeer.propagationServer.pingUpdate(rootHash), 5000, `headKey timed out for peer ${digPeer.IpAddress}`);
+        }
+    }
+    async syncStoreFromPeers(prioritizedPeer, maxRootsToProcess) {
+        // Check if synchronization is already active for this storeId
+        if (DigNetwork.networkSyncMap.get(this.dataStore.StoreId)) {
+            return;
+        }
+        console.log("Starting network sync for store:", this.dataStore.StoreId);
+        DigNetwork.networkSyncMap.set(this.dataStore.StoreId, true);
         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);
+            }
+            // 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(); // Reverse to download the latest first
+            if (!rootHistoryFiltered.length) {
+                console.log("All root hashes already exist locally. No need for download.");
+                return;
+            }
+            // If maxRootsToProcess is specified, limit the number of roots processed
+            const rootsToProcess = maxRootsToProcess
+                ? rootHistoryFiltered.slice(0, maxRootsToProcess)
+                : rootHistoryFiltered;
+            // Process the root hashes sequentially
+            for (const rootInfo of rootsToProcess) {
+                try {
+                    let selectedPeer = prioritizedPeer || null;
+                    if (!selectedPeer) {
+                        // Use the `findPeerWithStoreKey` method to find a peer with the store and root hash
+                        selectedPeer = await DigNetwork.findPeerWithStoreKey(this.dataStore.StoreId, rootInfo.root_hash);
+                    }
+                    if (!selectedPeer) {
+                        console.error(`No peer found with root hash ${rootInfo.root_hash}. Moving to next root.`);
+                        continue; // Move to the next rootInfo
                     }
+                    // Download the store root and associated data
+                    await selectedPeer.downloadStoreRoot(rootInfo.root_hash);
+                    // Break after successful download to proceed to next root hash
+                }
+                catch (error) {
+                    if (error.message)
+                        console.error(`Error downloading from peer ${prioritizedPeer?.IpAddress}. Retrying with another peer.`, error);
+                    // Continue to next rootInfo in case of error
                 }
-                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);
+            console.error("Error during syncing store from peers:", error);
             throw error;
         }
+        finally {
+            // Mark synchronization as inactive for this storeId
+            DigNetwork.networkSyncMap.set(this.dataStore.StoreId, false);
+            console.log(`Network sync for storeId: ${this.dataStore.StoreId} has completed.`);
+        }
     }
     // Fetches available peers for the store
     async fetchAvailablePeers() {
@@ -187,74 +195,6 @@ class DigNetwork {
         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;
+DigNetwork.networkSyncMap = new Map();

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(order?: "asc" | "desc"): Promise<void>;
+    pushStoreRoot(storeId: string, rootHash: string): Promise<void>;
+    downloadStoreRoot(rootHash: 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;AAItC,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;IAuCH,WAAW,CACtB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,MAAM,EAAO,GACnB,OAAO,CAAC,IAAI,CAAC;WAiBF,iBAAiB,CAAC,OAAO,EAAE,MAAM;IAqBlC,SAAS,CAAC,KAAK,GAAE,KAAK,GAAG,MAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBxD,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/D,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAOhE"}

package/dist/DigNetwork/DigPeer.js

@@ -9,11 +9,9 @@ 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 datalayer_driver_1 = require("@dignetwork/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;
@@ -37,122 +35,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;
-        }
-    }
-    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;
-        }
+    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 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 wallet.selectUnspentCoins(peer, totalAmount, totalFee, []);
+        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 +67,55 @@ 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();
+        if (!paymentAddress) {
+            throw new Error("Payment address not found.");
+        }
+        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(order = "desc") {
+        console.log('!');
+        const dataStore = blockchain_1.DataStore.from(this.storeId);
+        const rootHistory = await dataStore.getRootHistory();
+        let localRootHistory = rootHistory
+            .filter((root) => Boolean(root.synced))
+            .reverse();
+        if (order === "asc") {
+            localRootHistory = localRootHistory.reverse();
+        }
+        console.log(`Syncing store ${this.storeId} with ${this.IpAddress}`);
+        for (const item of localRootHistory) {
+            await this.pushStoreRoot(this.storeId, item.root_hash);
+        }
+    }
+    async pushStoreRoot(storeId, rootHash) {
+        await PropagationServer_1.PropagationServer.uploadStore(storeId, rootHash, this.IpAddress);
+    }
+    async downloadStoreRoot(rootHash) {
+        await PropagationServer_1.PropagationServer.downloadStore(this.storeId, rootHash, this.IpAddress);
+    }
 }
 exports.DigPeer = DigPeer;