@offckb/cli 0.2.7 → 0.3.0-canary-a9175e7.0

package/dist/scripts/util.js

@@ -0,0 +1,84 @@
+"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.readUserDeployedScriptsInfo = void 0;
+const fs = __importStar(require("fs"));
+const util_1 = require("../deploy/util");
+const migration_1 = require("../deploy/migration");
+const fs_1 = require("../util/fs");
+function readUserDeployedScriptsInfo(network) {
+    const deployedScriptsInfo = {};
+    // Read all files in the folder
+    const folder = (0, util_1.getContractsPath)(network);
+    if (!fs.existsSync(folder)) {
+        return deployedScriptsInfo;
+    }
+    const contractNames = (0, fs_1.getSubfolders)(folder);
+    for (const contractName of contractNames) {
+        const folderPath = (0, migration_1.getMigrationFolderPath)(contractName, network); // Replace with your function to get the folder path
+        const newestFilePath = (0, migration_1.getNewestMigrationFile)(folderPath);
+        if (newestFilePath) {
+            try {
+                // Read the file content
+                const recipe = (0, migration_1.readDeploymentRecipeJsonFile)(newestFilePath);
+                // todo: handle multiple cell recipes?
+                const firstCell = recipe.cellRecipes[0];
+                const isDepCode = recipe.depGroupRecipes.length > 0;
+                deployedScriptsInfo[firstCell.name] = {
+                    codeHash: (firstCell.typeId ? firstCell.typeId : firstCell.dataHash),
+                    hashType: firstCell.typeId ? 'type' : 'data1',
+                    cellDeps: !isDepCode
+                        ? [
+                            {
+                                cellDep: {
+                                    outPoint: {
+                                        txHash: firstCell.txHash,
+                                        index: +firstCell.index,
+                                    },
+                                    depType: 'code',
+                                },
+                            },
+                        ]
+                        : recipe.depGroupRecipes.map((depGroupRecipe) => {
+                            return {
+                                cellDep: {
+                                    outPoint: {
+                                        txHash: depGroupRecipe.txHash,
+                                        index: +depGroupRecipe.index,
+                                    },
+                                    depType: 'depGroup',
+                                },
+                            };
+                        }),
+                };
+            }
+            catch (error) {
+                console.error(`Error reading or parsing file '${newestFilePath}':`, error);
+            }
+        }
+    }
+    return deployedScriptsInfo;
+}
+exports.readUserDeployedScriptsInfo = readUserDeployedScriptsInfo;

package/dist/template/config.d.ts

@@ -0,0 +1,4 @@
+export declare class OffCKBConfigFile {
+    static updateVersion(version: string, filePath: string): void;
+    static readContractInfoFolder(filePath: string): string | null;
+}

package/dist/template/config.js

@@ -0,0 +1,60 @@
+"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.OffCKBConfigFile = void 0;
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("../util/fs");
+class OffCKBConfigFile {
+    static updateVersion(version, filePath) {
+        const versionTarget = '@offckb-update-version';
+        let fileContent = fs.readFileSync(filePath, 'utf-8');
+        fileContent = fileContent.replace(versionTarget, version);
+        // Write the updated content back to the file
+        fs.writeFileSync(filePath, fileContent, 'utf-8');
+    }
+    static readContractInfoFolder(filePath) {
+        // Read the contents of the TS file
+        const fileContents = fs.readFileSync(filePath, 'utf8');
+        // Use a regular expression to find the version value
+        const match = fileContents.match(/contractInfoFolder:\s*['"]([^'"]+)['"]/);
+        if (match && match[1]) {
+            const contractInfoFolderValue = match[1];
+            const folderPath = path_1.default.dirname(filePath);
+            const contractInfoFolder = (0, fs_1.isAbsolutePath)(contractInfoFolderValue)
+                ? contractInfoFolderValue
+                : path_1.default.resolve(folderPath, contractInfoFolderValue);
+            return contractInfoFolder;
+        }
+        else {
+            console.log('contractBinFolder value not found in offckb.config.ts');
+            return null;
+        }
+    }
+}
+exports.OffCKBConfigFile = OffCKBConfigFile;

package/dist/template/offckb.config.d.ts

@@ -0,0 +1,69 @@
+export type Network = 'devnet' | 'testnet' | 'mainnet';
+export type AddressPrefix = 'ckb' | 'ckt';
+export declare enum SystemScriptName {
+    secp256k1_blake160_sighash_all = "secp256k1_blake160_sighash_all",
+    secp256k1_blake160_multisig_all = "secp256k1_blake160_multisig_all",
+    dao = "dao",
+    sudt = "sudt",
+    xudt = "xudt",
+    omnilock = "omnilock",
+    anyone_can_pay = "anyone_can_pay",
+    always_success = "always_success",
+    spore = "spore",
+    spore_cluster = "spore_cluster",
+    spore_cluster_agent = "spore_cluster_agent",
+    spore_cluster_proxy = "spore_cluster_proxy",
+    spore_extension_lua = "spore_extension_lua"
+}
+export interface ScriptInfo {
+    codeHash: `0x${string}`;
+    hashType: 'type' | 'data';
+    cellDeps: {
+        cellDep: {
+            outPoint: {
+                txHash: `0x${string}`;
+                index: number;
+            };
+            depType: 'code' | 'dep_group';
+        };
+    }[];
+}
+export interface SystemScript {
+    name: string;
+    file?: string;
+    script: ScriptInfo;
+}
+export type SystemScriptsRecord = Record<SystemScriptName, SystemScript | undefined>;
+export interface NetworkSystemScripts {
+    devnet: SystemScriptsRecord;
+    testnet: SystemScriptsRecord;
+    mainnet: SystemScriptsRecord;
+}
+export type MyScriptsRecord = Record<string, ScriptInfo | undefined>;
+export interface NetworkMyScripts {
+    devnet: MyScriptsRecord;
+    testnet: MyScriptsRecord;
+    mainnet: MyScriptsRecord;
+}
+export interface NetworkConfig {
+    rpc_url: string;
+    addressPrefix: AddressPrefix;
+}
+export interface OffCKBConfig {
+    readonly version: string;
+    readonly contractBinFolder: string;
+    readonly contractInfoFolder: string;
+    readonly networks: {
+        devnet: NetworkConfig;
+        testnet: NetworkConfig;
+        mainnet: NetworkConfig;
+    };
+    readonly currentNetwork: Network;
+    readonly addressPrefix: AddressPrefix;
+    readonly rpcUrl: string;
+    readonly systemScripts: SystemScriptsRecord;
+    readonly myScripts: MyScriptsRecord;
+}
+export declare function readEnvNetwork(): Network;
+declare const offCKBConfig: OffCKBConfig;
+export default offCKBConfig;

package/dist/template/offckb.config.js

@@ -0,0 +1,79 @@
+"use strict";
+// this file is generated by offckb-cli
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEnvNetwork = exports.SystemScriptName = void 0;
+var SystemScriptName;
+(function (SystemScriptName) {
+    SystemScriptName["secp256k1_blake160_sighash_all"] = "secp256k1_blake160_sighash_all";
+    SystemScriptName["secp256k1_blake160_multisig_all"] = "secp256k1_blake160_multisig_all";
+    SystemScriptName["dao"] = "dao";
+    SystemScriptName["sudt"] = "sudt";
+    SystemScriptName["xudt"] = "xudt";
+    SystemScriptName["omnilock"] = "omnilock";
+    SystemScriptName["anyone_can_pay"] = "anyone_can_pay";
+    SystemScriptName["always_success"] = "always_success";
+    SystemScriptName["spore"] = "spore";
+    SystemScriptName["spore_cluster"] = "spore_cluster";
+    SystemScriptName["spore_cluster_agent"] = "spore_cluster_agent";
+    SystemScriptName["spore_cluster_proxy"] = "spore_cluster_proxy";
+    SystemScriptName["spore_extension_lua"] = "spore_extension_lua";
+})(SystemScriptName || (exports.SystemScriptName = SystemScriptName = {}));
+function readEnvNetwork() {
+    // you may need to update the env method
+    // according to your frontend framework
+    const network = process.env.NETWORK;
+    const defaultNetwork = 'devnet';
+    if (!network)
+        return defaultNetwork;
+    if (!['devnet', 'testnet', 'mainnet'].includes(network)) {
+        return defaultNetwork;
+    }
+    return network;
+}
+exports.readEnvNetwork = readEnvNetwork;
+const offCKBConfig = {
+    version: '@offckb-update-version',
+    contractBinFolder: '../build/release',
+    // this folder record the script deployment information
+    // If you change this folder, you need to update the following get systemScripts and get myScripts method
+    contractInfoFolder: './offckb',
+    networks: {
+        devnet: {
+            rpc_url: 'http://127.0.0.1:8114',
+            addressPrefix: 'ckt',
+        },
+        testnet: {
+            rpc_url: 'https://testnet.ckb.dev/rpc',
+            addressPrefix: 'ckt',
+        },
+        mainnet: {
+            rpc_url: 'https://mainnet.ckb.dev/rpc',
+            addressPrefix: 'ckb',
+        },
+    },
+    get currentNetwork() {
+        const network = readEnvNetwork();
+        return network;
+    },
+    get addressPrefix() {
+        const network = readEnvNetwork();
+        return this.networks[network].addressPrefix;
+    },
+    get rpcUrl() {
+        const network = readEnvNetwork();
+        return this.networks[network].rpc_url;
+    },
+    get systemScripts() {
+        const network = readEnvNetwork();
+        const networkSystemScripts = require('./offckb/system-scripts.json');
+        const systemScripts = networkSystemScripts[network];
+        return systemScripts;
+    },
+    get myScripts() {
+        const network = readEnvNetwork();
+        const networkMyScripts = require('./offckb/my-scripts.json');
+        const myScripts = networkMyScripts[network];
+        return myScripts;
+    },
+};
+exports.default = offCKBConfig;

package/dist/{util/template.js → template/option.js}

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadBareTemplateOpts = void 0;
-const template_json_1 = __importDefault(require("../../templates/template.json"));
+const option_json_1 = __importDefault(require("./option.json"));
 function loadBareTemplateOpts() {
-    return template_json_1.default;
+    return option_json_1.default;
 }
 exports.loadBareTemplateOpts = loadBareTemplateOpts;

package/dist/template/option.json

@@ -0,0 +1,16 @@
+[
+    {
+        "name": "Remix-Vite Bare Templates",
+        "value": "remix-vite-template",
+        "description": "A full-stack template with Remix-vite and ckb-script-templates",
+        "tag": ["remix", "vite", "tailwindcss", "ckb-script-templates", "typescript", "rust"],
+        "author": "retric@cryptape.com"
+    },
+    {
+        "name": "Next.js Bare Templates",
+        "value": "next-js-template",
+        "description": "A full-stack template with Next.js framework and ckb-script-templates",
+        "tag": ["next.js", "tailwindcss", "ckb-script-templates", "typescript", "rust"],
+        "author": "retric@cryptape.com"
+    }
+]

package/dist/tools/ckb-debugger.d.ts

@@ -0,0 +1,12 @@
+export interface DebugOption {
+    fullTxJsonFilePath: string;
+    cellIndex: number;
+    cellType: 'output' | 'input';
+    scriptGroupType: 'lock' | 'type';
+}
+export declare class CKBDebugger {
+    static runRaw(options: string): void;
+    static runTxCellScript({ fullTxJsonFilePath, cellIndex, cellType, scriptGroupType }: DebugOption): void;
+    static isBinaryInstalled(): boolean;
+    static installCKBDebugger(): void;
+}

package/dist/tools/ckb-debugger.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CKBDebugger = void 0;
+const child_process_1 = require("child_process");
+class CKBDebugger {
+    static runRaw(options) {
+        const command = `ckb-debugger ${options}`;
+        (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+    }
+    static runTxCellScript({ fullTxJsonFilePath, cellIndex, cellType, scriptGroupType }) {
+        const command = `ckb-debugger --tx-file ${fullTxJsonFilePath} --cell-index ${cellIndex} --cell-type ${cellType} --script-group-type ${scriptGroupType}`;
+        (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+    }
+    static isBinaryInstalled() {
+        const result = (0, child_process_1.spawnSync)('ckb-debugger', ['--version'], { stdio: 'ignore' });
+        return result.status === 0;
+    }
+    static installCKBDebugger() {
+        const command = `cargo install --git https://github.com/nervosnetwork/ckb-standalone-debugger ckb-debugger`;
+        try {
+            console.log('Installing ckb-debugger...');
+            (0, child_process_1.execSync)(command);
+            console.log('ckb-debugger installed successfully.');
+        }
+        catch (error) {
+            console.error('Failed to install ckb-debugger:', error);
+            process.exit(1);
+        }
+    }
+}
+exports.CKBDebugger = CKBDebugger;

package/dist/tools/ckb-tx-dumper.d.ts

@@ -0,0 +1,6 @@
+export interface DumpOption {
+    rpc: string;
+    txJsonFilePath: string;
+    outputFilePath: string;
+}
+export declare function dumpTransaction({ rpc, txJsonFilePath, outputFilePath }: DumpOption): void;

package/dist/tools/ckb-tx-dumper.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dumpTransaction = void 0;
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const setting_1 = require("../cfg/setting");
+function dumpTransaction({ rpc, txJsonFilePath, outputFilePath }) {
+    const ckbTransactionDumperPath = path_1.default.resolve(setting_1.packageRootPath, 'node_modules/.bin/ckb-transaction-dumper');
+    const command = `${ckbTransactionDumperPath} --rpc ${rpc} --tx "${txJsonFilePath}" --output "${outputFilePath}"`;
+    try {
+        (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+        console.debug('Dump transaction successfully');
+    }
+    catch (error) {
+        console.error('Command failed:', error.message);
+    }
+}
+exports.dumpTransaction = dumpTransaction;

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import http from 'http';
+import { Network } from '../util/type';
+export declare function createRPCProxy(network: Network, targetRpcUrl: string, port: number): {
+    server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    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

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRPCProxy = void 0;
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const http_1 = __importDefault(require("http"));
+const type_1 = require("../util/type");
+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
+    });
+    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');
+            }
+        });
+        proxy.on('proxyReq', (_, req) => {
+            let reqData = '';
+            req.on('data', (chunk) => {
+                reqData += chunk;
+            });
+            req.on('end', () => {
+                try {
+                    const jsonRpcContent = JSON.parse(reqData);
+                    console.debug('Incoming Request: ', jsonRpcContent);
+                    const method = jsonRpcContent.method;
+                    const params = jsonRpcContent.params;
+                    if (method === 'send_transaction') {
+                        const tx = params[0];
+                        // todo: record tx
+                        if (network === type_1.Network.devnet) {
+                            const cccTx = cccA.JsonRpcTransformers.transactionTo(tx);
+                            const txHash = cccTx.hash();
+                            const settings = (0, setting_1.readSettings)();
+                            console.log('txHash: ', txHash, settings, settings.devnet.transactionsPath);
+                            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));
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error('Error parsing JSON-RPC content:', err);
+                }
+            });
+        });
+        // Capture the content from the response (or request)
+        proxy.on('proxyRes', (proxyRes) => {
+            let data = '';
+            proxyRes.on('data', (chunk) => {
+                data += chunk;
+            });
+            proxyRes.on('end', () => {
+                console.log('Captured content:', data);
+                // Do something with the captured content
+            });
+        });
+    });
+    return {
+        server,
+        network,
+        start: () => {
+            return server.listen(port, () => {
+                console.debug(`CKB ${network} RPC Proxy server running on http://localhost:${port}`);
+            });
+        },
+        stop: () => {
+            return server.close();
+        },
+    };
+}
+exports.createRPCProxy = createRPCProxy;

package/dist/util/ckb.d.ts

@@ -69,7 +69,7 @@ export declare class CKB {
             };
             XUDT: {
                 CODE_HASH: string;
-                HASH_TYPE: "data1";
+                HASH_TYPE: "type";
                 TX_HASH: string;
                 INDEX: string;
                 DEP_TYPE: "code";
@@ -125,7 +125,7 @@ export declare class CKB {
             };
             XUDT: {
                 CODE_HASH: string;
-                HASH_TYPE: "type";
+                HASH_TYPE: "data1";
                 TX_HASH: string;
                 INDEX: string;
                 DEP_TYPE: "code";
@@ -137,4 +137,5 @@ export declare class CKB {
     transfer(options: Options, lumosConfig: config.Config): Promise<string>;
     transferAll(privateKey: string, toAddress: string, lumosConfig: config.Config): Promise<string>;
 }
+export declare function readPredefinedDevnetLumosConfig(): config.Config;
 export {};

package/dist/util/ckb.js

@@ -16,13 +16,13 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     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;
+exports.readPredefinedDevnetLumosConfig = 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 system_scripts_1 = require("../cmd/system-scripts");
 const { ScriptValue } = base_1.values;
 const networks = {
     devnet: {
@@ -70,7 +70,7 @@ class CKB {
     }
     getLumosConfig() {
         if (this.network === type_1.Network.devnet) {
-            return (0, config_1.readPredefinedDevnetLumosConfig)();
+            return readPredefinedDevnetLumosConfig();
         }
         if (this.network === type_1.Network.testnet) {
             return lumos_1.config.predefined.AGGRON4;
@@ -297,3 +297,16 @@ class CKB {
     }
 }
 exports.CKB = CKB;
+function readPredefinedDevnetLumosConfig() {
+    try {
+        const systemScripts = (0, system_scripts_1.getSystemScriptsFromListHashes)();
+        if (systemScripts) {
+            return (0, system_scripts_1.toLumosConfig)(systemScripts);
+        }
+        throw new Error('systemScripts not found!');
+    }
+    catch (error) {
+        throw new Error('getSystemScriptsFromListHashes error' + error.message);
+    }
+}
+exports.readPredefinedDevnetLumosConfig = readPredefinedDevnetLumosConfig;

package/dist/util/encoding.d.ts

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

package/dist/util/encoding.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setUTF8EncodingForWindows = void 0;
+exports.encodeBinPathForTerminal = exports.setUTF8EncodingForWindows = void 0;
 const child_process_1 = require("child_process");
 const os_1 = __importDefault(require("os"));
 function setUTF8EncodingForWindows() {
@@ -17,3 +17,9 @@ function setUTF8EncodingForWindows() {
     }
 }
 exports.setUTF8EncodingForWindows = setUTF8EncodingForWindows;
+function encodeBinPathForTerminal(path) {
+    // some path contains space in the string
+    // this fix the space in the terminal
+    return `"${path}"`;
+}
+exports.encodeBinPathForTerminal = encodeBinPathForTerminal;

package/dist/util/fs.d.ts

@@ -3,10 +3,9 @@ export declare function copyFolderSync(source: string, destination: string): voi
 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;
+export declare function getSubfolders(folderPath: string): string[];