@offckb/cli 0.4.8 → 0.4.9-canary-2b6b3af.0

package/build/index.js

@@ -235,16 +235,23 @@ exports.defaultSettings = {
         transactionsPath: path.resolve(exports.dataPath, 'mainnet/transactions'),
     },
     tools: {
+        rootFolder: path.resolve(exports.dataPath, 'tools'),
         ckbDebugger: {
             minVersion: '0.200.0',
         },
+        ckbTui: {
+            version: 'v0.1.3',
+        },
     },
 };
 function readSettings() {
     try {
         if (fs.existsSync(exports.configPath)) {
             const data = fs.readFileSync(exports.configPath, 'utf8');
-            return deepMerge(exports.defaultSettings, JSON.parse(data));
+            const parsed = JSON.parse(data);
+            validateSettings(parsed);
+            // Deep-clone defaults before merging to prevent mutation of the shared default
+            return deepMerge(deepClone(exports.defaultSettings), parsed);
         }
         else {
             return exports.defaultSettings;
@@ -274,10 +281,26 @@ function getCKBBinaryPath(version) {
     const binaryName = platform === 'win32' ? 'ckb.exe' : 'ckb';
     return path.join(getCKBBinaryInstallPath(version), binaryName);
 }
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(deepClone);
+    }
+    const clone = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            clone[key] = deepClone(obj[key]);
+        }
+    }
+    return clone;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function deepMerge(target, source) {
     for (const key in source) {
-        if (source[key] && typeof source[key] === 'object') {
-            if (!target[key]) {
+        if (source[key] !== null && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+            if (!target[key] || typeof target[key] !== 'object') {
                 target[key] = {};
             }
             deepMerge(target[key], source[key]);
@@ -288,6 +311,29 @@ function deepMerge(target, source) {
     }
     return target;
 }
+function validateSettings(raw) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error('Settings must be a JSON object');
+    }
+    const obj = raw;
+    if (obj.tools && typeof obj.tools === 'object') {
+        const tools = obj.tools;
+        if (tools.rootFolder !== undefined && typeof tools.rootFolder !== 'string') {
+            throw new Error('tools.rootFolder must be a string path');
+        }
+        if (tools.ckbTui && typeof tools.ckbTui === 'object') {
+            const ckbTui = tools.ckbTui;
+            if (ckbTui.version !== undefined && typeof ckbTui.version !== 'string') {
+                throw new Error('tools.ckbTui.version must be a string');
+            }
+        }
+    }
+    if (obj.proxy !== undefined && obj.proxy !== null) {
+        if (typeof obj.proxy !== 'object') {
+            throw new Error('proxy must be an object');
+        }
+    }
+}
 
 
 /***/ }),
@@ -316,6 +362,7 @@ const deposit_1 = __nccwpck_require__(48598);
 const deploy_1 = __nccwpck_require__(79617);
 const transfer_1 = __nccwpck_require__(40265);
 const balance_1 = __nccwpck_require__(77640);
+const udt_1 = __nccwpck_require__(50703);
 const create_1 = __nccwpck_require__(51534);
 const config_1 = __nccwpck_require__(93004);
 const devnet_config_1 = __nccwpck_require__(10015);
@@ -325,20 +372,34 @@ const transfer_all_1 = __nccwpck_require__(92039);
 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();
-program
+program.option('--json', 'Output logs in JSON format for agent/programmatic consumption');
+program.hook('preAction', (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.json) {
+        logger_1.logger.setJsonMode(true);
+    }
+});
+const nodeCommand = program
     .command('node [CKB-Version]')
     .description('Use the CKB to start devnet')
     .option('--network <network>', 'Specify the network to deploy to', 'devnet')
     .option('-b, --binary-path <binaryPath>', 'Specify the CKB binary path to use, only for devnet, when set, will ignore version and network')
+    .option('--daemon', 'Run the node in the background as a daemon (devnet only)')
     .action((version, options) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, node_1.startNode)({ version, network: options.network, binaryPath: options.binaryPath });
+    return (0, node_1.startNode)({ version, network: options.network, binaryPath: options.binaryPath, daemon: options.daemon });
 }));
+nodeCommand
+    .command('stop')
+    .description('Stop the running CKB devnet daemon')
+    .action(() => __awaiter(void 0, void 0, void 0, function* () { return (0, node_1.stopNode)(); }));
 program
     .command('create [project-name]')
     .description('Create a new CKB Smart Contract project in JavaScript.')
@@ -412,13 +473,15 @@ program
     return (0, deposit_1.deposit)(toAddress, amountInCKB, options);
 }));
 program
-    .command('transfer [toAddress] [amountInCKB]')
-    .description('Transfer CKB tokens to address, only devnet and testnet')
+    .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 CKB')
+    .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('--udt-type-args <typeArgs>', 'Specify the UDT type script args to transfer UDT')
     .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, transfer_1.transfer)(toAddress, amountInCKB, options);
+    .action((toAddress, amount, options) => __awaiter(void 0, void 0, void 0, function* () {
+    return (0, transfer_1.transfer)(toAddress, amount, options);
 }));
 program
     .command('transfer-all [toAddress]')
@@ -431,11 +494,36 @@ program
 }));
 program
     .command('balance [toAddress]')
-    .description('Check account balance, only devnet and testnet')
+    .description('Check account balance (CKB + detected SUDT/xUDT), only devnet and testnet')
     .option('--network <network>', 'Specify the network to check', 'devnet')
+    .addOption(new commander_1.Option('--udt-kind <kind>', 'Filter by UDT kind').choices(['sudt', 'xudt']))
+    .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);
 }));
+const udtCommand = program.command('udt').description('UDT token commands');
+udtCommand
+    .command('issue <amount>')
+    .description('Issue new UDT tokens, only devnet and testnet')
+    .option('--network <network>', 'Specify the network', 'devnet')
+    .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')
+    .action((amount, options) => __awaiter(void 0, void 0, void 0, function* () {
+    return (0, udt_1.udtIssue)(amount, options);
+}));
+udtCommand
+    .command('destroy <amount>')
+    .description('Destroy UDT tokens, only devnet and testnet')
+    .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')
+    .action((amount, options) => __awaiter(void 0, void 0, void 0, function* () {
+    return (0, udt_1.udtDestroy)(amount, options);
+}));
 program
     .command('debugger')
     .description('Port of the raw CKB Standalone Debugger')
@@ -445,6 +533,14 @@ program
     .action(() => __awaiter(void 0, void 0, void 0, function* () {
     return ckb_debugger_1.CKBDebugger.runWithArgs(process.argv.slice(2));
 }));
+program
+    .command('status')
+    .description('Show ckb-tui status interface')
+    .option('--network <network>', 'Specify the network whose node status to monitor', '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 });
+}));
 program
     .command('config <action> [item] [value]')
     .description('do a configuration action')
@@ -534,11 +630,31 @@ function balanceOf(address_1) {
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
         const ckb = new ckb_1.CKB({ network });
-        const balanceInCKB = yield ckb.balance(address);
-        logger_1.logger.info(`Balance: ${balanceInCKB} CKB`);
+        const [balanceInCKB, udtBalances] = yield Promise.all([
+            ckb.balance(address),
+            opt.udt !== false ? ckb.detectUdtBalances(address) : Promise.resolve([]),
+        ]);
+        logger_1.logger.info(`CKB: ${balanceInCKB}`);
+        const filtered = filterUdtBalances(udtBalances, opt);
+        if (filtered.length > 0) {
+            logger_1.logger.info('UDT:');
+            for (const udt of filtered) {
+                logger_1.logger.info(`  ${udt.kind} (args=${udt.args}): ${udt.balance}`);
+            }
+        }
         process.exit(0);
     });
 }
+function filterUdtBalances(balances, opt) {
+    if (!opt.udtKind && !opt.udtTypeArgs) {
+        return balances;
+    }
+    return balances.filter((udt) => {
+        const kindMatch = opt.udtKind ? udt.kind === opt.udtKind : true;
+        const argsMatch = opt.udtTypeArgs ? udt.args === opt.udtTypeArgs : true;
+        return kindMatch && argsMatch;
+    });
+}
 
 
 /***/ }),
@@ -1400,6 +1516,39 @@ function devnetConfig() {
 
 "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) {
@@ -1412,9 +1561,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.startNode = startNode;
 exports.nodeDevnet = nodeDevnet;
+exports.stopNode = stopNode;
 exports.nodeTestnet = nodeTestnet;
 exports.nodeMainnet = nodeMainnet;
 const child_process_1 = __nccwpck_require__(35317);
+const fs = __importStar(__nccwpck_require__(79896));
+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);
@@ -1422,13 +1574,20 @@ const encoding_1 = __nccwpck_require__(6851);
 const rpc_proxy_1 = __nccwpck_require__(46589);
 const base_1 = __nccwpck_require__(69951);
 const logger_1 = __nccwpck_require__(65370);
-function startNode({ version, network = base_1.Network.devnet, binaryPath }) {
+const DAEMON_LOG_DIR = 'logs';
+const DAEMON_LOG_FILE = 'daemon.log';
+const DAEMON_PID_FILE = 'daemon.pid';
+const DAEMON_CHILD_ENV = 'OFFCKB_DAEMON_CHILD';
+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.');
     }
+    if (daemon && network !== base_1.Network.devnet) {
+        logger_1.logger.warn('Daemon mode is only supported for devnet. The daemon flag will be ignored.');
+    }
     switch (network) {
         case base_1.Network.devnet:
-            return nodeDevnet({ version, binaryPath });
+            return nodeDevnet({ version, binaryPath, daemon });
         case base_1.Network.testnet:
             return nodeTestnet();
         case base_1.Network.mainnet:
@@ -1438,8 +1597,11 @@ function startNode({ version, network = base_1.Network.devnet, binaryPath }) {
     }
 }
 function nodeDevnet(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ version, binaryPath }) {
+    return __awaiter(this, arguments, void 0, function* ({ version, binaryPath, daemon }) {
         var _b, _c;
+        if (daemon) {
+            return startDaemon();
+        }
         const settings = (0, setting_1.readSettings)();
         const ckbVersion = version || settings.bins.defaultCKBVersion;
         let ckbBinPath = '';
@@ -1494,6 +1656,314 @@ function nodeDevnet(_a) {
         }
     });
 }
+function resolveDaemonPaths() {
+    const settings = (0, setting_1.readSettings)();
+    const logDir = path.join(settings.devnet.dataPath, DAEMON_LOG_DIR);
+    const logFile = path.join(logDir, DAEMON_LOG_FILE);
+    const pidFile = path.join(logDir, DAEMON_PID_FILE);
+    return { logDir, logFile, pidFile };
+}
+function readPidFile(pidFile) {
+    var _a, _b;
+    let raw;
+    try {
+        raw = fs.readFileSync(pidFile, 'utf8').trim();
+    }
+    catch (error) {
+        // Treat a missing or unreadable PID file as "no daemon".
+        return null;
+    }
+    if (!raw) {
+        return null;
+    }
+    // Backward compatibility: plain integer PID written by older versions.
+    const plainPid = Number(raw);
+    if (Number.isInteger(plainPid) && plainPid > 0) {
+        return { pid: plainPid, scriptPath: (_a = resolveCliEntry()) !== null && _a !== void 0 ? _a : '', startedAt: new Date(0).toISOString() };
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const pid = Number(parsed.pid);
+        if (Number.isInteger(pid) && pid > 0 && typeof parsed.scriptPath === 'string') {
+            return {
+                pid,
+                scriptPath: parsed.scriptPath,
+                startedAt: (_b = parsed.startedAt) !== null && _b !== void 0 ? _b : new Date(0).toISOString(),
+            };
+        }
+    }
+    catch (_c) {
+        // fall through to sentinel below
+    }
+    // Content exists but is neither a valid plain PID nor valid metadata.
+    // Return a sentinel so stopNode can report an invalid PID and clean up.
+    return { pid: NaN, scriptPath: '', startedAt: new Date(0).toISOString() };
+}
+function writePidFile(pidFile, metadata) {
+    fs.writeFileSync(pidFile, JSON.stringify(metadata, null, 2));
+}
+function resolveCliEntry() {
+    var _a;
+    // In priority order. process.argv[1] is the most reliable for a Node CLI.
+    // OFFCKB_CLI_PATH is an escape hatch for packaged/npx/weird environments.
+    // require.main?.filename is a final fallback when argv is unavailable.
+    const candidates = [process.env.OFFCKB_CLI_PATH, process.argv[1], (_a = require.main) === null || _a === void 0 ? void 0 : _a.filename].filter((c) => typeof c === 'string' && c.length > 0);
+    for (const candidate of candidates) {
+        try {
+            const resolved = path.resolve(candidate);
+            const stats = fs.statSync(resolved);
+            if (stats.isFile()) {
+                return resolved;
+            }
+        }
+        catch (_b) {
+            // Candidate is missing or not a file; try the next one.
+        }
+    }
+    return null;
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function cleanupPidFile(pidFile) {
+    try {
+        fs.unlinkSync(pidFile);
+    }
+    catch (error) {
+        logger_1.logger.warn(`Failed to remove PID file ${pidFile}:`, error);
+    }
+}
+function waitForProcessExit(pid, timeoutMs) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        const check = () => {
+            if (!isProcessAlive(pid)) {
+                resolve(true);
+                return;
+            }
+            if (Date.now() - start >= timeoutMs) {
+                resolve(false);
+                return;
+            }
+            setTimeout(check, 100);
+        };
+        check();
+    });
+}
+function getProcessCommandLine(pid) {
+    return new Promise((resolve) => {
+        if (process.platform === 'win32') {
+            (0, child_process_1.exec)(`wmic process where ProcessId=${pid} get CommandLine /format:list`, (error, stdout) => {
+                if (error) {
+                    resolve(null);
+                    return;
+                }
+                const match = stdout.match(/CommandLine=(.+)/);
+                resolve(match ? match[1].trim() : null);
+            });
+        }
+        else {
+            (0, child_process_1.exec)(`ps -p ${pid} -o args=`, (error, stdout) => {
+                if (error) {
+                    resolve(null);
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+        }
+    });
+}
+function verifyDaemonIdentity(pid, metadata) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cmdline = yield getProcessCommandLine(pid);
+        if (!cmdline) {
+            return false;
+        }
+        // The daemon child re-runs the same CLI entry point, so its command line
+        // should reference the same script and should be a Node process.
+        const scriptName = path.basename(metadata.scriptPath);
+        const scriptDir = path.dirname(metadata.scriptPath);
+        const looksLikeNode = cmdline.includes('node') || cmdline.includes('nodejs');
+        const looksLikeOurScript = cmdline.includes(metadata.scriptPath) || (scriptName !== '' && cmdline.includes(scriptName));
+        const looksLikeOffckb = cmdline.includes('offckb') || scriptDir.includes('offckb');
+        return looksLikeNode && (looksLikeOurScript || looksLikeOffckb);
+    });
+}
+function terminateProcess(pid, signal) {
+    return new Promise((resolve, reject) => {
+        if (process.platform === 'win32') {
+            // Windows has no POSIX signals and process.kill(pid) only terminates the
+            // single process. Use taskkill to terminate the whole tree.
+            // /T kills the process and all child processes.
+            // /F forces termination when SIGKILL is requested.
+            const args = signal === 'SIGKILL' ? ['/T', '/F', '/PID', String(pid)] : ['/T', '/PID', String(pid)];
+            const taskkill = (0, child_process_1.spawn)('taskkill', args, { stdio: 'ignore' });
+            taskkill.on('error', reject);
+            taskkill.on('exit', () => {
+                // taskkill may return non-zero if the process is already gone, which
+                // is acceptable for our purposes.
+                resolve();
+            });
+            return;
+        }
+        // On POSIX, detached: true makes the child a session/process group leader.
+        // A negative pid sends the signal to the entire process group, ensuring
+        // the CKB node, miner and RPC proxy all receive it.
+        try {
+            process.kill(-pid, signal);
+            resolve();
+        }
+        catch (error) {
+            reject(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,
+        });
+    }
+    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.');
+        closeFileDescriptors(out, err);
+        return;
+    }
+    child.unref();
+    child.on('error', (error) => {
+        logger_1.logger.error('Daemon child process failed to start:', error);
+        cleanupPidFile(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) {
+        if (fd === undefined)
+            continue;
+        try {
+            fs.closeSync(fd);
+        }
+        catch (_a) {
+            // ignore
+        }
+    }
+}
+function stopNode() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { pidFile } = resolveDaemonPaths();
+        const metadata = readPidFile(pidFile);
+        if (!metadata) {
+            logger_1.logger.warn(`No daemon PID file found at ${pidFile}. Is the devnet daemon running?`);
+            return;
+        }
+        const pid = metadata.pid;
+        if (!Number.isInteger(pid) || pid <= 0) {
+            logger_1.logger.error(`Invalid PID in ${pidFile}: ${pid}`);
+            cleanupPidFile(pidFile);
+            return;
+        }
+        if (!isProcessAlive(pid)) {
+            logger_1.logger.warn(`Daemon process ${pid} is not running.`);
+            cleanupPidFile(pidFile);
+            return;
+        }
+        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. ` +
+                `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 {
+            yield terminateProcess(pid, 'SIGTERM');
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ESRCH') {
+                logger_1.logger.warn(`Daemon process ${pid} is not running.`);
+                cleanupPidFile(pidFile);
+                return;
+            }
+            if (err.code === 'EPERM') {
+                logger_1.logger.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;
+        }
+        const exited = yield waitForProcessExit(pid, 5000);
+        if (!exited) {
+            logger_1.logger.warn(`Daemon process ${pid} did not exit gracefully, sending SIGKILL...`);
+            try {
+                yield terminateProcess(pid, 'SIGKILL');
+            }
+            catch (error) {
+                logger_1.logger.error(`Failed to send SIGKILL to daemon process ${pid}:`, error);
+            }
+        }
+        cleanupPidFile(pidFile);
+        logger_1.logger.success('CKB devnet daemon stopped.');
+    });
+}
 function nodeTestnet() {
     return __awaiter(this, void 0, void 0, function* () {
         // todo: maybe we can actually start a node for testnet later
@@ -1518,6 +1988,130 @@ function nodeMainnet() {
 }
 
 
+/***/ }),
+
+/***/ 71420:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"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) {
+        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.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 NETWORK_SETTINGS_KEY = {
+    [base_1.Network.devnet]: 'devnet',
+    [base_1.Network.testnet]: 'testnet',
+    [base_1.Network.mainnet]: 'mainnet',
+};
+function status(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ network }) {
+        var _b;
+        // 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);
+        }
+        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 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;
+        }
+    });
+}
+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');
+        });
+    });
+}
+
+
 /***/ }),
 
 /***/ 86198:
@@ -1829,9 +2423,9 @@ 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 logger_1 = __nccwpck_require__(65370);
-function transfer(toAddress_1, amountInCKB_1) {
-    return __awaiter(this, arguments, void 0, function* (toAddress, amountInCKB, opt = { network: base_1.Network.devnet }) {
+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) {
@@ -1839,16 +2433,89 @@ function transfer(toAddress_1, amountInCKB_1) {
         }
         const privateKey = opt.privkey;
         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);
+            const txHash = yield ckb.udtTransfer({
+                toAddress,
+                amount,
+                privateKey,
+                udtType,
+                kind,
+            });
+            (0, link_1.logTxSuccess)(network, txHash, 'transfer UDT');
+            return;
+        }
         const txHash = yield ckb.transfer({
             toAddress,
-            amountInCKB,
+            amountInCKB: amount,
             privateKey,
         });
-        if (network === 'testnet') {
-            logger_1.logger.info(`Successfully transfer, check ${(0, link_1.buildTestnetTxLink)(txHash)} for details.`);
-            return;
+        (0, link_1.logTxSuccess)(network, txHash, 'transfer');
+    });
+}
+
+
+/***/ }),
+
+/***/ 50703:
+/***/ (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.udtIssue = udtIssue;
+exports.udtDestroy = udtDestroy;
+const ckb_1 = __nccwpck_require__(83748);
+const base_1 = __nccwpck_require__(69951);
+const link_1 = __nccwpck_require__(27814);
+const validator_1 = __nccwpck_require__(39534);
+function udtIssue(amount_1) {
+    return __awaiter(this, arguments, void 0, function* (amount, opt = { network: base_1.Network.devnet, udtKind: 'sudt', privkey: '' }) {
+        const network = opt.network;
+        (0, validator_1.validateNetworkOpt)(network);
+        (0, validator_1.validateUdtKind)(opt.udtKind);
+        if (!opt.privkey) {
+            throw new Error('--privkey is required!');
         }
-        logger_1.logger.info('Successfully transfer, txHash:', txHash);
+        const ckb = new ckb_1.CKB({ network });
+        const txHash = yield ckb.udtIssue({
+            privateKey: opt.privkey,
+            kind: opt.udtKind,
+            amount,
+            typeArgs: opt.typeArgs ? (0, validator_1.validateUdtTypeArgs)(opt.udtKind, opt.typeArgs) : undefined,
+            toAddress: opt.to,
+        });
+        (0, link_1.logTxSuccess)(network, txHash, 'issued UDT');
+    });
+}
+function udtDestroy(amount_1) {
+    return __awaiter(this, arguments, void 0, function* (amount, opt = { network: base_1.Network.devnet, udtKind: 'sudt', typeArgs: '', privkey: '' }) {
+        const network = opt.network;
+        (0, validator_1.validateNetworkOpt)(network);
+        (0, validator_1.validateUdtKind)(opt.udtKind);
+        if (!opt.privkey) {
+            throw new Error('--privkey is required!');
+        }
+        const ckb = new ckb_1.CKB({ network });
+        const txHash = yield ckb.udtDestroy({
+            privateKey: opt.privkey,
+            kind: opt.udtKind,
+            amount,
+            typeArgs: (0, validator_1.validateUdtTypeArgs)(opt.udtKind, opt.typeArgs),
+        });
+        (0, link_1.logTxSuccess)(network, txHash, 'destroyed UDT');
     });
 }
 
@@ -3827,18 +4494,36 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.CKB = exports.CKBProps = void 0;
 const core_1 = __nccwpck_require__(39842);
 const validator_1 = __nccwpck_require__(39534);
 const network_1 = __nccwpck_require__(5370);
 const private_1 = __nccwpck_require__(5835);
+const public_1 = __nccwpck_require__(84535);
 const migration_1 = __nccwpck_require__(76679);
 const base_1 = __nccwpck_require__(69951);
 const logger_1 = __nccwpck_require__(65370);
+const DEFAULT_UDT_SCAN_MAX_CELLS = 1000;
+const DEFAULT_UDT_DESTROY_MAX_INPUT_CELLS = 100;
 class CKBProps {
 }
 exports.CKBProps = CKBProps;
+function readUdtBalance(outputData) {
+    try {
+        return BigInt(core_1.ccc.udtBalanceFrom(outputData));
+    }
+    catch (_a) {
+        return null;
+    }
+}
 class CKB {
     constructor({ network = base_1.Network.devnet, feeRate = 1000, isEnableProxyRpc = true }) {
         if (!(0, validator_1.isValidNetworkString)(network)) {
@@ -3972,6 +4657,286 @@ class CKB {
             return txHash;
         });
     }
+    getSystemScripts() {
+        if (this.network === base_1.Network.mainnet) {
+            return public_1.MAINNET_SYSTEM_SCRIPTS;
+        }
+        if (this.network === base_1.Network.testnet) {
+            return public_1.TESTNET_SYSTEM_SCRIPTS;
+        }
+        const scripts = (0, private_1.getDevnetSystemScriptsFromListHashes)();
+        if (!scripts) {
+            throw new Error(`Failed to load devnet system scripts`);
+        }
+        return scripts;
+    }
+    buildUdtTypeScript(kind, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (kind === 'xudt') {
+                return core_1.ccc.Script.fromKnownScript(this.client, core_1.ccc.KnownScript.XUdt, args);
+            }
+            const scriptInfo = yield this.getUdtScriptInfo(kind);
+            return core_1.ccc.Script.from({
+                codeHash: scriptInfo.codeHash,
+                hashType: scriptInfo.hashType,
+                args,
+            });
+        });
+    }
+    getUdtScriptInfo(kind) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (kind === 'xudt') {
+                return this.client.getKnownScript(core_1.ccc.KnownScript.XUdt);
+            }
+            const systemScripts = this.getSystemScripts();
+            const sudtScript = (_a = systemScripts.sudt) === null || _a === void 0 ? void 0 : _a.script;
+            if (!sudtScript) {
+                throw new Error(`SUDT script not found on ${this.network}`);
+            }
+            return sudtScript;
+        });
+    }
+    detectUdtBalances(address_1) {
+        return __awaiter(this, arguments, void 0, function* (address, { maxCells = DEFAULT_UDT_SCAN_MAX_CELLS } = {}) {
+            const lock = (yield core_1.ccc.Address.fromString(address, this.client)).script;
+            const sudtScriptInfo = yield this.getUdtScriptInfo('sudt').catch(() => null);
+            const xudtScriptInfo = yield this.getUdtScriptInfo('xudt').catch(() => null);
+            const balances = new Map();
+            let scanned = 0;
+            const scan = (scriptInfo, kind) => __awaiter(this, void 0, void 0, function* () {
+                var _a, e_1, _b, _c;
+                var _d, _e;
+                try {
+                    for (var _f = true, _g = __asyncValues(this.client.findCells({
+                        script: {
+                            codeHash: scriptInfo.codeHash,
+                            hashType: scriptInfo.hashType,
+                            args: '0x',
+                        },
+                        scriptType: 'type',
+                        scriptSearchMode: 'prefix',
+                        filter: { script: lock },
+                        withData: true,
+                    }, 'asc')), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                        _c = _h.value;
+                        _f = false;
+                        const cell = _c;
+                        if (scanned >= maxCells) {
+                            logger_1.logger.warn(`UDT balance scan stopped after ${maxCells} cells; balances may be incomplete`);
+                            break;
+                        }
+                        scanned++;
+                        const type = cell.cellOutput.type;
+                        if (!type) {
+                            continue;
+                        }
+                        const cellBalance = readUdtBalance(cell.outputData);
+                        if (cellBalance == null) {
+                            logger_1.logger.debug(`Skipping corrupted UDT cell ${(_d = cell.outPoint) === null || _d === void 0 ? void 0 : _d.txHash}:${(_e = cell.outPoint) === null || _e === void 0 ? void 0 : _e.index}`);
+                            continue;
+                        }
+                        const key = `${kind}:${type.codeHash}:${type.hashType}:${type.args}`;
+                        const entry = balances.get(key);
+                        if (entry) {
+                            entry.balance += cellBalance;
+                        }
+                        else {
+                            balances.set(key, {
+                                kind,
+                                codeHash: type.codeHash,
+                                hashType: String(type.hashType),
+                                args: type.args,
+                                balance: cellBalance,
+                            });
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            });
+            if (sudtScriptInfo) {
+                yield scan(sudtScriptInfo, 'sudt');
+            }
+            if (xudtScriptInfo) {
+                yield scan(xudtScriptInfo, 'xudt');
+            }
+            return Array.from(balances.values()).map((item) => (Object.assign(Object.assign({}, item), { balance: item.balance.toString() })));
+        });
+    }
+    udtBalance(address_1, udtType_1) {
+        return __awaiter(this, arguments, void 0, function* (address, udtType, { maxCells = DEFAULT_UDT_SCAN_MAX_CELLS } = {}) {
+            var _a, e_2, _b, _c;
+            const lock = (yield core_1.ccc.Address.fromString(address, this.client)).script;
+            let balance = BigInt(0);
+            let scanned = 0;
+            try {
+                for (var _d = true, _e = __asyncValues(this.client.findCellsByLock(lock, udtType, true)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const cell = _c;
+                    scanned++;
+                    if (scanned > maxCells) {
+                        logger_1.logger.warn(`UDT balance scan stopped after ${maxCells} cells; balances may be incomplete`);
+                        break;
+                    }
+                    const cellBalance = readUdtBalance(cell.outputData);
+                    if (cellBalance != null) {
+                        balance += cellBalance;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return balance.toString();
+        });
+    }
+    udtTransfer(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ privateKey, toAddress, amount, udtType, kind }) {
+            const signer = this.buildSigner(privateKey);
+            const to = yield core_1.ccc.Address.fromString(toAddress, this.client);
+            const amountBigInt = (0, validator_1.validateUdtAmount)(amount);
+            const outputsData = [core_1.ccc.hexFrom(core_1.ccc.numToBytes(amountBigInt, 16))];
+            const tx = core_1.ccc.Transaction.from({
+                outputs: [
+                    {
+                        lock: to.script,
+                        type: udtType,
+                        capacity: core_1.ccc.fixedPointFrom(0),
+                    },
+                ],
+                outputsData,
+            });
+            const scriptInfo = yield this.getUdtScriptInfo(kind);
+            tx.addCellDeps(scriptInfo.cellDeps.map((dep) => dep.cellDep));
+            yield tx.completeInputsByUdt(signer, udtType);
+            const inputsUdtBalance = yield tx.getInputsUdtBalance(this.client, udtType);
+            const outputsUdtBalance = tx.getOutputsUdtBalance(udtType);
+            const changeAmount = inputsUdtBalance - outputsUdtBalance;
+            if (changeAmount > BigInt(0)) {
+                const from = yield signer.getAddressObjSecp256k1();
+                tx.outputs.push(core_1.ccc.CellOutput.from({
+                    lock: from.script,
+                    type: udtType,
+                    capacity: core_1.ccc.fixedPointFrom(0),
+                }, core_1.ccc.hexFrom(core_1.ccc.numToBytes(changeAmount, 16))));
+                tx.outputsData.push(core_1.ccc.hexFrom(core_1.ccc.numToBytes(changeAmount, 16)));
+            }
+            yield tx.completeFeeBy(signer, this.feeRate);
+            const txHash = yield signer.sendTransaction(tx);
+            return txHash;
+        });
+    }
+    udtIssue(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ privateKey, kind, amount, typeArgs, toAddress }) {
+            const signer = this.buildSigner(privateKey);
+            const signerAddress = yield signer.getAddressObjSecp256k1();
+            const to = toAddress ? yield core_1.ccc.Address.fromString(toAddress, this.client) : signerAddress;
+            const amountBigInt = (0, validator_1.validateUdtAmount)(amount);
+            let resolvedTypeArgs;
+            if (kind === 'sudt') {
+                if (typeArgs) {
+                    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));
+            }
+            else {
+                if (typeArgs) {
+                    resolvedTypeArgs = (0, validator_1.validateUdtTypeArgs)(kind, typeArgs);
+                }
+                else {
+                    const issuerLockHash = signerAddress.script.hash();
+                    resolvedTypeArgs = issuerLockHash;
+                }
+            }
+            const udtType = yield this.buildUdtTypeScript(kind, resolvedTypeArgs);
+            const outputsData = [core_1.ccc.hexFrom(core_1.ccc.numToBytes(amountBigInt, 16))];
+            const tx = core_1.ccc.Transaction.from({
+                outputs: [
+                    {
+                        lock: to.script,
+                        type: udtType,
+                        capacity: core_1.ccc.fixedPointFrom(0),
+                    },
+                ],
+                outputsData,
+            });
+            const scriptInfo = yield this.getUdtScriptInfo(kind);
+            tx.addCellDeps(scriptInfo.cellDeps.map((dep) => dep.cellDep));
+            yield tx.completeInputsByCapacity(signer);
+            yield tx.completeFeeBy(signer, this.feeRate);
+            const txHash = yield signer.sendTransaction(tx);
+            return txHash;
+        });
+    }
+    udtDestroy(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ privateKey, kind, typeArgs, amount }, { maxInputCells = DEFAULT_UDT_DESTROY_MAX_INPUT_CELLS } = {}) {
+            var _b, e_3, _c, _d;
+            const signer = this.buildSigner(privateKey);
+            const from = yield signer.getAddressObjSecp256k1();
+            const validatedTypeArgs = (0, validator_1.validateUdtTypeArgs)(kind, typeArgs);
+            const udtType = yield this.buildUdtTypeScript(kind, validatedTypeArgs);
+            const destroyAmount = (0, validator_1.validateUdtAmount)(amount);
+            const cells = [];
+            let totalBalance = BigInt(0);
+            try {
+                for (var _e = true, _f = __asyncValues(this.client.findCellsByLock(from.script, udtType, true)), _g; _g = yield _f.next(), _b = _g.done, !_b; _e = true) {
+                    _d = _g.value;
+                    _e = false;
+                    const cell = _d;
+                    if (cells.length >= maxInputCells) {
+                        throw new Error(`Too many UDT cells to destroy (limit: ${maxInputCells}); split into smaller operations`);
+                    }
+                    const cellBalance = readUdtBalance(cell.outputData);
+                    if (cellBalance == null) {
+                        continue;
+                    }
+                    cells.push(cell);
+                    totalBalance += cellBalance;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_e && !_b && (_c = _f.return)) yield _c.call(_f);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            if (totalBalance < destroyAmount) {
+                throw new Error(`Insufficient UDT balance: ${totalBalance} < ${destroyAmount}`);
+            }
+            if (destroyAmount === totalBalance) {
+                throw new Error('Destroying the entire UDT balance may be rejected by the UDT script. Leave at least 1 token or use a smaller amount.');
+            }
+            const tx = core_1.ccc.Transaction.from({});
+            for (const cell of cells) {
+                tx.addInput({ previousOutput: cell.outPoint });
+            }
+            const remaining = totalBalance - destroyAmount;
+            tx.addOutput(core_1.ccc.CellOutput.from({
+                lock: from.script,
+                type: udtType,
+                capacity: core_1.ccc.fixedPointFrom(0),
+            }, core_1.ccc.hexFrom(core_1.ccc.numToBytes(remaining, 16))), core_1.ccc.hexFrom(core_1.ccc.numToBytes(remaining, 16)));
+            const scriptInfo = yield this.getUdtScriptInfo(kind);
+            tx.addCellDeps(scriptInfo.cellDeps.map((dep) => dep.cellDep));
+            yield tx.completeInputsByCapacity(signer);
+            yield tx.completeFeeBy(signer, this.feeRate);
+            const txHash = yield signer.sendTransaction(tx);
+            return txHash;
+        });
+    }
     deployScript(scriptBinBytes, privateKey) {
         return __awaiter(this, void 0, void 0, function* () {
             const signer = this.buildSigner(privateKey);
@@ -5103,222 +6068,530 @@ var __importStar = (this && this.__importStar) || (function () {
         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) {
-        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 __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.CKBDebugger = void 0;
+const child_process_1 = __nccwpck_require__(35317);
+const path = __importStar(__nccwpck_require__(16928));
+const setting_1 = __nccwpck_require__(25546);
+const ckb_debugger_wasm_1 = __nccwpck_require__(52948);
+const logger_1 = __nccwpck_require__(65370);
+class CKBDebugger {
+    static getWasmDebugger() {
+        if (!this.wasmDebugger) {
+            const wasmPath = path.join(__dirname, 'ckb-debugger.wasm');
+            this.wasmDebugger = new ckb_debugger_wasm_1.CkbDebuggerWasi({
+                wasmPath,
+                captureOutput: false, // Use stdio directly since custom capture doesn't work with WASI
+            });
+        }
+        return this.wasmDebugger;
+    }
+    /**
+     * Check if we're in a recursive call to avoid infinite loops
+     * This happens when ckb-debugger binary points to offckb CLI
+     */
+    static isRecursiveCall() {
+        // Check if we're already running as a ckb-debugger process
+        if (process.argv[1] && process.argv[1].includes('ckb-debugger')) {
+            logger_1.logger.debug('Detected ckb-debugger process, using WASM to avoid recursion');
+            return true;
+        }
+        // Check if we're running the debugger command (which could be called from ckb-debugger binary)
+        if (process.argv.includes('debugger')) {
+            logger_1.logger.debug('Detected debugger command, using WASM to avoid recursion');
+            return true;
+        }
+        return false;
+    }
+    static shouldUseWasm() {
+        if (this.isRecursiveCall()) {
+            return true;
+        }
+        if (this.isBinaryInstalled() && this.isBinaryVersionValid()) {
+            logger_1.logger.debug('Using native ckb-debugger (better performance)');
+            return false;
+        }
+        else {
+            logger_1.logger.debug('Native ckb-debugger not available, falling back to WASM version');
+            return true;
+        }
+    }
+    static execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.shouldUseWasm()) {
+                try {
+                    const result = yield this.getWasmDebugger().run(args);
+                    if (result.exitCode !== 0) {
+                        process.exit(result.exitCode);
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.error('WASM debugger execution failed:', error);
+                    process.exit(1);
+                }
+            }
+            else {
+                const command = `ckb-debugger ${args.join(' ')}`;
+                (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+            }
+        });
+    }
+    static runRaw(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = options.split(' ').filter((arg) => arg.trim());
+            yield this.execute(args);
+        });
+    }
+    static runTxCellScript(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ fullTxJsonFilePath, cellIndex, cellType, scriptGroupType }) {
+            const args = [
+                '--tx-file',
+                fullTxJsonFilePath,
+                '--cell-index',
+                cellIndex.toString(),
+                '--cell-type',
+                cellType,
+                '--script-group-type',
+                scriptGroupType,
+            ];
+            yield this.execute(args);
+        });
+    }
+    static isBinaryInstalled() {
+        const result = (0, child_process_1.spawnSync)('ckb-debugger', ['--version'], { stdio: 'ignore' });
+        return result.status === 0;
+    }
+    static isBinaryVersionValid() {
+        const result = (0, child_process_1.spawnSync)('ckb-debugger', ['--version']);
+        if (result.status !== 0) {
+            return false;
+        }
+        try {
+            const version = result.stdout.toString().split(' ')[1];
+            const settings = (0, setting_1.readSettings)();
+            if (version < settings.tools.ckbDebugger.minVersion) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static installCKBDebuggerBinary() {
+        const command = `cargo install --git https://github.com/nervosnetwork/ckb-standalone-debugger ckb-debugger`;
+        try {
+            logger_1.logger.info('Installing ckb-debugger...');
+            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+            logger_1.logger.info('ckb-debugger installed successfully. You can uninstall it by running: cargo uninstall ckb-debugger');
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to install ckb-debugger:', error);
+            process.exit(1);
+        }
+    }
+    /**
+     * Create a ckb-debugger fallback binary that points to offckb debugger
+     * This creates a shell script that calls: offckb debugger [args]
+     * Purpose: Reduce user friction by providing a placeholder when native binary is not available
+     * Users can install the real ckb-debugger binary for better performance if needed
+     */
+    static createCkbDebuggerFallback() {
+        const fs = __nccwpck_require__(79896);
+        const { spawnSync } = __nccwpck_require__(35317);
+        const isWindows = process.platform === 'win32';
+        const binName = isWindows ? 'ckb-debugger.cmd' : 'ckb-debugger';
+        // Find the offckb binary location
+        let offckbPath;
+        if (isWindows) {
+            const result = spawnSync('where', ['offckb'], { encoding: 'utf8' });
+            offckbPath = result.stdout.trim().split('\n')[0];
+        }
+        else {
+            const result = spawnSync('which', ['offckb'], { encoding: 'utf8' });
+            offckbPath = result.stdout.trim();
+        }
+        if (!offckbPath) {
+            logger_1.logger.error('❌ Could not find offckb binary. Please ensure offckb is installed and in your PATH.');
+            process.exit(1);
+        }
+        // Get the directory where offckb is located
+        const offckbDir = path.dirname(offckbPath);
+        const targetPath = path.join(offckbDir, binName);
+        // Create the binary content
+        let binContent;
+        if (isWindows) {
+            // Windows batch file
+            binContent = `@echo off
+offckb debugger %*`;
+        }
+        else {
+            // Unix shell script
+            binContent = `#!/bin/sh
+exec offckb debugger "$@"`;
+        }
+        try {
+            // Ensure directory exists
+            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+            // Write the binary
+            fs.writeFileSync(targetPath, binContent);
+            // Make executable on Unix systems
+            if (!isWindows) {
+                fs.chmodSync(targetPath, '755');
+            }
+            logger_1.logger.info(`✅ Created ckb-debugger fallback at: ${targetPath}`);
+            logger_1.logger.info(`   This fallback uses WASM and calls: offckb debugger [args]`);
+            logger_1.logger.info(`   For better performance, install the real binary: cargo install --git https://github.com/nervosnetwork/ckb-standalone-debugger ckb-debugger`);
+            logger_1.logger.info(`   To uninstall the fallback binary: rm ${targetPath}`);
+        }
+        catch (error) {
+            logger_1.logger.error(`❌ Failed to create ckb-debugger fallback: ${error.message}`);
+            logger_1.logger.error(`   Make sure you have write permissions to: ${path.dirname(targetPath)}`);
+            process.exit(1);
+        }
+    }
+    // Additional convenience methods that work with both native binary CLI and WASM
+    static runWithArgs(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.execute(args);
+        });
+    }
+    static version() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.shouldUseWasm()) {
+                const result = yield this.getWasmDebugger().run(['--version']);
+                return result;
+            }
+            else {
+                const result = (0, child_process_1.spawnSync)('ckb-debugger', ['--version'], { encoding: 'utf8' });
+                return {
+                    exitCode: result.status || 0,
+                    output: result.stdout,
+                    error: result.stderr,
+                };
+            }
+        });
+    }
+}
+exports.CKBDebugger = CKBDebugger;
+CKBDebugger.wasmDebugger = null;
+
+
+/***/ }),
+
+/***/ 7020:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CKBDebugger = void 0;
+exports.CKBTui = void 0;
 const child_process_1 = __nccwpck_require__(35317);
 const path = __importStar(__nccwpck_require__(16928));
+const fs = __importStar(__nccwpck_require__(79896));
+const os = __importStar(__nccwpck_require__(70857));
+const crypto = __importStar(__nccwpck_require__(76982));
+const adm_zip_1 = __importDefault(__nccwpck_require__(83746));
 const setting_1 = __nccwpck_require__(25546);
-const ckb_debugger_wasm_1 = __nccwpck_require__(52948);
 const logger_1 = __nccwpck_require__(65370);
-class CKBDebugger {
-    static getWasmDebugger() {
-        if (!this.wasmDebugger) {
-            const wasmPath = path.join(__dirname, 'ckb-debugger.wasm');
-            this.wasmDebugger = new ckb_debugger_wasm_1.CkbDebuggerWasi({
-                wasmPath,
-                captureOutput: false, // Use stdio directly since custom capture doesn't work with WASI
-            });
+const fs_1 = __nccwpck_require__(37293);
+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*)$/;
+class CKBTui {
+    /**
+     * Pure lookup — returns the expected binary path without triggering any
+     * download or installation side effects. May return null if not yet computed.
+     */
+    static getBinaryPath() {
+        if (!this.binaryPath) {
+            const settings = (0, setting_1.readSettings)();
+            const binDir = this.resolveAndValidateBinDir(settings.tools.rootFolder);
+            const binaryName = process.platform === 'win32' ? 'ckb-tui.exe' : 'ckb-tui';
+            this.binaryPath = path.join(binDir, binaryName);
         }
-        return this.wasmDebugger;
+        return this.binaryPath;
     }
     /**
-     * Check if we're in a recursive call to avoid infinite loops
-     * This happens when ckb-debugger binary points to offckb CLI
+     * Returns the binary path, downloading and installing if the binary
+     * does not already exist.
      */
-    static isRecursiveCall() {
-        // Check if we're already running as a ckb-debugger process
-        if (process.argv[1] && process.argv[1].includes('ckb-debugger')) {
-            logger_1.logger.debug('Detected ckb-debugger process, using WASM to avoid recursion');
-            return true;
+    static ensureInstalled() {
+        const binaryPath = this.getBinaryPath();
+        if (binaryPath && fs.existsSync(binaryPath)) {
+            return binaryPath;
         }
-        // Check if we're running the debugger command (which could be called from ckb-debugger binary)
-        if (process.argv.includes('debugger')) {
-            logger_1.logger.debug('Detected debugger command, using WASM to avoid recursion');
-            return true;
-        }
-        return false;
+        // Reset and re-install
+        this.binaryPath = null;
+        this.installSync();
+        return this.binaryPath;
     }
-    static shouldUseWasm() {
-        if (this.isRecursiveCall()) {
-            return true;
+    static isInstalled() {
+        try {
+            const binPath = this.getBinaryPath();
+            return binPath !== null && fs.existsSync(binPath);
         }
-        if (this.isBinaryInstalled() && this.isBinaryVersionValid()) {
-            logger_1.logger.debug('Using native ckb-debugger (better performance)');
+        catch (_a) {
             return false;
         }
-        else {
-            logger_1.logger.debug('Native ckb-debugger not available, falling back to WASM version');
-            return true;
-        }
-    }
-    static execute(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.shouldUseWasm()) {
-                try {
-                    const result = yield this.getWasmDebugger().run(args);
-                    if (result.exitCode !== 0) {
-                        process.exit(result.exitCode);
-                    }
-                }
-                catch (error) {
-                    logger_1.logger.error('WASM debugger execution failed:', error);
-                    process.exit(1);
-                }
-            }
-            else {
-                const command = `ckb-debugger ${args.join(' ')}`;
-                (0, child_process_1.execSync)(command, { stdio: 'inherit' });
-            }
-        });
     }
-    static runRaw(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const args = options.split(' ').filter((arg) => arg.trim());
-            yield this.execute(args);
-        });
+    static run(args = []) {
+        const binaryPath = this.ensureInstalled();
+        return (0, child_process_1.spawnSync)(binaryPath, args, { stdio: 'inherit' });
     }
-    static runTxCellScript(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ fullTxJsonFilePath, cellIndex, cellType, scriptGroupType }) {
-            const args = [
-                '--tx-file',
-                fullTxJsonFilePath,
-                '--cell-index',
-                cellIndex.toString(),
-                '--cell-type',
-                cellType,
-                '--script-group-type',
-                scriptGroupType,
-            ];
-            yield this.execute(args);
-        });
+    // --- private helpers ---
+    /**
+     * Resolve and validate that the configured rootFolder is under the
+     * OffCKB data directory. Rejects paths that resolve outside.
+     */
+    static resolveAndValidateBinDir(configuredRoot) {
+        const resolved = path.resolve(configuredRoot);
+        const resolvedData = path.resolve(setting_1.dataPath);
+        // Require the resolved path to be within the resolved data directory
+        const relative = path.relative(resolvedData, resolved);
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
+            throw new Error(`tools.rootFolder ("${configuredRoot}") resolves outside the OffCKB data directory ` +
+                `("${resolvedData}"). For security, tool binaries must be stored under the data path.`);
+        }
+        return resolved;
     }
-    static isBinaryInstalled() {
-        const result = (0, child_process_1.spawnSync)('ckb-debugger', ['--version'], { stdio: 'ignore' });
-        return result.status === 0;
+    static validateVersion(version) {
+        if (!STRICT_VERSION_REGEX.test(version)) {
+            throw new Error(`Invalid version format: "${version}". Expected format: vX.Y.Z (e.g., v0.1.3)`);
+        }
     }
-    static isBinaryVersionValid() {
-        const result = (0, child_process_1.spawnSync)('ckb-debugger', ['--version']);
-        if (result.status !== 0) {
-            return false;
+    static getAssetName() {
+        const platform = process.platform;
+        const arch = process.arch;
+        if (platform === 'darwin') {
+            if (arch !== 'arm64') {
+                throw new Error(`Unsupported architecture for macOS: ${arch}. Only Apple Silicon (arm64) is supported.`);
+            }
+            return 'ckb-tui-with-node-macos-aarch64.tar.gz';
         }
-        try {
-            const version = result.stdout.toString().split(' ')[1];
-            const settings = (0, setting_1.readSettings)();
-            if (version < settings.tools.ckbDebugger.minVersion) {
-                return false;
+        else if (platform === 'linux') {
+            if (arch !== 'x64') {
+                throw new Error(`Unsupported architecture for Linux: ${arch}. Only x86_64 is supported.`);
             }
-            return true;
+            return 'ckb-tui-with-node-linux-amd64.tar.gz';
         }
-        catch (error) {
-            return false;
+        else if (platform === 'win32') {
+            if (arch !== 'x64') {
+                throw new Error(`Unsupported architecture for Windows: ${arch}. Only x86_64 is supported.`);
+            }
+            return 'ckb-tui-with-node-windows-amd64.zip';
         }
+        throw new Error(`Unsupported platform: ${platform}`);
     }
-    static installCKBDebuggerBinary() {
-        const command = `cargo install --git https://github.com/nervosnetwork/ckb-standalone-debugger ckb-debugger`;
+    /**
+     * Synchronously download and install the ckb-tui binary.
+     * Uses spawnSync with array arguments (no shell interpolation) for security.
+     */
+    static installSync() {
+        const settings = (0, setting_1.readSettings)();
+        const version = settings.tools.ckbTui.version;
+        this.validateVersion(version);
+        const assetName = this.getAssetName();
+        const binDir = this.resolveAndValidateBinDir(settings.tools.rootFolder);
+        const binaryName = process.platform === 'win32' ? 'ckb-tui.exe' : 'ckb-tui';
+        this.binaryPath = path.join(binDir, binaryName);
+        const downloadUrl = `https://github.com/Officeyutong/ckb-tui/releases/download/${version}/${assetName}`;
+        // Ensure the target directory exists
+        fs.mkdirSync(binDir, { recursive: true });
+        // Use a temp directory for atomic download & extraction
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'offckb-ckb-tui-'));
+        const archivePath = path.join(tempDir, assetName);
         try {
-            logger_1.logger.info('Installing ckb-debugger...');
-            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
-            logger_1.logger.info('ckb-debugger installed successfully. You can uninstall it by running: cargo uninstall ckb-debugger');
+            // 1. Download
+            logger_1.logger.info(`Downloading ckb-tui from ${downloadUrl}...`);
+            const curlResult = (0, child_process_1.spawnSync)('curl', ['-fsSL', '--max-time', '300', '-o', archivePath, downloadUrl], {
+                stdio: 'inherit',
+                timeout: DOWNLOAD_TIMEOUT_MS,
+            });
+            if (curlResult.error) {
+                throw new Error(`Failed to download ckb-tui: ${curlResult.error.message}`);
+            }
+            if (curlResult.status !== 0) {
+                throw new Error(`curl exited with code ${curlResult.status}`);
+            }
+            // 2. Verify checksum (best-effort: warns if checksum file is unavailable)
+            this.verifyChecksum(version, assetName, archivePath);
+            // 3. Extract to temp directory
+            logger_1.logger.info('Extracting...');
+            const extractDir = path.join(tempDir, 'extracted');
+            fs.mkdirSync(extractDir, { recursive: true });
+            this.extractArchive(archivePath, extractDir);
+            // 4. Locate the extracted binary
+            const extractedBinary = (0, fs_1.findFileInFolder)(extractDir, binaryName);
+            if (!extractedBinary) {
+                throw new Error(`ckb-tui binary ("${binaryName}") was not found after extraction.`);
+            }
+            // 5. Atomically move to the final location
+            fs.renameSync(extractedBinary, this.binaryPath);
+            // 6. Make executable on Unix
+            if (process.platform !== 'win32') {
+                fs.chmodSync(this.binaryPath, 0o755);
+            }
+            logger_1.logger.info('ckb-tui installed successfully.');
         }
         catch (error) {
-            logger_1.logger.error('Failed to install ckb-debugger:', error);
-            process.exit(1);
+            // Reset cached path on failure so a subsequent call retries
+            this.binaryPath = null;
+            const message = error instanceof Error ? error.message : String(error);
+            logger_1.logger.error('Failed to download/install ckb-tui:', message, '\nPlease check your network connectivity, verify that the specified version exists in the releases, ' +
+                'and ensure you have sufficient file system permissions.');
+            throw error;
+        }
+        finally {
+            // Clean up the temp directory
+            try {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch (_a) {
+                // Best-effort cleanup — temp dir will be cleaned by the OS eventually
+            }
         }
     }
     /**
-     * Create a ckb-debugger fallback binary that points to offckb debugger
-     * This creates a shell script that calls: offckb debugger [args]
-     * Purpose: Reduce user friction by providing a placeholder when native binary is not available
-     * Users can install the real ckb-debugger binary for better performance if needed
+     * 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.
      */
-    static createCkbDebuggerFallback() {
-        const fs = __nccwpck_require__(79896);
-        const { spawnSync } = __nccwpck_require__(35317);
-        const isWindows = process.platform === 'win32';
-        const binName = isWindows ? 'ckb-debugger.cmd' : 'ckb-debugger';
-        // Find the offckb binary location
-        let offckbPath;
-        if (isWindows) {
-            const result = spawnSync('where', ['offckb'], { encoding: 'utf8' });
-            offckbPath = result.stdout.trim().split('\n')[0];
-        }
-        else {
-            const result = spawnSync('which', ['offckb'], { encoding: 'utf8' });
-            offckbPath = result.stdout.trim();
-        }
-        if (!offckbPath) {
-            logger_1.logger.error('❌ Could not find offckb binary. Please ensure offckb is installed and in your PATH.');
-            process.exit(1);
-        }
-        // Get the directory where offckb is located
-        const offckbDir = path.dirname(offckbPath);
-        const targetPath = path.join(offckbDir, binName);
-        // Create the binary content
-        let binContent;
-        if (isWindows) {
-            // Windows batch file
-            binContent = `@echo off
-offckb debugger %*`;
-        }
-        else {
-            // Unix shell script
-            binContent = `#!/bin/sh
-exec offckb debugger "$@"`;
+    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 {
-            // Ensure directory exists
-            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-            // Write the binary
-            fs.writeFileSync(targetPath, binContent);
-            // Make executable on Unix systems
-            if (!isWindows) {
-                fs.chmodSync(targetPath, '755');
+            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;
             }
-            logger_1.logger.info(`✅ Created ckb-debugger fallback at: ${targetPath}`);
-            logger_1.logger.info(`   This fallback uses WASM and calls: offckb debugger [args]`);
-            logger_1.logger.info(`   For better performance, install the real binary: cargo install --git https://github.com/nervosnetwork/ckb-standalone-debugger ckb-debugger`);
-            logger_1.logger.info(`   To uninstall the fallback binary: rm ${targetPath}`);
+            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.');
         }
-        catch (error) {
-            logger_1.logger.error(`❌ Failed to create ckb-debugger fallback: ${error.message}`);
-            logger_1.logger.error(`   Make sure you have write permissions to: ${path.dirname(targetPath)}`);
-            process.exit(1);
+        finally {
+            try {
+                fs.unlinkSync(checksumPath);
+            }
+            catch (_a) {
+                // Best effort
+            }
         }
     }
-    // Additional convenience methods that work with both native binary CLI and WASM
-    static runWithArgs(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.execute(args);
-        });
+    /**
+     * 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();
+            }
+        }
+        return null;
     }
-    static version() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.shouldUseWasm()) {
-                const result = yield this.getWasmDebugger().run(['--version']);
-                return result;
+    /**
+     * Extract a downloaded archive to the given directory.
+     * Uses AdmZip for .zip files (Node-native, no shell) and spawnSync with array
+     * arguments for .tar.gz (no shell interpolation).
+     */
+    static extractArchive(archivePath, extractDir) {
+        if (archivePath.endsWith('.tar.gz')) {
+            const result = (0, child_process_1.spawnSync)('tar', ['-xzf', archivePath, '-C', extractDir], {
+                stdio: 'inherit',
+                timeout: EXTRACT_TIMEOUT_MS,
+            });
+            if (result.error) {
+                throw new Error(`tar extraction failed: ${result.error.message}`);
             }
-            else {
-                const result = (0, child_process_1.spawnSync)('ckb-debugger', ['--version'], { encoding: 'utf8' });
-                return {
-                    exitCode: result.status || 0,
-                    output: result.stdout,
-                    error: result.stderr,
-                };
+            if (result.status !== 0) {
+                throw new Error(`tar exited with code ${result.status}`);
             }
-        });
+        }
+        else if (archivePath.endsWith('.zip')) {
+            try {
+                const zip = new adm_zip_1.default(archivePath);
+                zip.extractAllTo(extractDir, true);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`ZIP extraction failed: ${message}`);
+            }
+        }
+        else {
+            throw new Error(`Unsupported archive format: ${path.extname(archivePath)}`);
+        }
     }
 }
-exports.CKBDebugger = CKBDebugger;
-CKBDebugger.wasmDebugger = null;
+exports.CKBTui = CKBTui;
+CKBTui.binaryPath = null;
 
 
 /***/ }),
@@ -7749,15 +9022,25 @@ function getSubfolders(folderPath) {
 /***/ }),
 
 /***/ 27814:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.buildTestnetTxLink = buildTestnetTxLink;
+exports.logTxSuccess = logTxSuccess;
+const logger_1 = __nccwpck_require__(65370);
 function buildTestnetTxLink(txHash) {
     return `https://pudge.explorer.nervos.org/transaction/${txHash}`;
 }
+function logTxSuccess(network, txHash, action) {
+    if (network === 'testnet') {
+        logger_1.logger.info(`Successfully ${action}, check ${buildTestnetTxLink(txHash)} for details.`);
+    }
+    else {
+        logger_1.logger.info(`Successfully ${action}, txHash:`, txHash);
+    }
+}
 
 
 /***/ }),
@@ -7819,6 +9102,7 @@ class UnifiedLogger {
     constructor(options = {}) {
         this.enableColors = options.enableColors !== false;
         this.showLevel = options.showLevel !== false;
+        this.jsonMode = options.jsonMode === true;
         // Create Winston logger with custom format and levels
         this.logger = winston_1.default.createLogger({
             level: options.level || node_process_1.default.env.LOG_LEVEL || 'info',
@@ -7832,17 +9116,33 @@ class UnifiedLogger {
             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 }) => {
                 return this.formatMessage(level, message, timestamp);
             })),
-            transports: [
+            transports: options.transports || [
                 new winston_1.default.transports.Console({
                     stderrLevels: ['error', 'warn'],
                 }),
             ],
         });
     }
+    /**
+     * Toggle JSON output mode. When enabled, every log line is emitted as a
+     * structured JSON object, which is easier for agents and scripts to parse.
+     */
+    setJsonMode(enabled) {
+        this.jsonMode = enabled;
+    }
     /**
      * Format the message with appropriate colors and structure
      */
-    formatMessage(level, message, _timestamp) {
+    formatMessage(level, message, timestamp) {
+        // Agent-friendly JSON output: one JSON object per log line
+        if (this.jsonMode) {
+            const normalizedMessage = Array.isArray(message) ? message.join('\n') : String(message);
+            return JSON.stringify({
+                level,
+                message: normalizedMessage,
+                timestamp,
+            });
+        }
         // If showLevel is false, return just the message
         if (!this.showLevel) {
             if (Array.isArray(message)) {
@@ -7925,6 +9225,12 @@ class UnifiedLogger {
      * Log a message with the specified level
      */
     log(level, message) {
+        // In JSON mode, emit multi-line messages as a single structured log entry
+        // so agents can parse one complete JSON object per line.
+        if (this.jsonMode && Array.isArray(message)) {
+            this.logger.log(level, message.join('\n'));
+            return;
+        }
         if (Array.isArray(message)) {
             message.forEach((line) => this.logger.log(level, line));
         }
@@ -8091,6 +9397,11 @@ exports.isValidNetworkString = isValidNetworkString;
 exports.validateNetworkOpt = validateNetworkOpt;
 exports.isValidVersion = isValidVersion;
 exports.normalizePrivKey = normalizePrivKey;
+exports.isValidUdtKind = isValidUdtKind;
+exports.validateUdtKind = validateUdtKind;
+exports.validateUdtAmount = validateUdtAmount;
+exports.validateHexString = validateHexString;
+exports.validateUdtTypeArgs = validateUdtTypeArgs;
 const path_1 = __importDefault(__nccwpck_require__(16928));
 const fs_1 = __importDefault(__nccwpck_require__(79896));
 const base_1 = __nccwpck_require__(69951);
@@ -8179,6 +9490,46 @@ function normalizePrivKey(privKey) {
     // Return the formally strictly padded ckb format `0x` string
     return '0x' + key;
 }
+function isValidUdtKind(kind) {
+    return kind === 'sudt' || kind === 'xudt';
+}
+function validateUdtKind(kind) {
+    if (!kind) {
+        throw new Error('UDT kind is required');
+    }
+    if (!isValidUdtKind(kind)) {
+        throw new Error(`invalid UDT kind "${kind}", must be "sudt" or "xudt"`);
+    }
+}
+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`);
+    }
+    const value = BigInt(amount);
+    if (value > U128_MAX) {
+        throw new Error(`UDT amount exceeds 128-bit max: ${amount}`);
+    }
+    return value;
+}
+const HEX_REGEX = /^0x[0-9a-fA-F]*$/;
+function validateHexString(value, name) {
+    if (!value || !HEX_REGEX.test(value)) {
+        throw new Error(`invalid ${name} "${value}", must be a hex string starting with 0x`);
+    }
+    return value;
+}
+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 === 'xudt' && byteLength !== 32) {
+        throw new Error(`invalid xUDT type args length: expected 32 bytes, got ${byteLength}`);
+    }
+    return hex;
+}
 
 
 /***/ }),
@@ -128150,7 +129501,7 @@ module.exports = {"version":"3.17.0"};
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"rE":"0.4.8","h_":"ckb development network for your first try"}');
+module.exports = /*#__PURE__*/JSON.parse('{"rE":"0.4.9-canary-2b6b3af.0","h_":"ckb development network for your first try"}');
 
 /***/ })