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

package/dist/DigNetwork/PropagationServer.d.ts

@@ -1,3 +1,4 @@
+import http from 'http';
 import { Readable } from "stream";
 export declare class PropagationServer {
     private ipAddress;
@@ -10,7 +11,7 @@ export declare class PropagationServer {
     private static readonly maxDelay;
     private static readonly delayMultiplier;
     constructor(ipAddress: string, storeId: string);
-    pushFile(filePath: string, relativePath: string): Promise<void>;
+    pushFile(fileLocation: string, dataPath: string): Promise<void>;
     subscribeToStore(): Promise<void>;
     unsubscribeFromStore(): Promise<void>;
     getStoreStatus(): Promise<any>;
@@ -19,7 +20,12 @@ export declare class PropagationServer {
     getStatus(): Promise<{
         synced: boolean;
     }>;
-    headStore(): Promise<boolean>;
+    headStore(options?: {
+        hasRootHash: string;
+    }): Promise<{
+        success: boolean;
+        headers?: http.IncomingHttpHeaders;
+    }>;
     isStoreSynced(): Promise<boolean>;
     getUploadDetails(): Promise<{
         nonce: string;

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

@@ -1 +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"}
+{"version":3,"file":"PropagationServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/PropagationServer.ts"],"names":[],"mappings":"AAEA,OAAO,IAAI,MAAM,MAAM,CAAC;AAKxB,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,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,YAAY,EAAE,MAAM,EAAE,QAAQ,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,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,CAAA;KAAE,CAAC;IAW/G,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;YAsBY,WAAW;YAyCX,kBAAkB;YAsElB,gBAAgB;YAgEhB,cAAc;YAiCd,KAAK;YAmDL,IAAI;YAmEJ,SAAS;YAuCT,2BAA2B;YAiC3B,gBAAgB;CAyC/B"}

package/dist/DigNetwork/PropagationServer.js

@@ -9,7 +9,6 @@ const https_1 = __importDefault(require("https"));
 const url_1 = require("url");
 const ssl_1 = require("../utils/ssl");
 const credentialsUtils_1 = require("../utils/credentialsUtils");
-const spinnerUtils_1 = require("../utils/spinnerUtils");
 const blockchain_1 = require("../blockchain");
 class PropagationServer {
     constructor(ipAddress, storeId) {
@@ -22,13 +21,13 @@ class PropagationServer {
         }
     }
     // Method to upload a file to the propagation server
-    async pushFile(filePath, relativePath) {
+    async pushFile(fileLocation, dataPath) {
         const { nonce, username, password } = await this.getUploadDetails();
         const wallet = await blockchain_1.Wallet.load("default");
         const keyOwnershipSig = await wallet.createKeyOwnershipSignature(nonce);
         const publicKey = await wallet.getPublicSyntheticKey();
-        const uploadUrl = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}/${relativePath}`;
-        await this.retryOperation(() => this.uploadFileDirect(filePath, uploadUrl, username, password, keyOwnershipSig, publicKey.toString("hex"), nonce), `Upload failed for ${relativePath}`);
+        const uploadUrl = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}/${dataPath}`;
+        await this.retryOperation(() => this.uploadFileDirect(fileLocation, uploadUrl, username, password, keyOwnershipSig, publicKey.toString("hex"), nonce), `Upload failed for ${dataPath}`);
     }
     // Method to subscribe to a store on the propagation server
     async subscribeToStore() {
@@ -62,8 +61,11 @@ class PropagationServer {
         return JSON.parse(statusJson);
     }
     // Method to check if a specific store exists (HEAD request)
-    async headStore() {
-        const url = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}`;
+    async headStore(options) {
+        let url = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}`;
+        if (options?.hasRootHash) {
+            url += `?hasRootHash=${options.hasRootHash}`;
+        }
         return this.head(url);
     }
     // In PropagationServer.ts:
@@ -80,7 +82,9 @@ class PropagationServer {
             username = credentials.username;
             password = credentials.password;
         }
-        const uploadDetails = await this.fetchUploadDetails(username, password);
+        const wallet = await blockchain_1.Wallet.load("default");
+        const publicKey = await wallet.getPublicSyntheticKey();
+        const uploadDetails = await this.fetchUploadDetails(username, password, publicKey.toString("hex"));
         if (!uploadDetails) {
             throw new Error("Failed to retrieve upload details.");
         }
@@ -120,53 +124,52 @@ class PropagationServer {
     }
     // Method to fetch upload details from the server
     // Method to fetch upload details from the server
-    async fetchUploadDetails(username, password) {
+    async fetchUploadDetails(username, password, publicKey) {
         const remote = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}`;
-        return (0, spinnerUtils_1.waitForPromise)(() => {
-            return new Promise((resolve, reject) => {
-                const url = new url_1.URL(remote);
-                const options = {
-                    hostname: url.hostname,
-                    port: url.port,
-                    path: url.pathname,
-                    method: "HEAD",
-                    headers: {
-                        Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`,
-                    },
-                    key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                    cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                    rejectUnauthorized: false, // Allow self-signed certificates
-                };
-                const req = https_1.default.request(options, (res) => {
-                    if (res.statusCode === 200) {
-                        // Check if the headers are present and valid
-                        const nonce = res.headers["x-nonce"];
-                        const lastUploadedHash = res.headers?.["x-last-uploaded-hash"] ||
-                            "0000000000000000000000000000000000000000000000000000000000000000";
-                        const generationIndex = res.headers?.["x-generation-index"] || 0;
-                        console.log({ nonce, lastUploadedHash, generationIndex });
-                        if (nonce) {
-                            resolve({
-                                nonce: nonce,
-                                lastUploadedHash: lastUploadedHash,
-                                generationIndex: Number(generationIndex),
-                            });
-                        }
-                        else {
-                            reject(new Error("Missing required headers in the response."));
-                        }
+        return new Promise((resolve, reject) => {
+            const url = new url_1.URL(remote);
+            const options = {
+                hostname: url.hostname,
+                port: url.port,
+                path: url.pathname,
+                method: "HEAD",
+                headers: {
+                    Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`,
+                    'X-Public-Key': publicKey,
+                },
+                key: fs_1.default.readFileSync(PropagationServer.keyPath),
+                cert: fs_1.default.readFileSync(PropagationServer.certPath),
+                rejectUnauthorized: false, // Allow self-signed certificates
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    // Check if the headers are present and valid
+                    const nonce = res.headers["x-nonce"];
+                    const lastUploadedHash = res.headers?.["x-last-uploaded-hash"] ||
+                        "0000000000000000000000000000000000000000000000000000000000000000";
+                    const generationIndex = res.headers?.["x-generation-index"] || 0;
+                    console.log({ nonce, lastUploadedHash, generationIndex });
+                    if (nonce) {
+                        resolve({
+                            nonce: nonce,
+                            lastUploadedHash: lastUploadedHash,
+                            generationIndex: Number(generationIndex),
+                        });
                     }
                     else {
-                        reject(new Error(`Failed to perform preflight check: ${res.statusCode} ${res.statusMessage}`));
+                        reject(new Error("Missing required headers in the response."));
                     }
-                });
-                req.on("error", (err) => {
-                    console.error(err.message);
-                    resolve(false); // Resolve to false if there is an error
-                });
-                req.end();
+                }
+                else {
+                    reject(new Error(`Failed to perform preflight check: ${res.statusCode} ${res.statusMessage}`));
+                }
+            });
+            req.on("error", (err) => {
+                console.error(err.message);
+                resolve(false); // Resolve to false if there is an error
             });
-        }, "Performing remote preflight", "Preflight succeeded.", "Error on preflight.");
+            req.end();
+        });
     }
     // Core method to upload a file directly to the server using a stream
     async uploadFileDirect(filePath, uploadUrl, username, password, keyOwnershipSig, publicKey, nonce) {
@@ -271,38 +274,70 @@ class PropagationServer {
                 }
             });
             request.on("error", (error) => {
-                console.error(`Request error for ${url}:`, error);
+                console.error(`GET Request error for ${url}:`, error);
                 reject(error);
             });
             request.end();
         });
     }
     // Helper method to perform HEAD requests
-    async head(url) {
+    async head(url, maxRedirects = 5) {
         return new Promise((resolve, reject) => {
-            const urlObj = new url_1.URL(url);
-            const options = {
-                hostname: urlObj.hostname,
-                port: urlObj.port || PropagationServer.port,
-                path: urlObj.pathname + urlObj.search,
-                method: "HEAD",
-                key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                rejectUnauthorized: false,
-            };
-            const request = https_1.default.request(options, (response) => {
-                if (response.statusCode === 200) {
-                    resolve(true);
-                }
-                else {
-                    resolve(false);
-                }
-            });
-            request.on("error", (error) => {
-                console.error(`Request error for ${url}:`, error);
-                reject(false);
-            });
-            request.end();
+            try {
+                // Parse the input URL
+                const urlObj = new url_1.URL(url);
+                const requestOptions = {
+                    hostname: urlObj.hostname,
+                    port: urlObj.port || (urlObj.protocol === "https:" ? 443 : undefined),
+                    path: urlObj.pathname + urlObj.search,
+                    method: "HEAD",
+                    key: fs_1.default.readFileSync(PropagationServer.keyPath),
+                    cert: fs_1.default.readFileSync(PropagationServer.certPath),
+                    rejectUnauthorized: false,
+                };
+                const request = https_1.default.request(requestOptions, (response) => {
+                    const { statusCode, headers } = response;
+                    // If status code is 2xx, return success
+                    if (statusCode && statusCode >= 200 && statusCode < 300) {
+                        resolve({ success: true, headers });
+                    }
+                    // Handle 3xx redirection
+                    else if (statusCode && statusCode >= 300 && statusCode < 400 && headers.location) {
+                        if (maxRedirects > 0) {
+                            let redirectUrl = headers.location;
+                            // Check if the redirect URL is relative
+                            if (!/^https?:\/\//i.test(redirectUrl)) {
+                                // Resolve the relative URL based on the original URL
+                                redirectUrl = new url_1.URL(redirectUrl, url).toString();
+                                console.log(`Resolved relative redirect to: ${redirectUrl}`);
+                            }
+                            else {
+                                console.log(`Redirecting to: ${redirectUrl}`);
+                            }
+                            // Recursively follow the redirection
+                            this.head(redirectUrl, maxRedirects - 1)
+                                .then(resolve)
+                                .catch(reject);
+                        }
+                        else {
+                            reject({ success: false, message: "Too many redirects" });
+                        }
+                    }
+                    else {
+                        // For other status codes, consider it a failure
+                        resolve({ success: false });
+                    }
+                });
+                request.on("error", (error) => {
+                    console.error(`HEAD ${url}:`, error.message);
+                    reject({ success: false });
+                });
+                request.end();
+            }
+            catch (err) {
+                console.error(`Invalid URL: ${url}`, err.message);
+                reject({ success: false, message: "Invalid URL" });
+            }
         });
     }
     // Helper method to fetch JSON data from a URL
@@ -400,7 +435,7 @@ class PropagationServer {
                 }
             });
             request.on("error", (error) => {
-                console.error(`Request error for ${url}:`, error);
+                console.error(`GET ${url}:`, error.message);
                 reject(error);
             });
             request.end();

package/dist/blockchain/DataStore.d.ts

@@ -1,4 +1,4 @@
-import { DataStore as DataStoreDriver, DataStoreMetadata } from "datalayer-driver";
+import { DataStore as DataStoreDriver, DataStoreMetadata } from "@dignetwork/datalayer-driver";
 import { RootHistoryItem } from "../types";
 import { DataIntegrityTree, DataIntegrityTreeOptions } from "../DataIntegrityTree";
 import { CreateStoreUserInputs } from "../types";
@@ -44,13 +44,10 @@ export declare class DataStore {
     }>;
     private setCreationHeight;
     getRootHistory(): Promise<RootHistoryItem[]>;
-    getLocalRootHistory(): Promise<RootHistoryItem[] | undefined>;
-    validate(): Promise<boolean>;
     getMetaData(): Promise<DataStoreMetadata>;
     isSynced(): Promise<boolean>;
     hasMetaWritePermissions(publicSyntheticKey?: Buffer): Promise<boolean>;
     updateMetadata(metadata: DataStoreMetadata): Promise<DataStoreDriver>;
     getFileSetForRootHash(rootHash: string): Promise<string[]>;
-    getManifestHashes(): string[];
 }
 //# sourceMappingURL=DataStore.d.ts.map

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

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

package/dist/blockchain/DataStore.js

@@ -6,13 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataStore = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const datalayer_driver_1 = require("datalayer-driver");
+const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
 const util_1 = require("util");
 const FullNodePeer_1 = require("./FullNodePeer");
 const Wallet_1 = require("./Wallet");
 const config_1 = require("../utils/config");
 const coins_1 = require("./coins");
-const utils_1 = require("../utils");
 const hashUtils_1 = require("../utils/hashUtils");
 const DataIntegrityTree_1 = require("../DataIntegrityTree");
 const prompts_1 = require("../prompts");
@@ -293,88 +292,17 @@ class DataStore {
         return rootHashes.map((rootHash, index) => ({
             root_hash: rootHash.toString("hex"),
             timestamp: Number(rootHashesTimestamps?.[index].toString()),
+            synced: fs_1.default.existsSync(`${config_1.STORE_PATH}/${this.storeId}/${rootHash}.dat`),
         }));
     }
-    async getLocalRootHistory() {
-        const manifestFilePath = (0, config_1.getManifestFilePath)(this.storeId);
-        if (!fs_1.default.existsSync(manifestFilePath)) {
-            console.error("Manifest file not found", manifestFilePath);
-            return undefined;
-        }
-        const manifestHashes = fs_1.default
-            .readFileSync(manifestFilePath, "utf-8")
-            .split("\n")
-            .filter(Boolean);
-        return manifestHashes.map((rootHash) => ({
-            root_hash: rootHash,
-            timestamp: 0, // Timestamps are not yet included in the manifest
-        }));
-    }
-    async validate() {
-        const rootHistory = await this.getRootHistory();
-        const manifestFilePath = (0, config_1.getManifestFilePath)(this.storeId);
-        if (!fs_1.default.existsSync(manifestFilePath)) {
-            console.error("Manifest file not found", manifestFilePath);
-            return false;
-        }
-        const manifestHashes = fs_1.default
-            .readFileSync(manifestFilePath, "utf-8")
-            .split("\n")
-            .filter(Boolean);
-        if (manifestHashes.length > rootHistory.length) {
-            console.error("The store is corrupted: Manifest file has more hashes than the root history.");
-            return false;
-        }
-        if (rootHistory.length > manifestHashes.length) {
-            console.error("The store is not synced: Root history has more hashes than the manifest file.");
-            return false;
-        }
-        for (let i = 0; i < manifestHashes.length; i++) {
-            if (manifestHashes[i] !== rootHistory[i]?.root_hash) {
-                console.error(`Root hash mismatch at position ${i}: expected ${manifestHashes[i]} but found ${rootHistory[i]?.root_hash}`);
-                return false;
-            }
-        }
-        let filesIntegrityIntact = true;
-        for (const rootHash of manifestHashes) {
-            const datFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, `${rootHash}.dat`);
-            if (!fs_1.default.existsSync(datFilePath)) {
-                console.error(`Data file for root hash ${rootHash} not found`);
-                return false;
-            }
-            const datFileContent = JSON.parse(fs_1.default.readFileSync(datFilePath, "utf-8"));
-            if (datFileContent.root !== rootHash) {
-                console.error(`Root hash in data file does not match: ${datFileContent.root} !== ${rootHash}`);
-                return false;
-            }
-            for (const [fileKey, fileData] of Object.entries(datFileContent.files)) {
-                const integrityCheck = (0, utils_1.validateFileSha256)(fileData.sha256, path_1.default.join(config_1.STORE_PATH, this.storeId, "data"));
-                if (!integrityCheck) {
-                    filesIntegrityIntact = false;
-                }
-            }
-        }
-        if (!filesIntegrityIntact) {
-            console.error("Store Corrupted: Data failed SHA256 validation.");
-            return false;
-        }
-        return true;
-    }
     async getMetaData() {
         const { latestStore } = await this.fetchCoinInfo();
         return latestStore.metadata;
     }
     async isSynced() {
-        const rootHistory = await this.getRootHistory();
-        const manifestFilePath = (0, config_1.getManifestFilePath)(this.storeId);
-        if (!fs_1.default.existsSync(manifestFilePath)) {
-            return false;
-        }
-        const manifestHashes = fs_1.default
-            .readFileSync(manifestFilePath, "utf-8")
-            .split("\n")
-            .filter(Boolean);
-        return rootHistory.length === manifestHashes.length;
+        const dataStore = await DataStore.from(this.storeId);
+        const rootHistory = await dataStore.getRootHistory();
+        return !rootHistory.some((root) => !root.synced);
     }
     async hasMetaWritePermissions(publicSyntheticKey) {
         const wallet = await Wallet_1.Wallet.load("default");
@@ -423,11 +351,5 @@ class DataStore {
         }
         return filesInvolved;
     }
-    getManifestHashes() {
-        const manifestFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, "manifest.dat");
-        return fs_1.default.existsSync(manifestFilePath)
-            ? fs_1.default.readFileSync(manifestFilePath, "utf-8").split("\n").filter(Boolean)
-            : [];
-    }
 }
 exports.DataStore = DataStore;

package/dist/blockchain/DataStoreSerializer.d.ts

@@ -1,4 +1,4 @@
-import { DataStore } from "datalayer-driver";
+import { DataStore } from "@dignetwork/datalayer-driver";
 import { Buffer } from "buffer";
 export declare class DataStoreSerializer {
     private storeInfo;

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

@@ -1 +1 @@
-{"version":3,"file":"DataStoreSerializer.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStoreSerializer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAKV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,UAAU,CAAS;gBAEf,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAOnE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgDF,WAAW,CACvB,IAAI,EAAE;QACJ,WAAW,EAAE,GAAG,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,GACA;QACD,WAAW,EAAE,SAAS,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB;CAuEF"}
+{"version":3,"file":"DataStoreSerializer.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStoreSerializer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAKV,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,UAAU,CAAS;gBAEf,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAOnE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgDF,WAAW,CACvB,IAAI,EAAE;QACJ,WAAW,EAAE,GAAG,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,GACA;QACD,WAAW,EAAE,SAAS,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB;CAuEF"}

package/dist/blockchain/FullNodePeer.d.ts

@@ -1,12 +1,20 @@
-import { Peer } from "datalayer-driver";
+import { Peer } from "@dignetwork/datalayer-driver";
 export declare class FullNodePeer {
     private static cachedPeer;
     private static memoizedFetchNewPeerIPs;
     private peer;
+    private static deprioritizedIps;
     private constructor();
     static connect(): Promise<Peer>;
     private static isPortReachable;
     private static isValidIpAddress;
+    /**
+     * Retrieves the TRUSTED_FULLNODE IP from the environment
+     * and verifies if it is a valid IP address.
+     *
+     * @returns {string | null} The valid IP address or null if invalid
+     */
+    private static getTrustedFullNode;
     private static fetchNewPeerIPs;
     private static getPeerIPs;
     private static createPeerProxy;

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

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

package/dist/blockchain/FullNodePeer.js

@@ -7,7 +7,7 @@ exports.FullNodePeer = void 0;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const fs_1 = __importDefault(require("fs"));
-const datalayer_driver_1 = require("datalayer-driver");
+const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
 const chia_server_coin_1 = require("chia-server-coin");
 const promises_1 = require("dns/promises");
 const net_1 = __importDefault(require("net"));
@@ -16,6 +16,7 @@ const nanospinner_1 = require("nanospinner");
 const config_1 = require("../utils/config");
 const FULLNODE_PORT = 8444;
 const LOCALHOST = "127.0.0.1";
+const CHIA_NODES_HOST = "chia-nodes";
 const DNS_HOSTS = [
     "dns-introducer.chia.net",
     "chia.ctrlaltdel.ch",
@@ -48,19 +49,38 @@ class FullNodePeer {
         const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
         return ipv4Regex.test(ip);
     }
-    static async fetchNewPeerIPs() {
+    /**
+     * Retrieves the TRUSTED_FULLNODE IP from the environment
+     * and verifies if it is a valid IP address.
+     *
+     * @returns {string | null} The valid IP address or null if invalid
+     */
+    static getTrustedFullNode() {
         const trustedNodeIp = process.env.TRUSTED_FULLNODE || null;
+        if (trustedNodeIp && FullNodePeer.isValidIpAddress(trustedNodeIp)) {
+            return trustedNodeIp;
+        }
+        return null;
+    }
+    static async fetchNewPeerIPs() {
+        const trustedNodeIp = FullNodePeer.getTrustedFullNode();
         const priorityIps = [];
-        // Prioritize trustedNodeIp
+        // Prioritize trustedNodeIp unless it's deprioritized
         if (trustedNodeIp &&
-            FullNodePeer.isValidIpAddress(trustedNodeIp) &&
+            !FullNodePeer.deprioritizedIps.has(trustedNodeIp) &&
             (await FullNodePeer.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
             priorityIps.push(trustedNodeIp);
         }
-        // Prioritize LOCALHOST
-        if (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT)) {
+        // Prioritize LOCALHOST unless it's deprioritized
+        if (!FullNodePeer.deprioritizedIps.has(LOCALHOST) &&
+            (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT))) {
             priorityIps.push(LOCALHOST);
         }
+        // Prioritize CHIA_NODES_HOST unless it's deprioritized
+        if (!FullNodePeer.deprioritizedIps.has(CHIA_NODES_HOST) &&
+            (await FullNodePeer.isPortReachable(CHIA_NODES_HOST, FULLNODE_PORT))) {
+            priorityIps.push(CHIA_NODES_HOST);
+        }
         if (priorityIps.length > 0) {
             return priorityIps;
         }
@@ -102,23 +122,47 @@ class FullNodePeer {
         }
         // @ts-ignore
         if (FullNodePeer.memoizedFetchNewPeerIPs?.cache?.clear) {
+            // Clear cache and reset deprioritized IPs when cache is cleared
+            FullNodePeer.deprioritizedIps.clear();
             // @ts-ignore
             FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
         }
         return FullNodePeer.memoizedFetchNewPeerIPs();
     }
-    static createPeerProxy(peer, certFile, keyFile) {
+    static createPeerProxy(peer) {
         return new Proxy(peer, {
             get: (target, prop) => {
                 const originalMethod = target[prop];
                 if (typeof originalMethod === "function") {
                     return async (...args) => {
+                        let timeoutId;
+                        // Start the timeout to forget the peer after 1 minute
+                        const timeoutPromise = new Promise((_, reject) => {
+                            timeoutId = setTimeout(() => {
+                                FullNodePeer.cachedPeer = null;
+                                reject(new Error("Operation timed out. Reconnecting to a new peer."));
+                            }, 60000); // 1 minute
+                        });
                         try {
-                            return await originalMethod.apply(target, args);
+                            // Run the original method and race it against the timeout
+                            const result = await Promise.race([
+                                originalMethod.apply(target, args),
+                                timeoutPromise,
+                            ]);
+                            // Clear the timeout if the operation succeeded
+                            if (timeoutId) {
+                                clearTimeout(timeoutId);
+                            }
+                            return result;
                         }
                         catch (error) {
-                            if (error.message.includes("WebSocket")) {
+                            // If the error is WebSocket-related or timeout, reset the peer
+                            if (error.message.includes("WebSocket") || error.message.includes("Operation timed out")) {
                                 FullNodePeer.cachedPeer = null;
+                                // @ts-ignore
+                                FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
+                                FullNodePeer.deprioritizedIps.clear();
+                                console.info(`Fullnode Peer error, reconnecting to a new peer...`);
                                 const newPeer = await FullNodePeer.getBestPeer();
                                 return newPeer[prop](...args);
                             }
@@ -149,7 +193,7 @@ class FullNodePeer {
             if (ip) {
                 try {
                     const peer = await datalayer_driver_1.Peer.new(`${ip}:${FULLNODE_PORT}`, false, certFile, keyFile);
-                    return FullNodePeer.createPeerProxy(peer, certFile, keyFile);
+                    return FullNodePeer.createPeerProxy(peer);
                 }
                 catch (error) {
                     console.error(`Failed to create peer for IP ${ip}: ${error.message}`);
@@ -174,16 +218,17 @@ class FullNodePeer {
             throw new Error("No valid peak heights obtained from any peer.");
         }
         const highestPeak = Math.max(...validHeights);
-        // Prioritize LOCALHOST and TRUSTED_NODE_IP if they have the highest peak height
+        // Prioritize LOCALHOST, TRUSTED_NODE_IP, and CHIA_NODES_HOST if they have the highest peak height
         let bestPeerIndex = validHeights.findIndex((height, index) => height === highestPeak &&
-            (peerIPs[index] === LOCALHOST || peerIPs[index] === trustedNodeIp));
-        // If LOCALHOST or TRUSTED_NODE_IP don't have the highest peak, select any peer with the highest peak
+            !FullNodePeer.deprioritizedIps.has(peerIPs[index]) && // Exclude deprioritized IPs
+            (peerIPs[index] === LOCALHOST || peerIPs[index] === trustedNodeIp || peerIPs[index] === CHIA_NODES_HOST));
+        // If LOCALHOST, TRUSTED_NODE_IP, or CHIA_NODES_HOST don't have the highest peak, select any peer with the highest peak
         if (bestPeerIndex === -1) {
             bestPeerIndex = validHeights.findIndex((height) => height === highestPeak);
         }
         const bestPeer = peers[bestPeerIndex];
         FullNodePeer.cachedPeer = { peer: bestPeer, timestamp: now };
-        console.log(`Using Peer: ${peerIPs[bestPeerIndex]}`);
+        console.log(`Using Fullnode Peer: ${peerIPs[bestPeerIndex]}`);
         return bestPeer;
     }
     getPeer() {
@@ -210,6 +255,7 @@ class FullNodePeer {
 }
 exports.FullNodePeer = FullNodePeer;
 FullNodePeer.cachedPeer = null;
+FullNodePeer.deprioritizedIps = new Set(); // New set for deprioritized IPs
 (() => {
     FullNodePeer.memoizedFetchNewPeerIPs = (0, lodash_1.memoize)(FullNodePeer.fetchNewPeerIPs);
 })();