@offckb/cli 0.2.6 → 0.3.0-canary-cfe9b48.0

package/dist/deploy/migration.js

@@ -0,0 +1,131 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploymentRecipeFromJson = exports.deploymentRecipeToJson = exports.getNewestMigrationFile = exports.getMigrationFolderPath = exports.getFormattedMigrationDate = exports.readDeploymentRecipeJsonFile = exports.generateDeploymentRecipeJsonFile = void 0;
+const type_1 = require("../util/type");
+const path_1 = __importStar(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const util_1 = require("./util");
+function generateDeploymentRecipeJsonFile(name, deploymentRecipe, network = type_1.Network.devnet) {
+    const cellRecipes = deploymentRecipe.cellRecipes;
+    const depGroupRecipes = deploymentRecipe.depGroupRecipes;
+    const jsonString = JSON.stringify(deploymentRecipeToJson({ cellRecipes, depGroupRecipes }), null, 2);
+    const outputFilePath = `${(0, util_1.getContractsPath)(network)}/${name}/migrations/${getFormattedMigrationDate()}.json`;
+    if (outputFilePath) {
+        if (!fs_1.default.existsSync((0, path_1.dirname)(outputFilePath))) {
+            fs_1.default.mkdirSync((0, path_1.dirname)(outputFilePath), { recursive: true });
+        }
+        fs_1.default.writeFileSync(outputFilePath, jsonString);
+        console.log(`${name} migration json file ${outputFilePath} generated successfully.`);
+    }
+}
+exports.generateDeploymentRecipeJsonFile = generateDeploymentRecipeJsonFile;
+function readDeploymentRecipeJsonFile(filePath) {
+    const jsonString = fs_1.default.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(jsonString);
+    return deploymentRecipeFromJson(data);
+}
+exports.readDeploymentRecipeJsonFile = readDeploymentRecipeJsonFile;
+function getFormattedMigrationDate() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0'); // Months are zero-based
+    const day = String(now.getDate()).padStart(2, '0');
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    return `${year}-${month}-${day}-${hours}${minutes}${seconds}`;
+}
+exports.getFormattedMigrationDate = getFormattedMigrationDate;
+function getMigrationFolderPath(scriptName, network) {
+    const contractsPath = (0, util_1.getContractsPath)(network);
+    return path_1.default.resolve(contractsPath, `${scriptName}/migrations`);
+}
+exports.getMigrationFolderPath = getMigrationFolderPath;
+function getNewestMigrationFile(folderPath) {
+    const files = fs_1.default
+        .readdirSync(folderPath)
+        .filter((file) => file.endsWith('.json')) // Ensure only JSON files are considered
+        .sort((a, b) => {
+        // Extract the timestamp part of the filename and compare them
+        const timestampA = a.split('.json')[0];
+        const timestampB = b.split('.json')[0];
+        return timestampA.localeCompare(timestampB);
+    });
+    // Return the full path of the newest file (last in sorted array) or undefined if no files
+    return files.length > 0 ? path_1.default.join(folderPath, files[files.length - 1]) : undefined;
+}
+exports.getNewestMigrationFile = getNewestMigrationFile;
+function deploymentRecipeToJson(recipe) {
+    return {
+        cell_recipes: recipe.cellRecipes.map((val) => {
+            return {
+                name: val.name,
+                tx_hash: val.txHash,
+                index: val.index,
+                occupied_capacity: val.occupiedCapacity,
+                data_hash: val.dataHash,
+                type_id: val.typeId,
+            };
+        }),
+        dep_group_recipes: recipe.depGroupRecipes.map((val) => {
+            return {
+                name: val.name,
+                tx_hash: val.txHash,
+                index: val.index,
+                data_hash: val.dataHash,
+                occupied_capacity: val.occupiedCapacity,
+            };
+        }),
+    };
+}
+exports.deploymentRecipeToJson = deploymentRecipeToJson;
+function deploymentRecipeFromJson(json) {
+    return {
+        cellRecipes: json.cell_recipes.map((val) => {
+            return {
+                name: val.name,
+                txHash: val.tx_hash,
+                index: val.index,
+                occupiedCapacity: val.occupied_capacity,
+                dataHash: val.data_hash,
+                typeId: val.type_id,
+            };
+        }),
+        depGroupRecipes: json.dep_group_recipes.map((val) => {
+            return {
+                name: val.name,
+                txHash: val.tx_hash,
+                index: val.index,
+                dataHash: val.data_hash,
+                occupiedCapacity: val.occupied_capacity,
+            };
+        }),
+    };
+}
+exports.deploymentRecipeFromJson = deploymentRecipeFromJson;

package/dist/deploy/toml.d.ts

@@ -0,0 +1,38 @@
+import { Script } from '@ckb-lumos/lumos';
+import { Network } from '../util/type';
+import { HashType } from '@ckb-ccc/core';
+export interface DeploymentOptions {
+    name: string;
+    binFilePath: string;
+    enableTypeId: boolean;
+    lockScript: Script;
+}
+export interface DeploymentToml {
+    cells: {
+        name: string;
+        enable_type_id: 'true' | 'false';
+        location: {
+            file: string;
+        };
+    }[];
+    lock: {
+        code_hash: string;
+        args: string;
+        hash_type: HashType;
+    };
+}
+export declare function generateDeploymentToml(options: DeploymentOptions, network: Network): void;
+export declare function readDeploymentToml(scriptName: string, network: Network): {
+    cells: {
+        name: string;
+        enableTypeId: boolean;
+        location: {
+            file: string;
+        };
+    }[];
+    lock: {
+        codeHash: string;
+        args: string;
+        hashType: string;
+    };
+};

package/dist/deploy/toml.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDeploymentToml = exports.generateDeploymentToml = void 0;
+const fs_1 = __importDefault(require("fs"));
+const toml_1 = __importDefault(require("@iarna/toml"));
+const path_1 = require("path");
+const util_1 = require("./util");
+function generateDeploymentToml(options, network) {
+    const data = {
+        cells: [
+            {
+                name: options.name,
+                enable_type_id: options.enableTypeId ? 'true' : 'false',
+                location: {
+                    file: options.binFilePath,
+                },
+            },
+        ],
+        lock: {
+            code_hash: options.lockScript.codeHash,
+            args: options.lockScript.args,
+            hash_type: options.lockScript.hashType,
+        },
+    };
+    const tomlString = toml_1.default.stringify(data);
+    const outputFilePath = `${(0, util_1.getContractsPath)(network)}/${options.name}/deployment.toml`;
+    if (outputFilePath) {
+        if (!fs_1.default.existsSync((0, path_1.dirname)(outputFilePath))) {
+            fs_1.default.mkdirSync((0, path_1.dirname)(outputFilePath), { recursive: true });
+        }
+        fs_1.default.writeFileSync(outputFilePath, tomlString);
+        console.log(`${options.name} deployment.toml file ${outputFilePath} generated successfully.`);
+    }
+}
+exports.generateDeploymentToml = generateDeploymentToml;
+function readDeploymentToml(scriptName, network) {
+    const filePath = `${(0, util_1.getContractsPath)(network)}/${scriptName}/deployment.toml`;
+    const file = fs_1.default.readFileSync(filePath, 'utf-8');
+    const data = toml_1.default.parse(file);
+    return {
+        cells: [
+            {
+                name: data.cells[0].name,
+                enableTypeId: data.cells[0].enable_type_id === 'true' ? true : false,
+                location: {
+                    file: data.cells[0].location.file,
+                },
+            },
+        ],
+        lock: {
+            codeHash: data.lock.code_hash,
+            args: data.lock.args,
+            hashType: data.lock.hash_type,
+        },
+    };
+}
+exports.readDeploymentToml = readDeploymentToml;

package/dist/deploy/util.d.ts

@@ -0,0 +1,2 @@
+import { Network } from '../util/type';
+export declare function getContractsPath(network: Network): string;

package/dist/deploy/util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContractsPath = void 0;
+const setting_1 = require("../cfg/setting");
+const type_1 = require("../util/type");
+function getContractsPath(network) {
+    const settings = (0, setting_1.readSettings)();
+    if (network === type_1.Network.devnet) {
+        return settings.devnet.contractsPath;
+    }
+    if (network === type_1.Network.testnet) {
+        return settings.testnet.contractsPath;
+    }
+    if (network === type_1.Network.mainnet) {
+        return settings.mainnet.contractsPath;
+    }
+    throw new Error(`invalid network ${network}`);
+}
+exports.getContractsPath = getContractsPath;

package/dist/node/init-chain.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initChainIfNeeded = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fs_2 = require("../util/fs");
+const setting_1 = require("../cfg/setting");
+function initChainIfNeeded() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const settings = (0, setting_1.readSettings)();
+        const devnetSourcePath = path_1.default.resolve(setting_1.packageRootPath, './ckb/devnet');
+        const devnetConfigPath = settings.devnet.configPath;
+        if (!(0, fs_2.isFolderExists)(devnetConfigPath)) {
+            const devnetConfigPath = settings.devnet.configPath;
+            yield (0, fs_2.copyFilesWithExclusion)(devnetSourcePath, devnetConfigPath, ['data']);
+            console.debug(`init devnet config folder: ${devnetConfigPath}`);
+            // copy and edit ckb-miner.toml
+            const minerToml = path_1.default.join(devnetSourcePath, 'ckb-miner.toml');
+            const newMinerToml = path_1.default.join(devnetConfigPath, 'ckb-miner.toml');
+            // Read the content of the ckb-miner.toml file
+            const data = fs_1.default.readFileSync(minerToml, 'utf8');
+            // Replace the URL
+            const modifiedData = data.replace('http://ckb:8114/', settings.devnet.rpcUrl);
+            // Write the modified content back to the file
+            fs_1.default.writeFileSync(newMinerToml, modifiedData, 'utf8');
+        }
+    });
+}
+exports.initChainIfNeeded = initChainIfNeeded;

package/dist/{cmd/develop → node}/install.d.ts

@@ -1,10 +1,9 @@
-export declare function installDependency(): Promise<void>;
-export declare function downloadBinaryAndUnzip(): Promise<void>;
-export declare function downloadAndSaveCKBBinary(tempFilePath: string): Promise<void>;
+export declare function installCKBBinary(version: string): Promise<void>;
+export declare function downloadCKBBinaryAndUnzip(version: string): Promise<void>;
+export declare function downloadAndSaveCKBBinary(version: string, tempFilePath: string): Promise<void>;
 export declare function unZipFile(filePath: string, extractDir: string, useTar?: boolean): Promise<void>;
 export declare function decompressTarGzAsync(tarballPath: string, destinationDir: string): Promise<void>;
-export declare function getInstalledVersion(): string | null;
-export declare function isVersionOutdated(installedVersion: string): boolean;
+export declare function getVersionFromBinary(binPath: string): string | null;
 export declare function getOS(): string;
 export declare function getArch(): string;
 export declare function getExtension(): 'tar.gz' | 'zip';

package/dist/{cmd/develop → node}/install.js

@@ -35,8 +35,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDownloadUrl = exports.getExtension = exports.getArch = exports.getOS = exports.isVersionOutdated = exports.getInstalledVersion = exports.decompressTarGzAsync = exports.unZipFile = exports.downloadAndSaveCKBBinary = exports.downloadBinaryAndUnzip = exports.installDependency = void 0;
-const axios_1 = __importDefault(require("axios"));
+exports.buildDownloadUrl = exports.getExtension = exports.getArch = exports.getOS = exports.getVersionFromBinary = exports.decompressTarGzAsync = exports.unZipFile = exports.downloadAndSaveCKBBinary = exports.downloadCKBBinaryAndUnzip = exports.installCKBBinary = void 0;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -44,56 +43,61 @@ const semver_1 = __importDefault(require("semver"));
 const os_1 = __importDefault(require("os"));
 const adm_zip_1 = __importDefault(require("adm-zip"));
 const tar = __importStar(require("tar"));
-const const_1 = require("../../cfg/const");
-const BINARY = const_1.ckbBinPath;
-const MINIMAL_VERSION = const_1.minimalRequiredCKBVersion;
-// Function to download and install the dependency binary
-function installDependency() {
+const request_1 = require("../util/request");
+const setting_1 = require("../cfg/setting");
+const encoding_1 = require("../util/encoding");
+function installCKBBinary(version) {
     return __awaiter(this, void 0, void 0, function* () {
-        const version = getInstalledVersion();
-        if (version) {
-            if (isVersionOutdated(version)) {
-                console.log(`${BINARY} version ${version} is outdated, download and install the new version ${MINIMAL_VERSION}..`);
+        const ckbBinPath = (0, setting_1.getCKBBinaryPath)(version);
+        const outputVersion = getVersionFromBinary(ckbBinPath);
+        if (outputVersion) {
+            if (!semver_1.default.eq(version, outputVersion)) {
+                console.log(`CKB version ${outputVersion} is not equal to the ${version}, download and install the new version ${version}..`);
             }
             else {
                 return;
             }
         }
         else {
-            console.log(`${BINARY} not found, download and install the new version ${MINIMAL_VERSION}..`);
+            console.log(`CKB Binary not found, download and install the new version ${version}..`);
         }
-        yield downloadBinaryAndUnzip();
+        yield downloadCKBBinaryAndUnzip(version);
     });
 }
-exports.installDependency = installDependency;
-function downloadBinaryAndUnzip() {
+exports.installCKBBinary = installCKBBinary;
+function downloadCKBBinaryAndUnzip(version) {
     return __awaiter(this, void 0, void 0, function* () {
         const arch = getArch();
         const osname = getOS();
         const ext = getExtension();
-        const ckbVersionOSName = `ckb_v${MINIMAL_VERSION}_${arch}-${osname}`;
+        const ckbVersionOSName = `ckb_v${version}_${arch}-${osname}`;
         try {
             const tempFilePath = path.join(os_1.default.tmpdir(), `${ckbVersionOSName}.${ext}`);
-            yield downloadAndSaveCKBBinary(tempFilePath);
+            yield downloadAndSaveCKBBinary(version, tempFilePath);
             // Unzip the file
-            const extractDir = path.join(const_1.targetEnvironmentPath, `ckb_v${MINIMAL_VERSION}`);
+            const extractDir = path.join((0, setting_1.readSettings)().bins.downloadPath, `ckb_v${version}`);
             yield unZipFile(tempFilePath, extractDir, ext === 'tar.gz');
             // Install the extracted files
             const sourcePath = path.join(extractDir, ckbVersionOSName);
-            fs.renameSync(sourcePath, const_1.ckbFolderPath); // Move binary to desired location
-            fs.chmodSync(const_1.ckbBinPath, '755'); // Make the binary executable
-            console.log('CKB installed successfully.');
+            const targetPath = (0, setting_1.getCKBBinaryInstallPath)(version);
+            if (fs.existsSync(targetPath)) {
+                fs.rmdirSync(targetPath, { recursive: true });
+            }
+            fs.mkdirSync(targetPath, { recursive: true });
+            fs.renameSync(sourcePath, targetPath); // Move binary to desired location
+            fs.chmodSync((0, setting_1.getCKBBinaryPath)(version), '755'); // Make the binary executable
+            console.log(`CKB ${version} installed successfully.`);
         }
         catch (error) {
             console.error('Error installing dependency binary:', error);
         }
     });
 }
-exports.downloadBinaryAndUnzip = downloadBinaryAndUnzip;
-function downloadAndSaveCKBBinary(tempFilePath) {
+exports.downloadCKBBinaryAndUnzip = downloadCKBBinaryAndUnzip;
+function downloadAndSaveCKBBinary(version, tempFilePath) {
     return __awaiter(this, void 0, void 0, function* () {
-        const downloadURL = buildDownloadUrl(MINIMAL_VERSION);
-        const response = yield axios_1.default.get(downloadURL, {
+        const downloadURL = buildDownloadUrl(version);
+        const response = yield request_1.Request.get(downloadURL, {
             responseType: 'arraybuffer',
         });
         fs.writeFileSync(tempFilePath, response.data);
@@ -136,9 +140,9 @@ function decompressTarGzAsync(tarballPath, destinationDir) {
     });
 }
 exports.decompressTarGzAsync = decompressTarGzAsync;
-function getInstalledVersion() {
+function getVersionFromBinary(binPath) {
     try {
-        const versionOutput = (0, child_process_1.execSync)(`${BINARY} --version`, {
+        const versionOutput = (0, child_process_1.execSync)(`${(0, encoding_1.encodeBinPathForTerminal)(binPath)} --version`, {
             encoding: 'utf-8',
         });
         const versionMatch = versionOutput.match(/(\d+\.\d+\.\d+)/);
@@ -151,11 +155,7 @@ function getInstalledVersion() {
         return null;
     }
 }
-exports.getInstalledVersion = getInstalledVersion;
-function isVersionOutdated(installedVersion) {
-    return semver_1.default.lt(installedVersion, MINIMAL_VERSION);
-}
-exports.isVersionOutdated = isVersionOutdated;
+exports.getVersionFromBinary = getVersionFromBinary;
 function getOS() {
     const platform = os_1.default.platform();
     if (platform === 'darwin') {

package/dist/scripts/gen.d.ts

@@ -0,0 +1,5 @@
+import { NetworkMyScripts, NetworkSystemScripts } from './type';
+export declare function genSystemScripts(): NetworkSystemScripts | null;
+export declare function genSystemScriptsJsonFile(filePath: string): void;
+export declare function genMyScripts(): NetworkMyScripts;
+export declare function genMyScriptsJsonFile(filePath: string): void;

package/dist/scripts/gen.js

@@ -0,0 +1,69 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genMyScriptsJsonFile = exports.genMyScripts = exports.genSystemScriptsJsonFile = exports.genSystemScripts = void 0;
+const fs = __importStar(require("fs"));
+const public_1 = __importDefault(require("./public"));
+const system_scripts_1 = require("../cmd/system-scripts");
+const path_1 = __importDefault(require("path"));
+const type_1 = require("../util/type");
+const util_1 = require("./util");
+function genSystemScripts() {
+    const devnetScripts = (0, system_scripts_1.getSystemScriptsFromListHashes)();
+    if (devnetScripts != null) {
+        const networkScripts = {
+            devnet: devnetScripts,
+            testnet: public_1.default.testnet,
+            mainnet: public_1.default.mainnet,
+        };
+        return networkScripts;
+    }
+    return null;
+}
+exports.genSystemScripts = genSystemScripts;
+function genSystemScriptsJsonFile(filePath) {
+    const scripts = genSystemScripts();
+    fs.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(scripts, null, 2));
+}
+exports.genSystemScriptsJsonFile = genSystemScriptsJsonFile;
+function genMyScripts() {
+    const networkMyScripts = {
+        devnet: (0, util_1.readUserDeployedScriptsInfo)(type_1.Network.devnet),
+        testnet: (0, util_1.readUserDeployedScriptsInfo)(type_1.Network.testnet),
+        mainnet: (0, util_1.readUserDeployedScriptsInfo)(type_1.Network.mainnet),
+    };
+    return networkMyScripts;
+}
+exports.genMyScripts = genMyScripts;
+function genMyScriptsJsonFile(filePath) {
+    const scripts = genMyScripts();
+    fs.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(scripts, null, 2));
+}
+exports.genMyScriptsJsonFile = genMyScriptsJsonFile;

package/dist/scripts/public.d.ts

@@ -0,0 +1,8 @@
+import { SystemScriptsRecord } from './type';
+export declare const TESTNET_SYSTEM_SCRIPTS: SystemScriptsRecord;
+export declare const MAINNET_SYSTEM_SCRIPTS: SystemScriptsRecord;
+declare const _default: {
+    testnet: SystemScriptsRecord;
+    mainnet: SystemScriptsRecord;
+};
+export default _default;