@constellation-network/node-pilot 0.0.7 → 0.0.9

package/dist/helpers/project-helper.js

@@ -1,51 +1,50 @@
+import { input, select } from "@inquirer/prompts";
+import chalk from "chalk";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from 'node:url';
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
+import { githubService } from "../services/github-service.js";
 import { configHelper } from "./config-helper.js";
 import { getLayerEnvFileContent } from "./env-templates.js";
 export const projectHelper = {
     async generateLayerEnvFiles(layers) {
         const { layersToRun, projectDir } = configStore.getProjectInfo();
-        const { type } = configStore.getNetworkInfo();
-        const commonInfo = configStore.getEnvCommonInfo();
+        const { type: network } = configStore.getNetworkInfo();
+        const envInfo = configStore.getEnvInfo();
+        const envNetworkInfo = configStore.getEnvNetworkInfo(network);
         layers = layers || layersToRun;
-        for (const n of layers) {
-            const filePath = path.join(projectDir, `${n}.env`);
-            const envInfo = configStore.getEnvLayerInfo(n);
-            const fileContents = getLayerEnvFileContent(n, type, commonInfo, envInfo);
+        for (const layer of layers) {
+            const filePath = path.join(projectDir, `${layer}.env`);
+            const envLayerInfo = configStore.getEnvLayerInfo(network, layer);
+            const fileContents = getLayerEnvFileContent(layer, { ...envInfo, ...envNetworkInfo, ...envLayerInfo });
             clm.debug(`Writing layer env file: ${filePath}`);
             fs.writeFileSync(filePath, fileContents);
         }
     },
-    async importLayerEnvFiles() {
-        const { projectDir } = configStore.getProjectInfo();
-        const possibleLayers = ['gl0', 'gl1', 'ml0', 'cl1', 'dl1'];
-        for (const n of possibleLayers) {
-            const filePath = path.join(projectDir, 'layers', `${n}.env`);
-            if (fs.existsSync(filePath)) {
-                configStore.setEnvLayerInfo(n, configHelper.parseEnvFile(filePath));
-            }
-        }
-    },
-    async importNetworkEnvFiles() {
+    importEnvFiles() {
         const { projectDir } = configStore.getProjectInfo();
         const possibleNetworks = ['mainnet', 'testnet', 'integrationnet'];
+        const possibleLayers = ['gl0', 'gl1', 'ml0', 'cl1', 'dl1'];
         const supportedTypes = [];
-        const networkEnvInfo = {};
-        for (const n of possibleNetworks) {
-            const filePath = path.join(projectDir, 'networks', `${n}.env`);
+        for (const network of possibleNetworks) {
+            const filePath = path.join(projectDir, 'networks', network, 'network.env');
             if (fs.existsSync(filePath)) {
-                supportedTypes.push(n);
-                networkEnvInfo[n] = configHelper.parseEnvFile(filePath);
+                supportedTypes.push(network);
+                configStore.setEnvNetworkInfo(network, configHelper.parseEnvFile(filePath));
+            }
+            for (const layer of possibleLayers) {
+                const filePath = path.join(projectDir, 'networks', network, `${layer}.env`);
+                if (fs.existsSync(filePath)) {
+                    configStore.setEnvLayerInfo(network, layer, configHelper.parseEnvFile(filePath));
+                }
             }
         }
         if (supportedTypes.length === 0) {
             clm.error('No supported networks found in the project folder.');
         }
         configStore.setNetworkInfo({ supportedTypes });
-        configStore.setNetworkEnvInfo(networkEnvInfo);
         // eslint-disable-next-line no-warning-comments
         // TODO: verify all required env variables are present
     },
@@ -54,10 +53,7 @@ export const projectHelper = {
         if (!fs.existsSync(projectFolder)) {
             clm.error(`Project folder not found: ${projectFolder}`);
         }
-        await configStore.applyNewProjectStore(name);
-        const { projectDir } = configStore.getProjectInfo();
-        clm.debug(`Installing project from ${projectFolder} to ${projectDir}`);
-        fs.cpSync(projectFolder, projectDir, { recursive: true });
+        await this.installProject(name, projectFolder);
     },
     //  curl -s https://api.github.com/repos/Constellation-Labs/pacaswap-metagraph/releases/latest | jq -r '.assets[] | select(.name | contains("node-pilot"))'
     //  use .tag_name for the release version
@@ -72,14 +68,69 @@ export const projectHelper = {
         fs.mkdirSync(path.join(gl0DataDir, 'incremental_snapshot'), { recursive: true });
         fs.mkdirSync(path.join(gl0DataDir, 'snapshot_info'));
         fs.mkdirSync(path.join(gl0DataDir, 'tmp'));
-        // Set hypergraph layer defaults
-        configStore.setEnvLayerInfo('gl0', {
-            CL_CLI_HTTP_PORT: '9002', CL_DOCKER_JAVA_OPTS: '-Xms1024M -Xmx7G -Xss256K', CL_P2P_HTTP_PORT: '9001', CL_PUBLIC_HTTP_PORT: '9000'
-        });
-        configStore.setEnvLayerInfo('gl1', {
-            CL_CLI_HTTP_PORT: '9102', CL_DOCKER_JAVA_OPTS: '-Xms1024M -Xmx3G -Xss256K', CL_P2P_HTTP_PORT: '9101', CL_PUBLIC_HTTP_PORT: '9100'
+        this.importEnvFiles();
+    },
+    async installProject(name, projectFolder) {
+        if (!configStore.hasProjects()) {
+            // On first install, copy scripts
+            const scriptsFolder = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../scripts`);
+            const projectDir = path.join(configStore.getAppDir(), 'scripts');
+            clm.debug(`Installing node pilot scripts from ${scriptsFolder} to ${projectDir}`);
+            fs.mkdirSync(projectDir, { recursive: true });
+            fs.cpSync(scriptsFolder, projectDir, { recursive: true });
+        }
+        await configStore.applyNewProjectStore(name);
+        const { projectDir } = configStore.getProjectInfo();
+        clm.debug(`Installing project from ${projectFolder} to ${projectDir}`);
+        fs.cpSync(projectFolder, projectDir, { recursive: true });
+    },
+    async selectProject() {
+        // prompt user to install hypergraph or metagraph
+        const networkType = await select({
+            choices: [
+                { name: 'Hypergraph (Global layer)', value: 'hypergraph' },
+                { disabled: true, name: 'Metagraph (Dor, Pacaswap, and more)', value: 'metagraph' },
+            ],
+            message: 'Select network:'
         });
-        await this.importNetworkEnvFiles();
-        await this.importLayerEnvFiles();
+        if (networkType === 'hypergraph') {
+            await this.installHypergraph();
+        }
+        else if (networkType === 'metagraph') {
+            const project = await select({
+                choices: [
+                    { name: 'Dor', value: 'dor' },
+                    { name: 'Custom (Enter repo)', value: 'custom' },
+                ],
+                message: 'Select metagraph:'
+            });
+            const ghRepoRegex = /^https?:\/\/(?:www\.)?github\.com\/([A-Za-z0-9](?:-?[A-Za-z0-9]){0,38})\/([A-Za-z0-9._-]+)(?:\.git)?\/?$/;
+            if (project === 'dor') {
+                await this.installEmbedded('dor');
+            }
+            else if (project === 'custom') {
+                let repo = await input({
+                    message: `Enter Github repository URL:`,
+                    validate(value) {
+                        const m = value.trim().match(ghRepoRegex);
+                        if (m)
+                            return true;
+                        return 'Please enter a valid Github repo URL (e.g., https://github.com/user/repo or .git)';
+                    }
+                });
+                if (repo.endsWith('.git'))
+                    repo = repo.slice(0, -4);
+                const m = repo.trim().match(ghRepoRegex);
+                const userRepo = `${m[1]}/${m[2]}`; // owner/repo
+                clm.preStep(`Installing from Github repository: ${chalk.cyan(userRepo)}`);
+                if (await githubService.hasAssetInRelease('node-pilot', userRepo)) {
+                    await this.installFromGithub(userRepo);
+                }
+                else {
+                    clm.warn(`The repository ${repo} does not contain a release asset with the name "node-pilot"`);
+                    await this.selectProject();
+                }
+            }
+        }
     }
 };

package/dist/helpers/prompt-helper.d.ts

@@ -1,8 +1,6 @@
 export declare const promptHelper: {
-    configureAutoRestart(): Promise<void>;
     configureJavaMemoryArguments(): Promise<void>;
     doYouWishToContinue(defaultAnswer?: "n" | "y"): Promise<void>;
     selectLayers(): Promise<void>;
     selectNetwork(): Promise<void>;
-    selectProject(): Promise<void>;
 };

package/dist/helpers/prompt-helper.js

@@ -2,25 +2,17 @@ import { checkbox, input, number, select } from "@inquirer/prompts";
 import chalk from "chalk";
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
-import { githubHelper } from "./github-helper.js";
-import { projectHelper } from "./project-helper.js";
 export const promptHelper = {
-    async configureAutoRestart() {
-        const answer = await input({
-            default: 'y',
-            message: 'Do you want to enable auto-restart? (y/n): '
-        });
-        configStore.setProjectInfo({ autoRestart: answer === 'y' });
-    },
     async configureJavaMemoryArguments() {
         const { memory } = configStore.getSystemInfo();
         const { layersToRun, name } = configStore.getProjectInfo();
+        const { type: currentNetwork } = configStore.getNetworkInfo();
         const xmx = Number(memory);
         if (xmx === 8 && layersToRun.length > 1) {
             clm.warn('Minimum 8GB memory detected. Only a single layer will be allowed to run');
             await promptHelper.doYouWishToContinue();
             configStore.setProjectInfo({ layersToRun: [layersToRun[0]] });
-            configStore.setEnvLayerInfo(layersToRun[0], { CL_DOCKER_JAVA_OPTS: '-Xms1024M -Xmx7G -Xss256K' });
+            configStore.setEnvLayerInfo(currentNetwork, layersToRun[0], { CL_DOCKER_JAVA_OPTS: '-Xms1024M -Xmx7G -Xss256K' });
         }
         else if (name === 'hypergraph') {
             // prompt to use all detected memory
@@ -33,11 +25,16 @@ export const promptHelper = {
                 answer--;
             const subLayerMem = layersToRun.length > 1 ? Math.floor(answer / 3) : 0;
             const mainLayerMem = answer - subLayerMem;
-            clm.postStep(`${layersToRun[0]} memory allocation: ${mainLayerMem}GB`);
-            configStore.setEnvLayerInfo(layersToRun[0], { CL_DOCKER_JAVA_OPTS: `-Xms1024M -Xmx${mainLayerMem}G -Xss256K` });
-            if (subLayerMem) {
-                clm.postStep(`${layersToRun[1]} memory allocation: ${subLayerMem}GB`);
-                configStore.setEnvLayerInfo(layersToRun[1], { CL_DOCKER_JAVA_OPTS: `-Xms1024M -Xmx${subLayerMem}G -Xss256K` });
+            const { supportedTypes } = configStore.getNetworkInfo();
+            for (const type of supportedTypes) {
+                const network = type.toUpperCase();
+                const logMethod = type === currentNetwork ? clm.postStep : clm.debug;
+                logMethod(`${network}:: ${layersToRun[0]} memory allocation: ${mainLayerMem}GB`);
+                configStore.setEnvLayerInfo(type, layersToRun[0], { CL_DOCKER_JAVA_OPTS: `-Xms1024M -Xmx${mainLayerMem}G -Xss256K` });
+                if (subLayerMem) {
+                    logMethod(`${network}:: ${layersToRun[1]} memory allocation: ${subLayerMem}GB`);
+                    configStore.setEnvLayerInfo(type, layersToRun[1], { CL_DOCKER_JAVA_OPTS: `-Xms1024M -Xmx${subLayerMem}G -Xss256K` });
+                }
             }
         }
     },
@@ -69,7 +66,7 @@ export const promptHelper = {
         }
         if (supportedTypes.length === 1) {
             configStore.setNetworkInfo({ type: supportedTypes[0], version: "latest" });
-            configStore.setEnvCommonInfo(configStore.getNetworkEnvInfo(supportedTypes[0]));
+            // configStore.setEnvNetworkInfo(configStore.getNetworkEnvInfo(supportedTypes[0]));
             return;
         }
         const networkType = await select({
@@ -81,55 +78,7 @@ export const promptHelper = {
             message: 'Select network type:'
         });
         configStore.setNetworkInfo({ type: networkType, version: "latest" });
-        configStore.setEnvCommonInfo(configStore.getNetworkEnvInfo(networkType));
-    },
-    async selectProject() {
-        // prompt user to install hypergraph or metagraph
-        const networkType = await select({
-            choices: [
-                { name: 'Hypergraph (Global layer)', value: 'hypergraph' },
-                { disabled: true, name: 'Metagraph (Dor, Pacaswap, and more)', value: 'metagraph' },
-            ],
-            message: 'Select network:'
-        });
-        if (networkType === 'hypergraph') {
-            await projectHelper.installHypergraph();
-        }
-        else if (networkType === 'metagraph') {
-            const project = await select({
-                choices: [
-                    { name: 'Dor', value: 'dor' },
-                    { name: 'Custom (Enter repo)', value: 'custom' },
-                ],
-                message: 'Select metagraph:'
-            });
-            const ghRepoRegex = /^https?:\/\/(?:www\.)?github\.com\/([A-Za-z0-9](?:-?[A-Za-z0-9]){0,38})\/([A-Za-z0-9._-]+)(?:\.git)?\/?$/;
-            if (project === 'dor') {
-                await projectHelper.installEmbedded('dor');
-            }
-            else if (project === 'custom') {
-                let repo = await input({
-                    message: `Enter Github repository URL:`,
-                    validate(value) {
-                        const m = value.trim().match(ghRepoRegex);
-                        if (m)
-                            return true;
-                        return 'Please enter a valid Github repo URL (e.g., https://github.com/user/repo or .git)';
-                    }
-                });
-                if (repo.endsWith('.git'))
-                    repo = repo.slice(0, -4);
-                const m = repo.trim().match(ghRepoRegex);
-                const userRepo = `${m[1]}/${m[2]}`; // owner/repo
-                clm.preStep(`Installing from Github repository: ${chalk.cyan(userRepo)}`);
-                if (await githubHelper.hasAssetInRelease('node-pilot', userRepo)) {
-                    await projectHelper.installFromGithub(userRepo);
-                }
-                else {
-                    clm.warn(`The repository ${repo} does not contain a release asset with the name "node-pilot"`);
-                    await this.selectProject();
-                }
-            }
-        }
+        configStore.setProjectFlag('duplicateNodeIdChecked', false);
+        configStore.setProjectFlag('seedListChecked', false);
     }
 };

package/dist/services/archiver-service.d.ts

@@ -0,0 +1,17 @@
+export declare const archiverService: {
+    checkLogsForMissingSnapshots(): Promise<void>;
+    getArchiveSnapshotInfo(): Promise<{
+        clusterOrdinal: number;
+        distance: number;
+        endOrdinal: number;
+        startOrdinal: number;
+        total: number;
+        url: string;
+    }>;
+    getDownloadedSnapshotRange(): {
+        chunkOrdinal: number;
+        endOrdinal: number;
+        startOrdinal: number;
+    };
+    syncToLatestSnapshot(): Promise<void>;
+};

package/dist/services/archiver-service.js

@@ -0,0 +1,104 @@
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { clusterService } from "./cluster-service.js";
+import { FastforwardService } from "./fastforward-service.js";
+import { shellService } from "./shell-service.js";
+// http://5.161.243.241:7777/hash.txt
+const remoteIndexMap = {
+    integrationnet: "http://5.161.243.241:7777",
+    mainnet: "http://128.140.33.142:7777",
+    testnet: "http://65.108.87.84:7777"
+};
+export const archiverService = {
+    async checkLogsForMissingSnapshots() {
+        const { projectDir } = configStore.getProjectInfo();
+        const dataDir = path.join(projectDir, 'app-data', 'gl0-logs', 'app.log');
+        const result = await shellService.runCommandWithOutput(`grep -i 'Global snapshot not found for ordinal' ${dataDir}`).catch(() => '');
+        let oldestOrdinal = Number.MAX_SAFE_INTEGER;
+        for (const line of result.split('\n')) {
+            const number = line.match(/\d+/);
+            if (number) {
+                oldestOrdinal = Math.min(oldestOrdinal, Number(number[0]));
+            }
+        }
+        console.log(`Oldest ordinal: ${oldestOrdinal}`);
+    },
+    async getArchiveSnapshotInfo() {
+        const { type } = configStore.getNetworkInfo();
+        const clusterOrdinal = await clusterService.getSourceNodeLatestOrdinal('gl0');
+        return fetch(remoteIndexMap[type] + '/hash.txt')
+            .then(res => res.text())
+            .then(txt => {
+            const lines = txt.trim().split('\n');
+            const lastLine = lines.at(-1);
+            const filename = lastLine.split(' ')[1];
+            const parseName = filename.split('.')[0].split('-');
+            const startOrdinal = Number(parseName.at(1)?.slice(1));
+            const endOrdinal = parseName.length < 4 ? startOrdinal + 20_000 - 1 : Number(parseName.at(3)?.slice(1));
+            const distance = clusterOrdinal - endOrdinal;
+            const total = endOrdinal - startOrdinal + 1;
+            clm.debug(`Cluster Ordinal: ${chalk.yellow(clusterOrdinal)}, Archive End Ordinal: ${chalk.yellow(endOrdinal)}, Total Archive Snapshots: ${chalk.yellow(total)}, Distance: ${chalk.yellow(distance)}`);
+            return { clusterOrdinal, distance, endOrdinal, startOrdinal, total, url: remoteIndexMap[type] + '/' + filename };
+        });
+    },
+    getDownloadedSnapshotRange() {
+        const { projectDir } = configStore.getProjectInfo();
+        const dataDir = path.join(projectDir, 'app-data', 'gl0-data', 'incremental_snapshot', 'ordinal');
+        const result = { chunkOrdinal: 0, endOrdinal: 0, startOrdinal: 0 };
+        if (!fs.existsSync(dataDir)) {
+            return result;
+        }
+        // get last filename in directory
+        let files = fs.readdirSync(dataDir);
+        if (files.length === 0)
+            return result;
+        const latestChunk = files.sort().at(-1);
+        if (!latestChunk)
+            return result;
+        result.chunkOrdinal = Number(latestChunk);
+        files = fs.readdirSync(path.join(dataDir, latestChunk));
+        if (files.length === 0)
+            return result;
+        const filesSorted = files.sort();
+        const firstFile = filesSorted.at(0);
+        const lastFile = filesSorted.at(-1);
+        result.startOrdinal = Number(firstFile);
+        result.endOrdinal = Number(lastFile);
+        return result;
+    },
+    async syncToLatestSnapshot() {
+        const { clusterOrdinal, distance: archiveDistance, endOrdinal: remoteArchiveEndOrdinal, startOrdinal: remoteArchiveStartOrdinal, total, url } = await this.getArchiveSnapshotInfo();
+        if (archiveDistance > 1000) {
+            clm.preStep('Archive is far behind cluster. Initiating fast forward...');
+            await FastforwardService.synctoLatestSnapshot();
+            return;
+        }
+        const { endOrdinal: localEndOrdinal, startOrdinal: localStartOrdinal } = this.getDownloadedSnapshotRange();
+        const localDistanceFromCluster = clusterOrdinal - localEndOrdinal;
+        // if archive can improve local's snapshot range
+        const needToSync = remoteArchiveStartOrdinal < localStartOrdinal || remoteArchiveEndOrdinal > localEndOrdinal;
+        if (!needToSync) {
+            clm.step(`Already near latest ordinal. Skipping sync. Distance: ${localDistanceFromCluster}`);
+            return;
+        }
+        const requiredOldestOrdinal = clusterOrdinal - 10_000;
+        const archiveStartOrdinalMeetsOldestRequirement = remoteArchiveStartOrdinal <= requiredOldestOrdinal;
+        if (!archiveStartOrdinalMeetsOldestRequirement) {
+            clm.preStep('Archive is not in the optimal range, but proceeding with available data.');
+        }
+        const { projectDir } = configStore.getProjectInfo();
+        const dataDir = path.join(projectDir, 'app-data', 'gl0-data');
+        fs.mkdirSync(dataDir, { recursive: true });
+        clm.preStep(`Downloading latest snapshot archive ${chalk.yellow(remoteArchiveStartOrdinal)}-${chalk.yellow(remoteArchiveEndOrdinal)}; distance from cluster: ${chalk.yellow(archiveDistance)}\nCurrent oldest local ordinal: ${chalk.yellow(localStartOrdinal)}, Latest cluster ordinal: ${chalk.yellow(clusterOrdinal)}`);
+        // await shellService.runCommand(`curl -L ${url} -o ${dataDir}/snapshot.tar.gz`);
+        await shellService.runCommand(`wget --progress=bar:force -O ${dataDir}/snapshot.tar.gz ${url}`);
+        clm.preStep(`Extracting snapshot...`);
+        await shellService.runCommand(`tar -xf ${dataDir}/snapshot.tar.gz -C ${dataDir}`);
+        await shellService.runCommand(`rm ${dataDir}/snapshot.tar.gz`);
+        clm.postStep(`Total snapshots downloaded: ${chalk.yellow(total)}, Synced to ordinal: ${chalk.yellow(remoteArchiveEndOrdinal)}, Cluster Ordinal: ${chalk.yellow(clusterOrdinal)}, Distance from cluster: ${chalk.yellow(archiveDistance)}`);
+        clm.postStep(`Snapshot downloaded and extracted successfully.`);
+    }
+};

package/dist/services/cluster-service.d.ts

@@ -1,9 +1,14 @@
-import { ClusterInfo, NodeInfo } from "../types.js";
+import { ClusterConsensusInfo, ClusterInfo, NodeInfo, TessellationLayer } from "../types.js";
 export declare const clusterService: {
     fastForwardSnapshot(): Promise<void>;
-    getClusterInfo(): Promise<ClusterInfo[]>;
-    getLatestOrdinal(): Promise<any>;
-    getNodeInfo(): Promise<NodeInfo>;
+    getClusterInfo(layer?: TessellationLayer): Promise<ClusterInfo[]>;
+    getClusterNodeInfo(layer?: TessellationLayer): Promise<NodeInfo>;
+    getLatestConsensusInfo(layer?: TessellationLayer): Promise<ClusterConsensusInfo>;
+    getLayer0(): "gl0" | "ml0";
     getReleaseVersion(): Promise<string>;
-    getSourceNodeInfo(): Promise<NodeInfo>;
+    getSourceNodeInfo(layer: TessellationLayer): Promise<NodeInfo>;
+    getSourceNodeLatestOrdinal(layer: TessellationLayer): Promise<number>;
+    getSourceNodeOrdinalHash(layer: TessellationLayer, ordinal: number): Promise<string>;
+    makeClusterRequest(path: string, layer?: TessellationLayer): Promise<any>;
+    makeSourceNodeRequest(path: string, layer: TessellationLayer): Promise<any>;
 };

package/dist/services/cluster-service.js

@@ -1,4 +1,5 @@
 import { input } from "@inquirer/prompts";
+import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
 import { FastforwardService } from "./fastforward-service.js";
 export const clusterService = {
@@ -21,47 +22,56 @@ export const clusterService = {
             configStore.setProjectInfo({ fastForward: true });
         }
         await FastforwardService.synctoLatestSnapshot();
+        // await archiverService.syncToLatestSnapshot()
+        //     .catch(() => {
+        //         clm.warn(`Failed to download latest snapshots using Starchiver. Using fast forward to latest snapshot.`);
+        //         clusterService.fastForwardSnapshot();
+        //     })
     },
-    async getClusterInfo() {
-        const { type } = configStore.getNetworkInfo();
-        return fetch(`https://l0-lb-${type}.constellationnetwork.io/cluster/info`)
-            .then(res => {
-            if (res.ok)
-                return res.json();
-            throw new Error(`Failed`);
-        })
-            .catch(() => []);
+    async getClusterInfo(layer) {
+        return this.makeClusterRequest('cluster/info', layer);
     },
-    async getLatestOrdinal() {
-        const { type } = configStore.getNetworkInfo();
-        return fetch(`https://l0-lb-${type}.constellationnetwork.io/global-snapshots/latest`)
-            .then(res => {
-            if (res.ok)
-                return res.json().then(i => (i?.value?.ordinal || 0));
-            return 0;
-        })
-            .catch(() => 0);
+    async getClusterNodeInfo(layer) {
+        return this.makeClusterRequest('node/info', layer);
     },
-    async getNodeInfo() {
-        const { type } = configStore.getNetworkInfo();
-        return fetch(`https://l0-lb-${type}.constellationnetwork.io/node/info`)
-            .then(res => {
-            if (res.ok)
-                return res.json();
-            throw new Error(`Failed`);
-        })
-            .catch(() => ({ state: "Unavailable" }));
+    async getLatestConsensusInfo(layer) {
+        return this.makeClusterRequest('consensus/latest/peers', layer);
+    },
+    getLayer0() {
+        return configStore.getProjectInfo().layersToRun.includes('gl0') ? 'gl0' : 'ml0';
     },
     async getReleaseVersion() {
-        return this.getNodeInfo().then(i => i.version);
+        return this.getClusterNodeInfo().then(i => i.version);
+    },
+    async getSourceNodeInfo(layer) {
+        return this.makeSourceNodeRequest('node/info', layer);
+    },
+    async getSourceNodeLatestOrdinal(layer) {
+        return this.makeSourceNodeRequest('global-snapshots/latest', layer).then(i => i.value.ordinal);
     },
-    async getSourceNodeInfo() {
-        const { CL_L0_PEER_HTTP_HOST, CL_L0_PEER_HTTP_PORT } = configStore.getEnvCommonInfo();
-        return fetch(`http://${CL_L0_PEER_HTTP_HOST}:${CL_L0_PEER_HTTP_PORT}/node/info`)
-            .then(res => {
-            if (res.ok)
-                return res.json();
-            throw new Error(`Failed`);
-        });
+    async getSourceNodeOrdinalHash(layer, ordinal) {
+        return this.makeSourceNodeRequest(`global-snapshots/${ordinal}/hash`, layer);
+    },
+    async makeClusterRequest(path, layer) {
+        layer = layer || this.getLayer0();
+        const { type } = configStore.getNetworkInfo();
+        const envLayerInfo = configStore.getEnvLayerInfo(type, layer);
+        if (envLayerInfo.CL_LB) {
+            return fetch(`${envLayerInfo.CL_LB}/${path}`)
+                .then(res => res.json())
+                .catch(() => {
+                clm.debug(`Failed to get node info from ${envLayerInfo.CL_LB}. Attempting source node...`);
+                return this.makeSourceNodeRequest(path, layer);
+            });
+        }
+        return this.makeSourceNodeRequest(path, layer);
+    },
+    async makeSourceNodeRequest(path, layer) {
+        const { type } = configStore.getNetworkInfo();
+        const { CL_PUBLIC_HTTP_PORT } = configStore.getEnvLayerInfo(type, layer);
+        const { CL_L0_PEER_HTTP_HOST } = configStore.getEnvNetworkInfo(type);
+        clm.debug(`http://${CL_L0_PEER_HTTP_HOST}:${CL_PUBLIC_HTTP_PORT}/${path}`);
+        return fetch(`http://${CL_L0_PEER_HTTP_HOST}:${CL_PUBLIC_HTTP_PORT}/${path}`)
+            .then(res => res.json());
     }
 };

package/dist/services/docker-service.d.ts

@@ -0,0 +1,9 @@
+import { TessellationLayer } from "../types.js";
+export declare const dockerService: {
+    dockerBuild(): Promise<void>;
+    dockerDown(): Promise<void>;
+    dockerRestart(layer: TessellationLayer): Promise<void>;
+    dockerStartLayers(layers: TessellationLayer[]): Promise<void>;
+    dockerUp(): Promise<void>;
+    isRunning(): Promise<boolean>;
+};

package/dist/services/docker-service.js

@@ -0,0 +1,53 @@
+import ora from "ora";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { projectHelper } from "../helpers/project-helper.js";
+import { shellService } from "./shell-service.js";
+export const dockerService = {
+    async dockerBuild() {
+        if (shellService.existsProjectScript('scripts/docker-build.sh')) {
+            const silent = !process.env.DEBUG;
+            const spinner = ora('Building the node container...');
+            if (silent) {
+                spinner.start();
+                spinner.color = 'green';
+            }
+            else {
+                clm.preStep('Building the node container...');
+            }
+            await shellService.runProjectCommand('bash scripts/docker-build.sh', undefined, silent);
+            if (silent) {
+                spinner.stop();
+            }
+            clm.postStep('Node container built.');
+        }
+    },
+    async dockerDown() {
+        await run('down');
+    },
+    async dockerRestart(layer) {
+        await run('restart', [layer]);
+    },
+    async dockerStartLayers(layers) {
+        await run('up -d', layers);
+    },
+    async dockerUp() {
+        // If docker is already running, stop it
+        if (await this.isRunning()) {
+            await this.dockerDown();
+        }
+        await projectHelper.generateLayerEnvFiles();
+        // const userId = await shellService.runCommandWithOutput('echo "$(id -u):$(id -g)"')
+        // console.log('Setting DOCKER_USER_ID to', userId);
+        // configStore.setDockerEnvInfo({ DOCKER_USER_ID: userId });
+        await run('up -d');
+    },
+    async isRunning() {
+        return shellService.runCommand('docker ps | grep entrypoint.sh', undefined, true).then(Boolean).catch(() => false);
+    }
+};
+function run(command, layers) {
+    const { layersToRun } = configStore.getProjectInfo();
+    const args = (layers || layersToRun).map(l => `--profile ${l}`).join(' ');
+    return shellService.runProjectCommand(`docker compose ${args} ${command}`, configStore.getDockerEnvInfo());
+}

package/dist/services/fastforward-service.js

@@ -19,9 +19,9 @@ export class FastforwardService {
         this.dataDir = path.join(projectDir, 'app-data', 'gl0-data'); // gl0
         fs.mkdirSync(this.tmpDir, { recursive: true });
         fs.mkdirSync(this.dataDir, { recursive: true });
-        const env = configStore.getEnvCommonInfo();
+        const env = configStore.getEnvNetworkInfo(type);
         // this.lbUrl = `https://l0-lb-${this.network}.constellationnetwork.io`;
-        this.lbUrl = `http://${env.CL_GLOBAL_L0_PEER_HOST}:${env.CL_GLOBAL_L0_PEER_HTTP_PORT}`;
+        this.lbUrl = `http://${env.CL_L0_PEER_HTTP_HOST}:${env.CL_L0_PEER_HTTP_PORT}`;
     }
     static async synctoLatestSnapshot() {
         const ffs = new FastforwardService();
@@ -38,17 +38,23 @@ export class FastforwardService {
         fs.writeFileSync(path.join(snapshotInfoDir, ordinal.toString()), compressedSnapshotInfo);
         fs.writeFileSync(path.join(this.tmpDir, ordinal.toString() + '.c'), compressedSnapshotIncremental);
         await this.saveSnapshotFiles(ordinal.toString(), hash);
-        clm.postStep('Fastforward completed.');
+        clm.postStep(`Fastforward to snapshot "${ordinal}" completed.`);
     }
     async fetchLatestSnapshot() {
         const url = `${this.lbUrl}/global-snapshots/latest/combined`;
         clm.debug('Fetching latest snapshot ordinal from: ' + chalk.cyan(url));
-        return fetch(url).then(res => res.json()
+        return fetch(url)
+            .then(res => {
+            if (!res.ok) {
+                throw new Error(`Failed to fetch latest snapshot ordinal: ${res.statusText}`);
+            }
+            return res.json();
+        })
             .then(data => {
             const { ordinal } = data[0].value;
             clm.debug('fetchLatestSnapshot - ' + chalk.cyan(ordinal));
             return [ordinal, data[0], data[1]];
-        }));
+        });
     }
     async fetchSnapshot(ordinal) {
         const url = `${this.lbUrl}/global-snapshots/${ordinal}`;
@@ -57,7 +63,7 @@ export class FastforwardService {
     }
     async fetchSnapshotHash(ordinal) {
         const url = `${this.lbUrl}/global-snapshots/${ordinal}/hash`;
-        const hash = await fetch(url).then(res => res.text().then(t => t.replace(/^"(.*)"$/, '$1')));
+        const hash = await fetch(url).then(res => res.json());
         clm.debug('fetchLatestSnapshotHash: ' + chalk.cyan(hash));
         return hash;
     }

package/dist/services/get-random-node.d.ts

@@ -0,0 +1,2 @@
+import { NodeInfo } from "../types.js";
+export declare const getRandomNode: (nodes: Pick<NodeInfo, "host" | "id" | "publicPort">[]) => Promise<NodeInfo>;