@offckb/cli 0.4.9-canary-807f2ef.0 → 0.4.9

package/build/index.js

@@ -353,6 +353,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.runCli = runCli;
 const commander_1 = __nccwpck_require__(53497);
 const node_1 = __nccwpck_require__(998);
 const accounts_1 = __nccwpck_require__(87398);
@@ -367,6 +368,7 @@ const create_1 = __nccwpck_require__(51534);
 const config_1 = __nccwpck_require__(93004);
 const devnet_config_1 = __nccwpck_require__(10015);
 const devnet_fork_1 = __nccwpck_require__(36709);
+const devnet_info_1 = __nccwpck_require__(60905);
 const debug_1 = __nccwpck_require__(39591);
 const system_scripts_1 = __nccwpck_require__(86198);
 const transfer_all_1 = __nccwpck_require__(92039);
@@ -374,16 +376,26 @@ const gen_1 = __nccwpck_require__(750);
 const ckb_debugger_1 = __nccwpck_require__(14815);
 const logger_1 = __nccwpck_require__(65370);
 const status_1 = __nccwpck_require__(71420);
-const validator_1 = __nccwpck_require__(39534);
 const version = (__nccwpck_require__(8330)/* .version */ .rE);
 const description = (__nccwpck_require__(8330)/* .description */ .h_);
 // fix windows terminal encoding of simplified chinese text
 (0, encoding_1.setUTF8EncodingForWindows)();
 const program = new commander_1.Command();
 program.name('offckb').description(description).version(version).enablePositionalOptions();
+let activeCommand = 'offckb';
+function commandPath(command) {
+    const names = [];
+    let current = command;
+    while (current === null || current === void 0 ? void 0 : current.parent) {
+        names.unshift(current.name());
+        current = current.parent;
+    }
+    return names.join('.') || 'offckb';
+}
 program.option('--json', 'Output logs in JSON format for agent/programmatic consumption');
-program.hook('preAction', (thisCommand) => {
-    const opts = thisCommand.opts();
+program.hook('preAction', (_thisCommand, actionCommand) => {
+    activeCommand = commandPath(actionCommand);
+    const opts = actionCommand.optsWithGlobals();
     if (opts.json) {
         logger_1.logger.setJsonMode(true);
     }
@@ -420,7 +432,8 @@ program
     .option('--target <target>', 'Specify the script binaries file/folder path to deploy', './')
     .option('-o, --output <output>', 'Specify the output folder path for the deployment record files', './deployment')
     .option('-t, --type-id', 'Specify if use upgradable type id to deploy the script')
-    .option('--privkey <privkey>', 'Specify the private key to deploy scripts')
+    .option('--privkey <privkey>', 'Specify the private key to deploy scripts (visible in shell history)')
+    .option('--privkey-file <path>', 'Read the private key from a local file')
     .option('-y, --yes', 'Skip confirmation prompt and deploy immediately')
     .action((options) => (0, deploy_1.deploy)(options));
 program
@@ -433,8 +446,7 @@ program
     .action((option) => __awaiter(void 0, void 0, void 0, function* () {
     // For debugging, tx-hash is required
     if (!option.txHash) {
-        logger_1.logger.error('Error: --tx-hash is required for debugging operations');
-        process.exit(1);
+        throw new Error('--tx-hash is required for debugging operations');
     }
     const txHash = option.txHash;
     if (option.singleScript) {
@@ -464,34 +476,43 @@ program
     .description('Clean the devnet data, need to stop running the chain first')
     .option('-d, --data', 'Only remove chain data, keep devnet config files')
     .action((options) => (0, clean_1.clean)(options));
-program.command('accounts').description('Print account list info').action(accounts_1.accounts);
+program
+    .command('accounts')
+    .description('Print account list info')
+    .option('--show-private-keys', 'Include built-in dev private keys (hidden by default)')
+    .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+    yield (0, accounts_1.accounts)(options);
+}));
 program
     .command('deposit [toAddress] [amountInCKB]')
     .description('Deposit CKB tokens to address, only devnet and testnet')
     .option('--network <network>', 'Specify the network to deposit to', 'devnet')
     .option('-r, --proxy-rpc', 'Use Proxy RPC to connect to blockchain')
     .action((toAddress, amountInCKB, options) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, deposit_1.deposit)(toAddress, amountInCKB, options);
+    yield (0, deposit_1.deposit)(toAddress, amountInCKB, options);
 }));
 program
     .command('transfer [toAddress] [amount]')
     .description('Transfer CKB or UDT tokens to address, only devnet and testnet')
     .option('--network <network>', 'Specify the network to transfer to', 'devnet')
-    .option('--privkey <privkey>', 'Specify the private key to transfer')
-    .addOption(new commander_1.Option('--udt-kind <kind>', 'Specify the UDT kind').choices(['sudt', 'xudt']).default('sudt'))
+    .option('--privkey <privkey>', 'Specify the private key to transfer (visible in shell history)')
+    .option('--privkey-file <path>', 'Read the private key from a local file')
+    .addOption(new commander_1.Option('--udt-kind <kind>', 'Specify the UDT kind').choices(['sudt', 'xudt']))
     .option('--udt-type-args <typeArgs>', 'Specify the UDT type script args to transfer UDT')
+    .option('--allow-mainnet-replay-risk', 'Allow a non-built-in key on a Mainnet fork (copied inputs remain blocked)')
     .option('-r, --proxy-rpc', 'Use Proxy RPC to connect to blockchain')
     .action((toAddress, amount, options) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, transfer_1.transfer)(toAddress, amount, options);
+    yield (0, transfer_1.transfer)(toAddress, amount, options);
 }));
 program
     .command('transfer-all [toAddress]')
     .description('Transfer All CKB tokens to address, only devnet and testnet')
     .option('--network <network>', 'Specify the network to transfer to', 'devnet')
-    .option('--privkey <privkey>', 'Specify the private key to deploy scripts')
+    .option('--privkey <privkey>', 'Specify the private key (visible in shell history)')
+    .option('--privkey-file <path>', 'Read the private key from a local file')
     .option('-r, --proxy-rpc', 'Use Proxy RPC to connect to blockchain')
     .action((toAddress, options) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, transfer_all_1.transferAll)(toAddress, options);
+    yield (0, transfer_all_1.transferAll)(toAddress, options);
 }));
 program
     .command('balance [toAddress]')
@@ -501,7 +522,7 @@ program
     .option('--udt-type-args <typeArgs>', 'Filter by UDT type script args')
     .option('--no-udt', 'Skip UDT balance scan')
     .action((toAddress, options) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, balance_1.balanceOf)(toAddress, options);
+    yield (0, balance_1.balanceOf)(toAddress, options);
 }));
 const udtCommand = program.command('udt').description('UDT token commands');
 udtCommand
@@ -511,9 +532,10 @@ udtCommand
     .addOption(new commander_1.Option('--udt-kind <kind>', 'Specify the UDT kind').choices(['sudt', 'xudt']).default('sudt'))
     .option('--type-args <typeArgs>', 'Specify the UDT type script args (xudt only; defaults to signer lock hash)')
     .option('--to <toAddress>', 'Specify the receiver address (defaults to signer)')
-    .option('--privkey <privkey>', 'Specify the private key to issue UDT')
+    .option('--privkey <privkey>', 'Specify the private key to issue UDT (visible in shell history)')
+    .option('--privkey-file <path>', 'Read the private key from a local file')
     .action((amount, options) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, udt_1.udtIssue)(amount, options);
+    yield (0, udt_1.udtIssue)(amount, options);
 }));
 udtCommand
     .command('destroy <amount>')
@@ -521,9 +543,10 @@ udtCommand
     .option('--network <network>', 'Specify the network', 'devnet')
     .addOption(new commander_1.Option('--udt-kind <kind>', 'Specify the UDT kind').choices(['sudt', 'xudt']).default('sudt'))
     .requiredOption('--type-args <typeArgs>', 'Specify the UDT type script args')
-    .option('--privkey <privkey>', 'Specify the private key to destroy UDT')
+    .option('--privkey <privkey>', 'Specify the private key to destroy UDT (visible in shell history)')
+    .option('--privkey-file <path>', 'Read the private key from a local file')
     .action((amount, options) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, udt_1.udtDestroy)(amount, options);
+    yield (0, udt_1.udtDestroy)(amount, options);
 }));
 program
     .command('debugger')
@@ -537,10 +560,11 @@ program
 program
     .command('status')
     .description('Show ckb-tui status interface')
-    .option('--network <network>', 'Specify the network whose node status to monitor', 'devnet')
+    .addOption(new commander_1.Option('--network <network>', 'Specify the network whose node status to monitor')
+    .choices(['devnet', 'testnet', 'mainnet'])
+    .default('devnet'))
     .action((option) => __awaiter(void 0, void 0, void 0, function* () {
-    (0, validator_1.validateNetworkOpt)(option.network);
-    return yield (0, status_1.status)({ network: option.network });
+    yield (0, status_1.status)({ network: option.network });
 }));
 program
     .command('config <action> [item] [value]')
@@ -552,18 +576,77 @@ devnetCommand
     .description('Open a full-screen editor to tweak devnet config files')
     .option('-s, --set <key=value>', 'Set a devnet config field non-interactively (repeatable), e.g. --set ckb.logger.filter=info', (value, previous = []) => [...previous, value], [])
     .action(devnet_config_1.devnetConfig);
+devnetCommand
+    .command('info')
+    .description('Show fork metadata and node/indexer readiness')
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    yield (0, devnet_info_1.devnetInfo)();
+}));
 devnetCommand
     .command('fork')
     .description('Fork an existing mainnet/testnet chain data directory into the local devnet')
-    .requiredOption('--from <dir>', 'Path to the source CKB node directory (the one passed to ckb -C)')
+    .option('--from <dir>', 'Path to the source CKB node directory used with `ckb -C`')
     .option('--source <source>', 'Source chain: mainnet or testnet (auto-detected from the source ckb.toml when omitted)')
     .option('--spec-file <path>', 'Use a local chain spec file instead of downloading it')
     .option('--force', 'Replace the existing devnet (or a previous fork)')
+    .option('--migrate', 'Migrate only the copied database when the selected CKB version requires it')
+    .option('--dry-run', 'Run source/spec/database preflight without replacing the current devnet')
     .action(devnet_fork_1.devnetFork);
-program.parse(process.argv);
-// If no command is specified, display help
-if (!process.argv.slice(2).length) {
-    program.outputHelp();
+function normalizeGlobalJsonFlag(argv) {
+    const jsonRequested = argv.slice(2).includes('--json');
+    if (!jsonRequested)
+        return argv;
+    return [argv[0], argv[1], '--json', ...argv.slice(2).filter((arg) => arg !== '--json')];
+}
+function installBrokenPipeHandlers() {
+    for (const stream of [process.stdout, process.stderr]) {
+        stream.on('error', (error) => {
+            if (error.code === 'EPIPE') {
+                process.exit(0);
+            }
+            throw error;
+        });
+    }
+}
+function configureCommanderErrors(command) {
+    command.exitOverride();
+    command.configureOutput({
+        writeErr: (text) => {
+            if (!logger_1.logger.isJsonMode())
+                process.stderr.write(text);
+        },
+    });
+    command.commands.forEach(configureCommanderErrors);
+}
+function runCli() {
+    return __awaiter(this, arguments, void 0, function* (argv = process.argv) {
+        installBrokenPipeHandlers();
+        const normalizedArgv = normalizeGlobalJsonFlag(argv);
+        if (normalizedArgv.includes('--json'))
+            logger_1.logger.setJsonMode(true);
+        if (!normalizedArgv.slice(2).length) {
+            program.outputHelp();
+            return;
+        }
+        configureCommanderErrors(program);
+        try {
+            yield program.parseAsync(normalizedArgv);
+            if (logger_1.logger.isJsonMode() && !logger_1.logger.hasResult() && (process.exitCode == null || process.exitCode === 0)) {
+                logger_1.logger.result({ command: activeCommand, completed: true });
+            }
+        }
+        catch (error) {
+            if (error instanceof commander_1.CommanderError && error.exitCode === 0)
+                return;
+            const message = error instanceof Error ? error.message : String(error);
+            const code = error instanceof commander_1.CommanderError ? error.code : 'COMMAND_FAILED';
+            logger_1.logger.failure(code, message);
+            process.exitCode = error instanceof commander_1.CommanderError ? error.exitCode : 1;
+        }
+    });
+}
+if (require.main === require.cache[eval('__filename')]) {
+    void runCli();
 }
 
 
@@ -574,40 +657,90 @@ if (!process.argv.slice(2).length) {
 
 "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.accounts = accounts;
 const account_json_1 = __importDefault(__nccwpck_require__(13849));
+const core_1 = __nccwpck_require__(39842);
+const setting_1 = __nccwpck_require__(25546);
+const fork_1 = __nccwpck_require__(77912);
+const readiness_1 = __nccwpck_require__(19326);
+const base_1 = __nccwpck_require__(69951);
 const logger_1 = __nccwpck_require__(65370);
 function accounts() {
-    logger_1.logger.warn([
-        '#### All Accounts are for test and develop only  ####'.toUpperCase(),
-        "#### DON'T use these accounts on Mainnet         ####".toUpperCase(),
-        '#### Otherwise You will loose your money         ####'.toUpperCase(),
-        '',
-    ]);
-    logger_1.logger.info([
-        'Print account list, each account is funded with 42_000_000_00000000 capacity in the devnet genesis block.',
-        '',
-    ]);
-    const accountDetails = account_json_1.default.map((account, index) => {
-        return [
-            `- "#": ${index}`,
-            `address: ${account.address}`,
-            `privkey: ${account.privkey}`,
-            `pubkey: ${account.pubkey}`,
-            `lock_arg: ${account.lockScript.args}`,
-            'lockScript:',
-            `    codeHash: ${account.lockScript.codeHash}`,
-            `    hashType: ${account.lockScript.hashType}`,
-            `    args: ${account.lockScript.args}`,
+    return __awaiter(this, arguments, void 0, function* (options = {}) {
+        const settings = (0, setting_1.readSettings)();
+        const fork = (0, fork_1.readForkState)(settings.devnet.configPath);
+        const isMainnetFork = (fork === null || fork === void 0 ? void 0 : fork.source) === 'mainnet';
+        const client = isMainnetFork
+            ? new core_1.ccc.ClientPublicMainnet({ url: settings.devnet.rpcUrl, fallbacks: [] })
+            : new core_1.ccc.ClientPublicTestnet({ url: settings.devnet.rpcUrl, fallbacks: [] });
+        const context = fork ? `DEVNET (fork of ${fork.source.toUpperCase()})` : 'DEVNET';
+        const readiness = fork ? yield (0, readiness_1.warnIfForkIndexerIsBehind)(base_1.Network.devnet) : undefined;
+        const canReadSpendableBalance = (readiness === null || readiness === void 0 ? void 0 : readiness.ready) === true && readiness.indexerTip != null && readiness.indexerLag === BigInt(0);
+        logger_1.logger.warn([
+            '#### All Accounts are for test and develop only  ####'.toUpperCase(),
+            "#### DON'T use these accounts on Mainnet         ####".toUpperCase(),
+            '#### Otherwise You will lose your money          ####'.toUpperCase(),
             '',
-        ];
-    });
-    accountDetails.forEach((details, _index) => {
-        logger_1.logger.info(details);
+        ]);
+        if (fork) {
+            logger_1.logger.info([
+                `Print account list for ${context}. Addresses use the source-chain prefix.`,
+                'Forked devnets do not include the standard offckb genesis allocation; funds come from fork-mined cellbase cells.',
+                'Run `offckb devnet info` before trusting balances while the indexer catches up.',
+                '',
+            ]);
+        }
+        else {
+            logger_1.logger.info([
+                'Print account list, each account is funded with 42_000_000_00000000 capacity in the devnet genesis block.',
+                '',
+            ]);
+        }
+        const resolvedAccounts = yield Promise.all(account_json_1.default.map((account, index) => __awaiter(this, void 0, void 0, function* () {
+            const script = core_1.ccc.Script.from(account.lockScript);
+            const address = core_1.ccc.Address.fromScript(script, client).toString();
+            const spendableCkb = canReadSpendableBalance
+                ? core_1.ccc.fixedPointToString(yield client.getBalanceSingle(script))
+                : undefined;
+            return Object.assign(Object.assign(Object.assign({ index,
+                address }, (spendableCkb == null ? {} : { spendableCkb })), (options.showPrivateKeys ? { privkey: account.privkey } : {})), { pubkey: account.pubkey, lockArg: account.lockScript.args, lockScript: account.lockScript });
+        })));
+        const accountDetails = resolvedAccounts.map((account) => {
+            return [
+                `- "#": ${account.index}`,
+                `address: ${account.address}`,
+                ...('spendableCkb' in account ? [`spendable_ckb: ${account.spendableCkb}`] : []),
+                ...(options.showPrivateKeys ? [`privkey: ${account.privkey}`] : []),
+                `pubkey: ${account.pubkey}`,
+                `lock_arg: ${account.lockArg}`,
+                'lockScript:',
+                `    codeHash: ${account.lockScript.codeHash}`,
+                `    hashType: ${account.lockScript.hashType}`,
+                `    args: ${account.lockScript.args}`,
+                '',
+            ];
+        });
+        accountDetails.forEach((details, _index) => {
+            logger_1.logger.info(details);
+        });
+        if (!options.showPrivateKeys) {
+            logger_1.logger.info('Private keys are hidden by default. Use --show-private-keys only in a trusted local terminal.');
+        }
+        logger_1.logger.result({ command: 'accounts', context, forked: Boolean(fork), accounts: resolvedAccounts });
+        return resolvedAccounts;
     });
 }
 
@@ -634,10 +767,12 @@ const ckb_1 = __nccwpck_require__(83748);
 const validator_1 = __nccwpck_require__(39534);
 const base_1 = __nccwpck_require__(69951);
 const logger_1 = __nccwpck_require__(65370);
+const readiness_1 = __nccwpck_require__(19326);
 function balanceOf(address_1) {
     return __awaiter(this, arguments, void 0, function* (address, opt = { network: base_1.Network.devnet }) {
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
+        yield (0, readiness_1.warnIfForkIndexerIsBehind)(network);
         const ckb = new ckb_1.CKB({ network });
         const [balanceInCKB, udtBalances] = yield Promise.all([
             ckb.balance(address),
@@ -651,7 +786,9 @@ function balanceOf(address_1) {
                 logger_1.logger.info(`  ${udt.kind} (args=${udt.args}): ${udt.balance}`);
             }
         }
-        process.exit(0);
+        const result = { command: 'balance', network, address, ckb: balanceInCKB, udt: filtered };
+        logger_1.logger.result(result);
+        return result;
     });
 }
 function filterUdtBalances(balances, opt) {
@@ -695,8 +832,7 @@ function clean(options) {
                 logger_1.logger.info(`Chain data cleaned. Devnet config files preserved.`);
             }
             catch (error) {
-                logger_1.logger.info(`Did you stop running the chain first?`);
-                logger_1.logger.error(error.message);
+                throw new Error(`Failed to clean chain data. Did you stop the chain first? ${error.message}`);
             }
         }
         else {
@@ -712,8 +848,7 @@ function clean(options) {
                 logger_1.logger.info(`Chain data cleaned.`);
             }
             catch (error) {
-                logger_1.logger.info(`Did you stop running the chain first?`);
-                logger_1.logger.error(error.message);
+                throw new Error(`Failed to clean devnet data. Did you stop the chain first? ${error.message}`);
             }
         }
         else {
@@ -770,8 +905,7 @@ function Config(action, item, value) {
                     const settings = (0, setting_1.readSettings)();
                     const proxy = settings.proxy;
                     if (proxy == null) {
-                        logger_1.logger.info(`No Proxy.`);
-                        process.exit(0);
+                        return logger_1.logger.info(`No Proxy.`);
                     }
                     return logger_1.logger.info(`${request_1.Request.proxyConfigToUrl(proxy)}`);
                 }
@@ -796,7 +930,7 @@ function Config(action, item, value) {
                         return (0, setting_1.writeSettings)(settings);
                     }
                     catch (error) {
-                        return logger_1.logger.error(`invalid proxyURL, `, error.message);
+                        throw new Error(`invalid proxyURL: ${error.message}`);
                     }
                 }
                 case ConfigItem.ckbVersion: {
@@ -808,11 +942,11 @@ function Config(action, item, value) {
                             return (0, setting_1.writeSettings)(settings);
                         }
                         else {
-                            return logger_1.logger.error(`invalid version value, ${value}. Check available versions on https://github.com/nervosnetwork/ckb/tags`);
+                            throw new Error(`invalid version value, ${value}. Check available versions on https://github.com/nervosnetwork/ckb/tags`);
                         }
                     }
                     catch (error) {
-                        return logger_1.logger.error(`invalid version value, `, error.message);
+                        throw new Error(`invalid version value: ${error.message}`);
                     }
                 }
                 default:
@@ -932,8 +1066,7 @@ function createScriptProject(name_1) {
             const fullProjectPath = path.resolve(projectPath);
             // Check if directory already exists
             if (fs.existsSync(fullProjectPath)) {
-                logger_1.logger.error(`❌ Directory '${projectPath}' already exists!`);
-                process.exit(1);
+                throw new Error(`Directory '${projectPath}' already exists!`);
             }
             logger_1.logger.info([
                 '📝 Project details:',
@@ -954,8 +1087,7 @@ function createScriptProject(name_1) {
             // Get template directory (adjust path based on whether we're running from source or built)
             const templateDir = possiblePaths.find((p) => fs.existsSync(p)) || possiblePaths[0];
             if (!fs.existsSync(templateDir)) {
-                logger_1.logger.error(`❌ Template directory not found: ${templateDir}`);
-                process.exit(1);
+                throw new Error(`Template directory not found: ${templateDir}`);
             }
             // Initialize template processor
             const processor = new processor_1.TemplateProcessor(templateDir);
@@ -1031,8 +1163,7 @@ function createScriptProject(name_1) {
             }
         }
         catch (error) {
-            logger_1.logger.error(`\n❌ Failed to create project: ${error.message}`);
-            process.exit(1);
+            throw new Error(`Failed to create project: ${error.message}`);
         }
     });
 }
@@ -1257,8 +1388,7 @@ function buildContract(jsFile, outputFile, jsVmPath) {
             logger_1.logger.success(`✅ Contract built successfully: ${outputFile}`);
         }
         catch (error) {
-            logger_1.logger.error(`❌ Build failed: ${error}`);
-            process.exit(1);
+            throw new Error(`Build failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     });
 }
@@ -1294,14 +1424,19 @@ const deploy_1 = __nccwpck_require__(45615);
 const ckb_1 = __nccwpck_require__(83748);
 const prompts_1 = __nccwpck_require__(18167);
 const logger_1 = __nccwpck_require__(65370);
+const private_key_1 = __nccwpck_require__(26241);
+const readiness_1 = __nccwpck_require__(19326);
+const fork_safety_1 = __nccwpck_require__(47625);
 function deploy() {
     return __awaiter(this, arguments, void 0, function* (opt = { network: base_1.Network.devnet, typeId: false, target: './', output: './deployment' }) {
         var _a;
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
-        const ckb = new ckb_1.CKB({ network });
         // we use deployerAccount to deploy contract by default
-        const privateKey = opt.privkey || account_1.deployerAccount.privkey;
+        const privateKey = (0, private_key_1.resolvePrivateKey)(opt, account_1.deployerAccount.privkey);
+        (0, fork_safety_1.warnIfMainnetForkSigning)(network, privateKey);
+        yield (0, readiness_1.warnIfForkIndexerIsBehind)(network);
+        const ckb = new ckb_1.CKB({ network });
         const enableTypeId = (_a = opt.typeId) !== null && _a !== void 0 ? _a : false;
         const targetFolder = opt.target;
         const output = opt.output;
@@ -1325,7 +1460,7 @@ function deploy() {
             '',
             `   📁 Deployment artifacts will be saved to: ${outputFolder}`,
             `   🌐 Network: ${network}`,
-            `   🔑 Using ${opt.privkey ? 'custom' : 'default'} private key`,
+            `   🔑 Using ${opt.privkey || opt.privkeyFile || process.env.OFFCKB_PRIVATE_KEY ? 'custom' : 'default'} private key`,
             `   🔄 Type ID: ${enableTypeId ? 'enabled (upgradable)' : 'disabled (immutable)'}`,
         ]);
         // Skip confirmation if -y flag is provided
@@ -1371,22 +1506,40 @@ const link_1 = __nccwpck_require__(27814);
 const validator_1 = __nccwpck_require__(39534);
 const request_1 = __nccwpck_require__(65897);
 const logger_1 = __nccwpck_require__(65370);
+const readiness_1 = __nccwpck_require__(19326);
+const fork_safety_1 = __nccwpck_require__(47625);
+const TESTNET_FAUCET_CLAIM_AMOUNT = '10000';
 function deposit(toAddress_1, amountInCKB_1) {
     return __awaiter(this, arguments, void 0, function* (toAddress, amountInCKB, opt = { network: base_1.Network.devnet }) {
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
         const ckb = new ckb_1.CKB({ network });
         if (network === 'testnet') {
-            return yield depositFromTestnetFaucet(toAddress, ckb);
+            const txHash = yield depositFromTestnetFaucet(toAddress, ckb);
+            logger_1.logger.result({
+                command: 'deposit',
+                network,
+                source: 'fixed-testnet-faucet-claim',
+                requestedAmount: amountInCKB,
+                faucetClaimAmount: TESTNET_FAUCET_CLAIM_AMOUNT,
+                toAddress,
+                txHash,
+            });
+            return txHash;
         }
         // deposit from devnet miner
         const privateKey = account_1.ckbDevnetMinerAccount.privkey;
+        const rejectInputsAtOrBeforeBlock = (0, fork_safety_1.validateMainnetForkSigning)(network, privateKey);
+        yield (0, readiness_1.warnIfForkIndexerIsBehind)(network);
         const txHash = yield ckb.transfer({
             toAddress,
             privateKey,
             amountInCKB,
+            rejectInputsAtOrBeforeBlock,
         });
         logger_1.logger.info('tx hash: ', txHash);
+        logger_1.logger.result({ command: 'deposit', network, amount: amountInCKB, toAddress, txHash });
+        return txHash;
     });
 }
 function depositFromTestnetFaucet(ckbAddress, ckb) {
@@ -1412,6 +1565,7 @@ function depositFromTestnetFaucet(ckbAddress, ckb) {
         }
         const txHash = yield ckb.transferAll({ privateKey: randomAccountPrivateKey, toAddress: ckbAddress });
         logger_1.logger.info(`Done, check ${(0, link_1.buildTestnetTxLink)(txHash)} for details.`);
+        return txHash;
     });
 }
 function sendClaimRequest(toAddress) {
@@ -1427,7 +1581,7 @@ function sendClaimRequest(toAddress) {
         const body = JSON.stringify({
             claim_event: {
                 address_hash: toAddress,
-                amount: '10000', // unit: CKB
+                amount: TESTNET_FAUCET_CLAIM_AMOUNT, // unit: CKB
             },
         });
         const config = {
@@ -1509,12 +1663,8 @@ function devnetConfig() {
                 return;
             }
             if (!process.stdin.isTTY || !process.stdout.isTTY) {
-                logger_1.logger.error('Interactive devnet config editor requires a TTY terminal.');
-                logger_1.logger.info('Use non-interactive mode instead, e.g.:');
-                logger_1.logger.info('  offckb devnet config --set ckb.logger.filter=info');
-                logger_1.logger.info('  offckb devnet config --set miner.client.poll_interval=1500');
-                process.exitCode = 1;
-                return;
+                throw new Error('Interactive devnet config editor requires a TTY terminal. Use non-interactive mode, e.g. ' +
+                    '`offckb devnet config --set ckb.logger.filter=info`.');
             }
             const isSaved = yield (0, devnet_config_tui_1.runDevnetConfigTui)(editor, configPath);
             if (isSaved) {
@@ -1525,12 +1675,11 @@ function devnetConfig() {
             logger_1.logger.info('No changes saved.');
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger_1.logger.error(message);
+            let message = error instanceof Error ? error.message : String(error);
             if (error instanceof config_editor_1.InitializationError) {
-                logger_1.logger.info('Tip: run `offckb node` once to initialize devnet config files first.');
+                message += ' Tip: run `offckb node` once to initialize devnet config files first.';
             }
-            process.exitCode = 1;
+            throw new Error(message);
         }
     });
 }
@@ -1555,20 +1704,92 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.devnetFork = devnetFork;
 const fork_1 = __nccwpck_require__(77912);
-const logger_1 = __nccwpck_require__(65370);
 function devnetFork(options) {
     return __awaiter(this, void 0, void 0, function* () {
         if (options.source && options.source !== 'mainnet' && options.source !== 'testnet') {
-            logger_1.logger.error(`Invalid --source value: ${options.source}. Expected mainnet or testnet.`);
-            process.exit(1);
-        }
-        try {
-            yield (0, fork_1.forkDevnet)(options);
-        }
-        catch (error) {
-            logger_1.logger.error(error.message);
-            process.exit(1);
+            throw new Error(`Invalid --source value: ${options.source}. Expected mainnet or testnet.`);
         }
+        yield (0, fork_1.forkDevnet)(options);
+    });
+}
+
+
+/***/ }),
+
+/***/ 60905:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.devnetInfo = devnetInfo;
+const setting_1 = __nccwpck_require__(25546);
+const fork_1 = __nccwpck_require__(77912);
+const readiness_1 = __nccwpck_require__(19326);
+const logger_1 = __nccwpck_require__(65370);
+function devnetInfo() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const settings = (0, setting_1.readSettings)();
+        const fork = (0, fork_1.readForkState)(settings.devnet.configPath);
+        const readiness = yield (0, readiness_1.checkNodeReadiness)(settings.devnet.rpcUrl);
+        const indexerReady = readiness.indexerTip != null && readiness.indexerLag === BigInt(0);
+        const networkIsolated = fork && readiness.peers != null ? readiness.peers === 0 : undefined;
+        const result = {
+            command: 'devnet.info',
+            kind: fork ? `fork-of-${fork.source}` : 'pure-devnet',
+            configPath: settings.devnet.configPath,
+            rpcUrl: settings.devnet.rpcUrl,
+            proxyUrl: `http://127.0.0.1:${settings.devnet.rpcProxyPort}`,
+            ready: readiness.ready,
+            nodeTip: (_a = readiness.nodeTip) === null || _a === void 0 ? void 0 : _a.toString(),
+            indexerTip: (_b = readiness.indexerTip) === null || _b === void 0 ? void 0 : _b.toString(),
+            indexerLag: (_c = readiness.indexerLag) === null || _c === void 0 ? void 0 : _c.toString(),
+            indexerReady,
+            peers: readiness.peers,
+            networkIsolated,
+            error: readiness.error,
+            fork,
+        };
+        logger_1.logger.info(`Devnet: ${result.kind}`);
+        logger_1.logger.info(`RPC: ${result.rpcUrl}`);
+        logger_1.logger.info(`Proxy RPC: ${result.proxyUrl}`);
+        logger_1.logger.info(`Node ready: ${result.ready ? 'yes' : 'no'}`);
+        if (readiness.nodeTip != null)
+            logger_1.logger.info(`Node tip: ${readiness.nodeTip}`);
+        if (readiness.indexerTip != null)
+            logger_1.logger.info(`Indexer tip: ${readiness.indexerTip}`);
+        if (readiness.indexerLag != null) {
+            const message = `Indexer lag: ${readiness.indexerLag}`;
+            if (readiness.indexerLag > BigInt(0))
+                logger_1.logger.warn(`${message}; indexed queries may be stale.`);
+            else
+                logger_1.logger.info(message);
+        }
+        logger_1.logger.info(`Indexer ready: ${indexerReady ? 'yes' : 'no'}`);
+        if (readiness.peers != null)
+            logger_1.logger.info(`Peers: ${readiness.peers}`);
+        if (fork)
+            logger_1.logger.info(`Public network isolated: ${networkIsolated == null ? 'unknown' : networkIsolated ? 'yes' : 'NO'}`);
+        if (fork && readiness.peers != null && readiness.peers > 0) {
+            logger_1.logger.warn('A forked devnet has connected peers. Stop it and inspect ckb.toml before signing or mining.');
+        }
+        if ((fork === null || fork === void 0 ? void 0 : fork.source) === 'mainnet') {
+            logger_1.logger.warn('MAINNET FORK REPLAY RISK: only sign with built-in dev keys and fork-mined cells.');
+        }
+        if (readiness.error)
+            logger_1.logger.warn(readiness.error);
+        logger_1.logger.result(result);
+        return result;
     });
 }
 
@@ -1634,16 +1855,23 @@ const path = __importStar(__nccwpck_require__(16928));
 const init_chain_1 = __nccwpck_require__(1360);
 const install_1 = __nccwpck_require__(65611);
 const setting_1 = __nccwpck_require__(25546);
-const encoding_1 = __nccwpck_require__(6851);
 const rpc_proxy_1 = __nccwpck_require__(46589);
 const fork_1 = __nccwpck_require__(77912);
 const json_rpc_1 = __nccwpck_require__(51726);
 const base_1 = __nccwpck_require__(69951);
 const logger_1 = __nccwpck_require__(65370);
+const readiness_1 = __nccwpck_require__(19326);
 const DAEMON_LOG_DIR = 'logs';
 const DAEMON_LOG_FILE = 'daemon.log';
 const DAEMON_PID_FILE = 'daemon.pid';
 const DAEMON_CHILD_ENV = 'OFFCKB_DAEMON_CHILD';
+const NODE_READY_TIMEOUT_MS = 90000;
+const FORK_NODE_READY_TIMEOUT_MS = 10 * 60000;
+function cleanChildOutput(data) {
+    // CKB colors its output even when it is redirected. Strip ANSI control
+    // sequences so JSON logs stay machine-readable.
+    return String(data).replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '');
+}
 function startNode({ version, network = base_1.Network.devnet, binaryPath, daemon }) {
     if (binaryPath && network !== base_1.Network.devnet) {
         logger_1.logger.warn('Custom binaryPath is only supported for devnet. The provided binaryPath will be ignored.');
@@ -1664,7 +1892,7 @@ function startNode({ version, network = base_1.Network.devnet, binaryPath, daemo
 }
 function nodeDevnet(_a) {
     return __awaiter(this, arguments, void 0, function* ({ version, binaryPath, daemon }) {
-        var _b, _c;
+        var _b, _c, _d, _e, _f;
         if (daemon) {
             return startDaemon();
         }
@@ -1672,15 +1900,15 @@ function nodeDevnet(_a) {
         const ckbVersion = version || settings.bins.defaultCKBVersion;
         let ckbBinPath = '';
         if (binaryPath) {
-            ckbBinPath = (0, encoding_1.encodeBinPathForTerminal)(binaryPath);
+            ckbBinPath = binaryPath;
             logger_1.logger.info(`Using custom CKB binary path: ${ckbBinPath}`);
         }
         else {
             yield (0, install_1.installCKBBinary)(ckbVersion);
-            ckbBinPath = (0, encoding_1.encodeBinPathForTerminal)((0, setting_1.getCKBBinaryPath)(ckbVersion));
+            ckbBinPath = (0, setting_1.getCKBBinaryPath)(ckbVersion);
         }
         yield (0, init_chain_1.initChainIfNeeded)();
-        const devnetConfigPath = (0, encoding_1.encodeBinPathForTerminal)(settings.devnet.configPath);
+        const devnetConfigPath = settings.devnet.configPath;
         // A forked devnet must boot once with --skip-spec-check --overwrite-spec so
         // the imported (and patched) spec replaces the source chain's stored spec.
         const forkState = (0, fork_1.readForkState)(settings.devnet.configPath);
@@ -1688,50 +1916,98 @@ function nodeDevnet(_a) {
         if (forkState === null || forkState === void 0 ? void 0 : forkState.firstRunPending) {
             logger_1.logger.info(`Forked devnet (${forkState.source}) detected, first run uses --skip-spec-check --overwrite-spec.`);
         }
-        const ckbCmd = `${ckbBinPath} run -C ${devnetConfigPath}${firstRunFlags}`;
-        const minerCmd = `${ckbBinPath} miner -C ${devnetConfigPath}`;
         logger_1.logger.info(`Launching CKB devnet Node...`);
+        const runArgs = ['run', '-C', devnetConfigPath];
+        if (firstRunFlags)
+            runArgs.push('--skip-spec-check', '--overwrite-spec');
+        const ckbProcess = (0, child_process_1.spawn)(ckbBinPath, runArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+        (_b = ckbProcess.stdout) === null || _b === void 0 ? void 0 : _b.on('data', (data) => logger_1.logger.info(['CKB:', cleanChildOutput(data)]));
+        (_c = ckbProcess.stderr) === null || _c === void 0 ? void 0 : _c.on('data', (data) => logger_1.logger.error(['CKB error:', cleanChildOutput(data)]));
+        let ckbExited = false;
+        ckbProcess.once('exit', () => {
+            ckbExited = true;
+        });
+        ckbProcess.once('error', () => {
+            ckbExited = true;
+        });
+        const timeoutMs = forkState ? FORK_NODE_READY_TIMEOUT_MS : NODE_READY_TIMEOUT_MS;
+        const readiness = yield (0, readiness_1.waitForNodeReady)(settings.devnet.rpcUrl, timeoutMs, () => !ckbExited);
+        if (!readiness.ready) {
+            if (!ckbExited)
+                ckbProcess.kill('SIGTERM');
+            throw new Error(`CKB devnet failed to become ready: ${(_d = readiness.error) !== null && _d !== void 0 ? _d : 'CKB process exited'}`);
+        }
+        if (ckbExited) {
+            throw new Error('CKB devnet exited immediately after its readiness check.');
+        }
+        if (forkState === null || forkState === void 0 ? void 0 : forkState.firstRunPending) {
+            yield clearForkFirstRunWhenNodeUp(ckbProcess, settings.devnet.rpcUrl, settings.devnet.configPath, forkState.genesisHash);
+        }
+        let minerProcess;
         try {
-            // Run first command
-            const ckbProcess = (0, child_process_1.exec)(ckbCmd);
-            // Log first command's output
-            (_b = ckbProcess.stdout) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
-                logger_1.logger.info(['CKB:', data.toString()]);
-            });
-            (_c = ckbProcess.stderr) === null || _c === void 0 ? void 0 : _c.on('data', (data) => {
-                logger_1.logger.error(['CKB error:', data.toString()]);
-            });
-            if (forkState === null || forkState === void 0 ? void 0 : forkState.firstRunPending) {
-                // Only clear the flag once the spawned node is actually up and reports
-                // the fork's genesis; if startup fails, the next run retries the flags.
-                void clearForkFirstRunWhenNodeUp(ckbProcess, settings.devnet.rpcUrl, settings.devnet.configPath, forkState.genesisHash);
-            }
-            // Start the second command after 3 seconds
-            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                try {
-                    // Run second command
-                    const minerProcess = (0, child_process_1.exec)(minerCmd);
-                    (_a = minerProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-                        logger_1.logger.info(['CKB-Miner:', data.toString()]);
-                    });
-                    (_b = minerProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
-                        logger_1.logger.error(['CKB-Miner error:', data.toString()]);
-                    });
-                    // by default we start the proxy server
-                    const ckbRpc = settings.devnet.rpcUrl;
-                    const port = settings.devnet.rpcProxyPort;
-                    const proxy = (0, rpc_proxy_1.createRPCProxy)(base_1.Network.devnet, ckbRpc, port);
-                    proxy.start();
-                }
-                catch (error) {
-                    logger_1.logger.error('Error running CKB-Miner:', error);
-                }
-            }), 3000);
+            minerProcess = (0, child_process_1.spawn)(ckbBinPath, ['miner', '-C', devnetConfigPath], { stdio: ['ignore', 'pipe', 'pipe'] });
         }
         catch (error) {
-            logger_1.logger.error('Error:', error);
+            ckbProcess.kill('SIGTERM');
+            throw new Error(`CKB miner failed to start: ${error.message}`);
         }
+        (_e = minerProcess.stdout) === null || _e === void 0 ? void 0 : _e.on('data', (data) => logger_1.logger.info(['CKB-Miner:', cleanChildOutput(data)]));
+        (_f = minerProcess.stderr) === null || _f === void 0 ? void 0 : _f.on('data', (data) => logger_1.logger.error(['CKB-Miner error:', cleanChildOutput(data)]));
+        try {
+            yield waitForChildSpawn(minerProcess, 'CKB miner');
+        }
+        catch (error) {
+            ckbProcess.kill('SIGTERM');
+            throw error;
+        }
+        if (ckbExited) {
+            if (!minerProcess.killed)
+                minerProcess.kill('SIGTERM');
+            throw new Error('CKB devnet exited while the miner was starting.');
+        }
+        const proxy = (0, rpc_proxy_1.createRPCProxy)(base_1.Network.devnet, settings.devnet.rpcUrl, settings.devnet.rpcProxyPort);
+        proxy.start();
+        logger_1.logger.success(`CKB devnet is ready at ${settings.devnet.rpcUrl}.`);
+        logger_1.logger.result({
+            command: 'node',
+            network: base_1.Network.devnet,
+            daemon: false,
+            rpcUrl: settings.devnet.rpcUrl,
+            proxyUrl: `http://127.0.0.1:${settings.devnet.rpcProxyPort}`,
+        });
+        // Treat CKB, miner and proxy as one service. A dead CKB must not leave a
+        // healthy-looking proxy and a miner that retries forever.
+        let serviceStopping = false;
+        const stopService = (component, code, signal) => {
+            if (serviceStopping)
+                return;
+            serviceStopping = true;
+            if (component !== 'CKB node' && !ckbProcess.killed)
+                ckbProcess.kill('SIGTERM');
+            if (component !== 'CKB miner' && !minerProcess.killed)
+                minerProcess.kill('SIGTERM');
+            proxy.stop();
+            if (process.env[DAEMON_CHILD_ENV] === '1')
+                cleanupPidFile(resolveDaemonPaths().pidFile);
+            logger_1.logger.error(`${component} exited unexpectedly (code=${code !== null && code !== void 0 ? code : 'null'}, signal=${signal !== null && signal !== void 0 ? signal : 'none'}).`);
+            process.exitCode = typeof code === 'number' && code > 0 ? code : 1;
+        };
+        ckbProcess.once('exit', (code, signal) => stopService('CKB node', code, signal));
+        minerProcess.once('exit', (code, signal) => stopService('CKB miner', code, signal));
+    });
+}
+function waitForChildSpawn(child, label) {
+    return new Promise((resolve, reject) => {
+        const onSpawn = () => {
+            child.removeListener('error', onError);
+            resolve();
+        };
+        const onError = (error) => {
+            child.removeListener('spawn', onSpawn);
+            reject(new Error(`${label} failed to start: ${error.message}`));
+        };
+        child.once('spawn', onSpawn);
+        child.once('error', onError);
     });
 }
 function resolveDaemonPaths() {
@@ -1765,7 +2041,10 @@ function clearForkFirstRunWhenNodeUp(ckbProcess, rpcUrl, configPath, expectedGen
                         'leaving the first-run flags in place.');
                     return;
                 }
-                (0, fork_1.markForkFirstRunComplete)(configPath);
+                // The miner has not started yet, so this tip is the exact boundary
+                // between copied public-chain state and cells mined on the local fork.
+                const forkBlockNumber = BigInt(String(yield (0, json_rpc_1.callJsonRpc)(rpcUrl, 'get_tip_block_number', [], 5000))).toString();
+                (0, fork_1.markForkFirstRunComplete)(configPath, forkBlockNumber);
                 logger_1.logger.success('Forked devnet is up; first-run spec flags cleared.');
                 return;
             }
@@ -1807,6 +2086,7 @@ function readPidFile(pidFile) {
                 pid,
                 scriptPath: parsed.scriptPath,
                 startedAt: (_b = parsed.startedAt) !== null && _b !== void 0 ? _b : new Date(0).toISOString(),
+                status: parsed.status,
             };
         }
     }
@@ -1820,6 +2100,39 @@ function readPidFile(pidFile) {
 function writePidFile(pidFile, metadata) {
     fs.writeFileSync(pidFile, JSON.stringify(metadata, null, 2));
 }
+function reservePidFile(pidFile, scriptPath) {
+    let fd;
+    try {
+        fd = fs.openSync(pidFile, 'wx');
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === 'EEXIST') {
+            throw new Error('A CKB devnet daemon startup is already in progress. Try again after it completes.');
+        }
+        throw new Error(`Failed to reserve daemon PID file ${pidFile}: ${err.message}`);
+    }
+    let writeError;
+    try {
+        const reservation = {
+            pid: process.pid,
+            scriptPath,
+            startedAt: new Date().toISOString(),
+            status: 'starting',
+        };
+        fs.writeFileSync(fd, JSON.stringify(reservation, null, 2));
+    }
+    catch (error) {
+        writeError = error;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    if (writeError) {
+        cleanupPidFile(pidFile);
+        throw new Error(`Failed to initialize daemon PID reservation ${pidFile}: ${writeError.message}`);
+    }
+}
 function resolveCliEntry() {
     var _a;
     // In priority order. process.argv[1] is the most reliable for a Node CLI.
@@ -1841,12 +2154,19 @@ function resolveCliEntry() {
     return null;
 }
 function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
     try {
         process.kill(pid, 0);
         return true;
     }
-    catch (_a) {
-        return false;
+    catch (error) {
+        const err = error;
+        if (err.code === 'ESRCH')
+            return false;
+        if (err.code === 'EPERM')
+            throw new Error(`Permission denied when checking daemon process ${pid}.`);
+        throw error;
     }
 }
 function cleanupPidFile(pidFile) {
@@ -1859,10 +2179,16 @@ function cleanupPidFile(pidFile) {
 }
 function waitForProcessExit(pid, timeoutMs) {
     const start = Date.now();
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
         const check = () => {
-            if (!isProcessAlive(pid)) {
-                resolve(true);
+            try {
+                if (!isProcessAlive(pid)) {
+                    resolve(true);
+                    return;
+                }
+            }
+            catch (error) {
+                reject(error);
                 return;
             }
             if (Date.now() - start >= timeoutMs) {
@@ -1942,73 +2268,159 @@ function terminateProcess(pid, signal) {
         }
     });
 }
+function failDaemonStartup(error, pid, pidFile) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let exited = false;
+        try {
+            exited = !isProcessAlive(pid);
+            if (!exited) {
+                yield terminateProcess(pid, 'SIGTERM');
+                exited = yield waitForProcessExit(pid, 5000);
+                if (!exited) {
+                    yield terminateProcess(pid, 'SIGKILL');
+                    exited = yield waitForProcessExit(pid, 5000);
+                }
+            }
+        }
+        catch (_a) {
+            // The child may have exited while cleanup signals were sent. If liveness
+            // cannot be checked, preserve the PID file for a later explicit stop.
+            try {
+                exited = !isProcessAlive(pid);
+            }
+            catch (_b) {
+                exited = false;
+            }
+        }
+        if (exited) {
+            cleanupPidFile(pidFile);
+        }
+        else {
+            error.message += ` Process ${pid} is still running; PID file was preserved.`;
+        }
+        throw error;
+    });
+}
 function startDaemon() {
-    const { logDir, logFile, pidFile } = resolveDaemonPaths();
-    // Prevent duplicate daemon starts. If a daemon is already running, refuse
-    // to overwrite its PID file.
-    const existing = readPidFile(pidFile);
-    if (existing && isProcessAlive(existing.pid)) {
-        logger_1.logger.error(`A CKB devnet daemon is already running (PID ${existing.pid}). Stop it first with: offckb node stop`);
-        return;
-    }
-    if (existing && !isProcessAlive(existing.pid)) {
-        // Stale PID file from a crashed daemon; clean it up before starting anew.
-        cleanupPidFile(pidFile);
-    }
-    let out;
-    let err;
-    try {
-        fs.mkdirSync(logDir, { recursive: true });
-        out = fs.openSync(logFile, 'a');
-        err = fs.openSync(logFile, 'a');
-    }
-    catch (error) {
-        logger_1.logger.error(`Failed to prepare daemon log directory or log file at ${logFile}:`, error);
-        return;
-    }
-    const scriptPath = resolveCliEntry();
-    if (!scriptPath) {
-        logger_1.logger.error('Unable to determine the CLI entry point for daemon mode. Set OFFCKB_CLI_PATH to the offckb script.');
-        closeFileDescriptors(out, err);
-        return;
-    }
-    const childArgs = process.argv.slice(2).filter((arg) => arg !== '--daemon');
-    const childEnv = Object.assign(Object.assign({}, process.env), { [DAEMON_CHILD_ENV]: '1' });
-    let child;
-    try {
-        child = (0, child_process_1.spawn)(process.execPath, [scriptPath, ...childArgs], {
-            detached: true,
-            stdio: ['ignore', out, err],
-            env: childEnv,
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { logDir, logFile, pidFile } = resolveDaemonPaths();
+        try {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        catch (error) {
+            throw new Error(`Failed to prepare daemon log directory at ${logDir}: ${error.message}`);
+        }
+        const settings = (0, setting_1.readSettings)();
+        const activeNode = yield (0, readiness_1.checkNodeReadiness)(settings.devnet.rpcUrl, 1000);
+        if (activeNode.ready) {
+            throw new Error(`A CKB node is already answering at ${settings.devnet.rpcUrl}. Stop it before starting daemon mode.`);
+        }
+        // Prevent duplicate daemon starts. If a daemon is already running, refuse
+        // to overwrite its PID file.
+        const existing = readPidFile(pidFile);
+        if (existing) {
+            if (isProcessAlive(existing.pid)) {
+                const identityOk = yield verifyDaemonIdentity(existing.pid, existing);
+                if (identityOk) {
+                    if (existing.status === 'starting') {
+                        throw new Error(`Another CKB devnet daemon startup is already in progress (PID ${existing.pid}).`);
+                    }
+                    throw new Error(`A CKB devnet daemon is already running (PID ${existing.pid}). Stop it first with: offckb node stop`);
+                }
+                logger_1.logger.warn(`PID ${existing.pid} from ${pidFile} belongs to another process; removing stale daemon metadata without signaling it.`);
+            }
+            // Stale PID file from a crashed daemon; clean it up before atomically
+            // reserving the same control file for this startup attempt.
+            cleanupPidFile(pidFile);
+        }
+        const scriptPath = resolveCliEntry();
+        if (!scriptPath) {
+            throw new Error('Unable to determine the CLI entry point for daemon mode. Set OFFCKB_CLI_PATH to the offckb script.');
+        }
+        reservePidFile(pidFile, scriptPath);
+        let out;
+        let err;
+        try {
+            out = fs.openSync(logFile, 'a');
+            err = fs.openSync(logFile, 'a');
+        }
+        catch (error) {
+            closeFileDescriptors(out, err);
+            cleanupPidFile(pidFile);
+            throw new Error(`Failed to prepare daemon log directory or log file at ${logFile}: ${error.message}`);
+        }
+        const childArgs = process.argv.slice(2).filter((arg) => arg !== '--daemon');
+        const childEnv = Object.assign(Object.assign({}, process.env), { [DAEMON_CHILD_ENV]: '1' });
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(process.execPath, [scriptPath, ...childArgs], {
+                detached: true,
+                stdio: ['ignore', out, err],
+                env: childEnv,
+            });
+        }
+        catch (error) {
+            closeFileDescriptors(out, err);
+            cleanupPidFile(pidFile);
+            throw new Error(`Failed to spawn daemon process: ${error.message}`);
+        }
+        if (!child.pid) {
+            closeFileDescriptors(out, err);
+            cleanupPidFile(pidFile);
+            throw new Error('Failed to spawn daemon process: no PID returned.');
+        }
+        child.unref();
+        child.on('error', (error) => {
+            logger_1.logger.error('Daemon child process failed to start:', error);
+            cleanupPidFile(pidFile);
         });
-    }
-    catch (error) {
-        logger_1.logger.error('Failed to spawn daemon process:', error);
-        closeFileDescriptors(out, err);
-        return;
-    }
-    if (!child.pid) {
-        logger_1.logger.error('Failed to spawn daemon process: no PID returned.');
+        const metadata = {
+            pid: child.pid,
+            scriptPath,
+            startedAt: new Date().toISOString(),
+            status: 'starting',
+        };
+        try {
+            writePidFile(pidFile, metadata);
+        }
+        catch (error) {
+            closeFileDescriptors(out, err);
+            return failDaemonStartup(error, child.pid, pidFile);
+        }
+        // File descriptors are now owned by the spawned child; close our copies.
         closeFileDescriptors(out, err);
-        return;
-    }
-    child.unref();
-    child.on('error', (error) => {
-        logger_1.logger.error('Daemon child process failed to start:', error);
-        cleanupPidFile(pidFile);
+        const proxyUrl = `http://127.0.0.1:${settings.devnet.rpcProxyPort}`;
+        try {
+            const forkState = (0, fork_1.readForkState)(settings.devnet.configPath);
+            const timeoutMs = forkState ? FORK_NODE_READY_TIMEOUT_MS : NODE_READY_TIMEOUT_MS;
+            // The proxy only starts after the child has a healthy CKB RPC and has
+            // successfully spawned the miner, so this is the daemon's service-level
+            // readiness check rather than a port/process check.
+            const readiness = yield (0, readiness_1.waitForNodeReady)(proxyUrl, timeoutMs, () => isProcessAlive(child.pid));
+            if (!readiness.ready) {
+                throw new Error(`CKB devnet daemon failed to become ready. See ${logFile}. ${(_a = readiness.error) !== null && _a !== void 0 ? _a : 'Daemon process exited.'}`);
+            }
+            writePidFile(pidFile, Object.assign(Object.assign({}, metadata), { status: 'running' }));
+        }
+        catch (error) {
+            return failDaemonStartup(error, child.pid, pidFile);
+        }
+        logger_1.logger.success(`CKB devnet daemon started with PID ${child.pid} and passed its RPC/proxy health check.`);
+        logger_1.logger.info(`Logs: ${logFile}`);
+        logger_1.logger.info(`PID file: ${pidFile}`);
+        logger_1.logger.info('Stop the daemon with: offckb node stop');
+        logger_1.logger.result({
+            command: 'node',
+            network: base_1.Network.devnet,
+            daemon: true,
+            pid: child.pid,
+            rpcUrl: settings.devnet.rpcUrl,
+            proxyUrl,
+            logFile,
+            pidFile,
+        });
     });
-    const metadata = {
-        pid: child.pid,
-        scriptPath,
-        startedAt: new Date().toISOString(),
-    };
-    writePidFile(pidFile, metadata);
-    // File descriptors are now owned by the spawned child; close our copies.
-    closeFileDescriptors(out, err);
-    logger_1.logger.success(`CKB devnet daemon started with PID ${child.pid}.`);
-    logger_1.logger.info(`Logs: ${logFile}`);
-    logger_1.logger.info(`PID file: ${pidFile}`);
-    logger_1.logger.info('Stop the daemon with: offckb node stop');
 }
 function closeFileDescriptors(...fds) {
     for (const fd of fds) {
@@ -2028,24 +2440,28 @@ function stopNode() {
         const metadata = readPidFile(pidFile);
         if (!metadata) {
             logger_1.logger.warn(`No daemon PID file found at ${pidFile}. Is the devnet daemon running?`);
+            logger_1.logger.result({ command: 'node.stop', stopped: false, reason: 'not-running' });
             return;
         }
         const pid = metadata.pid;
         if (!Number.isInteger(pid) || pid <= 0) {
-            logger_1.logger.error(`Invalid PID in ${pidFile}: ${pid}`);
             cleanupPidFile(pidFile);
-            return;
+            throw new Error(`Invalid PID in ${pidFile}: ${pid}`);
         }
-        if (!isProcessAlive(pid)) {
+        const processAlive = isProcessAlive(pid);
+        if (!processAlive) {
             logger_1.logger.warn(`Daemon process ${pid} is not running.`);
             cleanupPidFile(pidFile);
+            logger_1.logger.result({ command: 'node.stop', stopped: false, reason: 'stale-pid', pid });
             return;
         }
+        if (metadata.status === 'starting') {
+            throw new Error(`CKB devnet daemon startup is still in progress (PID ${pid}). Try stopping it again shortly.`);
+        }
         const identityOk = yield verifyDaemonIdentity(pid, metadata);
         if (!identityOk) {
-            logger_1.logger.error(`Process ${pid} does not appear to be the offckb daemon. Refusing to send signals to avoid killing an unrelated process. ` +
+            throw new Error(`Process ${pid} does not appear to be the offckb daemon. Refusing to send signals to avoid killing an unrelated process. ` +
                 `If you are sure this is the daemon, stop it manually and remove ${pidFile}.`);
-            return;
         }
         logger_1.logger.info(`Stopping CKB devnet daemon (PID ${pid})...`);
         try {
@@ -2056,17 +2472,13 @@ function stopNode() {
             if (err.code === 'ESRCH') {
                 logger_1.logger.warn(`Daemon process ${pid} is not running.`);
                 cleanupPidFile(pidFile);
+                logger_1.logger.result({ command: 'node.stop', stopped: false, reason: 'already-exited', pid });
                 return;
             }
             if (err.code === 'EPERM') {
-                logger_1.logger.error(`Permission denied when sending SIGTERM to daemon process ${pid}.`);
+                throw new Error(`Permission denied when sending SIGTERM to daemon process ${pid}.`);
             }
-            else {
-                logger_1.logger.error(`Failed to send SIGTERM to daemon process ${pid}:`, error);
-            }
-            // Still try to clean up the PID file so the user can recover.
-            cleanupPidFile(pidFile);
-            return;
+            throw new Error(`Failed to send SIGTERM to daemon process ${pid}: ${err.message}`);
         }
         const exited = yield waitForProcessExit(pid, 5000);
         if (!exited) {
@@ -2075,11 +2487,12 @@ function stopNode() {
                 yield terminateProcess(pid, 'SIGKILL');
             }
             catch (error) {
-                logger_1.logger.error(`Failed to send SIGKILL to daemon process ${pid}:`, error);
+                throw new Error(`Failed to send SIGKILL to daemon process ${pid}: ${error.message}`);
             }
         }
         cleanupPidFile(pidFile);
         logger_1.logger.success('CKB devnet daemon stopped.');
+        logger_1.logger.result({ command: 'node.stop', stopped: true, pid });
     });
 }
 function nodeTestnet() {
@@ -2113,39 +2526,6 @@ function nodeMainnet() {
 
 "use strict";
 
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -2160,8 +2540,7 @@ exports.status = status;
 const setting_1 = __nccwpck_require__(25546);
 const ckb_tui_1 = __nccwpck_require__(7020);
 const base_1 = __nccwpck_require__(69951);
-const logger_1 = __nccwpck_require__(65370);
-const net = __importStar(__nccwpck_require__(69278));
+const readiness_1 = __nccwpck_require__(19326);
 const NETWORK_SETTINGS_KEY = {
     [base_1.Network.devnet]: 'devnet',
     [base_1.Network.testnet]: 'testnet',
@@ -2169,65 +2548,27 @@ const NETWORK_SETTINGS_KEY = {
 };
 function status(_a) {
     return __awaiter(this, arguments, void 0, function* ({ network }) {
-        var _b;
+        var _b, _c;
         // ckb-tui is an interactive terminal UI. Running it without a TTY
         // (pipe, redirect, CI) would hang or produce garbage output.
         if (!process.stdout.isTTY || !process.stdin.isTTY) {
-            logger_1.logger.error('The status command requires an interactive terminal (TTY). ' +
-                'It cannot be used in pipes, redirects, or non-interactive environments like CI.');
-            process.exit(1);
+            throw new Error('The status command requires an interactive terminal (TTY). It cannot be used in pipes, redirects, or CI.');
         }
         const settings = (0, setting_1.readSettings)();
         const networkKey = NETWORK_SETTINGS_KEY[network];
         const port = settings[networkKey].rpcProxyPort;
         const url = `http://127.0.0.1:${port}`;
-        const isListening = yield isRPCPortListening(port);
-        if (!isListening) {
-            logger_1.logger.error(`RPC port ${port} is not listening. Please make sure the ${network} node is running and Proxy RPC is enabled.`);
-            return;
+        const readiness = yield (0, readiness_1.checkNodeReadiness)(url);
+        if (!readiness.ready) {
+            throw new Error(`RPC proxy ${url} is not connected to a healthy ${network} node: ${(_b = readiness.error) !== null && _b !== void 0 ? _b : 'health check failed'}`);
         }
         const result = ckb_tui_1.CKBTui.run(['-r', url]);
         // Propagate ckb-tui exit code so scripts can detect TUI failure
         if (result.status !== 0) {
-            process.exitCode = (_b = result.status) !== null && _b !== void 0 ? _b : 1;
+            throw new Error(`ckb-tui exited with code ${(_c = result.status) !== null && _c !== void 0 ? _c : 'unknown'}`);
         }
     });
 }
-function isRPCPortListening(port) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!Number.isInteger(port) || port < 1 || port > 65535) {
-            return false;
-        }
-        const client = new net.Socket();
-        return new Promise((resolve) => {
-            let settled = false;
-            const TIMEOUT_MS = 2000;
-            const timeout = setTimeout(() => {
-                if (!settled) {
-                    settled = true;
-                    client.destroy();
-                    resolve(false);
-                }
-            }, TIMEOUT_MS);
-            client.once('error', () => {
-                if (!settled) {
-                    settled = true;
-                    clearTimeout(timeout);
-                    resolve(false);
-                }
-            });
-            client.once('connect', () => {
-                if (!settled) {
-                    settled = true;
-                    clearTimeout(timeout);
-                    client.end();
-                    resolve(true);
-                }
-            });
-            client.connect(port, '127.0.0.1');
-        });
-    });
-}
 
 
 /***/ }),
@@ -2460,14 +2801,16 @@ const base_1 = __nccwpck_require__(69951);
 const link_1 = __nccwpck_require__(27814);
 const validator_1 = __nccwpck_require__(39534);
 const logger_1 = __nccwpck_require__(65370);
+const private_key_1 = __nccwpck_require__(26241);
+const readiness_1 = __nccwpck_require__(19326);
+const fork_safety_1 = __nccwpck_require__(47625);
 function transferAll(toAddress_1) {
     return __awaiter(this, arguments, void 0, function* (toAddress, opt = { network: base_1.Network.devnet }) {
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
-        if (opt.privkey == null) {
-            throw new Error('--privkey is required!');
-        }
-        const privateKey = opt.privkey;
+        const privateKey = (0, private_key_1.resolvePrivateKey)(opt);
+        (0, fork_safety_1.warnIfMainnetForkSigning)(network, privateKey);
+        yield (0, readiness_1.warnIfForkIndexerIsBehind)(network);
         const ckb = new ckb_1.CKB({ network });
         const txHash = yield ckb.transferAll({
             toAddress,
@@ -2475,9 +2818,12 @@ function transferAll(toAddress_1) {
         });
         if (network === 'testnet') {
             logger_1.logger.info(`Successfully transfer, check ${(0, link_1.buildTestnetTxLink)(txHash)} for details.`);
-            return;
+            logger_1.logger.result({ command: 'transfer-all', network, toAddress, txHash });
+            return txHash;
         }
         logger_1.logger.info('Successfully transfer, txHash:', txHash);
+        logger_1.logger.result({ command: 'transfer-all', network, toAddress, txHash });
+        return txHash;
     });
 }
 
@@ -2504,37 +2850,61 @@ const ckb_1 = __nccwpck_require__(83748);
 const base_1 = __nccwpck_require__(69951);
 const link_1 = __nccwpck_require__(27814);
 const validator_1 = __nccwpck_require__(39534);
+const private_key_1 = __nccwpck_require__(26241);
+const logger_1 = __nccwpck_require__(65370);
+const readiness_1 = __nccwpck_require__(19326);
+const fork_safety_1 = __nccwpck_require__(47625);
 function transfer(toAddress_1, amount_1) {
     return __awaiter(this, arguments, void 0, function* (toAddress, amount, opt = { network: base_1.Network.devnet }) {
         var _a;
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
-        if (opt.privkey == null) {
-            throw new Error('--privkey is required!');
-        }
-        const privateKey = opt.privkey;
+        let udtKind;
+        let udtTypeArgs;
+        if (opt.udtKind != null || opt.udtTypeArgs != null) {
+            if (!opt.udtTypeArgs) {
+                throw new Error('UDT type args are required for a UDT transfer');
+            }
+            (0, validator_1.validateUdtAmount)(amount);
+            udtKind = (_a = opt.udtKind) !== null && _a !== void 0 ? _a : 'sudt';
+            (0, validator_1.validateUdtKind)(udtKind);
+            udtTypeArgs = (0, validator_1.validateUdtTypeArgs)(udtKind, opt.udtTypeArgs);
+        }
+        const privateKey = (0, private_key_1.resolvePrivateKey)(opt);
+        const rejectInputsAtOrBeforeBlock = (0, fork_safety_1.validateMainnetForkSigning)(network, privateKey, opt.allowMainnetReplayRisk);
+        yield (0, readiness_1.warnIfForkIndexerIsBehind)(network);
         const ckb = new ckb_1.CKB({ network });
-        if (opt.udtTypeArgs) {
-            const kind = (_a = opt.udtKind) !== null && _a !== void 0 ? _a : 'sudt';
-            (0, validator_1.validateUdtKind)(kind);
-            const udtTypeArgs = (0, validator_1.validateUdtTypeArgs)(kind, opt.udtTypeArgs);
-            const udtType = yield ckb.buildUdtTypeScript(kind, udtTypeArgs);
+        if (udtKind && udtTypeArgs) {
+            const udtType = yield ckb.buildUdtTypeScript(udtKind, udtTypeArgs);
             const txHash = yield ckb.udtTransfer({
                 toAddress,
                 amount,
                 privateKey,
                 udtType,
-                kind,
+                kind: udtKind,
+                rejectInputsAtOrBeforeBlock,
             });
             (0, link_1.logTxSuccess)(network, txHash, 'transfer UDT');
-            return;
+            logger_1.logger.result({
+                command: 'udt.transfer',
+                network,
+                kind: udtKind,
+                amount,
+                typeArgs: udtTypeArgs,
+                toAddress,
+                txHash,
+            });
+            return txHash;
         }
         const txHash = yield ckb.transfer({
             toAddress,
             amountInCKB: amount,
             privateKey,
+            rejectInputsAtOrBeforeBlock,
         });
         (0, link_1.logTxSuccess)(network, txHash, 'transfer');
+        logger_1.logger.result({ command: 'transfer', network, amount, toAddress, txHash });
+        return txHash;
     });
 }
 
@@ -2562,41 +2932,65 @@ const ckb_1 = __nccwpck_require__(83748);
 const base_1 = __nccwpck_require__(69951);
 const link_1 = __nccwpck_require__(27814);
 const validator_1 = __nccwpck_require__(39534);
+const private_key_1 = __nccwpck_require__(26241);
+const logger_1 = __nccwpck_require__(65370);
+const readiness_1 = __nccwpck_require__(19326);
+const fork_safety_1 = __nccwpck_require__(47625);
 function udtIssue(amount_1) {
-    return __awaiter(this, arguments, void 0, function* (amount, opt = { network: base_1.Network.devnet, udtKind: 'sudt', privkey: '' }) {
+    return __awaiter(this, arguments, void 0, function* (amount, opt = { network: base_1.Network.devnet, udtKind: 'sudt' }) {
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
         (0, validator_1.validateUdtKind)(opt.udtKind);
-        if (!opt.privkey) {
-            throw new Error('--privkey is required!');
-        }
+        (0, validator_1.validateUdtAmount)(amount);
+        const typeArgs = opt.typeArgs ? (0, validator_1.validateUdtTypeArgs)(opt.udtKind, opt.typeArgs) : undefined;
+        const privateKey = (0, private_key_1.resolvePrivateKey)(opt);
+        (0, fork_safety_1.warnIfMainnetForkSigning)(network, privateKey);
+        yield (0, readiness_1.warnIfForkIndexerIsBehind)(network);
         const ckb = new ckb_1.CKB({ network });
-        const txHash = yield ckb.udtIssue({
-            privateKey: opt.privkey,
+        const result = yield ckb.udtIssue({
+            privateKey,
             kind: opt.udtKind,
             amount,
-            typeArgs: opt.typeArgs ? (0, validator_1.validateUdtTypeArgs)(opt.udtKind, opt.typeArgs) : undefined,
+            typeArgs,
             toAddress: opt.to,
         });
-        (0, link_1.logTxSuccess)(network, txHash, 'issued UDT');
+        (0, link_1.logTxSuccess)(network, result.txHash, 'issued UDT');
+        logger_1.logger.info(`UDT kind: ${opt.udtKind}`);
+        logger_1.logger.info(`UDT type args: ${result.typeArgs}`);
+        logger_1.logger.info(`Receiver: ${result.receiver}`);
+        logger_1.logger.info(`Next: offckb balance ${result.receiver} --udt-kind ${opt.udtKind} --udt-type-args ${result.typeArgs}`);
+        logger_1.logger.result({
+            command: 'udt.issue',
+            network,
+            kind: opt.udtKind,
+            amount,
+            receiver: result.receiver,
+            typeArgs: result.typeArgs,
+            txHash: result.txHash,
+        });
+        return result;
     });
 }
 function udtDestroy(amount_1) {
-    return __awaiter(this, arguments, void 0, function* (amount, opt = { network: base_1.Network.devnet, udtKind: 'sudt', typeArgs: '', privkey: '' }) {
+    return __awaiter(this, arguments, void 0, function* (amount, opt = { network: base_1.Network.devnet, udtKind: 'sudt', typeArgs: '' }) {
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
         (0, validator_1.validateUdtKind)(opt.udtKind);
-        if (!opt.privkey) {
-            throw new Error('--privkey is required!');
-        }
+        (0, validator_1.validateUdtAmount)(amount);
+        const typeArgs = (0, validator_1.validateUdtTypeArgs)(opt.udtKind, opt.typeArgs);
+        const privateKey = (0, private_key_1.resolvePrivateKey)(opt);
+        (0, fork_safety_1.warnIfMainnetForkSigning)(network, privateKey);
+        yield (0, readiness_1.warnIfForkIndexerIsBehind)(network);
         const ckb = new ckb_1.CKB({ network });
         const txHash = yield ckb.udtDestroy({
-            privateKey: opt.privkey,
+            privateKey,
             kind: opt.udtKind,
             amount,
-            typeArgs: (0, validator_1.validateUdtTypeArgs)(opt.udtKind, opt.typeArgs),
+            typeArgs,
         });
         (0, link_1.logTxSuccess)(network, txHash, 'destroyed UDT');
+        logger_1.logger.result({ command: 'udt.destroy', network, kind: opt.udtKind, amount, typeArgs, txHash });
+        return txHash;
     });
 }
 
@@ -3598,9 +3992,13 @@ exports.parseGenesisHashFromInitOutput = parseGenesisHashFromInitOutput;
 exports.parseGenesisHashFromListHashes = parseGenesisHashFromListHashes;
 exports.expectedGenesisHash = expectedGenesisHash;
 exports.patchDevSpecForFork = patchDevSpecForFork;
+exports.copySourceData = copySourceData;
+exports.isolateForkCkbConfig = isolateForkCkbConfig;
+exports.migrationNeededFromExitCode = migrationNeededFromExitCode;
 exports.forkDevnet = forkDevnet;
 const child_process_1 = __nccwpck_require__(35317);
 const fs_1 = __importDefault(__nccwpck_require__(79896));
+const os_1 = __importDefault(__nccwpck_require__(70857));
 const path_1 = __importDefault(__nccwpck_require__(16928));
 const toml_1 = __importDefault(__nccwpck_require__(2811));
 const setting_1 = __nccwpck_require__(25546);
@@ -3644,11 +4042,11 @@ function writeForkState(configPath, state) {
     fs_1.default.writeFileSync(tempPath, JSON.stringify(state, null, 2));
     fs_1.default.renameSync(tempPath, statePath);
 }
-function markForkFirstRunComplete(configPath) {
+function markForkFirstRunComplete(configPath, forkBlockNumber) {
     const state = readForkState(configPath);
     if (!state || !state.firstRunPending)
         return;
-    writeForkState(configPath, Object.assign(Object.assign({}, state), { firstRunPending: false }));
+    writeForkState(configPath, Object.assign(Object.assign(Object.assign({}, state), { firstRunPending: false }), (forkBlockNumber == null ? {} : { forkBlockNumber })));
 }
 function detectSourceFromCkbToml(ckbTomlContent) {
     let parsed;
@@ -3823,7 +4221,28 @@ function copySourceData(sourceDir, configPath) {
     fs_1.default.mkdirSync(configPath, { recursive: true });
     // Full copy on purpose: never hardlink — RocksDB appends to WAL/MANIFEST in
     // place, and linked files would corrupt the source chain.
-    fs_1.default.cpSync(sourceData, targetData, { recursive: true });
+    const excludedTopLevelEntries = new Set(['network', 'logs', 'tmp']);
+    fs_1.default.mkdirSync(targetData, { recursive: true });
+    // Enumerate top-level entries instead of relying on fs.cp's filter paths,
+    // which may use Windows extended-length prefixes and bypass relative-path
+    // comparisons.
+    for (const entry of fs_1.default.readdirSync(sourceData)) {
+        if (excludedTopLevelEntries.has(entry))
+            continue;
+        fs_1.default.cpSync(path_1.default.join(sourceData, entry), path_1.default.join(targetData, entry), { recursive: true });
+    }
+    logger_1.logger.info('Excluded source network peers and transient logs/tmp data from the fork.');
+}
+function isolateForkCkbConfig(config) {
+    var _a, _b;
+    const network = Object.assign({}, ((_a = config.network) !== null && _a !== void 0 ? _a : {}));
+    network.bootnodes = [];
+    network.max_outbound_peers = 0;
+    network.whitelist_only = true;
+    network.discovery_local_address = false;
+    const loggerConfig = Object.assign({}, ((_b = config.logger) !== null && _b !== void 0 ? _b : {}));
+    loggerConfig.filter = 'warn';
+    return Object.assign(Object.assign({}, config), { network, logger: loggerConfig });
 }
 function runCkbInit(ckbBinPath, configPath, specFile) {
     // argv form, never a shell: --spec-file is user input and quote-wrapping
@@ -3831,7 +4250,48 @@ function runCkbInit(ckbBinPath, configPath, specFile) {
     // inside double quotes).
     const args = ['init', '-C', configPath, '--chain', 'dev', '--import-spec', specFile, '--force'];
     logger_1.logger.debug(`Running: ${ckbBinPath} ${args.join(' ')}`);
-    return (0, child_process_1.execFileSync)(ckbBinPath, args, { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    return (0, child_process_1.execFileSync)(ckbBinPath, args, {
+        encoding: 'utf8',
+        maxBuffer: 16 * 1024 * 1024,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+}
+function migrationNeededFromExitCode(status) {
+    if (status === 0)
+        return true;
+    if (status === 64)
+        return false;
+    throw new Error(`ckb migrate --check failed with exit code ${status !== null && status !== void 0 ? status : 'unknown'}`);
+}
+function isDatabaseMigrationNeeded(ckbBinPath, configPath) {
+    const result = (0, child_process_1.spawnSync)(ckbBinPath, ['migrate', '--check', '-C', configPath], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.error) {
+        throw new Error(`Could not check the CKB database version: ${result.error.message}`);
+    }
+    try {
+        return migrationNeededFromExitCode(result.status);
+    }
+    catch (error) {
+        const details = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+        throw new Error(`${error.message}${details ? `: ${details}` : ''}`);
+    }
+}
+function migrateDatabaseCopy(ckbBinPath, configPath) {
+    var _a, _b;
+    logger_1.logger.info('Migrating the copied database (the source directory remains untouched) ..');
+    const result = (0, child_process_1.spawnSync)(ckbBinPath, ['migrate', '--force', '-C', configPath], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.error || result.status !== 0) {
+        const details = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+        throw new Error(`Failed to migrate the copied database: ${(_b = (_a = result.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : `exit code ${result.status}`}` +
+            `${details ? `\n${details}` : ''}`);
+    }
+    logger_1.logger.success('Copied database migration completed.');
 }
 // Best-effort read of the source directory's own chain identity. `ckb
 // list-hashes` resolves the chain spec of the given config dir (no database
@@ -3850,6 +4310,34 @@ function readSourceGenesisHash(ckbBinPath, sourceDir) {
         return null;
     }
 }
+function validateForkSpec(ckbBinPath, sourceDir, specFile, declaredSource) {
+    var _a;
+    const tempConfigPath = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'offckb-fork-preflight-'));
+    try {
+        const initOutput = runCkbInit(ckbBinPath, tempConfigPath, specFile);
+        const genesisHash = parseGenesisHashFromInitOutput(initOutput);
+        if (!genesisHash) {
+            throw new Error(`Could not parse the genesis hash from ckb init output:\n${initOutput}`);
+        }
+        const source = (_a = declaredSource !== null && declaredSource !== void 0 ? declaredSource : (0, const_1.identifyPublicChainByGenesisHash)(genesisHash)) !== null && _a !== void 0 ? _a : 'custom';
+        if (source !== 'custom') {
+            const expected = expectedGenesisHash(source);
+            if (genesisHash !== expected) {
+                throw new Error(`Genesis hash mismatch: expected ${expected} for ${source}, got ${genesisHash}. ` +
+                    'This usually means the chain spec does not match the source data.');
+            }
+        }
+        const sourceGenesisHash = readSourceGenesisHash(ckbBinPath, sourceDir);
+        if (sourceGenesisHash && sourceGenesisHash !== genesisHash) {
+            throw new Error(`The source directory is configured for a different chain (genesis ${sourceGenesisHash}) ` +
+                `than the imported spec (genesis ${genesisHash}). Pass a matching --source or --spec-file.`);
+        }
+        return { source, genesisHash };
+    }
+    finally {
+        fs_1.default.rmSync(tempConfigPath, { recursive: true, force: true });
+    }
+}
 // Overwrite the ckb-init-generated configs with offckb's own devnet configs so
 // the fork behaves like a normal offckb devnet (miner account as block
 // assembler, RPC on 8114 with the Indexer module, proxy on 28114). The
@@ -3857,29 +4345,26 @@ function readSourceGenesisHash(ckbBinPath, sourceDir) {
 function alignConfigsWithOffckb(configPath) {
     const settings = (0, setting_1.readSettings)();
     const devnetSourcePath = path_1.default.resolve(setting_1.packageRootPath, './ckb/devnet');
-    fs_1.default.copyFileSync(path_1.default.join(devnetSourcePath, 'ckb.toml'), path_1.default.join(configPath, 'ckb.toml'));
+    const ckbConfigPath = path_1.default.join(configPath, 'ckb.toml');
+    const parsedCkbConfig = toml_1.default.parse(fs_1.default.readFileSync(path_1.default.join(devnetSourcePath, 'ckb.toml'), 'utf8'));
+    const ckbConfig = isolateForkCkbConfig(parsedCkbConfig);
+    fs_1.default.writeFileSync(ckbConfigPath, toml_1.default.stringify(ckbConfig));
     fs_1.default.copyFileSync(path_1.default.join(devnetSourcePath, 'default.db-options'), path_1.default.join(configPath, 'default.db-options'));
     const minerToml = fs_1.default.readFileSync(path_1.default.join(devnetSourcePath, 'ckb-miner.toml'), 'utf8');
     fs_1.default.writeFileSync(path_1.default.join(configPath, 'ckb-miner.toml'), minerToml.replace('http://ckb:8114/', settings.devnet.rpcUrl));
 }
 function forkDevnet(options) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+        var _a;
+        if (!options.from) {
+            throw new Error('Database fork requires a source CKB directory: --from <dir>.');
+        }
         const settings = (0, setting_1.readSettings)();
         const configPath = settings.devnet.configPath;
         const ckbVersion = settings.bins.defaultCKBVersion;
         const sourceDir = path_1.default.resolve(options.from);
         validateSourceDir(sourceDir);
         assertSourceNodeStopped(sourceDir);
-        assertOffckbDevnetStopped();
-        if ((0, fs_2.isFolderExists)(configPath)) {
-            if (!options.force) {
-                throw new Error(`A devnet already exists at ${configPath}. Re-run with --force to replace it, ` +
-                    `or reset it first with: offckb clean`);
-            }
-            logger_1.logger.info(`Removing existing devnet at ${configPath} ..`);
-            fs_1.default.rmSync(configPath, { recursive: true, force: true });
-        }
         // Identify the source chain: explicit flag > ckb.toml bundled spec.
         let source = (_a = options.source) !== null && _a !== void 0 ? _a : null;
         if (source == null) {
@@ -3894,41 +4379,55 @@ function forkDevnet(options) {
         }
         yield (0, install_1.installCKBBinary)(ckbVersion);
         const ckbBinPath = (0, setting_1.getCKBBinaryPath)(ckbVersion);
+        const databaseMigrationNeeded = isDatabaseMigrationNeeded(ckbBinPath, sourceDir);
+        const sourcePeerStoreDetected = fs_1.default.existsSync(path_1.default.join(sourceDir, 'data', 'network', 'peer_store'));
+        const specFile = yield resolveSpecFile(options, source !== null && source !== void 0 ? source : 'mainnet', ckbVersion);
+        const specPreflight = validateForkSpec(ckbBinPath, sourceDir, specFile, source);
+        source = specPreflight.source;
+        logger_1.logger.info(`Fork preflight: source=${source}, genesis=${specPreflight.genesisHash}, CKB=${ckbVersion}, migration=${databaseMigrationNeeded ? 'required' : 'not required'}.`);
+        if (sourcePeerStoreDetected) {
+            logger_1.logger.info('A persisted source peer store was detected and will be excluded from the fork.');
+        }
+        if (options.dryRun) {
+            logger_1.logger.success('Fork preflight passed. No devnet files were changed.');
+            logger_1.logger.result({
+                command: 'devnet.fork.preflight',
+                sourceDir,
+                source,
+                genesisHash: specPreflight.genesisHash,
+                ckbVersion,
+                databaseMigrationNeeded,
+                sourcePeerStoreDetected,
+                sourcePeerStoreWillBeExcluded: true,
+                targetDir: configPath,
+            });
+            return;
+        }
+        assertOffckbDevnetStopped();
+        if (databaseMigrationNeeded && !options.migrate) {
+            throw new Error(`The source database requires migration for CKB v${ckbVersion}. ` +
+                'Re-run with --migrate to migrate only the copied devnet, leaving the source untouched.');
+        }
+        if ((0, fs_2.isFolderExists)(configPath)) {
+            if (!options.force) {
+                throw new Error(`A devnet already exists at ${configPath}. Re-run with --force to replace it, ` +
+                    `or reset it first with: offckb clean`);
+            }
+            logger_1.logger.info(`Removing existing devnet at ${configPath} ..`);
+            fs_1.default.rmSync(configPath, { recursive: true, force: true });
+        }
         try {
             // Inside the try so a failed copy (disk full, permissions, I/O) gets the
             // same rollback: a partial configPath would otherwise block the next
             // attempt as an "existing devnet".
             copySourceData(sourceDir, configPath);
-            const specFile = yield resolveSpecFile(options, source !== null && source !== void 0 ? source : 'mainnet', ckbVersion);
             const initOutput = runCkbInit(ckbBinPath, configPath, specFile);
             const genesisHash = parseGenesisHashFromInitOutput(initOutput);
             if (!genesisHash) {
                 throw new Error(`Could not parse the genesis hash from ckb init output:\n${initOutput}`);
             }
-            // A custom spec may still be a well-known chain; let the chain data
-            // self-identify via its genesis hash.
-            if (source == null) {
-                source = (_b = (0, const_1.identifyPublicChainByGenesisHash)(genesisHash)) !== null && _b !== void 0 ? _b : 'custom';
-            }
-            if (source !== 'custom') {
-                const expected = expectedGenesisHash(source);
-                if (genesisHash !== expected) {
-                    throw new Error(`Genesis hash mismatch: expected ${expected} for ${source}, got ${genesisHash}. ` +
-                        `This usually means the chain spec does not match the source data. ` +
-                        `(Importing a testnet spec with a CKB older than v0.207.0 sets a wrong genesis_epoch_length, ` +
-                        `see nervosnetwork/ckb#5205.)`);
-                }
-            }
-            // The genesis above comes from the imported spec alone — it cannot see
-            // that --source/--spec-file contradicts the copied data (e.g. a mainnet
-            // spec over testnet data would pass and only fail when the node boots).
-            // Cross-check the source directory's own configured genesis and reject
-            // mismatches now. Skipped (null) when the source is not a standard
-            // config dir; the node's boot-time genesis check remains the backstop.
-            const sourceGenesisHash = readSourceGenesisHash(ckbBinPath, sourceDir);
-            if (sourceGenesisHash && sourceGenesisHash !== genesisHash) {
-                throw new Error(`The source directory is configured for a different chain (genesis ${sourceGenesisHash}) ` +
-                    `than the imported spec (genesis ${genesisHash}). Pass a matching --source or --spec-file.`);
+            if (genesisHash !== specPreflight.genesisHash) {
+                throw new Error(`Chain spec changed after preflight: expected genesis ${specPreflight.genesisHash}, got ${genesisHash}.`);
             }
             const devSpecPath = path_1.default.join(configPath, 'specs', 'dev.toml');
             const spec = toml_1.default.parse(fs_1.default.readFileSync(devSpecPath, 'utf8'));
@@ -3937,6 +4436,9 @@ function forkDevnet(options) {
             fs_1.default.writeFileSync(tempSpecPath, toml_1.default.stringify(patched));
             fs_1.default.renameSync(tempSpecPath, devSpecPath);
             alignConfigsWithOffckb(configPath);
+            if (databaseMigrationNeeded) {
+                migrateDatabaseCopy(ckbBinPath, configPath);
+            }
             const state = {
                 source,
                 sourceDir,
@@ -3944,11 +4446,28 @@ function forkDevnet(options) {
                 genesisHash,
                 forkedAt: new Date().toISOString(),
                 firstRunPending: true,
+                databaseMigrated: databaseMigrationNeeded,
+                networkIsolated: true,
             };
             writeForkState(configPath, state);
             logger_1.logger.success(`Devnet forked from ${sourceDir} (${source}, genesis ${genesisHash}).`);
-            logger_1.logger.info('Start it with: offckb node');
+            logger_1.logger.info('Start it with: offckb node --daemon');
             logger_1.logger.info('The first run applies --skip-spec-check --overwrite-spec automatically.');
+            logger_1.logger.info('Then inspect node, Indexer, and network isolation with: offckb devnet info');
+            logger_1.logger.info('List source-prefix dev addresses with: offckb accounts');
+            if (source === 'mainnet') {
+                logger_1.logger.warn('MAINNET FORK REPLAY RISK: only sign with built-in dev keys and fork-mined cells.');
+            }
+            logger_1.logger.result({
+                command: 'devnet.fork',
+                sourceDir,
+                source,
+                genesisHash,
+                ckbVersion,
+                databaseMigrated: databaseMigrationNeeded,
+                networkIsolated: true,
+                next: ['offckb node --daemon', 'offckb devnet info', 'offckb accounts'],
+            });
         }
         catch (error) {
             // Leave no half-forked devnet behind.
@@ -3959,6 +4478,124 @@ function forkDevnet(options) {
 }
 
 
+/***/ }),
+
+/***/ 19326:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.checkNodeReadiness = checkNodeReadiness;
+exports.waitForNodeReady = waitForNodeReady;
+exports.checkConfiguredDevnetReadiness = checkConfiguredDevnetReadiness;
+exports.warnIfForkIndexerIsBehind = warnIfForkIndexerIsBehind;
+const setting_1 = __nccwpck_require__(25546);
+const base_1 = __nccwpck_require__(69951);
+const logger_1 = __nccwpck_require__(65370);
+const json_rpc_1 = __nccwpck_require__(51726);
+const fork_1 = __nccwpck_require__(77912);
+function parseHexNumber(value) {
+    if (typeof value !== 'string' || !/^0x[0-9a-f]+$/i.test(value))
+        return undefined;
+    return BigInt(value);
+}
+function checkNodeReadiness(rpcUrl_1) {
+    return __awaiter(this, arguments, void 0, function* (rpcUrl, timeoutMs = 3000) {
+        try {
+            const [nodeInfo, tipValue] = yield Promise.all([
+                (0, json_rpc_1.callJsonRpc)(rpcUrl, 'local_node_info', [], timeoutMs),
+                (0, json_rpc_1.callJsonRpc)(rpcUrl, 'get_tip_block_number', [], timeoutMs),
+            ]);
+            const nodeTip = parseHexNumber(tipValue);
+            if (nodeTip == null) {
+                throw new Error(`Invalid node tip returned by ${rpcUrl}`);
+            }
+            let indexerTip;
+            try {
+                const value = yield (0, json_rpc_1.callJsonRpc)(rpcUrl, 'get_indexer_tip', [], timeoutMs);
+                indexerTip = parseHexNumber(value === null || value === void 0 ? void 0 : value.block_number);
+            }
+            catch (_a) {
+                // Indexer readiness is reported separately and does not make the node RPC unhealthy.
+            }
+            let peers;
+            try {
+                const value = yield (0, json_rpc_1.callJsonRpc)(rpcUrl, 'get_peers', [], timeoutMs);
+                peers = Array.isArray(value) ? value.length : undefined;
+            }
+            catch (_b) {
+                // The Net RPC module can be disabled on custom nodes.
+            }
+            const indexerLag = indexerTip == null ? undefined : indexerTip >= nodeTip ? BigInt(0) : nodeTip - indexerTip;
+            return {
+                ready: true,
+                rpcUrl,
+                version: typeof (nodeInfo === null || nodeInfo === void 0 ? void 0 : nodeInfo.version) === 'string' ? nodeInfo.version : undefined,
+                nodeTip,
+                indexerTip,
+                indexerLag,
+                peers,
+            };
+        }
+        catch (error) {
+            return {
+                ready: false,
+                rpcUrl,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    });
+}
+function waitForNodeReady(rpcUrl_1, timeoutMs_1) {
+    return __awaiter(this, arguments, void 0, function* (rpcUrl, timeoutMs, isProcessAlive = () => true) {
+        const start = Date.now();
+        let last = yield checkNodeReadiness(rpcUrl);
+        while (!last.ready && isProcessAlive() && Date.now() - start < timeoutMs) {
+            yield new Promise((resolve) => setTimeout(resolve, 500));
+            last = yield checkNodeReadiness(rpcUrl);
+        }
+        return last;
+    });
+}
+function checkConfiguredDevnetReadiness() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return checkNodeReadiness((0, setting_1.readSettings)().devnet.rpcUrl);
+    });
+}
+function warnIfForkIndexerIsBehind(network) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (network !== base_1.Network.devnet)
+            return undefined;
+        const settings = (0, setting_1.readSettings)();
+        if (!(0, fork_1.readForkState)(settings.devnet.configPath))
+            return undefined;
+        const readiness = yield checkNodeReadiness(settings.devnet.rpcUrl);
+        if (!readiness.ready) {
+            logger_1.logger.warn(`The forked devnet is not RPC-ready: ${(_a = readiness.error) !== null && _a !== void 0 ? _a : 'health check failed'}`);
+        }
+        else if (readiness.indexerTip == null) {
+            logger_1.logger.warn('The CKB indexer is not ready yet; cell and balance lookups may be incomplete. Check `offckb devnet info`.');
+        }
+        else if (readiness.indexerLag && readiness.indexerLag > BigInt(0)) {
+            logger_1.logger.warn(`The CKB indexer is ${readiness.indexerLag} blocks behind the node; cell and balance lookups may be incomplete. ` +
+                'Check `offckb devnet info`.');
+        }
+        return readiness;
+    });
+}
+
+
 /***/ }),
 
 /***/ 1360:
@@ -3990,19 +4627,27 @@ function initChainIfNeeded() {
         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']);
+        const requiredConfigFiles = ['ckb.toml', 'ckb-miner.toml', path_1.default.join('specs', 'dev.toml')];
+        const isInitialized = (0, fs_2.isFolderExists)(devnetConfigPath) &&
+            requiredConfigFiles.every((relativePath) => fs_1.default.existsSync(path_1.default.join(devnetConfigPath, relativePath)));
+        const minerConfigPath = path_1.default.join(devnetConfigPath, 'ckb-miner.toml');
+        const minerConfigWasMissing = !fs_1.default.existsSync(minerConfigPath);
+        // Daemon mode creates data/logs before the child starts. A directory-only
+        // check therefore mistakes a fresh install for an initialized chain. Check
+        // the files CKB actually needs instead, and repair an incomplete directory.
+        if (!isInitialized) {
+            yield (0, fs_2.copyFilesWithExclusion)(devnetSourcePath, devnetConfigPath, ['data'], false);
             logger_1.logger.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');
+            if (minerConfigWasMissing) {
+                // 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(minerConfigPath, modifiedData, 'utf8');
+            }
         }
     });
 }
@@ -4132,6 +4777,7 @@ function downloadCKBBinaryAndUnzip(version) {
         }
         catch (error) {
             logger_1.logger.error('Error installing dependency binary:', error.message);
+            throw error;
         }
     });
 }
@@ -5193,7 +5839,7 @@ class CKB {
         });
     }
     transfer(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ privateKey, toAddress, amountInCKB }) {
+        return __awaiter(this, arguments, void 0, function* ({ privateKey, toAddress, amountInCKB, rejectInputsAtOrBeforeBlock, }) {
             const signer = this.buildSigner(privateKey);
             const to = yield core_1.ccc.Address.fromString(toAddress, this.client);
             const tx = core_1.ccc.Transaction.from({
@@ -5206,6 +5852,7 @@ class CKB {
             });
             yield tx.completeInputsByCapacity(signer);
             yield tx.completeFeeBy(signer, this.feeRate);
+            yield this.assertInputsCreatedAfter(tx, rejectInputsAtOrBeforeBlock);
             const txHash = yield signer.sendTransaction(tx);
             return txHash;
         });
@@ -5375,7 +6022,7 @@ class CKB {
         });
     }
     udtTransfer(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ privateKey, toAddress, amount, udtType, kind }) {
+        return __awaiter(this, arguments, void 0, function* ({ privateKey, toAddress, amount, udtType, kind, rejectInputsAtOrBeforeBlock, }) {
             const signer = this.buildSigner(privateKey);
             const to = yield core_1.ccc.Address.fromString(toAddress, this.client);
             const amountBigInt = (0, validator_1.validateUdtAmount)(amount);
@@ -5406,10 +6053,28 @@ class CKB {
                 tx.outputsData.push(core_1.ccc.hexFrom(core_1.ccc.numToBytes(changeAmount, 16)));
             }
             yield tx.completeFeeBy(signer, this.feeRate);
+            yield this.assertInputsCreatedAfter(tx, rejectInputsAtOrBeforeBlock);
             const txHash = yield signer.sendTransaction(tx);
             return txHash;
         });
     }
+    assertInputsCreatedAfter(tx, blockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (blockNumber == null)
+                return;
+            for (const input of tx.inputs) {
+                const outPoint = input.previousOutput;
+                const origin = yield this.client.getTransactionNoCache(outPoint.txHash);
+                if ((origin === null || origin === void 0 ? void 0 : origin.blockNumber) == null) {
+                    throw new Error(`Refusing to sign: could not verify the origin block of input ${outPoint.txHash}:${outPoint.index}.`);
+                }
+                if (origin.blockNumber <= blockNumber) {
+                    throw new Error(`Refusing to sign: input ${outPoint.txHash}:${outPoint.index} was created at block ${origin.blockNumber}, ` +
+                        `at or before the Mainnet fork boundary ${blockNumber}.`);
+                }
+            }
+        });
+    }
     udtIssue(_a) {
         return __awaiter(this, arguments, void 0, function* ({ privateKey, kind, amount, typeArgs, toAddress }) {
             const signer = this.buildSigner(privateKey);
@@ -5422,7 +6087,7 @@ class CKB {
                     logger_1.logger.warn('SUDT type args are derived from the issuer lock hash; --type-args is ignored');
                 }
                 const issuerLockHash = signerAddress.script.hash();
-                resolvedTypeArgs = ('0x' + issuerLockHash.slice(2, 42));
+                resolvedTypeArgs = issuerLockHash;
             }
             else {
                 if (typeArgs) {
@@ -5450,7 +6115,7 @@ class CKB {
             yield tx.completeInputsByCapacity(signer);
             yield tx.completeFeeBy(signer, this.feeRate);
             const txHash = yield signer.sendTransaction(tx);
-            return txHash;
+            return { txHash, typeArgs: resolvedTypeArgs, receiver: to.toString() };
         });
     }
     udtDestroy(_a) {
@@ -6917,6 +7582,16 @@ const DOWNLOAD_TIMEOUT_MS = 120000;
 const EXTRACT_TIMEOUT_MS = 60000;
 // Strict semver regex: v<major>.<minor>.<patch> (no leading zeros on digits)
 const STRICT_VERSION_REGEX = /^v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+// Independently pinned digests for the default release. Keeping these in
+// offckb makes the default installation verifiable even though ckb-tui v0.1.3
+// did not upload a checksums-sha256.txt asset.
+const KNOWN_SHA256 = {
+    'v0.1.3': {
+        'ckb-tui-with-node-linux-amd64.tar.gz': '33455cefe2c016149fa8fa3abde7960b348d4606afef9279d787ac8a8b59956f',
+        'ckb-tui-with-node-macos-aarch64.tar.gz': 'de18107ec179ced03608da956013e38ae82e6c1fae588f12c17d138ee6ee072c',
+        'ckb-tui-with-node-windows-amd64.zip': '749d8e09fd5d23fc8af12892b7d197add5aae004f7438678023e4a973f3fd58b',
+    },
+};
 class CKBTui {
     /**
      * Pure lookup — returns the expected binary path without triggering any
@@ -7033,7 +7708,7 @@ class CKBTui {
             if (curlResult.status !== 0) {
                 throw new Error(`curl exited with code ${curlResult.status}`);
             }
-            // 2. Verify checksum (best-effort: warns if checksum file is unavailable)
+            // 2. Verify checksum. Installation fails closed if no trusted digest exists.
             this.verifyChecksum(version, assetName, archivePath);
             // 3. Extract to temp directory
             logger_1.logger.info('Extracting...');
@@ -7071,64 +7746,24 @@ class CKBTui {
             }
         }
     }
-    /**
-     * Best-effort SHA-256 checksum verification.
-     * Downloads the checksum file published alongside the release asset and
-     * verifies the downloaded archive. Logs a warning (but does not fail) if
-     * the checksum file is unavailable — this maintains compatibility while
-     * the upstream project adopts checksum publishing.
-     */
+    /** Verify against an independently pinned digest. */
     static verifyChecksum(version, assetName, archivePath) {
-        const checksumUrl = `https://github.com/Officeyutong/ckb-tui/releases/download/${version}/checksums-sha256.txt`;
-        const checksumPath = path.join(path.dirname(archivePath), 'checksums-sha256.txt');
-        const fetchResult = (0, child_process_1.spawnSync)('curl', ['-fsSL', '--max-time', '30', '-o', checksumPath, checksumUrl], {
-            stdio: 'pipe',
-            timeout: 30000,
-        });
-        if (fetchResult.status !== 0) {
-            logger_1.logger.warn(`SHA-256 checksum file not available for version ${version}. ` +
-                'Skipping integrity verification. Consider asking the upstream maintainer to publish checksum files.');
-            return;
-        }
-        try {
-            const checksumContent = fs.readFileSync(checksumPath, 'utf8');
-            const expectedHash = this.parseChecksumFile(checksumContent, assetName);
-            if (!expectedHash) {
-                logger_1.logger.warn(`Checksum entry for "${assetName}" not found in checksums file. Skipping verification.`);
-                return;
-            }
-            const actualHash = crypto.createHash('sha256').update(fs.readFileSync(archivePath)).digest('hex');
-            if (actualHash !== expectedHash) {
-                throw new Error(`SHA-256 checksum mismatch for ${assetName}.\n` +
-                    `Expected: ${expectedHash}\nActual:   ${actualHash}\n` +
-                    'The downloaded file may be corrupted or tampered with.');
-            }
-            logger_1.logger.info('SHA-256 checksum verified successfully.');
-        }
-        finally {
-            try {
-                fs.unlinkSync(checksumPath);
-            }
-            catch (_a) {
-                // Best effort
-            }
+        var _a;
+        const pinnedHash = (_a = KNOWN_SHA256[version]) === null || _a === void 0 ? void 0 : _a[assetName];
+        if (!pinnedHash) {
+            throw new Error(`No trusted SHA-256 checksum is pinned for ckb-tui ${version} (${assetName}). ` +
+                'Refusing to install an unverified binary.');
         }
+        this.assertChecksum(archivePath, assetName, pinnedHash);
     }
-    /**
-     * Parse a standard SHA-256 checksum file (format: "<hash>  <filename>" per line)
-     * and return the hex hash for the given asset name, or null if not found.
-     */
-    static parseChecksumFile(content, assetName) {
-        for (const line of content.split('\n')) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#'))
-                continue;
-            const match = trimmed.match(/^([0-9a-fA-F]{64})\s+[*]?(.+)$/);
-            if (match && match[2] === assetName) {
-                return match[1].toLowerCase();
-            }
+    static assertChecksum(archivePath, assetName, expectedHash) {
+        const actualHash = crypto.createHash('sha256').update(fs.readFileSync(archivePath)).digest('hex');
+        if (actualHash !== expectedHash) {
+            throw new Error(`SHA-256 checksum mismatch for ${assetName}.\n` +
+                `Expected: ${expectedHash}\nActual:   ${actualHash}\n` +
+                'The downloaded file may be corrupted or tampered with.');
         }
-        return null;
+        logger_1.logger.info('SHA-256 checksum verified successfully.');
     }
     /**
      * Extract a downloaded archive to the given directory.
@@ -9380,6 +10015,77 @@ function encodeBinPathForTerminal(path) {
 }
 
 
+/***/ }),
+
+/***/ 47625:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.warnIfMainnetForkSigning = warnIfMainnetForkSigning;
+exports.validateMainnetForkSigning = validateMainnetForkSigning;
+const account_json_1 = __importDefault(__nccwpck_require__(13849));
+const account_1 = __nccwpck_require__(59489);
+const setting_1 = __nccwpck_require__(25546);
+const fork_1 = __nccwpck_require__(77912);
+const base_1 = __nccwpck_require__(69951);
+const logger_1 = __nccwpck_require__(65370);
+const BUILT_IN_DEV_KEYS = new Set([...account_json_1.default.map((account) => account.privkey), account_1.ckbDevnetMinerAccount.privkey].map((key) => key.toLowerCase()));
+function warnIfMainnetForkSigning(network, privateKey) {
+    if (!readMainnetForkState(network))
+        return;
+    logMainnetForkSigningWarning(privateKey);
+}
+/**
+ * Fail closed before a Mainnet-fork transfer is constructed or signed.
+ * Returns the copied-chain tip so the transaction layer can reject inputs
+ * created at or before the fork boundary after input selection.
+ */
+function validateMainnetForkSigning(network, privateKey, allowMainnetReplayRisk = false) {
+    const fork = readMainnetForkState(network);
+    if (!fork)
+        return undefined;
+    logMainnetForkSigningWarning(privateKey);
+    if (!BUILT_IN_DEV_KEYS.has(privateKey.trim().toLowerCase()) && !allowMainnetReplayRisk) {
+        throw new Error('Refusing to sign with a non-built-in private key on a Mainnet fork. ' +
+            'Use --allow-mainnet-replay-risk only after verifying that no copied Mainnet input will be selected.');
+    }
+    if (fork.forkBlockNumber == null) {
+        throw new Error('Mainnet fork boundary metadata is missing. Restart or recreate the fork before signing so input origins can be verified.');
+    }
+    try {
+        const blockNumber = BigInt(fork.forkBlockNumber);
+        if (blockNumber < BigInt(0))
+            throw new Error('negative block number');
+        return blockNumber;
+    }
+    catch (_a) {
+        throw new Error(`Invalid Mainnet fork boundary metadata: ${fork.forkBlockNumber}`);
+    }
+}
+function readMainnetForkState(network) {
+    if (network !== base_1.Network.devnet)
+        return null;
+    const settings = (0, setting_1.readSettings)();
+    const fork = (0, fork_1.readForkState)(settings.devnet.configPath);
+    return (fork === null || fork === void 0 ? void 0 : fork.source) === 'mainnet' ? fork : null;
+}
+function logMainnetForkSigningWarning(privateKey) {
+    logger_1.logger.warn([
+        'MAINNET FORK REPLAY RISK: CKB transactions have no chain id.',
+        'A transaction spending cells copied from Mainnet can also be valid on Mainnet.',
+        'Use only built-in dev keys and fork-mined cells unless you explicitly accept that risk.',
+    ]);
+    if (!BUILT_IN_DEV_KEYS.has(privateKey.trim().toLowerCase())) {
+        logger_1.logger.warn('A non-built-in private key is being used on a Mainnet fork. Verify every input before signing.');
+    }
+}
+
+
 /***/ }),
 
 /***/ 37293:
@@ -9485,22 +10191,23 @@ function copyFileSync(source, target) {
     }
     fs.writeFileSync(targetFile, fs.readFileSync(source));
 }
-function copyFilesWithExclusion(sourceDir, destinationDir, excludedFolders) {
-    return __awaiter(this, void 0, void 0, function* () {
+function copyFilesWithExclusion(sourceDir_1, destinationDir_1, excludedFolders_1) {
+    return __awaiter(this, arguments, void 0, function* (sourceDir, destinationDir, excludedFolders, overwrite = true) {
         try {
             // Ensure the destination directory exists
             yield fs.promises.mkdir(destinationDir, { recursive: true });
             // Start copying recursively from the source directory
-            yield copyRecursive(sourceDir, destinationDir, excludedFolders);
+            yield copyRecursive(sourceDir, destinationDir, excludedFolders, overwrite);
         }
         catch (error) {
             logger_1.logger.error('An error occurred during copying files:', error);
+            throw error;
         }
     });
 }
 // Function to recursively copy files and directories
-function copyRecursive(source, destination, excludedFolders) {
-    return __awaiter(this, void 0, void 0, function* () {
+function copyRecursive(source_1, destination_1, excludedFolders_1) {
+    return __awaiter(this, arguments, void 0, function* (source, destination, excludedFolders, overwrite = true) {
         // Get a list of all files and directories in the source directory
         const files = yield fs.promises.readdir(source);
         // Iterate through each file or directory
@@ -9517,12 +10224,14 @@ function copyRecursive(source, destination, excludedFolders) {
                 else {
                     // Ensure destination directory exists before copying
                     yield fs.promises.mkdir(destPath, { recursive: true });
-                    yield copyRecursive(sourcePath, destPath, excludedFolders);
+                    yield copyRecursive(sourcePath, destPath, excludedFolders, overwrite);
                 }
             }
             else {
                 // Otherwise, copy the file
-                yield fs.promises.copyFile(sourcePath, destPath);
+                if (overwrite || !fs.existsSync(destPath)) {
+                    yield fs.promises.copyFile(sourcePath, destPath);
+                }
             }
         }
     });
@@ -9767,6 +10476,7 @@ const levelColors = {
 };
 class UnifiedLogger {
     constructor(options = {}) {
+        this.resultEmitted = false;
         this.enableColors = options.enableColors !== false;
         this.showLevel = options.showLevel !== false;
         this.jsonMode = options.jsonMode === true;
@@ -9776,8 +10486,8 @@ class UnifiedLogger {
             levels: {
                 error: 0,
                 warn: 1,
-                info: 2,
-                success: 3,
+                success: 2,
+                info: 3,
                 debug: 4,
             },
             format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.errors({ stack: true }), winston_1.default.format.printf(({ level, message, timestamp }) => {
@@ -9789,6 +10499,7 @@ class UnifiedLogger {
                 }),
             ],
         });
+        this.setJsonMode(this.jsonMode);
     }
     /**
      * Toggle JSON output mode. When enabled, every log line is emitted as a
@@ -9796,6 +10507,36 @@ class UnifiedLogger {
      */
     setJsonMode(enabled) {
         this.jsonMode = enabled;
+        // In machine mode stdout is reserved for command result records. Progress
+        // and diagnostics remain NDJSON, but go to stderr so callers can parse one
+        // stable stdout object without filtering human-oriented logs.
+        for (const transport of this.logger.transports) {
+            if (transport instanceof winston_1.default.transports.Console) {
+                const consoleTransport = transport;
+                consoleTransport.stderrLevels = Object.fromEntries((enabled ? Object.keys(levelColors) : ['error', 'warn']).map((level) => [level, true]));
+            }
+        }
+    }
+    isJsonMode() {
+        return this.jsonMode;
+    }
+    /** Emit one stable, command-level result record for programmatic callers. */
+    result(result) {
+        if (this.jsonMode && !this.resultEmitted) {
+            this.resultEmitted = true;
+            node_process_1.default.stdout.write(`${JSON.stringify(Object.assign({ ok: true }, result))}\n`);
+        }
+    }
+    hasResult() {
+        return this.resultEmitted;
+    }
+    /** Emit a stable error record without exposing internal stack traces. */
+    failure(code, message, details) {
+        if (this.jsonMode) {
+            node_process_1.default.stderr.write(`${JSON.stringify(Object.assign({ ok: false, code, message }, (details == null ? {} : { details })))}\n`);
+            return;
+        }
+        this.error(message);
     }
     /**
      * Format the message with appropriate colors and structure
@@ -9978,6 +10719,43 @@ const logger = UnifiedLogger.create({ showLevel: false });
 exports.logger = logger;
 
 
+/***/ }),
+
+/***/ 26241:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.resolvePrivateKey = resolvePrivateKey;
+const fs_1 = __importDefault(__nccwpck_require__(79896));
+const path_1 = __importDefault(__nccwpck_require__(16928));
+function resolvePrivateKey(input, defaultKey) {
+    if (input.privkey && input.privkeyFile) {
+        throw new Error('Use only one of --privkey or --privkey-file.');
+    }
+    if (input.privkey)
+        return input.privkey;
+    if (input.privkeyFile) {
+        const filePath = path_1.default.resolve(input.privkeyFile);
+        try {
+            return fs_1.default.readFileSync(filePath, 'utf8').trim();
+        }
+        catch (error) {
+            throw new Error(`Could not read private key file ${filePath}: ${error.message}`);
+        }
+    }
+    if (process.env.OFFCKB_PRIVATE_KEY)
+        return process.env.OFFCKB_PRIVATE_KEY;
+    if (defaultKey)
+        return defaultKey;
+    throw new Error('--privkey, --privkey-file, or OFFCKB_PRIVATE_KEY is required!');
+}
+
+
 /***/ }),
 
 /***/ 65897:
@@ -10072,7 +10850,6 @@ exports.validateUdtTypeArgs = validateUdtTypeArgs;
 const path_1 = __importDefault(__nccwpck_require__(16928));
 const fs_1 = __importDefault(__nccwpck_require__(79896));
 const base_1 = __nccwpck_require__(69951);
-const logger_1 = __nccwpck_require__(65370);
 function validateTypescriptWorkspace() {
     const cwd = process.cwd();
     // Check if package.json exists
@@ -10114,8 +10891,7 @@ function validateNetworkOpt(network) {
         throw new Error('invalid network option, ' + network);
     }
     if (network === base_1.Network.mainnet) {
-        logger_1.logger.info('Mainnet not support yet. Please use CKB-CLI to operate on mainnet for better security. Check https://github.com/nervosnetwork/ckb-cli');
-        process.exit(1);
+        throw new Error('Mainnet not support yet. Please use CKB-CLI to operate on mainnet for better security. Check https://github.com/nervosnetwork/ckb-cli');
     }
 }
 function isValidVersion(version) {
@@ -10171,9 +10947,12 @@ function validateUdtKind(kind) {
 const U128_MAX = (BigInt(1) << BigInt(128)) - BigInt(1);
 function validateUdtAmount(amount) {
     if (!/^\d+$/.test(amount)) {
-        throw new Error(`invalid UDT amount "${amount}", must be a non-negative decimal integer`);
+        throw new Error(`invalid UDT amount "${amount}", must be a positive decimal integer`);
     }
     const value = BigInt(amount);
+    if (value === BigInt(0)) {
+        throw new Error('invalid UDT amount "0", must be greater than zero');
+    }
     if (value > U128_MAX) {
         throw new Error(`UDT amount exceeds 128-bit max: ${amount}`);
     }
@@ -10189,8 +10968,8 @@ function validateHexString(value, name) {
 function validateUdtTypeArgs(kind, typeArgs) {
     const hex = validateHexString(typeArgs, 'type args');
     const byteLength = (hex.length - 2) / 2;
-    if (kind === 'sudt' && byteLength !== 20) {
-        throw new Error(`invalid SUDT type args length: expected 20 bytes, got ${byteLength}`);
+    if (kind === 'sudt' && byteLength !== 32) {
+        throw new Error(`invalid SUDT type args length: expected 32 bytes, got ${byteLength}`);
     }
     if (kind === 'xudt' && byteLength !== 32) {
         throw new Error(`invalid xUDT type args length: expected 32 bytes, got ${byteLength}`);
@@ -130322,7 +131101,7 @@ module.exports = {"version":"3.17.0"};
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"rE":"0.4.9-canary-807f2ef.0","h_":"ckb development network for your first try"}');
+module.exports = /*#__PURE__*/JSON.parse('{"rE":"0.4.9","h_":"ckb development network for your first try"}');
 
 /***/ })