@offckb/cli 0.3.4 → 0.4.0-canary-113bf31.0

package/dist/tools/moleculec-es.js

@@ -1,100 +0,0 @@
-"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.MoleculecES = void 0;
-const path_1 = __importDefault(require("path"));
-const setting_1 = require("../cfg/setting");
-const install_1 = require("../node/install");
-const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
-const request_1 = require("../util/request");
-const encoding_1 = require("../util/encoding");
-class MoleculecES {
-    static isBinaryInstalled() {
-        return fs_1.default.existsSync(this.binPath);
-    }
-    static installMoleculeES(version) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const arch = getArch();
-            const osname = getOS();
-            const fileName = `moleculec-es-v${version}-${osname}-${arch}.tar.gz`;
-            try {
-                const tempFilePath = path_1.default.join(os_1.default.tmpdir(), fileName);
-                yield MoleculecES.downloadAndSaveMoleculeES(version, tempFilePath);
-                // Unzip the file
-                const extractDir = path_1.default.join((0, setting_1.readSettings)().tools.moleculeES.downloadPath, `molecule-es_v${version}`);
-                yield (0, install_1.unZipFile)(tempFilePath, extractDir, true);
-                // Install the extracted files
-                const sourcePath = path_1.default.join(extractDir, 'moleculec-es');
-                const targetPath = MoleculecES.binPath;
-                fs_1.default.mkdirSync(path_1.default.dirname(targetPath), { recursive: true });
-                fs_1.default.copyFileSync(sourcePath, targetPath);
-                fs_1.default.chmodSync(targetPath, '755'); // Make the binary executable
-                console.log(`Molecule-ES ${version} installed successfully.`);
-            }
-            catch (error) {
-                console.error('Error installing Molecule-ES:', error);
-            }
-        });
-    }
-    static get binPath() {
-        return path_1.default.join((0, setting_1.readSettings)().tools.moleculeES.binFolder, 'moleculec-es');
-    }
-    static get bin() {
-        return (0, encoding_1.encodeBinPathForTerminal)(this.binPath);
-    }
-    static downloadAndSaveMoleculeES(version, tempFilePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const downloadURL = MoleculecES.buildDownloadUrl(version);
-            const response = yield request_1.Request.send(downloadURL);
-            const arrayBuffer = yield response.arrayBuffer();
-            fs_1.default.writeFileSync(tempFilePath, Buffer.from(arrayBuffer));
-        });
-    }
-    static buildDownloadUrl(version) {
-        const osName = getOS();
-        const archName = getArch();
-        // https://github.com/nervosnetwork/moleculec-es/releases/download/0.4.6/moleculec-es_0.4.6_darwin_arm64.tar.gz
-        // https://github.com/nervosnetwork/moleculec-es/releases/download/0.4.6/moleculec-es_0.4.6_darwin_amd64.tar.gz
-        return `https://github.com/nervosnetwork/moleculec-es/releases/download/${version}/moleculec-es_${version}_${osName}_${archName}.tar.gz`;
-    }
-}
-exports.MoleculecES = MoleculecES;
-function getOS() {
-    const platform = os_1.default.platform();
-    if (platform === 'darwin') {
-        return 'darwin';
-    }
-    else if (platform === 'linux') {
-        return 'linux';
-    }
-    else if (platform === 'win32') {
-        return 'windows';
-    }
-    else {
-        throw new Error('Unsupported operating system');
-    }
-}
-function getArch() {
-    const arch = os_1.default.arch();
-    if (arch === 'x64') {
-        return 'amd64';
-    }
-    else if (arch === 'arm64') {
-        return 'arm64';
-    }
-    else {
-        throw new Error('Unsupported architecture');
-    }
-}

package/dist/tools/moleculec-go.d.ts

@@ -1,5 +0,0 @@
-export declare class MoleculecGo {
-    static isBinaryInstalled(): boolean;
-    static checkVersion(): boolean;
-    static installBinary(): void;
-}

package/dist/tools/moleculec-go.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoleculecGo = void 0;
-const child_process_1 = require("child_process");
-class MoleculecGo {
-    static isBinaryInstalled() {
-        const result = (0, child_process_1.spawnSync)('moleculec-go', ['--version'], { stdio: 'ignore' });
-        return result.status === 0 && this.checkVersion();
-    }
-    static checkVersion() {
-        // cmd: moleculec-go --version
-        // output: Moleculec Plugin 0.1.11
-        // check if the version is greater than or equal to 0.1.11
-        const result = (0, child_process_1.execSync)('moleculec-go --version').toString();
-        const version = result.split(' ')[2];
-        const versionNumber = version.split('.');
-        const major = parseInt(versionNumber[0]);
-        const minor = parseInt(versionNumber[1]);
-        const patch = parseInt(versionNumber[2]);
-        return major > 0 || (major === 0 && (minor > 1 || (minor === 1 && patch >= 11)));
-    }
-    static installBinary() {
-        const command = `cargo install moleculec-go`;
-        try {
-            console.log('Installing ckb-moleculec-go...');
-            (0, child_process_1.execSync)(command);
-            console.log('ckb-moleculec-go installed successfully.');
-        }
-        catch (error) {
-            console.error('Failed to install ckb-moleculec-go:', error);
-            process.exit(1);
-        }
-    }
-}
-exports.MoleculecGo = MoleculecGo;

package/dist/tools/moleculec-rust.d.ts

@@ -1,5 +0,0 @@
-export declare class MoleculecRust {
-    static isBinaryInstalled(): boolean;
-    static checkVersion(): boolean;
-    static installBinary(): void;
-}

package/dist/tools/moleculec-rust.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoleculecRust = void 0;
-const child_process_1 = require("child_process");
-class MoleculecRust {
-    static isBinaryInstalled() {
-        const result = (0, child_process_1.spawnSync)('moleculec', ['--version'], { stdio: 'ignore' });
-        return result.status === 0 && this.checkVersion();
-    }
-    static checkVersion() {
-        // cmd: moleculec --version
-        // output: Moleculec 0.8.0
-        // check if the version is greater than or equal to 0.8.0
-        const result = (0, child_process_1.execSync)('moleculec --version').toString();
-        const version = result.split(' ')[1];
-        const versionNumber = version.split('.');
-        const major = parseInt(versionNumber[0]);
-        const minor = parseInt(versionNumber[1]);
-        const patch = parseInt(versionNumber[2]);
-        return major > 0 || (major === 0 && (minor > 8 || (minor === 8 && patch >= 0)));
-    }
-    static installBinary() {
-        const command = `cargo install moleculec`;
-        try {
-            console.log('Installing ckb-moleculec...');
-            (0, child_process_1.execSync)(command);
-            console.log('ckb-moleculec installed successfully.');
-        }
-        catch (error) {
-            console.error('Failed to install ckb-moleculec:', error);
-            process.exit(1);
-        }
-    }
-}
-exports.MoleculecRust = MoleculecRust;

package/dist/tools/rpc-proxy.d.ts

@@ -1,7 +0,0 @@
-import http from 'http';
-import { Network } from '../type/base';
-export declare function createRPCProxy(network: Network, targetRpcUrl: string, port: number): {
-    network: Network;
-    start: () => http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    stop: () => http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-};

package/dist/tools/rpc-proxy.js

@@ -1,90 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRPCProxy = createRPCProxy;
-const http_proxy_1 = __importDefault(require("http-proxy"));
-const http_1 = __importDefault(require("http"));
-const base_1 = require("../type/base");
-const fs_1 = __importDefault(require("fs"));
-const setting_1 = require("../cfg/setting");
-const path_1 = __importDefault(require("path"));
-// todo: if we use import this throws error in tsc building
-const { cccA } = require('@ckb-ccc/core/advanced');
-function createRPCProxy(network, targetRpcUrl, port) {
-    const proxy = http_proxy_1.default.createProxyServer({
-        target: targetRpcUrl, // Target RPC server
-    });
-    proxy.on('proxyReq', (_, req) => {
-        let reqData = '';
-        req.on('data', (chunk) => {
-            reqData += chunk;
-        });
-        req.on('end', () => {
-            try {
-                const jsonRpcContent = JSON.parse(reqData);
-                const method = jsonRpcContent.method;
-                const params = jsonRpcContent.params;
-                console.debug('RPC Req: ', method);
-                if (method === 'send_transaction') {
-                    const tx = params[0];
-                    // todo: record tx
-                    if (network === base_1.Network.devnet) {
-                        const cccTx = cccA.JsonRpcTransformers.transactionTo(tx);
-                        const txHash = cccTx.hash();
-                        const settings = (0, setting_1.readSettings)();
-                        if (!fs_1.default.existsSync(settings.devnet.transactionsPath)) {
-                            fs_1.default.mkdirSync(settings.devnet.transactionsPath);
-                        }
-                        const txFile = path_1.default.resolve(settings.devnet.transactionsPath, `${txHash}.json`);
-                        fs_1.default.writeFileSync(txFile, JSON.stringify(tx, null, 2));
-                        console.debug(`RPC Req:  store tx ${txHash}`);
-                    }
-                }
-            }
-            catch (err) {
-                console.error('Error parsing JSON-RPC content:', err);
-            }
-        });
-    });
-    proxy.on('proxyRes', function (proxyRes, _req, _res) {
-        const body = [];
-        proxyRes.on('data', function (chunk) {
-            body.push(chunk);
-        });
-        proxyRes.on('end', function () {
-            const res = Buffer.concat(body).toString();
-            try {
-                const jsonRpcResponse = JSON.parse(res);
-                const error = jsonRpcResponse.error;
-                if (error) {
-                    console.debug('RPC Response: ', jsonRpcResponse);
-                }
-            }
-            catch (err) {
-                console.error('Error parsing JSON-RPC content:', err);
-            }
-        });
-    });
-    const server = http_1.default.createServer((req, res) => {
-        proxy.web(req, res, {}, (err) => {
-            if (err) {
-                console.error('Proxy error:', err);
-                res.writeHead(500, { 'Content-Type': 'text/plain' });
-                res.end('Proxy error');
-            }
-        });
-    });
-    return {
-        network,
-        start: () => {
-            return server.listen(port, () => {
-                console.debug(`CKB ${network} RPC Proxy server running on http://localhost:${port}`);
-            });
-        },
-        stop: () => {
-            return server.close();
-        },
-    };
-}

package/dist/type/base.d.ts

@@ -1,11 +0,0 @@
-export declare enum Network {
-    devnet = "devnet",
-    testnet = "testnet",
-    mainnet = "mainnet"
-}
-export interface NetworkOption {
-    network: Network;
-}
-export type H256 = string;
-export type HexString = string;
-export type HexNumber = string;

package/dist/type/base.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Network = void 0;
-// network
-var Network;
-(function (Network) {
-    Network["devnet"] = "devnet";
-    Network["testnet"] = "testnet";
-    Network["mainnet"] = "mainnet";
-})(Network || (exports.Network = Network = {}));

package/dist/util/encoding.d.ts

@@ -1,2 +0,0 @@
-export declare function setUTF8EncodingForWindows(): void;
-export declare function encodeBinPathForTerminal(path: string): string;

package/dist/util/encoding.js

@@ -1,24 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setUTF8EncodingForWindows = setUTF8EncodingForWindows;
-exports.encodeBinPathForTerminal = encodeBinPathForTerminal;
-const child_process_1 = require("child_process");
-const os_1 = __importDefault(require("os"));
-function setUTF8EncodingForWindows() {
-    if (os_1.default.platform() === 'win32') {
-        try {
-            (0, child_process_1.execSync)('chcp 65001');
-        }
-        catch (error) {
-            console.error('Failed to set UTF-8 encoding for Windows terminal.', error.message);
-        }
-    }
-}
-function encodeBinPathForTerminal(path) {
-    // some path contains space in the string
-    // this fix the space in the terminal
-    return `"${path}"`;
-}

package/dist/util/fs.d.ts

@@ -1,13 +0,0 @@
-export declare function isFolderExists(folderPath: string): boolean;
-export declare function copyFolderSync(source: string, destination: string): void;
-export declare function copyFileSync(source: string, target: string): void;
-export declare function copyFilesWithExclusion(sourceDir: string, destinationDir: string, excludedFolders: string[]): Promise<void>;
-export declare function copyRecursive(source: string, destination: string, excludedFolders: string[]): Promise<void>;
-export declare function readFileToUint8Array(filePath: string): Promise<Uint8Array>;
-export declare function getBinaryFilesFromPath(fileOrFolderPath: string): string[];
-export declare function listBinaryFilesInFolder(folderPath: string): string[];
-export declare function isBinaryFile(filePath: string): boolean;
-export declare function getBinaryFileSizeInBytes(filePath: string): number;
-export declare function isAbsolutePath(filePath: string): boolean;
-export declare function findFileInFolder(folderPath: string, fileName: string): string | null;
-export declare function getSubfolders(folderPath: string): string[];

package/dist/util/fs.js

@@ -1,218 +0,0 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFolderExists = isFolderExists;
-exports.copyFolderSync = copyFolderSync;
-exports.copyFileSync = copyFileSync;
-exports.copyFilesWithExclusion = copyFilesWithExclusion;
-exports.copyRecursive = copyRecursive;
-exports.readFileToUint8Array = readFileToUint8Array;
-exports.getBinaryFilesFromPath = getBinaryFilesFromPath;
-exports.listBinaryFilesInFolder = listBinaryFilesInFolder;
-exports.isBinaryFile = isBinaryFile;
-exports.getBinaryFileSizeInBytes = getBinaryFileSizeInBytes;
-exports.isAbsolutePath = isAbsolutePath;
-exports.findFileInFolder = findFileInFolder;
-exports.getSubfolders = getSubfolders;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-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;
-    }
-}
-function copyFolderSync(source, destination) {
-    if (!fs.existsSync(destination)) {
-        fs.mkdirSync(destination, { recursive: true });
-    }
-    const files = fs.readdirSync(source);
-    for (const file of files) {
-        const currentPath = path.join(source, file);
-        const destinationPath = path.join(destination, file);
-        if (fs.statSync(currentPath).isDirectory()) {
-            copyFolderSync(currentPath, destinationPath);
-        }
-        else {
-            fs.copyFileSync(currentPath, destinationPath);
-        }
-    }
-}
-function copyFileSync(source, target) {
-    let targetFile = target;
-    // If target is a directory, a new file with the same name will be created
-    if (fs.existsSync(target)) {
-        if (fs.lstatSync(target).isDirectory()) {
-            targetFile = path.join(target, path.basename(source));
-        }
-    }
-    fs.writeFileSync(targetFile, fs.readFileSync(source));
-}
-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.join(source, file);
-            const destPath = path.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);
-            }
-        }
-    });
-}
-function readFileToUint8Array(filePath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return new Promise((resolve, reject) => {
-            fs.readFile(filePath, (err, data) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve(new Uint8Array(data));
-            });
-        });
-    });
-}
-function getBinaryFilesFromPath(fileOrFolderPath) {
-    if (!fs.existsSync(fileOrFolderPath)) {
-        throw new Error(`File or Folder not exits ${fileOrFolderPath}`);
-    }
-    // Check if the provided path is a directory
-    if (fs.lstatSync(fileOrFolderPath).isDirectory()) {
-        return listBinaryFilesInFolder(fileOrFolderPath);
-    }
-    if (fs.lstatSync(fileOrFolderPath).isFile() && isBinaryFile(fileOrFolderPath)) {
-        return [fileOrFolderPath];
-    }
-    throw new Error(`${fileOrFolderPath} is not a valid path to deploy scripts.`);
-}
-function listBinaryFilesInFolder(folderPath) {
-    // Check if the provided path is a directory
-    if (!fs.existsSync(folderPath) || !fs.lstatSync(folderPath).isDirectory()) {
-        throw new Error(`${folderPath} is not a valid directory.`);
-    }
-    // Read the contents of the directory
-    const files = fs.readdirSync(folderPath).map((f) => path.join(folderPath, f));
-    // Filter out only the binary files (assuming they have extensions like .exe, .bin, .dll, etc.)
-    const binaryFiles = files.filter((file) => fs.statSync(file).isFile() && isBinaryFile(file));
-    return binaryFiles;
-}
-// Function to check if a file is binary
-function isBinaryFile(filePath) {
-    const buffer = fs.readFileSync(filePath);
-    for (let i = 0; i < buffer.length; i++) {
-        // If any byte has a value greater than 127, it's likely a binary file
-        if (buffer[i] > 127) {
-            return true;
-        }
-    }
-    return false;
-}
-function getBinaryFileSizeInBytes(filePath) {
-    const stats = fs.statSync(filePath);
-    return stats.size;
-}
-function isAbsolutePath(filePath) {
-    return path.isAbsolute(filePath);
-}
-function findFileInFolder(folderPath, fileName) {
-    const files = fs.readdirSync(folderPath);
-    for (const file of files) {
-        const filePath = path.join(folderPath, file);
-        const stats = fs.statSync(filePath);
-        if (stats.isDirectory()) {
-            const foundFilePath = findFileInFolder(filePath, fileName);
-            if (foundFilePath) {
-                return foundFilePath;
-            }
-        }
-        else if (file === fileName) {
-            return filePath;
-        }
-    }
-    return null;
-}
-function getSubfolders(folderPath) {
-    return fs.readdirSync(folderPath).filter((file) => {
-        const fullPath = path.join(folderPath, file);
-        return fs.statSync(fullPath).isDirectory();
-    });
-}

package/dist/util/git.d.ts

@@ -1,2 +0,0 @@
-export declare function isGitInstalled(): boolean;
-export declare function gitCloneAndDownloadFolderSync(repoUrl: string, branch: string, subFolderName: string, targetPath: string): undefined;