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

package/dist/cmd/system-scripts.d.ts

@@ -0,0 +1,42 @@
+import { config } from '@ckb-lumos/lumos';
+import { SystemCell } from './list-hashes';
+import { CellDepInfoLike, Script } from '@ckb-ccc/core';
+import { SystemScriptsRecord } from '../scripts/type';
+export type PrintProps = 'lumos' | 'ccc';
+export declare function printSystemScripts(props?: PrintProps): Promise<void>;
+export declare function printInSystemStyle(systemScripts: SystemScriptsRecord): void;
+export declare function printInLumosConfigStyle(scripts: SystemScriptsRecord): void;
+export declare function printInCCCStyle(scripts: SystemScriptsRecord): void;
+export declare function getSystemScriptsFromListHashes(): SystemScriptsRecord | null;
+export declare function systemCellToScriptInfo(cell: SystemCell, depType: 'code' | 'depGroup', depGroup?: {
+    txHash: string;
+    index: number;
+}): {
+    codeHash: string;
+    hashType: string;
+    cellDeps: {
+        cellDep: {
+            outPoint: {
+                txHash: string;
+                index: number;
+            };
+            depType: "code";
+        };
+    }[];
+} | {
+    codeHash: string;
+    hashType: string;
+    cellDeps: {
+        cellDep: {
+            outPoint: {
+                txHash: string;
+                index: number;
+            };
+            depType: "depGroup";
+        };
+    }[];
+};
+export declare function toLumosConfig(scripts: SystemScriptsRecord, addressPrefix?: 'ckb' | 'ckt'): config.Config;
+export declare function toCCCKnownScripts(scripts: SystemScriptsRecord): Record<string, Pick<Script, "codeHash" | "hashType"> & {
+    cellDeps: CellDepInfoLike[];
+}>;

package/dist/cmd/system-scripts.js

@@ -0,0 +1,265 @@
+"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.toCCCKnownScripts = exports.toLumosConfig = exports.systemCellToScriptInfo = exports.getSystemScriptsFromListHashes = exports.printInCCCStyle = exports.printInLumosConfigStyle = exports.printInSystemStyle = exports.printSystemScripts = void 0;
+const setting_1 = require("../cfg/setting");
+const list_hashes_1 = require("./list-hashes");
+const toml_1 = __importDefault(require("@iarna/toml"));
+const core_1 = require("@ckb-ccc/core");
+function printSystemScripts(props) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const systemScripts = getSystemScriptsFromListHashes();
+        if (systemScripts) {
+            if (!props) {
+                return printInSystemStyle(systemScripts);
+            }
+            if (props === 'lumos') {
+                return printInLumosConfigStyle(systemScripts);
+            }
+            if (props === 'ccc') {
+                return printInCCCStyle(systemScripts);
+            }
+        }
+    });
+}
+exports.printSystemScripts = printSystemScripts;
+function printInSystemStyle(systemScripts) {
+    console.log('*** OffCKB Devnet System Scripts ***\n');
+    for (const [name, script] of Object.entries(systemScripts)) {
+        console.log(`- name: ${name}`);
+        if (script == null) {
+            return console.log(`  undefined\n`);
+        }
+        console.log(`  file: ${script.file}`);
+        console.log(`  code_hash: ${script.script.codeHash}`);
+        console.log(`  hash_type: ${script.script.hashType}`);
+        console.log(`  cellDeps: ${JSON.stringify(script.script.cellDeps, null, 2)}\n`);
+    }
+}
+exports.printInSystemStyle = printInSystemStyle;
+function printInLumosConfigStyle(scripts) {
+    const config = toLumosConfig(scripts);
+    console.log('*** OffCKB Devnet System Scripts As LumosConfig ***\n');
+    console.log(JSON.stringify(config, null, 2));
+}
+exports.printInLumosConfigStyle = printInLumosConfigStyle;
+function printInCCCStyle(scripts) {
+    const knownsScripts = toCCCKnownScripts(scripts);
+    console.log('*** OffCKB Devnet System Scripts As CCC KnownScripts ***\n');
+    console.log(JSON.stringify(knownsScripts, null, 2));
+}
+exports.printInCCCStyle = printInCCCStyle;
+function getSystemScriptsFromListHashes() {
+    const settings = (0, setting_1.readSettings)();
+    const listHashesString = (0, list_hashes_1.getListHashes)(settings.bins.defaultCKBVersion);
+    if (listHashesString) {
+        const listHashes = toml_1.default.parse(listHashesString);
+        const systemScriptArray = listHashes.offckb.system_cells
+            .map((cell) => {
+            var _a;
+            // Extract the file name
+            const name = ((_a = cell.path.split('/').pop()) === null || _a === void 0 ? void 0 : _a.replace(')', '')) || 'unknown script';
+            const depGroupIndex = listHashes.offckb.dep_groups.findIndex((depGroup) => depGroup.included_cells.includes(`Bundled(specs/cells/${name})`));
+            const depType = depGroupIndex === -1 ? 'code' : 'depGroup';
+            const depGroup = depGroupIndex === -1
+                ? undefined
+                : {
+                    txHash: listHashes.offckb.dep_groups[depGroupIndex].tx_hash,
+                    index: listHashes.offckb.dep_groups[depGroupIndex].index,
+                };
+            const scriptInfo = systemCellToScriptInfo(cell, depType, depGroup);
+            return {
+                name,
+                file: cell.path,
+                script: scriptInfo,
+            };
+        })
+            .filter((s) => s.name != 'secp256k1_data');
+        const systemScripts = systemScriptArray.reduce((acc, item) => {
+            const key = item.name;
+            acc[key] = item;
+            return acc;
+        }, {});
+        return systemScripts;
+    }
+    else {
+        console.log(`list-hashes not found!`);
+        return null;
+    }
+}
+exports.getSystemScriptsFromListHashes = getSystemScriptsFromListHashes;
+function systemCellToScriptInfo(cell, depType, depGroup) {
+    if (depType === 'depGroup' && !depGroup) {
+        throw new Error('require depGroup info since the dep type is depGroup');
+    }
+    if (depType === 'code') {
+        return {
+            codeHash: cell.type_hash || cell.data_hash,
+            hashType: cell.type_hash ? 'type' : 'data',
+            cellDeps: [
+                {
+                    cellDep: {
+                        outPoint: {
+                            txHash: cell.tx_hash,
+                            index: cell.index,
+                        },
+                        depType,
+                    },
+                },
+            ],
+        };
+    }
+    return {
+        codeHash: cell.type_hash || cell.data_hash,
+        hashType: cell.type_hash ? 'type' : 'data',
+        cellDeps: [
+            {
+                cellDep: {
+                    outPoint: {
+                        txHash: depGroup.txHash,
+                        index: depGroup.index,
+                    },
+                    depType,
+                },
+            },
+        ],
+    };
+}
+exports.systemCellToScriptInfo = systemCellToScriptInfo;
+function toLumosConfig(scripts, addressPrefix = 'ckt') {
+    const config = {
+        PREFIX: addressPrefix,
+        SCRIPTS: {
+            SECP256K1_BLAKE160: {
+                CODE_HASH: scripts.secp256k1_blake160_sighash_all.script.codeHash,
+                HASH_TYPE: scripts.secp256k1_blake160_sighash_all.script.hashType,
+                TX_HASH: scripts.secp256k1_blake160_sighash_all.script.cellDeps[0].cellDep.outPoint.txHash,
+                INDEX: '0x' + scripts.secp256k1_blake160_sighash_all.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+                DEP_TYPE: scripts.secp256k1_blake160_sighash_all.script.cellDeps[0].cellDep.depType,
+                SHORT_ID: 1,
+            },
+            SECP256K1_BLAKE160_MULTISIG: {
+                CODE_HASH: scripts.secp256k1_blake160_multisig_all.script.codeHash,
+                HASH_TYPE: scripts.secp256k1_blake160_multisig_all.script.hashType,
+                TX_HASH: scripts.secp256k1_blake160_multisig_all.script.cellDeps[0].cellDep.outPoint.txHash,
+                INDEX: '0x' + scripts.secp256k1_blake160_multisig_all.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+                DEP_TYPE: scripts.secp256k1_blake160_multisig_all.script.cellDeps[0].cellDep.depType,
+            },
+            DAO: {
+                CODE_HASH: scripts.dao.script.codeHash,
+                HASH_TYPE: scripts.dao.script.hashType,
+                TX_HASH: scripts.dao.script.cellDeps[0].cellDep.outPoint.txHash,
+                INDEX: '0x' + scripts.dao.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+                DEP_TYPE: scripts.dao.script.cellDeps[0].cellDep.depType,
+                SHORT_ID: 2,
+            },
+            SUDT: {
+                CODE_HASH: scripts.sudt.script.codeHash,
+                HASH_TYPE: scripts.sudt.script.hashType,
+                TX_HASH: scripts.sudt.script.cellDeps[0].cellDep.outPoint.txHash,
+                INDEX: '0x' + scripts.sudt.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+                DEP_TYPE: scripts.sudt.script.cellDeps[0].cellDep.depType,
+            },
+            XUDT: {
+                CODE_HASH: scripts.xudt.script.codeHash,
+                HASH_TYPE: scripts.xudt.script.hashType,
+                TX_HASH: scripts.xudt.script.cellDeps[0].cellDep.outPoint.txHash,
+                INDEX: '0x' + scripts.xudt.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+                DEP_TYPE: scripts.xudt.script.cellDeps[0].cellDep.depType,
+            },
+            OMNILOCK: {
+                CODE_HASH: scripts.omnilock.script.codeHash,
+                HASH_TYPE: scripts.omnilock.script.hashType,
+                TX_HASH: scripts.omnilock.script.cellDeps[0].cellDep.outPoint.txHash,
+                INDEX: '0x' + scripts.omnilock.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+                DEP_TYPE: scripts.omnilock.script.cellDeps[0].cellDep.depType,
+            },
+            ANYONE_CAN_PAY: {
+                CODE_HASH: scripts.anyone_can_pay.script.codeHash,
+                HASH_TYPE: scripts.anyone_can_pay.script.hashType,
+                TX_HASH: scripts.anyone_can_pay.script.cellDeps[0].cellDep.outPoint.txHash,
+                INDEX: '0x' + scripts.anyone_can_pay.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+                DEP_TYPE: scripts.anyone_can_pay.script.cellDeps[0].cellDep.depType,
+            },
+            SPORE: {
+                CODE_HASH: scripts.spore.script.codeHash,
+                HASH_TYPE: scripts.spore.script.hashType,
+                TX_HASH: scripts.spore.script.cellDeps[0].cellDep.outPoint.txHash,
+                INDEX: '0x' + scripts.spore.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+                DEP_TYPE: scripts.spore.script.cellDeps[0].cellDep.depType,
+            },
+            SPORE_CLUSTER: {
+                CODE_HASH: scripts.spore_cluster.script.codeHash,
+                HASH_TYPE: scripts.spore_cluster.script.hashType,
+                TX_HASH: scripts.spore_cluster.script.cellDeps[0].cellDep.outPoint.txHash,
+                INDEX: '0x' + scripts.spore_cluster.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+                DEP_TYPE: scripts.spore_cluster.script.cellDeps[0].cellDep.depType,
+            },
+        },
+    };
+    if (scripts.always_success) {
+        config.SCRIPTS['ALWAYS_SUCCESS'] = {
+            CODE_HASH: scripts.always_success.script.codeHash,
+            HASH_TYPE: scripts.always_success.script.hashType,
+            TX_HASH: scripts.always_success.script.cellDeps[0].cellDep.outPoint.txHash,
+            INDEX: '0x' + scripts.always_success.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+            DEP_TYPE: scripts.always_success.script.cellDeps[0].cellDep.depType,
+        };
+    }
+    if (scripts.spore_cluster_agent) {
+        config.SCRIPTS['SPORE_CLUSTER_AGENT'] = {
+            CODE_HASH: scripts.spore_cluster_agent.script.codeHash,
+            HASH_TYPE: scripts.spore_cluster_agent.script.hashType,
+            TX_HASH: scripts.spore_cluster_agent.script.cellDeps[0].cellDep.outPoint.txHash,
+            INDEX: '0x' + scripts.spore_cluster_agent.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+            DEP_TYPE: scripts.spore_cluster_agent.script.cellDeps[0].cellDep.depType,
+        };
+    }
+    if (scripts.spore_cluster_proxy) {
+        config.SCRIPTS['SPORE_CLUSTER_PROXY'] = {
+            CODE_HASH: scripts.spore_cluster_proxy.script.codeHash,
+            HASH_TYPE: scripts.spore_cluster_proxy.script.hashType,
+            TX_HASH: scripts.spore_cluster_proxy.script.cellDeps[0].cellDep.outPoint.txHash,
+            INDEX: '0x' + scripts.spore_cluster_proxy.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+            DEP_TYPE: scripts.spore_cluster_proxy.script.cellDeps[0].cellDep.depType,
+        };
+    }
+    if (scripts.spore_extension_lua) {
+        config.SCRIPTS['SPORE_LUA'] = {
+            CODE_HASH: scripts.spore_extension_lua.script.codeHash,
+            HASH_TYPE: scripts.spore_extension_lua.script.hashType,
+            TX_HASH: scripts.spore_extension_lua.script.cellDeps[0].cellDep.outPoint.txHash,
+            INDEX: '0x' + scripts.spore_extension_lua.script.cellDeps[0].cellDep.outPoint.index.toString(16),
+            DEP_TYPE: scripts.spore_extension_lua.script.cellDeps[0].cellDep.depType,
+        };
+    }
+    return config;
+}
+exports.toLumosConfig = toLumosConfig;
+function toCCCKnownScripts(scripts) {
+    const DEVNET_SCRIPTS = {
+        [core_1.KnownScript.Secp256k1Blake160]: scripts.secp256k1_blake160_sighash_all.script,
+        [core_1.KnownScript.Secp256k1Multisig]: scripts.secp256k1_blake160_multisig_all.script,
+        [core_1.KnownScript.AnyoneCanPay]: scripts.anyone_can_pay.script,
+        [core_1.KnownScript.OmniLock]: scripts.omnilock.script,
+        [core_1.KnownScript.XUdt]: scripts.xudt.script,
+        [core_1.KnownScript.TypeId]: {
+            codeHash: '0x00000000000000000000000000000000000000000000000000545950455f4944',
+            hashType: 'type',
+            cellDeps: [],
+        },
+    };
+    return DEVNET_SCRIPTS;
+}
+exports.toCCCKnownScripts = toCCCKnownScripts;

package/dist/deploy/migration.d.ts

@@ -0,0 +1,45 @@
+import { HexNumber } from '@ckb-lumos/lumos';
+import { Network } from '../util/type';
+export interface CellRecipe {
+    name: string;
+    txHash: string;
+    index: HexNumber;
+    occupiedCapacity: HexNumber;
+    dataHash: string;
+    typeId?: string;
+}
+export interface DepGroupRecipe {
+    name: string;
+    txHash: string;
+    index: HexNumber;
+    dataHash: string;
+    occupiedCapacity: HexNumber;
+}
+export interface DeploymentRecipe {
+    cellRecipes: CellRecipe[];
+    depGroupRecipes: DepGroupRecipe[];
+}
+export interface DeploymentRecipeJson {
+    cell_recipes: {
+        name: string;
+        tx_hash: string;
+        index: HexNumber;
+        occupied_capacity: HexNumber;
+        data_hash: string;
+        type_id?: string;
+    }[];
+    dep_group_recipes: {
+        name: string;
+        tx_hash: string;
+        index: HexNumber;
+        data_hash: string;
+        occupied_capacity: HexNumber;
+    }[];
+}
+export declare function generateDeploymentRecipeJsonFile(name: string, deploymentRecipe: DeploymentRecipe, network?: Network): void;
+export declare function readDeploymentRecipeJsonFile(filePath: string): DeploymentRecipe;
+export declare function getFormattedMigrationDate(): string;
+export declare function getMigrationFolderPath(scriptName: string, network: Network): string;
+export declare function getNewestMigrationFile(folderPath: string): string | undefined;
+export declare function deploymentRecipeToJson(recipe: DeploymentRecipe): DeploymentRecipeJson;
+export declare function deploymentRecipeFromJson(json: DeploymentRecipeJson): DeploymentRecipe;

package/dist/deploy/migration.js

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

package/dist/deploy/toml.d.ts

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

package/dist/deploy/toml.js

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

package/dist/deploy/util.d.ts

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

package/dist/deploy/util.js

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

package/dist/node/init-chain.js

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

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

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