@offckb/cli 0.1.0-rc1

package/dist/cmd/genkey.js

@@ -0,0 +1,146 @@
+"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 __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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printIssueSectionForToml = exports.genAccount = exports.buildAccounts = exports.genkey = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const const_1 = require("../cfg/const");
+const lumos_1 = require("@ckb-lumos/lumos");
+const readline = __importStar(require("readline"));
+const build_lumos_config_1 = require("./build-lumos-config");
+function genkey() {
+    const numKeys = 20; // Number of keys to generate
+    const keyLength = 64; // Length of each key
+    generateKeysFile(numKeys, keyLength);
+    console.log(`Generated ${numKeys} keys in keys file.`);
+}
+exports.genkey = genkey;
+function generateHex(length) {
+    const characters = 'abcdef0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters[Math.floor(Math.random() * characters.length)];
+    }
+    return result;
+}
+function generateKeysFile(numKeys, keyLength) {
+    const targetDir = path.join(const_1.accountTargetDir, `keys`);
+    const stream = fs.createWriteStream(targetDir);
+    for (let i = 0; i < numKeys; i++) {
+        const key = generateHex(keyLength);
+        stream.write(key + '\n');
+    }
+    stream.end();
+}
+function buildAccounts() {
+    var _a, e_1, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const keysDir = path.join(const_1.accountTargetDir, `keys`);
+        // Create a Readable stream from the file
+        const fileStream = fs.createReadStream(keysDir);
+        // Create an interface for reading data from the stream line by line
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity, // Specify Infinity to read all lines without removing newlines
+        });
+        const accounts = [];
+        try {
+            // Read each line from the file
+            for (var _d = true, rl_1 = __asyncValues(rl), rl_1_1; rl_1_1 = yield rl_1.next(), _a = rl_1_1.done, !_a; _d = true) {
+                _c = rl_1_1.value;
+                _d = false;
+                const line = _c;
+                const privkey = `0x${line}`;
+                const account = genAccount(privkey);
+                accounts.push(account);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = rl_1.return)) yield _b.call(rl_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        const accountDir = path.join(const_1.accountTargetDir, `account.json`);
+        fs.writeFile(accountDir, JSON.stringify(accounts, null, 2), 'utf8', (err) => {
+            if (err) {
+                return console.error('Error writing file:', err);
+            }
+        });
+    });
+}
+exports.buildAccounts = buildAccounts;
+function genAccount(privkey) {
+    const pubkey = lumos_1.hd.key.privateToPublic(privkey);
+    const args = lumos_1.hd.key.publicKeyToBlake160(pubkey);
+    const template = build_lumos_config_1.devnetConfig.SCRIPTS['SECP256K1_BLAKE160'];
+    const lockScript = {
+        codeHash: template.CODE_HASH,
+        hashType: template.HASH_TYPE,
+        args: args,
+    };
+    const address = lumos_1.helpers.encodeToAddress(lockScript, {
+        config: build_lumos_config_1.devnetConfig,
+    });
+    return {
+        privkey,
+        pubkey,
+        lockScript,
+        address,
+        args,
+    };
+}
+exports.genAccount = genAccount;
+function printIssueSectionForToml() {
+    const config = require('../../account/account.json');
+    for (const account of config) {
+        const section = `# issue for account private key: ${account.privkey}
+[[genesis.issued_cells]]
+capacity = 42_000_000_00000000
+lock.code_hash = "${account.lockScript.codeHash}"
+lock.args = "${account.lockScript.args}"
+lock.hash_type = "${account.lockScript.hashType}"
+    `;
+        console.log(section);
+    }
+}
+exports.printIssueSectionForToml = printIssueSectionForToml;

package/dist/cmd/init-chain.d.ts

@@ -0,0 +1 @@
+export declare function initChainIfNeeded(): Promise<void>;

package/dist/cmd/init-chain.js

@@ -0,0 +1,118 @@
+"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 __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 = __importStar(require("fs"));
+const const_1 = require("../cfg/const");
+const path_1 = __importDefault(require("path"));
+const util_1 = require("../util");
+function initChainIfNeeded() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(0, util_1.isFolderExists)(const_1.devnetPath)) {
+            yield doInitChain();
+        }
+    });
+}
+exports.initChainIfNeeded = initChainIfNeeded;
+function doInitChain() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield copyFilesWithExclusion(const_1.devnetSourcePath, const_1.devnetPath, ['data']);
+        console.debug(`init devnet config folder: ${const_1.devnetPath}`);
+        copyAndEditMinerToml();
+    });
+}
+function copyAndEditMinerToml() {
+    const minerToml = path_1.default.join(const_1.devnetSourcePath, 'ckb-miner.toml');
+    const newMinerToml = path_1.default.join(const_1.devnetPath, 'ckb-miner.toml');
+    // Read the content of the ckb-miner.toml file
+    fs.readFile(minerToml, 'utf8', (err, data) => {
+        if (err) {
+            return console.error('Error reading file:', err);
+        }
+        // Replace the URL
+        const modifiedData = data.replace('http://ckb:8114/', 'http://localhost:8114');
+        // Write the modified content back to the file
+        fs.writeFile(newMinerToml, modifiedData, 'utf8', (err) => {
+            if (err) {
+                return console.error('Error writing file:', err);
+            }
+            console.debug('modified ', newMinerToml);
+        });
+    });
+}
+function copyFilesWithExclusion(sourceDir, destinationDir, excludedFolders) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Ensure the destination directory exists
+            yield fs.promises.mkdir(destinationDir, { recursive: true });
+            // Start copying recursively from the source directory
+            yield copyRecursive(sourceDir, destinationDir, excludedFolders);
+        }
+        catch (error) {
+            console.error('An error occurred during copying files:', error);
+        }
+    });
+}
+// Function to recursively copy files and directories
+function copyRecursive(source, destination, excludedFolders) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Get a list of all files and directories in the source directory
+        const files = yield fs.promises.readdir(source);
+        // Iterate through each file or directory
+        for (const file of files) {
+            const sourcePath = path_1.default.join(source, file);
+            const destPath = path_1.default.join(destination, file);
+            // Get the file's stats
+            const stats = yield fs.promises.stat(sourcePath);
+            // If it's a directory, recursively copy it (unless it's excluded)
+            if (stats.isDirectory()) {
+                if (excludedFolders.includes(file)) {
+                    // Skipping directory: ${sourcePath}
+                }
+                else {
+                    // Ensure destination directory exists before copying
+                    yield fs.promises.mkdir(destPath, { recursive: true });
+                    yield copyRecursive(sourcePath, destPath, excludedFolders);
+                }
+            }
+            else {
+                // Otherwise, copy the file
+                yield fs.promises.copyFile(sourcePath, destPath);
+            }
+        }
+    });
+}

package/dist/cmd/init.d.ts

@@ -0,0 +1 @@
+export declare function init(name: string): void;

package/dist/cmd/init.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const child_process_1 = require("child_process");
+const const_1 = require("../cfg/const");
+const path_1 = __importDefault(require("path"));
+function init(name) {
+    const targetPath = path_1.default.resolve(const_1.currentExecPath, name);
+    (0, child_process_1.execSync)(`cp -r ${const_1.dappTemplatePath} ${targetPath}`);
+    console.log(`init CKB dapp project with lumos: ${targetPath}`);
+}
+exports.init = init;

package/dist/cmd/install.d.ts

@@ -0,0 +1 @@
+export declare function installDependency(): Promise<void>;

package/dist/cmd/install.js

@@ -0,0 +1,140 @@
+"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 __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.installDependency = void 0;
+const axios_1 = __importDefault(require("axios"));
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const os_1 = __importDefault(require("os"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+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() {
+    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}..`);
+                console.log(buildDownloadUrl(MINIMAL_VERSION));
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            console.log(`${BINARY} not found, download and install the new version ${MINIMAL_VERSION}..`);
+        }
+        const arch = getArch();
+        const osname = getOS();
+        const ckbVersionOSName = `ckb_v${MINIMAL_VERSION}_${arch}-${osname}`;
+        try {
+            const downloadURL = buildDownloadUrl(MINIMAL_VERSION);
+            const response = yield axios_1.default.get(downloadURL, {
+                responseType: 'arraybuffer',
+            });
+            const tempFilePath = path.join(os_1.default.tmpdir(), `${ckbVersionOSName}.zip`);
+            fs.writeFileSync(tempFilePath, response.data);
+            // Unzip the file
+            const zip = new adm_zip_1.default(tempFilePath);
+            const extractDir = path.join(const_1.targetEnvironmentPath, `ckb_v${MINIMAL_VERSION}`);
+            zip.extractAllTo(extractDir, /*overwrite*/ true);
+            const sourcePath = path.join(extractDir, ckbVersionOSName);
+            // Install the extracted files
+            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.');
+        }
+        catch (error) {
+            console.error('Error installing dependency binary:', error);
+        }
+    });
+}
+exports.installDependency = installDependency;
+function getInstalledVersion() {
+    try {
+        const versionOutput = (0, child_process_1.execSync)(`${BINARY} --version`, {
+            encoding: 'utf-8',
+        });
+        const versionMatch = versionOutput.match(/(\d+\.\d+\.\d+)/);
+        if (versionMatch) {
+            return versionMatch[0];
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+function isVersionOutdated(installedVersion) {
+    return semver_1.default.lt(installedVersion, MINIMAL_VERSION);
+}
+function getOS() {
+    const platform = os_1.default.platform();
+    if (platform === 'darwin') {
+        return 'apple-darwin';
+    }
+    else if (platform === 'linux') {
+        return 'unknown-linux-gnu';
+    }
+    else if (platform === 'win32') {
+        return 'pc-windows-msvc';
+    }
+    else {
+        throw new Error('Unsupported operating system');
+    }
+}
+function getArch() {
+    const arch = os_1.default.arch();
+    if (arch === 'x64') {
+        return 'x86_64';
+    }
+    else if (arch === 'arm64') {
+        return 'aarch64';
+    }
+    else {
+        throw new Error('Unsupported architecture');
+    }
+}
+function buildDownloadUrl(version) {
+    const os = getOS();
+    const arch = getArch();
+    return `https://github.com/nervosnetwork/ckb/releases/download/v${version}/ckb_v${version}_${arch}-${os}.zip`;
+}

package/dist/cmd/list-hashes.d.ts

@@ -0,0 +1 @@
+export declare function listHashes(): Promise<void>;

package/dist/cmd/list-hashes.js

@@ -0,0 +1,32 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listHashes = void 0;
+const child_process_1 = require("child_process");
+const const_1 = require("../cfg/const");
+const install_1 = require("./install");
+const init_chain_1 = require("./init-chain");
+function listHashes() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, install_1.installDependency)();
+        yield (0, init_chain_1.initChainIfNeeded)();
+        const cmd = `${const_1.ckbBinPath} list-hashes  -C ${const_1.devnetPath}`;
+        try {
+            (0, child_process_1.execSync)(cmd, {
+                stdio: 'inherit',
+            });
+        }
+        catch (error) {
+            console.error('Error running dependency binary:', error);
+        }
+    });
+}
+exports.listHashes = listHashes;

package/dist/cmd/node.d.ts

@@ -0,0 +1 @@
+export declare function node(): Promise<void>;

package/dist/cmd/node.js

@@ -0,0 +1,57 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.node = void 0;
+const child_process_1 = require("child_process");
+const const_1 = require("../cfg/const");
+const init_chain_1 = require("./init-chain");
+const install_1 = require("./install");
+function node() {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, install_1.installDependency)();
+        yield (0, init_chain_1.initChainIfNeeded)();
+        const ckbCmd = `${const_1.ckbBinPath} run -C ${const_1.devnetPath}`;
+        const minerCmd = `${const_1.ckbBinPath} miner -C ${const_1.devnetPath}`;
+        try {
+            // Run first command
+            const ckbProcess = (0, child_process_1.exec)(ckbCmd);
+            // Log first command's output
+            (_a = ckbProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                console.log('CKB output:', data.toString());
+            });
+            (_b = ckbProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+                console.error('CKB error:', data.toString());
+            });
+            // Start the second command after 3 seconds
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                var _c, _d;
+                try {
+                    // Run second command
+                    const minerProcess = (0, child_process_1.exec)(minerCmd);
+                    (_c = minerProcess.stdout) === null || _c === void 0 ? void 0 : _c.on('data', (data) => {
+                        console.log('CKB-Miner:', data.toString());
+                    });
+                    (_d = minerProcess.stderr) === null || _d === void 0 ? void 0 : _d.on('data', (data) => {
+                        console.error('CKB-Miner error:', data.toString());
+                    });
+                }
+                catch (error) {
+                    console.error('Error running CKB-Miner:', error);
+                }
+            }), 3000);
+        }
+        catch (error) {
+            console.error('Error:', error);
+        }
+    });
+}
+exports.node = node;

package/dist/util.d.ts

@@ -0,0 +1 @@
+export declare function isFolderExists(folderPath: string): boolean;

package/dist/util.js

@@ -0,0 +1,41 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFolderExists = void 0;
+const fs = __importStar(require("fs"));
+function isFolderExists(folderPath) {
+    try {
+        // Check if the path exists
+        fs.accessSync(folderPath, fs.constants.F_OK);
+        // Check if it's a directory
+        const stats = fs.statSync(folderPath);
+        return stats.isDirectory();
+    }
+    catch (error) {
+        // If the access or stat fails, or if it's not a directory, return false
+        return false;
+    }
+}
+exports.isFolderExists = isFolderExists;

package/docker/devnet/check-ckb-started-successfully.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+while true; do
+    sleep 1
+
+    echo '{
+        "id": 2,
+        "jsonrpc": "2.0",
+        "method": "get_tip_block_number",
+        "params": []
+    }' \
+    | tr -d '\n' \
+    | curl -H 'content-type: application/json' -d @- \
+    http://ckb:8114
+
+    if [ $? -eq 0 ]; then
+        break
+    fi
+done
+
+exit 0

package/docker/devnet/ckb-miner.toml

@@ -0,0 +1,43 @@
+# Config generated by `ckb init --chain dev`
+
+data_dir = "data"
+
+[chain]
+# Choose the kind of chains to run, possible values:
+# - { file = "specs/dev.toml" }
+# - { bundled = "specs/testnet.toml" }
+# - { bundled = "specs/mainnet.toml" }
+spec = { file = "specs/dev.toml" }
+
+[logger]
+filter = "info"
+color = true
+log_to_file = true
+log_to_stdout = true
+
+[sentry]
+# set to blank to disable sentry error collection
+dsn = ""
+# if you are willing to help us to improve,
+# please leave a way to contact you when we have troubles to reproduce the errors.
+# org_contact = ""
+
+# # **Experimental** Monitor memory changes.
+# [memory_tracker]
+# # Seconds between checking the process, 0 is disable, default is 0.
+# interval = 600
+
+[miner.client]
+rpc_url = "http://ckb:8114/"
+block_on_submit = true
+
+# block template polling interval in milliseconds
+poll_interval = 1000
+
+# enable listen notify mode
+# listen = "127.0.0.1:8888"
+
+[[miner.workers]]
+worker_type = "Dummy"
+delay_type = "Constant"
+value = 5000