@dignetwork/dig-sdk 0.0.1-alpha.2

package/dist/DigNetwork/PropagationServer.js

@@ -0,0 +1,415 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropagationServer = void 0;
+const fs_1 = __importDefault(require("fs"));
+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) {
+        this.ipAddress = ipAddress;
+        this.storeId = storeId;
+        if (!PropagationServer.certPath || !PropagationServer.keyPath) {
+            const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
+            PropagationServer.certPath = certPath;
+            PropagationServer.keyPath = keyPath;
+        }
+    }
+    // Method to upload a file to the propagation server
+    async pushFile(filePath, relativePath) {
+        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}`);
+    }
+    // Method to subscribe to a store on the propagation server
+    async subscribeToStore() {
+        const url = `https://${this.ipAddress}:${PropagationServer.port}/subscribe`;
+        const data = JSON.stringify({ storeId: this.storeId });
+        await this.postRequest(url, data);
+    }
+    // Method to unsubscribe from a store on the propagation server
+    async unsubscribeFromStore() {
+        const url = `https://${this.ipAddress}:${PropagationServer.port}/unsubscribe`;
+        const data = JSON.stringify({ storeId: this.storeId });
+        await this.postRequest(url, data);
+    }
+    // Method to check the status of a store on the propagation server
+    async getStoreStatus() {
+        const url = `https://${this.ipAddress}:${PropagationServer.port}/status/${this.storeId}`;
+        return this.fetchJson(url);
+    }
+    async streamStoreData(dataPath) {
+        const url = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}/${dataPath}`;
+        return this.createReadStreamWithRetries(url);
+    }
+    // Method to retrieve a store's key
+    async getStoreData(dataPath) {
+        const url = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}/${dataPath}`;
+        return this.fetch(url);
+    }
+    async getStatus() {
+        const url = `https://${this.ipAddress}:${PropagationServer.port}/status/${this.storeId}`;
+        const statusJson = await this.fetch(url);
+        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}`;
+        return this.head(url);
+    }
+    // In PropagationServer.ts:
+    async isStoreSynced() {
+        const status = await this.getStatus();
+        return status.synced === true;
+    }
+    // Method to handle upload details including nonce
+    async getUploadDetails() {
+        let username;
+        let password;
+        if (!username || !password) {
+            const credentials = await (0, credentialsUtils_1.promptCredentials)(this.ipAddress);
+            username = credentials.username;
+            password = credentials.password;
+        }
+        const uploadDetails = await this.fetchUploadDetails(username, password);
+        if (!uploadDetails) {
+            throw new Error("Failed to retrieve upload details.");
+        }
+        return { ...uploadDetails, username, password };
+    }
+    // Method to send a POST request
+    async postRequest(url, data) {
+        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,
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Content-Length": Buffer.byteLength(data),
+                },
+                key: fs_1.default.readFileSync(PropagationServer.keyPath),
+                cert: fs_1.default.readFileSync(PropagationServer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`POST request failed with status ${res.statusCode}: ${res.statusMessage}`));
+                }
+            });
+            req.on("error", (err) => {
+                reject(err);
+            });
+            req.write(data);
+            req.end();
+        });
+    }
+    // Method to fetch upload details from the server
+    // Method to fetch upload details from the server
+    async fetchUploadDetails(username, password) {
+        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."));
+                        }
+                    }
+                    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
+                });
+                req.end();
+            });
+        }, "Performing remote preflight", "Preflight succeeded.", "Error on preflight.");
+    }
+    // Core method to upload a file directly to the server using a stream
+    async uploadFileDirect(filePath, uploadUrl, username, password, keyOwnershipSig, publicKey, nonce) {
+        const fileStream = fs_1.default.createReadStream(filePath);
+        const fileSize = fs_1.default.statSync(filePath).size;
+        return new Promise((resolve, reject) => {
+            const url = new url_1.URL(uploadUrl);
+            const options = {
+                hostname: url.hostname,
+                port: url.port,
+                path: url.pathname,
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/octet-stream",
+                    "Content-Length": fileSize,
+                    Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`,
+                    "x-key-ownership-sig": keyOwnershipSig,
+                    "x-public-key": publicKey,
+                    "x-nonce": nonce,
+                },
+                key: fs_1.default.readFileSync(PropagationServer.keyPath),
+                cert: fs_1.default.readFileSync(PropagationServer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Upload failed with status ${res.statusCode}: ${res.statusMessage}`));
+                }
+            });
+            req.on("error", (err) => {
+                reject(err);
+            });
+            fileStream.pipe(req);
+            fileStream.on("error", (err) => {
+                reject(err);
+            });
+            req.on("end", () => {
+                resolve();
+            });
+        });
+    }
+    // Generic retry operation handler to reduce redundancy
+    async retryOperation(operation, errorMessage) {
+        let attempt = 0;
+        let delay = PropagationServer.initialDelay;
+        while (attempt < PropagationServer.maxRetries) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                if (attempt < PropagationServer.maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed: ${error.message}. Retrying in ${delay / 1000} seconds...`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    delay = Math.min(PropagationServer.maxDelay, delay * PropagationServer.delayMultiplier);
+                }
+                else {
+                    console.error(`${errorMessage}. Aborting.`);
+                    throw error;
+                }
+            }
+            attempt++;
+        }
+        throw new Error(errorMessage);
+    }
+    // Core method to fetch content from a URL
+    async fetch(url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port,
+                path: urlObj.pathname + urlObj.search,
+                method: "GET",
+                key: fs_1.default.readFileSync(PropagationServer.keyPath),
+                cert: fs_1.default.readFileSync(PropagationServer.certPath),
+                rejectUnauthorized: false,
+            };
+            const request = https_1.default.request(options, (response) => {
+                let data = "";
+                if (response.statusCode === 200) {
+                    response.on("data", (chunk) => {
+                        data += chunk;
+                    });
+                    response.on("end", () => {
+                        resolve(data);
+                    });
+                }
+                else if (response.statusCode === 301 || response.statusCode === 302) {
+                    const redirectUrl = response.headers.location;
+                    if (redirectUrl) {
+                        this.fetch(redirectUrl).then(resolve).catch(reject);
+                    }
+                    else {
+                        reject(new Error("Redirected without a location header"));
+                    }
+                }
+                else {
+                    reject(new Error(`Failed to retrieve data from ${url}. Status code: ${response.statusCode}`));
+                }
+            });
+            request.on("error", (error) => {
+                console.error(`Request error for ${url}:`, error);
+                reject(error);
+            });
+            request.end();
+        });
+    }
+    // Helper method to perform HEAD requests
+    async head(url) {
+        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();
+        });
+    }
+    // Helper method to fetch JSON data from a URL
+    async fetchJson(url) {
+        const response = await this.fetch(url);
+        return JSON.parse(response);
+    }
+    // Helper method to fetch content with retries and redirection handling
+    /*private async fetchWithRetries(url: string): Promise<string> {
+      let attempt = 0;
+      const maxRetries = 5;
+      const initialDelay = 2000; // 2 seconds
+      const maxDelay = 10000; // 10 seconds
+      const delayMultiplier = 1.5;
+      let delay = initialDelay;
+  
+      while (attempt < maxRetries) {
+        try {
+          return await this.fetch(url);
+        } catch (error: any) {
+          if (attempt < maxRetries - 1) {
+            console.warn(
+              `Attempt ${attempt + 1} failed: ${error.message}. Retrying in ${
+                delay / 1000
+              } seconds...`
+            );
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay = Math.min(maxDelay, delay * delayMultiplier);
+          } else {
+            console.error(`Failed to retrieve data from ${url}. Aborting.`);
+            throw new Error(`Failed to retrieve data: ${error.message}`);
+          }
+        }
+        attempt++;
+      }
+      throw new Error(
+        `Failed to retrieve data from ${url} after ${maxRetries} attempts.`
+      );
+    }*/
+    // Helper method to create a stream with retry logic
+    async createReadStreamWithRetries(url) {
+        let attempt = 0;
+        const maxRetries = 1;
+        const initialDelay = PropagationServer.initialDelay;
+        const maxDelay = PropagationServer.maxDelay;
+        const delayMultiplier = PropagationServer.delayMultiplier;
+        let delay = initialDelay;
+        while (attempt < maxRetries) {
+            try {
+                return await this.createReadStream(url); // Stream data chunk by chunk
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed: ${error.message}. Retrying in ${delay / 1000} seconds...`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    delay = Math.min(maxDelay, delay * delayMultiplier);
+                }
+                else {
+                    console.error(`Failed to create stream from ${url}. Aborting.`);
+                    throw new Error(`Failed to create stream: ${error.message}`);
+                }
+            }
+            attempt++;
+        }
+        throw new Error(`Failed to create stream from ${url} after ${maxRetries} attempts.`);
+    }
+    // Helper method to fetch a readable stream from a URL
+    async createReadStream(url) {
+        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: "GET",
+                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(response); // Return the response stream chunk by chunk
+                }
+                else if (response.statusCode === 301 || response.statusCode === 302) {
+                    const redirectUrl = response.headers.location;
+                    if (redirectUrl) {
+                        this.createReadStream(redirectUrl).then(resolve).catch(reject);
+                    }
+                    else {
+                        reject(new Error("Redirected without a location header"));
+                    }
+                }
+                else {
+                    reject(new Error(`Failed to retrieve stream from ${url}. Status code: ${response.statusCode}`));
+                }
+            });
+            request.on("error", (error) => {
+                console.error(`Request error for ${url}:`, error);
+                reject(error);
+            });
+            request.end();
+        });
+    }
+}
+exports.PropagationServer = PropagationServer;
+PropagationServer.port = 4159;
+PropagationServer.maxRetries = 5;
+PropagationServer.initialDelay = 2000; // 2 seconds
+PropagationServer.maxDelay = 10000; // 10 seconds
+PropagationServer.delayMultiplier = 1.5;

package/dist/DigNetwork/index.d.ts

@@ -0,0 +1,4 @@
+export * from './DigPeer';
+export * from './DigNetwork';
+export * from './DigChallenge';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC"}

package/dist/DigNetwork/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DigPeer"), exports);
+__exportStar(require("./DigNetwork"), exports);
+__exportStar(require("./DigChallenge"), exports);

package/dist/blockchain/DataStore.d.ts

@@ -0,0 +1,54 @@
+import { DataStore as DataStoreDriver, DataStoreMetadata } from "datalayer-driver";
+import { RootHistoryItem } from "../types";
+import { DataIntegrityTree, DataIntegrityTreeOptions } from "../DataIntegrityTree";
+import { CreateStoreUserInputs } from "../types";
+export declare class DataStore {
+    private storeId;
+    private tree;
+    constructor(storeId: string, options?: DataIntegrityTreeOptions);
+    get StoreId(): string;
+    get Tree(): DataIntegrityTree;
+    toBuffer(): Buffer;
+    toString(): string;
+    serialize(): string;
+    static getActiveStore(): Promise<DataStore | undefined>;
+    static deserialize(serialized: string): DataStore;
+    static from(storeId: string | Buffer): DataStore;
+    static create(inputs?: CreateStoreUserInputs): Promise<DataStore>;
+    private static mint;
+    /**
+     * Instance method to calculate the disk space used by the store/storeId folder.
+     * @returns {Promise<number>} - The total disk space used by the store in bytes.
+     */
+    getDiskSpace(): Promise<bigint>;
+    /**
+     * Static method to calculate the total disk space used by all stores in the store folder.
+     * @returns {Promise<number>} - The total disk space used by the store folder in bytes.
+     */
+    static getTotalDiskSpace(): Promise<bigint>;
+    /**
+     * Helper method to calculate the size of a folder and its subfolders recursively.
+     * @param folderPath - The path of the folder to calculate the size of.
+     * @returns {Promise<number>} - The total size of the folder in bytes.
+     */
+    private static calculateFolderSize;
+    static getAllStores(): DataStore[];
+    fetchCoinInfo(): Promise<{
+        latestStore: DataStoreDriver;
+        latestHeight: number;
+        latestHash: Buffer;
+    }>;
+    getCreationHeight(): Promise<{
+        createdAtHeight: number;
+        createdAtHash: Buffer;
+    }>;
+    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>;
+}
+//# sourceMappingURL=DataStore.d.ts.map

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

@@ -0,0 +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;CA8C5B"}