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

package/dist/cmd/list-hashes.js

@@ -9,24 +9,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listHashes = void 0;
+exports.getListHashes = exports.listHashes = void 0;
 const child_process_1 = require("child_process");
-const const_1 = require("../cfg/const");
-const install_1 = require("./develop/install");
-const init_chain_1 = require("./develop/init-chain");
-function listHashes() {
+const setting_1 = require("../cfg/setting");
+const encoding_1 = require("../util/encoding");
+function listHashes(version) {
     return __awaiter(this, void 0, void 0, function* () {
-        yield (0, install_1.installDependency)();
-        yield (0, init_chain_1.initChainIfNeeded)();
-        const cmd = `${const_1.ckbBinPath} list-hashes  -C ${const_1.devnetPath}`;
-        try {
-            (0, child_process_1.execSync)(cmd, {
-                stdio: 'inherit',
-            });
-        }
-        catch (error) {
-            console.error('Error running dependency binary:', error);
-        }
+        const output = getListHashes(version);
+        console.log(output);
     });
 }
 exports.listHashes = listHashes;
+function getListHashes(version) {
+    const settings = (0, setting_1.readSettings)();
+    const ckbVersion = version || settings.bins.defaultCKBVersion;
+    const ckbBinPath = (0, encoding_1.encodeBinPathForTerminal)((0, setting_1.getCKBBinaryPath)(ckbVersion));
+    const devnetPath = (0, encoding_1.encodeBinPathForTerminal)(settings.devnet.configPath);
+    const cmd = `${ckbBinPath} list-hashes  -C ${devnetPath}`;
+    try {
+        const output = (0, child_process_1.execSync)(cmd, {
+            encoding: 'utf-8',
+        });
+        return output;
+    }
+    catch (error) {
+        console.error('Error running dependency binary:', error);
+        return null;
+    }
+}
+exports.getListHashes = getListHashes;

package/dist/cmd/{deployed-scripts.d.ts → my-scripts.d.ts}

@@ -1,4 +1,4 @@
 import { NetworkOption } from '../util/type';
 export interface DeployedScriptOption extends NetworkOption {
 }
-export declare function deployedScripts(option?: DeployedScriptOption): void;
+export declare function printMyScripts(option?: DeployedScriptOption): void;

package/dist/cmd/my-scripts.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printMyScripts = void 0;
+const toml_1 = require("../deploy/toml");
+const util_1 = require("../deploy/util");
+const util_2 = require("../scripts/util");
+const type_1 = require("../util/type");
+const validator_1 = require("../util/validator");
+function printMyScripts(option = { network: type_1.Network.devnet }) {
+    const network = option.network;
+    (0, validator_1.validateNetworkOpt)(network);
+    const scriptsInfo = (0, util_2.readUserDeployedScriptsInfo)(network);
+    console.log(`*** User-deployed Scripts on ${network.toUpperCase()} ***`);
+    const scriptNames = Object.keys(scriptsInfo);
+    scriptNames.forEach((scriptName) => {
+        const deployToml = (0, toml_1.readDeploymentToml)(scriptName, network);
+        console.log(`- ${scriptName}`);
+        console.log(`Path: ${(0, util_1.getContractsPath)(network)}/${scriptName}`);
+        console.log(`Binary File: ${deployToml.cells[0].location.file}`);
+        console.log(`Enable Type Id: ${deployToml.cells[0].enableTypeId}`);
+        console.log(`Script Info: ${JSON.stringify(scriptsInfo[scriptName], null, 2)}`);
+        console.log(`\n`);
+    });
+}
+exports.printMyScripts = printMyScripts;

package/dist/cmd/node.d.ts

@@ -1 +1,5 @@
-export declare function node(): Promise<void>;
+export interface NodeProp {
+    version?: string;
+    noProxyServer?: boolean;
+}
+export declare function node({ version, noProxyServer }: NodeProp): Promise<void>;

package/dist/cmd/node.js

@@ -11,22 +11,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.node = void 0;
 const child_process_1 = require("child_process");
-const const_1 = require("../cfg/const");
-const init_chain_1 = require("./develop/init-chain");
-const install_1 = require("./develop/install");
-function node() {
+const init_chain_1 = require("../node/init-chain");
+const install_1 = require("../node/install");
+const setting_1 = require("../cfg/setting");
+const encoding_1 = require("../util/encoding");
+const rpc_proxy_1 = require("../tools/rpc-proxy");
+const type_1 = require("../util/type");
+function node({ version, noProxyServer }) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
-        yield (0, install_1.installDependency)();
+        const settings = (0, setting_1.readSettings)();
+        const ckbVersion = version || settings.bins.defaultCKBVersion;
+        yield (0, install_1.installCKBBinary)(ckbVersion);
         yield (0, init_chain_1.initChainIfNeeded)();
-        const ckbCmd = `${const_1.ckbBinPath} run -C ${const_1.devnetPath}`;
-        const minerCmd = `${const_1.ckbBinPath} miner -C ${const_1.devnetPath}`;
+        const ckbBinPath = (0, encoding_1.encodeBinPathForTerminal)((0, setting_1.getCKBBinaryPath)(ckbVersion));
+        const devnetConfigPath = (0, encoding_1.encodeBinPathForTerminal)(settings.devnet.configPath);
+        const ckbCmd = `${ckbBinPath} run -C ${devnetConfigPath}`;
+        const minerCmd = `${ckbBinPath} miner -C ${devnetConfigPath}`;
         try {
             // Run first command
             const ckbProcess = (0, child_process_1.exec)(ckbCmd);
             // Log first command's output
             (_a = ckbProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-                console.log('CKB output:', data.toString());
+                console.log('CKB:', data.toString());
             });
             (_b = ckbProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
                 console.error('CKB error:', data.toString());
@@ -43,6 +50,13 @@ function node() {
                     (_d = minerProcess.stderr) === null || _d === void 0 ? void 0 : _d.on('data', (data) => {
                         console.error('CKB-Miner error:', data.toString());
                     });
+                    console.log('noProxyServer: ', noProxyServer);
+                    if (!noProxyServer) {
+                        const ckbRpc = settings.devnet.rpcUrl;
+                        const port = settings.rpc.proxyPort;
+                        const proxy = (0, rpc_proxy_1.createRPCProxy)(type_1.Network.devnet, ckbRpc, port);
+                        proxy.start();
+                    }
                 }
                 catch (error) {
                     console.error('Error running CKB-Miner:', error);

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

@@ -0,0 +1,7 @@
+import { Network } from '../util/type';
+export interface ProxyRpcOptions {
+    ckbRpc?: string;
+    port?: number;
+    network?: Network;
+}
+export declare function proxyRpc(options: ProxyRpcOptions): void;

package/dist/cmd/proxy-rpc.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyRpc = void 0;
+const setting_1 = require("../cfg/setting");
+const rpc_proxy_1 = require("../tools/rpc-proxy");
+const type_1 = require("../util/type");
+function proxyRpc(options) {
+    const settings = (0, setting_1.readSettings)();
+    const network = options.network || type_1.Network.devnet;
+    let ckbRpc = options.ckbRpc;
+    if (!ckbRpc) {
+        ckbRpc =
+            network === type_1.Network.devnet
+                ? settings.devnet.rpcUrl
+                : network === type_1.Network.testnet
+                    ? settings.testnet.rpcUrl
+                    : settings.mainnet.rpcUrl;
+    }
+    const port = options.port || settings.rpc.proxyPort;
+    const proxy = (0, rpc_proxy_1.createRPCProxy)(network, ckbRpc, port);
+    proxy.start();
+}
+exports.proxyRpc = proxyRpc;

package/dist/cmd/sync-config.js

@@ -1,19 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncConfig = void 0;
-const const_1 = require("../cfg/const");
-const config_1 = require("../util/config");
-const type_1 = require("../util/type");
+const path_1 = __importDefault(require("path"));
 const validator_1 = require("../util/validator");
+const gen_1 = require("../scripts/gen");
+const config_1 = require("../template/config");
 function syncConfig() {
     (0, validator_1.validateExecDappEnvironment)();
-    // update the offckb.config.ts file in users workspace
-    const devnetFullLumosConfig = (0, config_1.buildFullLumosConfig)(type_1.Network.devnet);
-    const testnetFullLumosConfig = (0, config_1.buildFullLumosConfig)(type_1.Network.testnet);
-    const mainnetFullLumosConfig = (0, config_1.buildFullLumosConfig)(type_1.Network.mainnet);
-    (0, config_1.updateScriptInfoInOffCKBConfigTs)(devnetFullLumosConfig, const_1.userOffCKBConfigPath, type_1.Network.devnet);
-    (0, config_1.updateScriptInfoInOffCKBConfigTs)(testnetFullLumosConfig, const_1.userOffCKBConfigPath, type_1.Network.testnet);
-    (0, config_1.updateScriptInfoInOffCKBConfigTs)(mainnetFullLumosConfig, const_1.userOffCKBConfigPath, type_1.Network.mainnet);
-    console.log('offCKB config updated.');
+    const userOffCKBConfigPath = path_1.default.resolve(process.cwd(), 'offckb.config.ts');
+    const contractInfoFolder = config_1.OffCKBConfigFile.readContractInfoFolder(userOffCKBConfigPath);
+    if (!contractInfoFolder) {
+        throw new Error('No contract info folder found in offckb.config.ts!');
+    }
+    const systemJsonFilePath = path_1.default.resolve(contractInfoFolder, 'system-scripts.json');
+    (0, gen_1.genSystemScriptsJsonFile)(systemJsonFilePath);
+    const myScriptsJsonFilePath = path_1.default.resolve(contractInfoFolder, 'my-scripts.json');
+    (0, gen_1.genMyScriptsJsonFile)(myScriptsJsonFilePath);
+    console.log('scripts json config updated.');
 }
 exports.syncConfig = syncConfig;

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;