@offckb/cli 0.1.1 → 0.1.2-canary-a369f24.0

package/dist/util/ckb.js

@@ -0,0 +1,299 @@
+"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 __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.CKB = void 0;
+const lumos_1 = require("@ckb-lumos/lumos");
+const base_1 = require("@ckb-lumos/base");
+const codec_1 = require("@ckb-lumos/codec");
+const config_1 = require("./config");
+const validator_1 = require("./validator");
+const type_1 = require("./type");
+const { ScriptValue } = base_1.values;
+const networks = {
+    devnet: {
+        rpc_url: 'http://127.0.0.1:8114',
+        rpc: new lumos_1.RPC('http://127.0.0.1:8114'),
+        indexer: new lumos_1.Indexer('http://127.0.0.1:8114'),
+    },
+    testnet: {
+        rpc_url: 'https://testnet.ckb.dev/rpc',
+        rpc: new lumos_1.RPC('https://testnet.ckb.dev/rpc'),
+        indexer: new lumos_1.Indexer('https://testnet.ckb.dev/rpc'),
+    },
+    mainnet: {
+        rpc_url: 'https://mainnet.ckb.dev/rpc',
+        rpc: new lumos_1.RPC('https://mainnet.ckb.dev/rpc'),
+        indexer: new lumos_1.Indexer('https://mainnet.ckb.dev/rpc'),
+    },
+};
+class CKB {
+    constructor(network = type_1.Network.devnet) {
+        if (!(0, validator_1.isValidNetworkString)(network)) {
+            throw new Error('invalid network option');
+        }
+        this.network = network;
+        this.rpc_url = networks[network].rpc_url;
+        this.rpc = networks[network].rpc;
+        this.indexer = networks[network].indexer;
+    }
+    static generateAccountFromPrivateKey(privKey, lumosConfig) {
+        const pubKey = lumos_1.hd.key.privateToPublic(privKey);
+        const args = lumos_1.hd.key.publicKeyToBlake160(pubKey);
+        const template = lumosConfig.SCRIPTS['SECP256K1_BLAKE160'];
+        const lockScript = {
+            codeHash: template.CODE_HASH,
+            hashType: template.HASH_TYPE,
+            args: args,
+        };
+        const address = lumos_1.helpers.encodeToAddress(lockScript, { config: lumosConfig });
+        return {
+            lockScript,
+            address,
+            pubKey,
+            privKey,
+        };
+    }
+    getLumosConfig() {
+        if (this.network === type_1.Network.devnet) {
+            return (0, config_1.readPredefinedDevnetLumosConfig)();
+        }
+        if (this.network === type_1.Network.testnet) {
+            return lumos_1.config.predefined.AGGRON4;
+        }
+        return lumos_1.config.predefined.LINA;
+    }
+    initializedLumosConfig() {
+        return lumos_1.config.initializeConfig(this.getLumosConfig());
+    }
+    capacityOf(address, lumosConfig) {
+        var _a, e_1, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const collector = this.indexer.collector({
+                lock: lumos_1.helpers.parseAddress(address, { config: lumosConfig }),
+            });
+            let balance = lumos_1.BI.from(0);
+            try {
+                for (var _d = true, _e = __asyncValues(collector.collect()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const cell = _c;
+                    balance = balance.add(cell.cellOutput.capacity);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return balance;
+        });
+    }
+    transfer(options, lumosConfig) {
+        var _a, e_2, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let txSkeleton = lumos_1.helpers.TransactionSkeleton({});
+            const fromScript = lumos_1.helpers.parseAddress(options.from, {
+                config: lumosConfig,
+            });
+            const toScript = lumos_1.helpers.parseAddress(options.to, { config: lumosConfig });
+            if (lumos_1.BI.from(options.amount).lt(lumos_1.BI.from('6100000000'))) {
+                throw new Error(`every cell's capacity must be at least 61 CKB, see https://medium.com/nervosnetwork/understanding-the-nervos-dao-and-cell-model-d68f38272c24`);
+            }
+            // additional 0.001 ckb for tx fee
+            // the tx fee could calculated by tx size
+            // this is just a simple example
+            const neededCapacity = lumos_1.BI.from(options.amount).add(100000);
+            let collectedSum = lumos_1.BI.from(0);
+            const collected = [];
+            const collector = this.indexer.collector({ lock: fromScript, type: 'empty' });
+            try {
+                for (var _d = true, _e = __asyncValues(collector.collect()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const cell = _c;
+                    collectedSum = collectedSum.add(cell.cellOutput.capacity);
+                    collected.push(cell);
+                    if (collectedSum >= neededCapacity)
+                        break;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            if (collectedSum.lt(neededCapacity)) {
+                throw new Error(`Not enough CKB, ${collectedSum} < ${neededCapacity}`);
+            }
+            const transferOutput = {
+                cellOutput: {
+                    capacity: lumos_1.BI.from(options.amount).toHexString(),
+                    lock: toScript,
+                },
+                data: '0x',
+            };
+            const changeOutput = {
+                cellOutput: {
+                    capacity: collectedSum.sub(neededCapacity).toHexString(),
+                    lock: fromScript,
+                },
+                data: '0x',
+            };
+            txSkeleton = txSkeleton.update('inputs', (inputs) => inputs.push(...collected));
+            txSkeleton = txSkeleton.update('outputs', (outputs) => outputs.push(transferOutput, changeOutput));
+            txSkeleton = txSkeleton.update('cellDeps', (cellDeps) => cellDeps.push({
+                outPoint: {
+                    txHash: lumosConfig.SCRIPTS.SECP256K1_BLAKE160.TX_HASH,
+                    index: lumosConfig.SCRIPTS.SECP256K1_BLAKE160.INDEX,
+                },
+                depType: lumosConfig.SCRIPTS.SECP256K1_BLAKE160.DEP_TYPE,
+            }));
+            const firstIndex = txSkeleton
+                .get('inputs')
+                .findIndex((input) => new ScriptValue(input.cellOutput.lock, { validate: false }).equals(new ScriptValue(fromScript, { validate: false })));
+            if (firstIndex !== -1) {
+                while (firstIndex >= txSkeleton.get('witnesses').size) {
+                    txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.push('0x'));
+                }
+                let witness = txSkeleton.get('witnesses').get(firstIndex);
+                const newWitnessArgs = {
+                    /* 65-byte zeros in hex */
+                    lock: '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+                };
+                if (witness !== '0x') {
+                    const witnessArgs = base_1.blockchain.WitnessArgs.unpack(codec_1.bytes.bytify(witness));
+                    const lock = witnessArgs.lock;
+                    if (!!lock && !!newWitnessArgs.lock && !codec_1.bytes.equal(lock, newWitnessArgs.lock)) {
+                        throw new Error('Lock field in first witness is set aside for signature!');
+                    }
+                    const inputType = witnessArgs.inputType;
+                    if (inputType) {
+                        newWitnessArgs.inputType = inputType;
+                    }
+                    const outputType = witnessArgs.outputType;
+                    if (outputType) {
+                        newWitnessArgs.outputType = outputType;
+                    }
+                }
+                witness = codec_1.bytes.hexify(base_1.blockchain.WitnessArgs.pack(newWitnessArgs));
+                txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.set(firstIndex, witness));
+            }
+            txSkeleton = lumos_1.commons.common.prepareSigningEntries(txSkeleton);
+            const message = txSkeleton.get('signingEntries').get(0).message;
+            const Sig = lumos_1.hd.key.signRecoverable(message, options.privKey);
+            const tx = lumos_1.helpers.sealTransaction(txSkeleton, [Sig]);
+            const hash = yield this.rpc.sendTransaction(tx, 'passthrough');
+            return hash;
+        });
+    }
+    transferAll(privateKey, toAddress, lumosConfig) {
+        var _a, e_3, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let txSkeleton = lumos_1.helpers.TransactionSkeleton({});
+            const from = CKB.generateAccountFromPrivateKey(privateKey, lumosConfig);
+            const fromScript = from.lockScript;
+            const toScript = lumos_1.helpers.parseAddress(toAddress, { config: lumosConfig });
+            const balance = yield this.capacityOf(from.address, lumosConfig);
+            // additional 0.001 ckb for tx fee
+            // the tx fee could calculated by tx size
+            // this is just a simple example
+            const neededCapacity = balance.sub(100000);
+            let collectedSum = lumos_1.BI.from(0);
+            const collected = [];
+            const collector = this.indexer.collector({ lock: fromScript, type: 'empty' });
+            try {
+                for (var _d = true, _e = __asyncValues(collector.collect()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const cell = _c;
+                    collectedSum = collectedSum.add(cell.cellOutput.capacity);
+                    collected.push(cell);
+                    if (collectedSum >= neededCapacity)
+                        break;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            if (collectedSum.lt(neededCapacity)) {
+                throw new Error(`Not enough CKB, ${collectedSum} < ${neededCapacity}`);
+            }
+            const transferOutput = {
+                cellOutput: {
+                    capacity: neededCapacity.toHexString(),
+                    lock: toScript,
+                },
+                data: '0x',
+            };
+            txSkeleton = txSkeleton.update('inputs', (inputs) => inputs.push(...collected));
+            txSkeleton = txSkeleton.update('outputs', (outputs) => outputs.push(transferOutput));
+            txSkeleton = txSkeleton.update('cellDeps', (cellDeps) => cellDeps.push({
+                outPoint: {
+                    txHash: lumosConfig.SCRIPTS.SECP256K1_BLAKE160.TX_HASH,
+                    index: lumosConfig.SCRIPTS.SECP256K1_BLAKE160.INDEX,
+                },
+                depType: lumosConfig.SCRIPTS.SECP256K1_BLAKE160.DEP_TYPE,
+            }));
+            const firstIndex = txSkeleton
+                .get('inputs')
+                .findIndex((input) => new ScriptValue(input.cellOutput.lock, { validate: false }).equals(new ScriptValue(fromScript, { validate: false })));
+            if (firstIndex !== -1) {
+                while (firstIndex >= txSkeleton.get('witnesses').size) {
+                    txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.push('0x'));
+                }
+                let witness = txSkeleton.get('witnesses').get(firstIndex);
+                const newWitnessArgs = {
+                    /* 65-byte zeros in hex */
+                    lock: '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+                };
+                if (witness !== '0x') {
+                    const witnessArgs = base_1.blockchain.WitnessArgs.unpack(codec_1.bytes.bytify(witness));
+                    const lock = witnessArgs.lock;
+                    if (!!lock && !!newWitnessArgs.lock && !codec_1.bytes.equal(lock, newWitnessArgs.lock)) {
+                        throw new Error('Lock field in first witness is set aside for signature!');
+                    }
+                    const inputType = witnessArgs.inputType;
+                    if (inputType) {
+                        newWitnessArgs.inputType = inputType;
+                    }
+                    const outputType = witnessArgs.outputType;
+                    if (outputType) {
+                        newWitnessArgs.outputType = outputType;
+                    }
+                }
+                witness = codec_1.bytes.hexify(base_1.blockchain.WitnessArgs.pack(newWitnessArgs));
+                txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.set(firstIndex, witness));
+            }
+            txSkeleton = lumos_1.commons.common.prepareSigningEntries(txSkeleton);
+            const message = txSkeleton.get('signingEntries').get(0).message;
+            const Sig = lumos_1.hd.key.signRecoverable(message, privateKey);
+            const tx = lumos_1.helpers.sealTransaction(txSkeleton, [Sig]);
+            const hash = yield this.rpc.sendTransaction(tx, 'passthrough');
+            return hash;
+        });
+    }
+}
+exports.CKB = CKB;

package/dist/util/config.d.ts

@@ -0,0 +1,8 @@
+import { config } from '@ckb-lumos/lumos';
+import { Network } from './type';
+export declare function updateScriptInfoInOffCKBConfigTs(newConfig: config.Config, filePath: string, network: Network): void;
+export declare function readUserDeployedScriptsInfo(network: Network): Record<string, config.ScriptConfig>;
+export declare function readPredefinedDevnetLumosConfig(): config.Config;
+export declare function readPredefinedMainnetLumosConfig(): config.Config;
+export declare function readPredefinedTestnetLumosConfig(): config.Config;
+export declare function buildFullLumosConfig(network: Network): any;

package/dist/util/config.js

@@ -0,0 +1,127 @@
+"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.buildFullLumosConfig = exports.readPredefinedTestnetLumosConfig = exports.readPredefinedMainnetLumosConfig = exports.readPredefinedDevnetLumosConfig = exports.readUserDeployedScriptsInfo = exports.updateScriptInfoInOffCKBConfigTs = 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 type_1 = require("./type");
+function updateScriptInfoInOffCKBConfigTs(newConfig, filePath, network) {
+    // Read the content of the offckb.config.ts file
+    let fileContent = fs.readFileSync(filePath, 'utf-8');
+    if (network === type_1.Network.devnet) {
+        /// Define the regular expression pattern to match the JSON content
+        const regexPattern = /\/\/ ---devnet lumos config---([\s\S]*?)\/\/ ---end of devnet lumos config---/;
+        // Replace the old JSON content with the new JSON content using the regular expression
+        fileContent = fileContent.replace(regexPattern, `// ---devnet lumos config---\nconst lumosConfig: config.Config = ${JSON.stringify(newConfig, null, 2)} as config.Config;\n// ---end of devnet lumos config---`);
+        // Write the updated content back to the file
+        fs.writeFileSync(filePath, fileContent, 'utf-8');
+    }
+    if (network === type_1.Network.testnet) {
+        /// Define the regular expression pattern to match the JSON content
+        const regexPattern = /\/\/ ---testnet lumos config---([\s\S]*?)\/\/ ---end of testnet lumos config---/;
+        // Replace the old JSON content with the new JSON content using the regular expression
+        fileContent = fileContent.replace(regexPattern, `// ---testnet lumos config---\nconst testnetLumosConfig: config.Config = ${JSON.stringify(newConfig, null, 2)} as config.Config;\n// ---end of testnet lumos config---`);
+        // Write the updated content back to the file
+        fs.writeFileSync(filePath, fileContent, 'utf-8');
+    }
+    if (network === type_1.Network.mainnet) {
+        /// Define the regular expression pattern to match the JSON content
+        const regexPattern = /\/\/ ---mainnet lumos config---([\s\S]*?)\/\/ ---end of mainnet lumos config---/;
+        // Replace the old JSON content with the new JSON content using the regular expression
+        fileContent = fileContent.replace(regexPattern, `// ---mainnet lumos config---\nconst mainnetLumosConfig: config.Config = ${JSON.stringify(newConfig, null, 2)} as config.Config;\n// ---end of mainnet lumos config---`);
+        // Write the updated content back to the file
+        fs.writeFileSync(filePath, fileContent, 'utf-8');
+    }
+}
+exports.updateScriptInfoInOffCKBConfigTs = updateScriptInfoInOffCKBConfigTs;
+function readUserDeployedScriptsInfo(network) {
+    const deployedScriptsInfo = {};
+    // Read all files in the folder
+    const folder = path.resolve(const_1.deployedContractInfoFolderPath, network);
+    if (!fs.existsSync(folder)) {
+        return deployedScriptsInfo;
+    }
+    const files = fs.readdirSync(folder);
+    // Iterate through each file
+    files.forEach((fileName) => {
+        // Construct the full file path
+        const filePath = path.join(folder, fileName);
+        // Check if the file is a JSON file
+        if (fileName.endsWith('.json')) {
+            try {
+                // Read the file content
+                const fileContent = fs.readFileSync(filePath, 'utf-8');
+                // Parse the JSON content
+                const scriptContent = JSON.parse(fileContent);
+                const rawFileName = path.parse(fileName).name.replace(/-/g, '_');
+                // Add the file content to the result object with the file name as the key
+                deployedScriptsInfo[rawFileName] = scriptContent;
+            }
+            catch (error) {
+                console.error(`Error reading or parsing file '${fileName}':`, error);
+            }
+        }
+    });
+    return deployedScriptsInfo;
+}
+exports.readUserDeployedScriptsInfo = readUserDeployedScriptsInfo;
+function readPredefinedDevnetLumosConfig() {
+    const filePath = path.resolve(const_1.dappTemplatePath, 'config.json');
+    try {
+        const fileContent = fs.readFileSync(filePath, 'utf-8');
+        const jsonData = JSON.parse(fileContent);
+        return jsonData;
+    }
+    catch (error) {
+        throw new Error('Error reading the json file:' + error.message);
+    }
+}
+exports.readPredefinedDevnetLumosConfig = readPredefinedDevnetLumosConfig;
+function readPredefinedMainnetLumosConfig() {
+    const predefined = lumos_1.config.predefined.LINA;
+    // add more example like spore;
+    return predefined;
+}
+exports.readPredefinedMainnetLumosConfig = readPredefinedMainnetLumosConfig;
+function readPredefinedTestnetLumosConfig() {
+    const predefined = lumos_1.config.predefined.AGGRON4;
+    // add more example like spore;
+    return predefined;
+}
+exports.readPredefinedTestnetLumosConfig = readPredefinedTestnetLumosConfig;
+function buildFullLumosConfig(network) {
+    const config = network === type_1.Network.devnet
+        ? readPredefinedDevnetLumosConfig()
+        : network === type_1.Network.testnet
+            ? readPredefinedTestnetLumosConfig()
+            : readPredefinedMainnetLumosConfig();
+    const userDeployedScripts = readUserDeployedScriptsInfo(network);
+    const conf = JSON.parse(JSON.stringify(config));
+    conf.SCRIPTS = Object.assign(Object.assign({}, config.SCRIPTS), userDeployedScripts);
+    return conf;
+}
+exports.buildFullLumosConfig = buildFullLumosConfig;

package/dist/util/fs.d.ts

@@ -0,0 +1,12 @@
+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 updateVersionInTSFile(newVersion: string, filePath: string): void;
+export declare function readFileToUint8Array(filePath: string): Promise<Uint8Array>;
+export declare function convertFilenameToUppercase(filePath: string): string;
+export declare function listBinaryFilesInFolder(folderPath: string): string[];
+export declare function isBinaryFile(filePath: string): boolean;
+export declare function isAbsolutePath(filePath: string): boolean;
+export declare function findFileInFolder(folderPath: string, fileName: string): string | null;

package/dist/{util.js → util/fs.js}

@@ -31,17 +31,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.loadTemplateOpts = exports.gitCloneAndDownloadFolderSync = exports.isGitInstalled = exports.copyRecursive = exports.copyFilesWithExclusion = exports.copyFileSync = exports.copyFolderSync = exports.isFolderExists = void 0;
-const child_process_1 = require("child_process");
+exports.findFileInFolder = exports.isAbsolutePath = exports.isBinaryFile = exports.listBinaryFilesInFolder = exports.convertFilenameToUppercase = exports.readFileToUint8Array = exports.updateVersionInTSFile = exports.copyRecursive = exports.copyFilesWithExclusion = exports.copyFileSync = exports.copyFolderSync = exports.isFolderExists = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const const_1 = require("./cfg/const");
-const axios_1 = __importDefault(require("axios"));
-const const_2 = require("./cfg/const");
 function isFolderExists(folderPath) {
     try {
         // Check if the path exists
@@ -128,70 +121,98 @@ function copyRecursive(source, destination, excludedFolders) {
     });
 }
 exports.copyRecursive = copyRecursive;
-function isGitInstalled() {
+function updateVersionInTSFile(newVersion, filePath) {
     try {
-        (0, child_process_1.execSync)('git --version');
-        return true;
+        // Read the contents of the TS file
+        const fileContents = fs.readFileSync(filePath, 'utf8');
+        // Use a regular expression to find the version value
+        const regex = /const\s+offCKBConfig:\s+OffCKBConfig\s*=\s*\{\s*version:\s*'([^']+)'/;
+        const match = fileContents.match(regex);
+        if (match) {
+            // Replace the version value with the new value
+            const updatedContents = fileContents.replace(regex, `const offCKBConfig: OffCKBConfig = {\n  version: '${newVersion}'`);
+            // Write the updated contents back to the file
+            fs.writeFileSync(filePath, updatedContents, 'utf8');
+            console.log(`Version updated to '${newVersion}' in ${filePath}`);
+        }
+        else {
+            console.error(`Could not find version value in ${filePath}`);
+        }
     }
     catch (error) {
-        return false;
+        console.error(`Error updating version in ${filePath}: ${error}`);
     }
 }
-exports.isGitInstalled = isGitInstalled;
-function gitCloneAndDownloadFolderSync(repoUrl, branch, subFolderName, targetPath) {
-    console.log('start cloning the dapp template..');
-    const tempFolder = path.resolve(const_1.dappTemplatePath, 'temp-clone-folder');
-    if (!isGitInstalled()) {
-        console.log('Git is not installed, please check https://git-scm.com/');
-        return process.exit(1);
-    }
-    // Empty the temp folder if it exists
-    if (fs.existsSync(tempFolder)) {
-        fs.rmSync(tempFolder, { recursive: true });
-    }
-    // Create the temp folder
-    fs.mkdirSync(tempFolder, { recursive: true });
-    // Clone the repository
-    try {
-        const cloneCommand = `git clone -n --depth=1 --single-branch --branch ${branch} --filter=tree:0 ${repoUrl} ${tempFolder}`;
-        (0, child_process_1.execSync)(cloneCommand);
-    }
-    catch (error) {
-        console.error('Error:', error);
-        process.exit(1);
-    }
-    // checkout the examples sub folder
-    try {
-        (0, child_process_1.execSync)(`git sparse-checkout set ${subFolderName}`, { cwd: tempFolder });
-        (0, child_process_1.execSync)(`git checkout`, { cwd: tempFolder });
-    }
-    catch (error) {
-        console.error('Error:', error);
-        process.exit(1);
-    }
-    // Ensure targetPath exists and is a directory
-    if (!fs.existsSync(targetPath) || !fs.statSync(targetPath).isDirectory()) {
-        fs.mkdirSync(targetPath, { recursive: true });
-    }
-    const source = path.resolve(tempFolder, subFolderName);
-    copyFolderSync(source, targetPath);
-    // Empty the temp folder if it exists
-    if (fs.existsSync(tempFolder)) {
-        fs.rmSync(tempFolder, { recursive: true });
+exports.updateVersionInTSFile = updateVersionInTSFile;
+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));
+            });
+        });
+    });
+}
+exports.readFileToUint8Array = readFileToUint8Array;
+function convertFilenameToUppercase(filePath) {
+    // Extract the filename from the file path
+    const filename = path.basename(filePath);
+    // Convert the filename to uppercase
+    const uppercaseFilename = filename.toUpperCase();
+    return uppercaseFilename;
+}
+exports.convertFilenameToUppercase = convertFilenameToUppercase;
+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);
+    // Filter out only the binary files (assuming they have extensions like .exe, .bin, .dll, etc.)
+    const binaryFiles = files.filter((file) => {
+        const filePath = path.join(folderPath, file);
+        // Check if the file is a regular file and not a directory
+        return fs.statSync(filePath).isFile() && isBinaryFile(filePath);
+    });
+    return binaryFiles;
+}
+exports.listBinaryFilesInFolder = listBinaryFilesInFolder;
+// 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;
+        }
     }
-    console.log(`Folder ${subFolderName} downloaded successfully from ${repoUrl} and moved to ${targetPath}`);
+    return false;
 }
-exports.gitCloneAndDownloadFolderSync = gitCloneAndDownloadFolderSync;
-function loadTemplateOpts() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const githubUrl = `https://raw.githubusercontent.com/${const_2.dappTemplateGitRepoUserAndName}/${const_2.dappTemplateGitBranch}/${const_2.dappTemplateGitFolder}/${const_2.dappTemplateGitSelectOptionFile}`;
-        try {
-            const response = yield axios_1.default.get(githubUrl);
-            return response.data;
+exports.isBinaryFile = isBinaryFile;
+function isAbsolutePath(filePath) {
+    return path.isAbsolute(filePath);
+}
+exports.isAbsolutePath = isAbsolutePath;
+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;
+            }
         }
-        catch (error) {
-            throw new Error(`Error fetching JSON: ${error.message}`);
+        else if (file === fileName) {
+            return filePath;
         }
-    });
+    }
+    return null;
 }
-exports.loadTemplateOpts = loadTemplateOpts;
+exports.findFileInFolder = findFileInFolder;

package/dist/util/git.d.ts

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