@offckb/cli 0.4.8 → 0.4.9-canary-807f2ef.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,29 +362,45 @@ 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);
+const devnet_fork_1 = __nccwpck_require__(36709);
 const debug_1 = __nccwpck_require__(39591);
 const system_scripts_1 = __nccwpck_require__(86198);
 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 +474,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 +495,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 +534,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')
@@ -455,6 +552,14 @@ 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('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('--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)')
+    .action(devnet_fork_1.devnetFork);
 program.parse(process.argv);
 // If no command is specified, display help
 if (!process.argv.slice(2).length) {
@@ -534,11 +639,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;
+    });
+}
 
 
 /***/ }),
@@ -973,6 +1098,7 @@ const path_1 = __importDefault(__nccwpck_require__(16928));
 const advanced_1 = __nccwpck_require__(98486);
 const base_1 = __nccwpck_require__(69951);
 const encoding_1 = __nccwpck_require__(6851);
+const json_rpc_1 = __nccwpck_require__(51726);
 const logger_1 = __nccwpck_require__(65370);
 function debugTransaction(txHash, network) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -1043,8 +1169,8 @@ function buildTxFileOptionBy(txHash, network) {
         if (!fs_1.default.existsSync(outputFilePath)) {
             const rpc = settings[network].rpcUrl;
             const txJsonFilePath = buildTransactionJsonFilePath(network, txHash);
-            if (!fs_1.default.existsSync(outputFilePath)) {
-                fs_1.default.mkdirSync(path_1.default.dirname(outputFilePath), { recursive: true });
+            if (!fs_1.default.existsSync(txJsonFilePath)) {
+                yield fetchTransactionIntoCache(rpc, txHash, txJsonFilePath);
             }
             yield (0, ckb_tx_dumper_1.dumpTransaction)({ rpc, txJsonFilePath, outputFilePath });
         }
@@ -1052,6 +1178,23 @@ function buildTxFileOptionBy(txHash, network) {
         return opt;
     });
 }
+// Fallback for transactions that never went through the local RPC proxy
+// (e.g. historical transactions on a forked devnet): pull the transaction
+// from the node and cache it in the same JSON-RPC format the proxy stores.
+function fetchTransactionIntoCache(rpc, txHash, txJsonFilePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.logger.info(`Transaction ${txHash} not found in local cache, fetching from ${rpc} ..`);
+        const result = yield (0, json_rpc_1.callJsonRpc)(rpc, 'get_transaction', [txHash]).catch((error) => {
+            throw new Error(`Failed to fetch transaction ${txHash} from ${rpc}: ${error.message}`);
+        });
+        if (!(result === null || result === void 0 ? void 0 : result.transaction)) {
+            throw new Error(`Transaction ${txHash} not found on ${rpc}. ` +
+                `Check the hash and the --network option, or send the transaction through the offckb RPC proxy first.`);
+        }
+        fs_1.default.mkdirSync(path_1.default.dirname(txJsonFilePath), { recursive: true });
+        fs_1.default.writeFileSync(txJsonFilePath, JSON.stringify(result.transaction, null, 2));
+    });
+}
 function buildTransactionJsonFilePath(network, txHash) {
     const settings = (0, setting_1.readSettings)();
     if (network === base_1.Network.devnet) {
@@ -1393,6 +1536,43 @@ function devnetConfig() {
 }
 
 
+/***/ }),
+
+/***/ 36709:
+/***/ (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.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);
+        }
+    });
+}
+
+
 /***/ }),
 
 /***/ 998:
@@ -1400,6 +1580,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,23 +1625,35 @@ 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);
 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);
-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 +1663,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 = '';
@@ -1453,7 +1681,14 @@ function nodeDevnet(_a) {
         }
         yield (0, init_chain_1.initChainIfNeeded)();
         const devnetConfigPath = (0, encoding_1.encodeBinPathForTerminal)(settings.devnet.configPath);
-        const ckbCmd = `${ckbBinPath} run -C ${devnetConfigPath}`;
+        // 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);
+        const firstRunFlags = (forkState === null || forkState === void 0 ? void 0 : forkState.firstRunPending) ? ' --skip-spec-check --overwrite-spec' : '';
+        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...`);
         try {
@@ -1466,6 +1701,11 @@ function nodeDevnet(_a) {
             (_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;
@@ -1494,6 +1734,354 @@ 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 };
+}
+// Poll the devnet RPC until the spawned node answers with the fork's genesis
+// hash, then mark the first run as done so subsequent `offckb node` runs boot
+// normally. Two guards against clearing the flag on the wrong signal:
+//   - the poll aborts when the spawned ckb process exits (e.g. failed boot),
+//   - an answering node is only trusted when its genesis matches the fork
+//     state — an unrelated node occupying the port must not clear the flag.
+function clearForkFirstRunWhenNodeUp(ckbProcess, rpcUrl, configPath, expectedGenesisHash) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let processExited = false;
+        const markExited = () => {
+            processExited = true;
+        };
+        ckbProcess.once('exit', markExited);
+        ckbProcess.once('error', markExited);
+        const timeoutMs = 10 * 60 * 1000; // large forks take a while to boot
+        const start = Date.now();
+        while (!processExited && Date.now() - start < timeoutMs) {
+            try {
+                const genesisHash = String(yield (0, json_rpc_1.callJsonRpc)(rpcUrl, 'get_block_hash', ['0x0'], 5000)).toLowerCase();
+                if (genesisHash !== expectedGenesisHash.toLowerCase()) {
+                    logger_1.logger.warn(`A node is answering at ${rpcUrl} but reports a different genesis (${genesisHash}); ` +
+                        'leaving the first-run flags in place.');
+                    return;
+                }
+                (0, fork_1.markForkFirstRunComplete)(configPath);
+                logger_1.logger.success('Forked devnet is up; first-run spec flags cleared.');
+                return;
+            }
+            catch (_a) {
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+        if (processExited) {
+            logger_1.logger.warn('The CKB process exited before the forked devnet came up; first-run flags will be retried next time.');
+        }
+        else {
+            logger_1.logger.warn('Timed out waiting for the forked devnet to start; first-run flags will be retried next time.');
+        }
+    });
+}
+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 +2106,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:
@@ -1540,7 +2252,6 @@ exports.printSystemScripts = printSystemScripts;
 exports.printInSystemStyle = printInSystemStyle;
 exports.printInLumosConfigStyle = printInLumosConfigStyle;
 exports.printInCCCStyle = printInCCCStyle;
-exports.systemCellToScriptInfo = systemCellToScriptInfo;
 exports.toLumosConfig = toLumosConfig;
 const base_1 = __nccwpck_require__(69951);
 const public_1 = __nccwpck_require__(84535);
@@ -1554,26 +2265,41 @@ var PrintStyle;
 })(PrintStyle || (exports.PrintStyle = PrintStyle = {}));
 function printSystemScripts(_a) {
     return __awaiter(this, arguments, void 0, function* ({ style = PrintStyle.system, network = base_1.Network.devnet }) {
-        const systemScripts = network === base_1.Network.mainnet
-            ? public_1.MAINNET_SYSTEM_SCRIPTS
-            : network === base_1.Network.testnet
-                ? public_1.TESTNET_SYSTEM_SCRIPTS
-                : (0, private_1.getDevnetSystemScriptsFromListHashes)();
+        var _b;
+        let systemScripts;
+        // Display label and address prefix follow the chain the devnet actually
+        // runs: a fork carries the source chain's genesis, scripts and prefix.
+        let label = network.toUpperCase();
+        let addressPrefix = network === base_1.Network.mainnet ? 'ckb' : 'ckt';
+        if (network === base_1.Network.mainnet) {
+            systemScripts = public_1.MAINNET_SYSTEM_SCRIPTS;
+        }
+        else if (network === base_1.Network.testnet) {
+            systemScripts = public_1.TESTNET_SYSTEM_SCRIPTS;
+        }
+        else {
+            const resolved = (0, private_1.resolveDevnetSystemScripts)();
+            systemScripts = (_b = resolved === null || resolved === void 0 ? void 0 : resolved.scripts) !== null && _b !== void 0 ? _b : null;
+            if (resolved === null || resolved === void 0 ? void 0 : resolved.forkedFrom) {
+                label = `DEVNET (fork of ${resolved.forkedFrom.toUpperCase()})`;
+                addressPrefix = resolved.forkedFrom === 'mainnet' ? 'ckb' : 'ckt';
+            }
+        }
         if (!systemScripts)
             return logger_1.logger.info(`SystemScripts is null, ${network}`);
         if (style === PrintStyle.system) {
-            return printInSystemStyle(systemScripts, network);
+            return printInSystemStyle(systemScripts, label);
         }
         if (style === PrintStyle.lumos) {
-            return printInLumosConfigStyle(systemScripts, network);
+            return printInLumosConfigStyle(systemScripts, label, addressPrefix);
         }
         if (style === PrintStyle.ccc) {
-            return printInCCCStyle(systemScripts, network);
+            return printInCCCStyle(systemScripts, label);
         }
     });
 }
-function printInSystemStyle(systemScripts, network) {
-    logger_1.logger.info(`*** CKB ${network.toUpperCase()} System Scripts ***\n`);
+function printInSystemStyle(systemScripts, label) {
+    logger_1.logger.info(`*** CKB ${label} System Scripts ***\n`);
     for (const [name, script] of Object.entries(systemScripts)) {
         logger_1.logger.info(`- name: ${name}`);
         if (script == null) {
@@ -1586,67 +2312,16 @@ function printInSystemStyle(systemScripts, network) {
         logger_1.logger.info(`  cellDeps: ${JSON.stringify(script.script.cellDeps, null, 2)}\n`);
     }
 }
-function printInLumosConfigStyle(scripts, network) {
-    const config = toLumosConfig(scripts, network === base_1.Network.mainnet ? 'ckb' : 'ckt');
-    logger_1.logger.info(`*** CKB ${network.toUpperCase()} System Scripts As LumosConfig ***\n`);
+function printInLumosConfigStyle(scripts, label, addressPrefix) {
+    const config = toLumosConfig(scripts, addressPrefix);
+    logger_1.logger.info(`*** CKB ${label} System Scripts As LumosConfig ***\n`);
     logger_1.logger.info(JSON.stringify(config, null, 2));
 }
-function printInCCCStyle(scripts, network) {
+function printInCCCStyle(scripts, label) {
     const knownsScripts = (0, private_1.toCCCKnownScripts)(scripts);
-    logger_1.logger.info(`*** CKB ${network.toUpperCase()} System Scripts As CCC KnownScripts ***\n`);
+    logger_1.logger.info(`*** CKB ${label} System Scripts As CCC KnownScripts ***\n`);
     logger_1.logger.info(JSON.stringify(knownsScripts, null, 2));
 }
-function systemCellToScriptInfo({ cell, depType, depGroup, extraCellDeps, }) {
-    // todo: we left the type in cellDepsInfo since it requires async fetching and
-    // chain running to get the full type script of the type-id deps.
-    // Also, in devnet there is no real need to auto upgrade the system scripts with type-id
-    if (depType === 'code') {
-        let cellDeps = [
-            {
-                cellDep: {
-                    outPoint: {
-                        txHash: cell.tx_hash,
-                        index: cell.index,
-                    },
-                    depType,
-                },
-            },
-        ];
-        if (extraCellDeps && extraCellDeps.length > 0) {
-            cellDeps = [...extraCellDeps, ...cellDeps];
-        }
-        return {
-            codeHash: (cell.type_hash || cell.data_hash),
-            hashType: cell.type_hash ? 'type' : 'data2',
-            cellDeps,
-        };
-    }
-    if (depType === 'depGroup') {
-        if (!depGroup) {
-            throw new Error('require depGroup info since the dep type is depGroup');
-        }
-        let cellDeps = [
-            {
-                cellDep: {
-                    outPoint: {
-                        txHash: depGroup.txHash,
-                        index: depGroup.index,
-                    },
-                    depType,
-                },
-            },
-        ];
-        if (extraCellDeps && extraCellDeps.length > 0) {
-            cellDeps = [...extraCellDeps, ...cellDeps];
-        }
-        return {
-            codeHash: (cell.type_hash || cell.data_hash),
-            hashType: cell.type_hash ? 'type' : 'data2',
-            cellDeps,
-        };
-    }
-    throw new Error(`unknown DepType ${depType}`);
-}
 function toLumosConfig(scripts, addressPrefix = 'ckt') {
     const config = {
         PREFIX: addressPrefix,
@@ -1829,9 +2504,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 +2514,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');
     });
 }
 
@@ -2820,6 +3568,397 @@ class InitializationError extends Error {
 exports.InitializationError = InitializationError;
 
 
+/***/ }),
+
+/***/ 77912:
+/***/ (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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.FORK_STATE_FILE = void 0;
+exports.getForkStatePath = getForkStatePath;
+exports.readForkState = readForkState;
+exports.writeForkState = writeForkState;
+exports.markForkFirstRunComplete = markForkFirstRunComplete;
+exports.detectSourceFromCkbToml = detectSourceFromCkbToml;
+exports.parseGenesisHashFromInitOutput = parseGenesisHashFromInitOutput;
+exports.parseGenesisHashFromListHashes = parseGenesisHashFromListHashes;
+exports.expectedGenesisHash = expectedGenesisHash;
+exports.patchDevSpecForFork = patchDevSpecForFork;
+exports.forkDevnet = forkDevnet;
+const child_process_1 = __nccwpck_require__(35317);
+const fs_1 = __importDefault(__nccwpck_require__(79896));
+const path_1 = __importDefault(__nccwpck_require__(16928));
+const toml_1 = __importDefault(__nccwpck_require__(2811));
+const setting_1 = __nccwpck_require__(25546);
+const install_1 = __nccwpck_require__(65611);
+const fs_2 = __nccwpck_require__(37293);
+const request_1 = __nccwpck_require__(65897);
+const logger_1 = __nccwpck_require__(65370);
+const const_1 = __nccwpck_require__(75587);
+exports.FORK_STATE_FILE = 'fork.json';
+// The official guide requires genesis_epoch_length to stay at 1743 for a
+// mainnet fork, and to fall back to the default 1000 for a testnet fork
+// (i.e. the key must be absent). Getting this wrong produces a different
+// genesis hash and the node refuses to start. See nervosnetwork/ckb#5205.
+const MAINNET_GENESIS_EPOCH_LENGTH = 1743;
+function getForkStatePath(configPath) {
+    return path_1.default.join(configPath, exports.FORK_STATE_FILE);
+}
+function readForkState(configPath) {
+    const statePath = getForkStatePath(configPath);
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(statePath, 'utf8');
+    }
+    catch (_a) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.source !== 'string' || typeof parsed.firstRunPending !== 'boolean') {
+            return null;
+        }
+        return parsed;
+    }
+    catch (_b) {
+        return null;
+    }
+}
+function writeForkState(configPath, state) {
+    const statePath = getForkStatePath(configPath);
+    const tempPath = `${statePath}.tmp`;
+    fs_1.default.writeFileSync(tempPath, JSON.stringify(state, null, 2));
+    fs_1.default.renameSync(tempPath, statePath);
+}
+function markForkFirstRunComplete(configPath) {
+    const state = readForkState(configPath);
+    if (!state || !state.firstRunPending)
+        return;
+    writeForkState(configPath, Object.assign(Object.assign({}, state), { firstRunPending: false }));
+}
+function detectSourceFromCkbToml(ckbTomlContent) {
+    let parsed;
+    try {
+        parsed = toml_1.default.parse(ckbTomlContent);
+    }
+    catch (_a) {
+        return null;
+    }
+    const chain = parsed.chain;
+    if (chain == null || typeof chain !== 'object')
+        return null;
+    const spec = chain.spec;
+    if (spec == null || typeof spec !== 'object')
+        return null;
+    const bundled = spec.bundled;
+    if (typeof bundled !== 'string')
+        return null;
+    if (bundled.includes('mainnet'))
+        return 'mainnet';
+    if (bundled.includes('testnet'))
+        return 'testnet';
+    return null;
+}
+function parseGenesisHashFromInitOutput(output) {
+    const match = output.match(/Genesis Hash:\s*(0x[0-9a-fA-F]{64})/);
+    return match ? match[1].toLowerCase() : null;
+}
+// `ckb list-hashes` prints TOML with a single table whose `genesis` field is
+// the chain's genesis hash.
+function parseGenesisHashFromListHashes(output) {
+    const match = output.match(/^\s*genesis\s*=\s*"(0x[0-9a-fA-F]{64})"\s*$/m);
+    return match ? match[1].toLowerCase() : null;
+}
+function expectedGenesisHash(source) {
+    return source === 'mainnet' ? const_1.MAINNET_GENESIS_HASH : const_1.TESTNET_GENESIS_HASH;
+}
+// Patch the imported chain spec into a minable dev chain, following
+// https://docs.nervos.org/docs/node/devnet-from-existing-data
+function patchDevSpecForFork(spec, source) {
+    var _a, _b;
+    const pow = Object.assign(Object.assign({}, ((_a = spec.pow) !== null && _a !== void 0 ? _a : {})), { func: 'Dummy' });
+    const params = Object.assign({}, ((_b = spec.params) !== null && _b !== void 0 ? _b : {}));
+    params.cellbase_maturity = 0;
+    params.permanent_difficulty_in_dummy = true;
+    if (source === 'mainnet') {
+        params.genesis_epoch_length = MAINNET_GENESIS_EPOCH_LENGTH;
+    }
+    else if (source === 'testnet') {
+        // testnet derives genesis_epoch_length from the default (1000); a leftover
+        // mainnet value here is exactly the nervosnetwork/ckb#5205 trap.
+        delete params.genesis_epoch_length;
+    }
+    // custom specs keep whatever genesis_epoch_length they declared
+    return Object.assign(Object.assign({}, spec), { pow, params });
+}
+function validateSourceDir(sourceDir) {
+    if (!(0, fs_2.isFolderExists)(sourceDir)) {
+        throw new Error(`Source directory does not exist: ${sourceDir}`);
+    }
+    if (!(0, fs_2.isFolderExists)(path_1.default.join(sourceDir, 'data', 'db'))) {
+        throw new Error(`${sourceDir} does not look like a CKB node directory (missing data/db). ` +
+            `Point --from at the directory the source node runs with (-C).`);
+    }
+}
+// Best-effort detection of a running ckb process using the given directory.
+// Returns null when the check cannot be performed (Windows, no ps).
+function isCkbNodeRunningOn(dir) {
+    if (process.platform === 'win32')
+        return null;
+    let processes = '';
+    try {
+        processes = (0, child_process_1.execSync)('ps -eo args', { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    }
+    catch (_a) {
+        return null;
+    }
+    return processes.split('\n').some((line) => {
+        var _a;
+        const tokens = line.trim().split(/\s+/);
+        // The program itself must be a ckb binary — a looser match would flag
+        // unrelated processes that merely mention the directory.
+        const program = path_1.default.basename((_a = tokens[0]) !== null && _a !== void 0 ? _a : '');
+        if (program !== 'ckb' && program !== 'ckb.exe')
+            return false;
+        return tokens.includes('run') && line.includes(dir);
+    });
+}
+function assertSourceNodeStopped(sourceDir) {
+    const running = isCkbNodeRunningOn(sourceDir);
+    if (running === null) {
+        logger_1.logger.warn('Make sure the source CKB node is stopped; copying a live database produces corrupted data.');
+        return;
+    }
+    if (running) {
+        throw new Error(`A CKB node appears to be running on ${sourceDir}. Stop it first; ` +
+            `copying a live database produces corrupted data.`);
+    }
+}
+function assertOffckbDevnetStopped() {
+    const settings = (0, setting_1.readSettings)();
+    // Foreground `offckb node` (no daemon pid file): look for the ckb process.
+    if (isCkbNodeRunningOn(settings.devnet.configPath) === true) {
+        throw new Error('An offckb devnet node appears to be running. Stop it before forking.');
+    }
+    // Daemon mode: check the pid file.
+    const pidFile = path_1.default.join(settings.devnet.dataPath, 'logs', 'daemon.pid');
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(pidFile, 'utf8').trim();
+    }
+    catch (_a) {
+        return;
+    }
+    let pid = Number(raw);
+    if (!Number.isInteger(pid) || pid <= 0) {
+        try {
+            pid = Number(JSON.parse(raw).pid);
+        }
+        catch (_b) {
+            return;
+        }
+    }
+    if (!Number.isInteger(pid) || pid <= 0)
+        return;
+    let alive = true;
+    try {
+        process.kill(pid, 0);
+    }
+    catch (_c) {
+        alive = false; // ESRCH: stale pid file, no daemon running
+    }
+    if (alive) {
+        throw new Error(`The offckb devnet daemon is running (PID ${pid}). Stop it first with: offckb node stop`);
+    }
+}
+function resolveSpecFile(options, source, ckbVersion) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (options.specFile) {
+            const specFile = path_1.default.resolve(options.specFile);
+            if (!fs_1.default.existsSync(specFile)) {
+                throw new Error(`Spec file not found: ${specFile}`);
+            }
+            return specFile;
+        }
+        const cacheDir = path_1.default.join(setting_1.cachePath, 'specs', ckbVersion);
+        const cachedSpec = path_1.default.join(cacheDir, `${source}.toml`);
+        if (fs_1.default.existsSync(cachedSpec)) {
+            logger_1.logger.debug(`Using cached ${source} spec: ${cachedSpec}`);
+            return cachedSpec;
+        }
+        const url = `https://raw.githubusercontent.com/nervosnetwork/ckb/v${ckbVersion}/resource/specs/${source}.toml`;
+        logger_1.logger.info(`Downloading ${source} chain spec from ${url} ..`);
+        try {
+            const response = yield request_1.Request.send(url);
+            const content = yield response.text();
+            fs_1.default.mkdirSync(cacheDir, { recursive: true });
+            fs_1.default.writeFileSync(cachedSpec, content);
+            return cachedSpec;
+        }
+        catch (error) {
+            throw new Error(`Failed to download the ${source} chain spec for CKB v${ckbVersion}: ${error.message}. ` +
+                `Pass a local copy with --spec-file.`);
+        }
+    });
+}
+function copySourceData(sourceDir, configPath) {
+    const sourceData = path_1.default.join(sourceDir, 'data');
+    const targetData = path_1.default.join(configPath, 'data');
+    logger_1.logger.info(`Copying chain data from ${sourceData} to ${targetData} ..`);
+    logger_1.logger.info('This can take a while for large chains.');
+    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 });
+}
+function runCkbInit(ckbBinPath, configPath, specFile) {
+    // argv form, never a shell: --spec-file is user input and quote-wrapping
+    // alone does not stop shell expansion (command substitution still runs
+    // 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 });
+}
+// 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
+// access needed), which tells us which chain the source node was configured
+// for. Returns null when the source is not a standard config dir.
+function readSourceGenesisHash(ckbBinPath, sourceDir) {
+    try {
+        const output = (0, child_process_1.execFileSync)(ckbBinPath, ['list-hashes', '-C', sourceDir], {
+            encoding: 'utf8',
+            maxBuffer: 16 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return parseGenesisHashFromListHashes(output);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+// 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
+// imported specs/dev.toml is kept.
+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'));
+    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;
+        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) {
+            const sourceCkbToml = path_1.default.join(sourceDir, 'ckb.toml');
+            if (fs_1.default.existsSync(sourceCkbToml)) {
+                source = detectSourceFromCkbToml(fs_1.default.readFileSync(sourceCkbToml, 'utf8'));
+            }
+        }
+        if (source == null && !options.specFile) {
+            throw new Error('Could not identify the source chain from the source directory. ' +
+                'Pass --source mainnet|testnet, or provide the chain spec with --spec-file.');
+        }
+        yield (0, install_1.installCKBBinary)(ckbVersion);
+        const ckbBinPath = (0, setting_1.getCKBBinaryPath)(ckbVersion);
+        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.`);
+            }
+            const devSpecPath = path_1.default.join(configPath, 'specs', 'dev.toml');
+            const spec = toml_1.default.parse(fs_1.default.readFileSync(devSpecPath, 'utf8'));
+            const patched = patchDevSpecForFork(spec, source);
+            const tempSpecPath = `${devSpecPath}.tmp`;
+            fs_1.default.writeFileSync(tempSpecPath, toml_1.default.stringify(patched));
+            fs_1.default.renameSync(tempSpecPath, devSpecPath);
+            alignConfigsWithOffckb(configPath);
+            const state = {
+                source,
+                sourceDir,
+                ckbVersion,
+                genesisHash,
+                forkedAt: new Date().toISOString(),
+                firstRunPending: 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('The first run applies --skip-spec-check --overwrite-spec automatically.');
+        }
+        catch (error) {
+            // Leave no half-forked devnet behind.
+            fs_1.default.rmSync(configPath, { recursive: true, force: true });
+            throw error;
+        }
+    });
+}
+
+
 /***/ }),
 
 /***/ 1360:
@@ -2934,7 +4073,7 @@ const fs = __importStar(__nccwpck_require__(79896));
 const path = __importStar(__nccwpck_require__(16928));
 const semver_1 = __importDefault(__nccwpck_require__(89939));
 const os_1 = __importDefault(__nccwpck_require__(70857));
-const adm_zip_1 = __importDefault(__nccwpck_require__(83746));
+const adm_zip_1 = __importDefault(__nccwpck_require__(3858));
 const tar = __importStar(__nccwpck_require__(80228));
 const request_1 = __nccwpck_require__(65897);
 const setting_1 = __nccwpck_require__(25546);
@@ -3154,7 +4293,8 @@ function buildDownloadUrl(version, opt = {}) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TYPE_ID_SCRIPT = void 0;
+exports.TESTNET_GENESIS_HASH = exports.MAINNET_GENESIS_HASH = exports.TYPE_ID_SCRIPT = void 0;
+exports.identifyPublicChainByGenesisHash = identifyPublicChainByGenesisHash;
 exports.TYPE_ID_SCRIPT = {
     name: 'type_id',
     script: {
@@ -3163,6 +4303,18 @@ exports.TYPE_ID_SCRIPT = {
         cellDeps: [],
     },
 };
+// Well-known genesis block hashes, used to identify which chain a devnet
+// actually runs (a forked devnet carries the source chain's genesis).
+// https://github.com/nervosnetwork/ckb/tree/master/resource/specs
+exports.MAINNET_GENESIS_HASH = '0x92b197aa1fba0f63633922c61c92375c9c074a93e85963554f5499fe1450d0e5';
+exports.TESTNET_GENESIS_HASH = '0x10639e0895502b5688a6be8cf69460d76541bfa4821629d86d62ba0aae3f9606';
+function identifyPublicChainByGenesisHash(genesisHash) {
+    if (genesisHash === exports.MAINNET_GENESIS_HASH)
+        return 'mainnet';
+    if (genesisHash === exports.TESTNET_GENESIS_HASH)
+        return 'testnet';
+    return null;
+}
 
 
 /***/ }),
@@ -3250,30 +4402,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.resolveDevnetSystemScripts = resolveDevnetSystemScripts;
 exports.getDevnetSystemScriptsFromListHashes = getDevnetSystemScriptsFromListHashes;
 exports.toCCCKnownScripts = toCCCKnownScripts;
 exports.buildCCCDevnetKnownScripts = buildCCCDevnetKnownScripts;
+exports.buildDevnetCCCClient = buildDevnetCCCClient;
 const core_1 = __nccwpck_require__(39842);
 const setting_1 = __nccwpck_require__(25546);
-const system_scripts_1 = __nccwpck_require__(86198);
 const list_hashes_1 = __nccwpck_require__(31603);
 const logger_1 = __nccwpck_require__(65370);
 const const_1 = __nccwpck_require__(75587);
+const public_1 = __nccwpck_require__(84535);
 const toml_1 = __importDefault(__nccwpck_require__(2811));
 const util_1 = __nccwpck_require__(58642);
-function getDevnetSystemScriptsFromListHashes() {
+function buildSystemScriptsFromSpecHashes(chainSpecHashes) {
     var _a;
-    const settings = (0, setting_1.readSettings)();
-    const listHashesString = (0, list_hashes_1.getDevnetListHashes)(settings.bins.defaultCKBVersion);
-    if (!listHashesString) {
-        logger_1.logger.info(`list-hashes not found!`);
-        return null;
-    }
-    const listHashes = toml_1.default.parse(listHashesString);
-    const chainSpecHashes = Object.values(listHashes)[0];
-    if (chainSpecHashes == null) {
-        throw new Error(`invalid chain spec hashes file ${listHashesString}`);
-    }
     const systemScriptArray = chainSpecHashes.system_cells
         .map((cell) => {
         // Extract the file name from the path using the helper function
@@ -3286,7 +4429,7 @@ function getDevnetSystemScriptsFromListHashes() {
                 txHash: chainSpecHashes.dep_groups[depGroupIndex].tx_hash,
                 index: chainSpecHashes.dep_groups[depGroupIndex].index,
             };
-        const scriptInfo = (0, system_scripts_1.systemCellToScriptInfo)({ cell, depType, depGroup });
+        const scriptInfo = (0, util_1.systemCellToScriptInfo)({ cell, depType, depGroup });
         return {
             name,
             file: cell.path,
@@ -3306,6 +4449,46 @@ function getDevnetSystemScriptsFromListHashes() {
     systemScripts.type_id = const_1.TYPE_ID_SCRIPT;
     return systemScripts;
 }
+// `ckb list-hashes` only reports what the chain spec declares in genesis.
+// Post-genesis deployments (sudt/xudt/omnilock/spore on mainnet and testnet)
+// can never appear there, so for a forked devnet we fill the gaps from the
+// well-known static records of the chain the genesis belongs to. Genesis
+// scripts always come from list-hashes — the chain's own spec wins.
+function supplementFromStaticRecord(scripts, staticRecord) {
+    for (const [name, script] of Object.entries(staticRecord)) {
+        const key = name;
+        if (scripts[key] == null && script != null) {
+            // deep clone so callers can never mutate the shared static record
+            scripts[key] = JSON.parse(JSON.stringify(script));
+        }
+    }
+}
+function resolveDevnetSystemScripts() {
+    const settings = (0, setting_1.readSettings)();
+    const listHashesString = (0, list_hashes_1.getDevnetListHashes)(settings.bins.defaultCKBVersion);
+    if (!listHashesString) {
+        logger_1.logger.info(`list-hashes not found!`);
+        return null;
+    }
+    const listHashes = toml_1.default.parse(listHashesString);
+    const chainSpecHashes = Object.values(listHashes)[0];
+    if (chainSpecHashes == null) {
+        throw new Error(`invalid chain spec hashes file ${listHashesString}`);
+    }
+    const scripts = buildSystemScriptsFromSpecHashes(chainSpecHashes);
+    const forkedFrom = (0, const_1.identifyPublicChainByGenesisHash)(chainSpecHashes.genesis);
+    if (forkedFrom === 'mainnet') {
+        supplementFromStaticRecord(scripts, public_1.MAINNET_SYSTEM_SCRIPTS);
+    }
+    else if (forkedFrom === 'testnet') {
+        supplementFromStaticRecord(scripts, public_1.TESTNET_SYSTEM_SCRIPTS);
+    }
+    return { scripts, forkedFrom, genesisHash: chainSpecHashes.genesis };
+}
+function getDevnetSystemScriptsFromListHashes() {
+    var _a, _b;
+    return (_b = (_a = resolveDevnetSystemScripts()) === null || _a === void 0 ? void 0 : _a.scripts) !== null && _b !== void 0 ? _b : null;
+}
 function toCCCKnownScripts(scripts) {
     const DEVNET_SCRIPTS = {
         [core_1.KnownScript.Secp256k1Blake160]: scripts.secp256k1_blake160_sighash_all.script,
@@ -3333,6 +4516,19 @@ function buildCCCDevnetKnownScripts() {
     const devnetKnownScripts = toCCCKnownScripts(devnetSystemScripts);
     return devnetKnownScripts;
 }
+// Build the ccc client for the devnet. A forked devnet carries the source
+// chain's genesis, so a mainnet fork must use the `ckb` address prefix
+// (ClientPublicMainnet); everything else uses the `ckt` prefix. Known scripts
+// always come from the fork-aware resolver above.
+function buildDevnetCCCClient(url, fallbacks = []) {
+    const resolved = resolveDevnetSystemScripts();
+    if (resolved == null) {
+        throw new Error('can not getSystemScriptsFromListHashes in devnet');
+    }
+    const scripts = toCCCKnownScripts(resolved.scripts);
+    const ClientCtor = resolved.forkedFrom === 'mainnet' ? core_1.ccc.ClientPublicMainnet : core_1.ccc.ClientPublicTestnet;
+    return new ClientCtor({ url, scripts, fallbacks });
+}
 
 
 /***/ }),
@@ -3717,6 +4913,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.readDeployedScriptInfoFrom = readDeployedScriptInfoFrom;
 exports.getScriptInfoFrom = getScriptInfoFrom;
 exports.extractScriptNameFromPath = extractScriptNameFromPath;
+exports.systemCellToScriptInfo = systemCellToScriptInfo;
 const fs = __importStar(__nccwpck_require__(79896));
 const migration_1 = __nccwpck_require__(76679);
 const path_1 = __importDefault(__nccwpck_require__(16928));
@@ -3807,6 +5004,57 @@ function extractScriptNameFromPath(pathString) {
     // On Windows, it handles backslashes; on Unix, it handles forward slashes
     return path_1.default.basename(pathString);
 }
+function systemCellToScriptInfo({ cell, depType, depGroup, extraCellDeps, }) {
+    // todo: we left the type in cellDepsInfo since it requires async fetching and
+    // chain running to get the full type script of the type-id deps.
+    // Also, in devnet there is no real need to auto upgrade the system scripts with type-id
+    if (depType === 'code') {
+        let cellDeps = [
+            {
+                cellDep: {
+                    outPoint: {
+                        txHash: cell.tx_hash,
+                        index: cell.index,
+                    },
+                    depType,
+                },
+            },
+        ];
+        if (extraCellDeps && extraCellDeps.length > 0) {
+            cellDeps = [...extraCellDeps, ...cellDeps];
+        }
+        return {
+            codeHash: (cell.type_hash || cell.data_hash),
+            hashType: cell.type_hash ? 'type' : 'data2',
+            cellDeps,
+        };
+    }
+    if (depType === 'depGroup') {
+        if (!depGroup) {
+            throw new Error('require depGroup info since the dep type is depGroup');
+        }
+        let cellDeps = [
+            {
+                cellDep: {
+                    outPoint: {
+                        txHash: depGroup.txHash,
+                        index: depGroup.index,
+                    },
+                    depType,
+                },
+            },
+        ];
+        if (extraCellDeps && extraCellDeps.length > 0) {
+            cellDeps = [...extraCellDeps, ...cellDeps];
+        }
+        return {
+            codeHash: (cell.type_hash || cell.data_hash),
+            hashType: cell.type_hash ? 'type' : 'data2',
+            cellDeps,
+        };
+    }
+    throw new Error(`unknown DepType ${depType}`);
+}
 
 
 /***/ }),
@@ -3827,18 +5075,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)) {
@@ -3856,11 +5122,7 @@ class CKB {
                             url: network_1.networks.testnet.proxy_rpc_url,
                             fallbacks: [network_1.networks.testnet.rpc_url],
                         }) // we keep the fallbacks in case the proxy rpc is not started
-                        : new core_1.ccc.ClientPublicTestnet({
-                            url: network_1.networks.devnet.proxy_rpc_url,
-                            scripts: (0, private_1.buildCCCDevnetKnownScripts)(),
-                            fallbacks: [network_1.networks.devnet.rpc_url],
-                        });
+                        : (0, private_1.buildDevnetCCCClient)(network_1.networks.devnet.proxy_rpc_url, [network_1.networks.devnet.rpc_url]);
         }
         else {
             this.client =
@@ -3874,11 +5136,7 @@ class CKB {
                             url: network_1.networks.testnet.rpc_url,
                             fallbacks: [],
                         }) // pass it to avoid using websocket and fallback RPCs
-                        : new core_1.ccc.ClientPublicTestnet({
-                            url: network_1.networks.devnet.rpc_url,
-                            scripts: (0, private_1.buildCCCDevnetKnownScripts)(),
-                            fallbacks: [], // pass it to avoid using websocket and fallback RPCs
-                        });
+                        : (0, private_1.buildDevnetCCCClient)(network_1.networks.devnet.rpc_url);
         }
     }
     buildSigner(privateKey) {
@@ -3972,6 +5230,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);
@@ -5321,6 +6859,314 @@ 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.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__(3858));
+const setting_1 = __nccwpck_require__(25546);
+const logger_1 = __nccwpck_require__(65370);
+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.binaryPath;
+    }
+    /**
+     * Returns the binary path, downloading and installing if the binary
+     * does not already exist.
+     */
+    static ensureInstalled() {
+        const binaryPath = this.getBinaryPath();
+        if (binaryPath && fs.existsSync(binaryPath)) {
+            return binaryPath;
+        }
+        // Reset and re-install
+        this.binaryPath = null;
+        this.installSync();
+        return this.binaryPath;
+    }
+    static isInstalled() {
+        try {
+            const binPath = this.getBinaryPath();
+            return binPath !== null && fs.existsSync(binPath);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    static run(args = []) {
+        const binaryPath = this.ensureInstalled();
+        return (0, child_process_1.spawnSync)(binaryPath, args, { stdio: 'inherit' });
+    }
+    // --- 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 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 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';
+        }
+        else if (platform === 'linux') {
+            if (arch !== 'x64') {
+                throw new Error(`Unsupported architecture for Linux: ${arch}. Only x86_64 is supported.`);
+            }
+            return 'ckb-tui-with-node-linux-amd64.tar.gz';
+        }
+        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}`);
+    }
+    /**
+     * 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 {
+            // 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) {
+            // 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
+            }
+        }
+    }
+    /**
+     * 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 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
+            }
+        }
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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}`);
+            }
+            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.CKBTui = CKBTui;
+CKBTui.binaryPath = null;
+
+
 /***/ }),
 
 /***/ 20924:
@@ -5346,6 +7192,7 @@ const fs_1 = __importDefault(__nccwpck_require__(79896));
 const path_1 = __importDefault(__nccwpck_require__(16928));
 const core_1 = __nccwpck_require__(39842);
 const advanced_1 = __nccwpck_require__(98486);
+const json_rpc_1 = __nccwpck_require__(51726);
 const logger_1 = __nccwpck_require__(65370);
 const OutPointCodec = core_1.ccc.mol.struct({
     txHash: core_1.ccc.mol.Byte32,
@@ -5470,6 +7317,19 @@ function resolveInputs(client, inputs) {
         return resolved;
     });
 }
+function resolveHeaderDeps(rpc, headerDeps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const headers = [];
+        for (const hash of headerDeps) {
+            const header = yield (0, json_rpc_1.callJsonRpc)(rpc, 'get_header', [hash]);
+            if (!header) {
+                throw new Error(`Header not found: ${hash}`);
+            }
+            headers.push(header);
+        }
+        return headers;
+    });
+}
 function dumpTransaction(_a) {
     return __awaiter(this, arguments, void 0, function* ({ rpc, txJsonFilePath, outputFilePath }) {
         try {
@@ -5485,15 +7345,16 @@ function dumpTransaction(_a) {
                 });
             const txJson = JSON.parse(fs_1.default.readFileSync(txJsonFilePath, 'utf-8'));
             const tx = advanced_1.cccA.JsonRpcTransformers.transactionTo(txJson);
-            const [cell_deps, inputs] = yield Promise.all([
+            const [cell_deps, inputs, header_deps] = yield Promise.all([
                 resolveCellDeps(client, tx.cellDeps),
                 resolveInputs(client, tx.inputs),
+                resolveHeaderDeps(rpc, tx.headerDeps),
             ]);
             const mockTx = {
                 mock_info: {
                     inputs,
                     cell_deps,
-                    header_deps: tx.headerDeps.map((h) => h.toString()),
+                    header_deps,
                 },
                 tx: {
                     version: '0x' + tx.version.toString(16),
@@ -7746,18 +9607,107 @@ function getSubfolders(folderPath) {
 }
 
 
+/***/ }),
+
+/***/ 51726:
+/***/ (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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.callJsonRpc = callJsonRpc;
+const http_1 = __importDefault(__nccwpck_require__(58611));
+const https_1 = __importDefault(__nccwpck_require__(65692));
+// Minimal raw JSON-RPC caller. Unlike Request.send it never goes through the
+// configured proxy, which makes it safe for talking to the local devnet node.
+function callJsonRpc(rpcUrl_1, method_1, params_1) {
+    return __awaiter(this, arguments, void 0, function* (rpcUrl, method, params, timeoutMs = 30000) {
+        const body = JSON.stringify({ id: 1, jsonrpc: '2.0', method, params });
+        const url = new URL(rpcUrl);
+        const transport = url.protocol === 'https:' ? https_1.default : http_1.default;
+        return new Promise((resolve, reject) => {
+            const req = transport.request({
+                hostname: url.hostname,
+                port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                path: url.pathname + url.search,
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    'content-length': Buffer.byteLength(body),
+                },
+                timeout: timeoutMs,
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                // The response stream can error or close before `end` (connection
+                // reset, truncated body). Without these listeners the promise would
+                // hang until the request timeout — or the process would crash on an
+                // unhandled stream error.
+                res.once('error', reject);
+                res.on('close', () => {
+                    if (!res.complete) {
+                        reject(new Error(`JSON-RPC ${method} to ${rpcUrl} returned a truncated response`));
+                    }
+                });
+                res.on('end', () => {
+                    try {
+                        const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                        if (parsed.error) {
+                            reject(new Error(`JSON-RPC ${method} failed: ${JSON.stringify(parsed.error)}`));
+                            return;
+                        }
+                        resolve(parsed.result);
+                    }
+                    catch (error) {
+                        reject(new Error(`Invalid JSON-RPC response from ${rpcUrl}: ${error.message}`));
+                    }
+                });
+            });
+            req.on('timeout', () => {
+                req.destroy(new Error(`JSON-RPC ${method} to ${rpcUrl} timed out`));
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    });
+}
+
+
 /***/ }),
 
 /***/ 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 +9769,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 +9783,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 +9892,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 +10064,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 +10157,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;
+}
 
 
 /***/ }),
@@ -15922,13 +17940,13 @@ exports.randomBytes = randomBytes;
 
 /***/ }),
 
-/***/ 83746:
+/***/ 3858:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-const Utils = __nccwpck_require__(28605);
+const Utils = __nccwpck_require__(91373);
 const pth = __nccwpck_require__(16928);
-const ZipEntry = __nccwpck_require__(59155);
-const ZipFile = __nccwpck_require__(43985);
+const ZipEntry = __nccwpck_require__(58851);
+const ZipFile = __nccwpck_require__(46593);
 
 const get_Bool = (...val) => Utils.findLast(val, (c) => typeof c === "boolean");
 const get_Str = (...val) => Utils.findLast(val, (c) => typeof c === "string");
@@ -15974,6 +17992,18 @@ module.exports = function (/**String*/ input, /** object */ options) {
     // instanciate utils filesystem
     const filetools = new Utils(opts);
 
+    // Restore the archived permissions on extracted directories. This has to run
+    // after a directory's contents are written: applying a restrictive mode
+    // (e.g. 0o500) up front would stop us writing the files it contains. Applying
+    // the deepest paths first keeps parent directories traversable while their
+    // children are updated (issue #530).
+    const applyDirAttributes = (dirEntries) => {
+        dirEntries
+            .filter((d) => d.attr)
+            .sort((a, b) => b.path.length - a.path.length)
+            .forEach((d) => filetools.fs.chmodSync(d.path, d.attr));
+    };
+
     if (typeof opts.decoder !== "object" || typeof opts.decoder.encode !== "function" || typeof opts.decoder.decode !== "function") {
         opts.decoder = Utils.decoder;
     }
@@ -16013,7 +18043,7 @@ module.exports = function (/**String*/ input, /** object */ options) {
     function fixPath(zipPath) {
         const { join, normalize, sep } = pth.posix;
         // convert windows file separators and normalize
-        return join(".", normalize(sep + zipPath.split("\\").join(sep) + sep));
+        return join(pth.isAbsolute(zipPath) ? "/": '.',  normalize(sep + zipPath.split("\\").join(sep) + sep));
     }
 
     function filenameFilter(filterfn) {
@@ -16128,6 +18158,7 @@ module.exports = function (/**String*/ input, /** object */ options) {
          * Remove the entry from the file or the entry and all it's nested directories and files if the given entry is a directory
          *
          * @param {ZipEntry|string} entry
+         * @param {boolean} withsubfolders
          * @returns {void}
          */
         deleteFile: function (entry, withsubfolders = true) {
@@ -16412,7 +18443,7 @@ module.exports = function (/**String*/ input, /** object */ options) {
         addLocalFolderAsync2: function (options, callback) {
             const self = this;
             options = typeof options === "object" ? options : { localPath: options };
-            localPath = pth.resolve(fixPath(options.localPath));
+            const localPath = pth.resolve(fixPath(options.localPath));
             let { zipPath, filter, namefix } = options;
 
             if (filter instanceof RegExp) {
@@ -16431,7 +18462,7 @@ module.exports = function (/**String*/ input, /** object */ options) {
             zipPath = zipPath ? fixPath(zipPath) : "";
 
             // Check Namefix function
-            if (namefix == "latin1") {
+            if (namefix === "latin1") {
                 namefix = (str) =>
                     str
                         .normalize("NFD")
@@ -16607,7 +18638,7 @@ module.exports = function (/**String*/ input, /** object */ options) {
 
             var entryName = canonical(item.entryName);
 
-            var target = sanitize(targetPath, outFileName && !item.isDirectory ? outFileName : maintainEntryPath ? entryName : pth.basename(entryName));
+            var target = sanitize(targetPath, outFileName && !item.isDirectory ? canonical(outFileName) : maintainEntryPath ? entryName : pth.basename(entryName));
 
             if (item.isDirectory) {
                 var children = _zip.getEntryChildren(item);
@@ -16617,8 +18648,12 @@ module.exports = function (/**String*/ input, /** object */ options) {
                     if (!content) {
                         throw Utils.Errors.CANT_EXTRACT_FILE();
                     }
-                    var name = canonical(child.entryName);
-                    var childName = sanitize(targetPath, maintainEntryPath ? name : pth.basename(name));
+                    // When not maintaining the full entry path, keep each child's path
+                    // relative to the extracted directory (drop the directory's own
+                    // prefix) instead of flattening every file to its basename, which
+                    // collapsed subdirectories together (issue #306).
+                    var name = canonical(maintainEntryPath ? child.entryName : child.entryName.substring(item.entryName.length));
+                    var childName = sanitize(targetPath, name);
                     // The reverse operation for attr depend on method addFile()
                     const fileAttr = keepOriginalPermission ? child.header.fileAttr : undefined;
                     filetools.writeFileTo(childName, content, overwrite, fileAttr);
@@ -16648,12 +18683,14 @@ module.exports = function (/**String*/ input, /** object */ options) {
                 return false;
             }
 
-            for (var entry in _zip.entries) {
+            for (var entry of _zip.entries) {
                 try {
                     if (entry.isDirectory) {
                         continue;
                     }
-                    var content = _zip.entries[entry].getData(pass);
+                    // was `_zip.entries[entry]` (indexing the array with an entry
+                    // object -> undefined -> threw -> test() always returned false)
+                    var content = entry.getData(pass);
                     if (!content) {
                         return false;
                     }
@@ -16680,10 +18717,13 @@ module.exports = function (/**String*/ input, /** object */ options) {
             overwrite = get_Bool(false, overwrite);
             if (!_zip) throw Utils.Errors.NO_ZIP();
 
+            const dirEntries = [];
             _zip.entries.forEach(function (entry) {
                 var entryName = sanitize(targetPath, canonical(entry.entryName));
                 if (entry.isDirectory) {
                     filetools.makeDir(entryName);
+                    // defer restoring the directory permission until its files are written
+                    if (keepOriginalPermission) dirEntries.push({ path: entryName, attr: entry.header.fileAttr });
                     return;
                 }
                 var content = entry.getData(pass);
@@ -16694,11 +18734,15 @@ module.exports = function (/**String*/ input, /** object */ options) {
                 const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
                 filetools.writeFileTo(entryName, content, overwrite, fileAttr);
                 try {
+                    // best-effort: an invalid date in the archive or a filesystem that
+                    // rejects utimes must not fail extraction of already-written content (issue #379)
                     filetools.fs.utimesSync(entryName, entry.header.time, entry.header.time);
                 } catch (err) {
-                    throw Utils.Errors.CANT_EXTRACT_FILE();
+                    /* ignore timestamp failures */
                 }
             });
+
+            applyDirAttributes(dirEntries);
         },
 
         /**
@@ -16749,20 +18793,41 @@ module.exports = function (/**String*/ input, /** object */ options) {
 
             // Create directory entries first synchronously
             // this prevents race condition and assures folders are there before writing files
+            const deferredDirAttr = [];
             for (const entry of dirEntries) {
                 const dirPath = getPath(entry);
                 // The reverse operation for attr depend on method addFile()
                 const dirAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
                 try {
                     filetools.makeDir(dirPath);
-                    if (dirAttr) filetools.fs.chmodSync(dirPath, dirAttr);
-                    // in unix timestamp will change if files are later added to folder, but still
-                    filetools.fs.utimesSync(dirPath, entry.header.time, entry.header.time);
                 } catch (er) {
                     callback(getError("Unable to create folder", dirPath));
+                    continue;
+                }
+                // defer restoring the directory permission until its files are written:
+                // a restrictive mode applied now would block writing them
+                if (dirAttr) deferredDirAttr.push({ path: dirPath, attr: dirAttr });
+                try {
+                    // in unix timestamp will change if files are later added to folder, but still.
+                    // best-effort: a utimes failure must not abort extraction (issue #379)
+                    filetools.fs.utimesSync(dirPath, entry.header.time, entry.header.time);
+                } catch (er) {
+                    /* ignore timestamp failures */
                 }
             }
 
+            // restore directory permissions once every file has been extracted
+            const done = (err) => {
+                if (!err) {
+                    try {
+                        applyDirAttributes(deferredDirAttr);
+                    } catch (er) {
+                        return callback(getError("Unable to set folder permissions", er.path || ""));
+                    }
+                }
+                callback(err);
+            };
+
             fileEntries.reverse().reduce(function (next, entry) {
                 return function (err) {
                     if (err) {
@@ -16780,21 +18845,19 @@ module.exports = function (/**String*/ input, /** object */ options) {
                                 const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
                                 filetools.writeFileToAsync(filePath, content, overwrite, fileAttr, function (succ) {
                                     if (!succ) {
-                                        next(getError("Unable to write file", filePath));
+                                        return next(getError("Unable to write file", filePath));
                                     }
-                                    filetools.fs.utimes(filePath, entry.header.time, entry.header.time, function (err_2) {
-                                        if (err_2) {
-                                            next(getError("Unable to set times", filePath));
-                                        } else {
-                                            next();
-                                        }
+                                    filetools.fs.utimes(filePath, entry.header.time, entry.header.time, function () {
+                                        // best-effort: a utimes failure must not abort extraction
+                                        // of already-written content (issue #379)
+                                        next();
                                     });
                                 });
                             }
                         });
                     }
                 };
-            }, callback)();
+            }, done)();
         },
 
         /**
@@ -16878,10 +18941,10 @@ module.exports = function (/**String*/ input, /** object */ options) {
 
 /***/ }),
 
-/***/ 2916:
+/***/ 88436:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-var Utils = __nccwpck_require__(28605),
+var Utils = __nccwpck_require__(91373),
     Constants = Utils.Constants;
 
 /* The central directory file header */
@@ -16970,6 +19033,7 @@ module.exports = function () {
             switch (val) {
                 case Constants.STORED:
                     this.version = 10;
+                    break;
                 case Constants.DEFLATED:
                 default:
                     this.version = 20;
@@ -16981,6 +19045,7 @@ module.exports = function () {
             return Utils.fromDOS2Date(this.timeval);
         },
         set time(val) {
+            val = new Date(val);
             this.timeval = Utils.fromDate2DOS(val);
         },
 
@@ -17103,6 +19168,8 @@ module.exports = function () {
             _localHeader.version = data.readUInt16LE(Constants.LOCVER);
             // general purpose bit flag
             _localHeader.flags = data.readUInt16LE(Constants.LOCFLG);
+            // desc flag
+            _localHeader.flags_desc = (_localHeader.flags & Constants.FLG_DESC) > 0;
             // compression method
             _localHeader.method = data.readUInt16LE(Constants.LOCHOW);
             // modification time (2 bytes time, 2 bytes date)
@@ -17169,7 +19236,11 @@ module.exports = function () {
             // version needed to extract
             data.writeUInt16LE(_version, Constants.LOCVER);
             // general purpose bit flag
-            data.writeUInt16LE(_flags, Constants.LOCFLG);
+            // clear bit 3 (data descriptor): we always write the real crc-32
+            // and sizes into this local header, so no trailing descriptor is
+            // emitted. Leaving the flag set would make the output unreadable
+            // (see issue #555).
+            data.writeUInt16LE(_flags & ~Constants.FLG_DESC, Constants.LOCFLG);
             // compression method
             data.writeUInt16LE(_method, Constants.LOCHOW);
             // modification time (2 bytes time, 2 bytes date)
@@ -17197,7 +19268,9 @@ module.exports = function () {
             // version needed to extract
             data.writeUInt16LE(_version, Constants.CENVER);
             // encrypt, decrypt flags
-            data.writeUInt16LE(_flags, Constants.CENFLG);
+            // clear bit 3 (data descriptor) to match the local header we emit
+            // (real crc/sizes are written, no descriptor follows the data) — issue #555
+            data.writeUInt16LE(_flags & ~Constants.FLG_DESC, Constants.CENFLG);
             // compression method
             data.writeUInt16LE(_method, Constants.CENHOW);
             // modification time (2 bytes time, 2 bytes date)
@@ -17259,19 +19332,19 @@ module.exports = function () {
 
 /***/ }),
 
-/***/ 57405:
+/***/ 77837:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
-exports.EntryHeader = __nccwpck_require__(2916);
-exports.MainHeader = __nccwpck_require__(81289);
+exports.EntryHeader = __nccwpck_require__(88436);
+exports.MainHeader = __nccwpck_require__(88889);
 
 
 /***/ }),
 
-/***/ 81289:
+/***/ 88889:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-var Utils = __nccwpck_require__(28605),
+var Utils = __nccwpck_require__(91373),
     Constants = Utils.Constants;
 
 /* The entries in the end of central directory */
@@ -17282,6 +19355,8 @@ module.exports = function () {
         _offset = 0,
         _commentLength = 0;
 
+    const needsZip64 = () => _volumeEntries > Constants.EF_ZIP64_OR_16 || _totalEntries > Constants.EF_ZIP64_OR_16 || _size > Constants.EF_ZIP64_OR_32 || _offset > Constants.EF_ZIP64_OR_32;
+
     return {
         get diskEntries() {
             return _volumeEntries;
@@ -17319,7 +19394,7 @@ module.exports = function () {
         },
 
         get mainHeaderSize() {
-            return Constants.ENDHDR + _commentLength;
+            return (needsZip64() ? Constants.ZIP64HDR + Constants.END64HDR : 0) + Constants.ENDHDR + _commentLength;
         },
 
         loadFromBinary: function (/*Buffer*/ data) {
@@ -17349,7 +19424,7 @@ module.exports = function () {
                 // total number of entries
                 _totalEntries = Utils.readBigUInt64LE(data, Constants.ZIP64TOT);
                 // central directory size in bytes
-                _size = Utils.readBigUInt64LE(data, Constants.ZIP64SIZE);
+                _size = Utils.readBigUInt64LE(data, Constants.ZIP64SIZB);
                 // offset of first CEN header
                 _offset = Utils.readBigUInt64LE(data, Constants.ZIP64OFF);
 
@@ -17358,22 +19433,67 @@ module.exports = function () {
         },
 
         toBinary: function () {
-            var b = Buffer.alloc(Constants.ENDHDR + _commentLength);
+            if (!needsZip64()) {
+                var b = Buffer.alloc(Constants.ENDHDR + _commentLength);
+                // "PK 05 06" signature
+                b.writeUInt32LE(Constants.ENDSIG, 0);
+                b.writeUInt32LE(0, 4);
+                // number of entries on this volume
+                b.writeUInt16LE(_volumeEntries, Constants.ENDSUB);
+                // total number of entries
+                b.writeUInt16LE(_totalEntries, Constants.ENDTOT);
+                // central directory size in bytes
+                b.writeUInt32LE(_size, Constants.ENDSIZ);
+                // offset of first CEN header
+                b.writeUInt32LE(_offset, Constants.ENDOFF);
+                // zip file comment length
+                b.writeUInt16LE(_commentLength, Constants.ENDCOM);
+                // fill comment memory with spaces so no garbage is left there
+                b.fill(" ", Constants.ENDHDR);
+
+                return b;
+            }
+
+            var b = Buffer.alloc(this.mainHeaderSize);
+            let offset = 0;
+
+            // Zip64 end of central directory record.
+            b.writeUInt32LE(Constants.ZIP64SIG, offset);
+            Utils.writeBigUInt64LE(b, Constants.ZIP64HDR - Constants.ZIP64LEAD, offset + Constants.ZIP64SIZE);
+            b.writeUInt16LE(45, offset + Constants.ZIP64VEM);
+            b.writeUInt16LE(45, offset + Constants.ZIP64VER);
+            b.writeUInt32LE(0, offset + Constants.ZIP64DSK);
+            b.writeUInt32LE(0, offset + Constants.ZIP64DSKDIR);
+            Utils.writeBigUInt64LE(b, _volumeEntries, offset + Constants.ZIP64SUB);
+            Utils.writeBigUInt64LE(b, _totalEntries, offset + Constants.ZIP64TOT);
+            Utils.writeBigUInt64LE(b, _size, offset + Constants.ZIP64SIZB);
+            Utils.writeBigUInt64LE(b, _offset, offset + Constants.ZIP64OFF);
+
+            const zip64EndOffset = _offset + _size;
+            offset += Constants.ZIP64HDR;
+
+            // Zip64 end of central directory locator.
+            b.writeUInt32LE(Constants.END64SIG, offset);
+            b.writeUInt32LE(0, offset + Constants.END64START);
+            Utils.writeBigUInt64LE(b, zip64EndOffset, offset + Constants.END64OFF);
+            b.writeUInt32LE(1, offset + Constants.END64NUMDISKS);
+            offset += Constants.END64HDR;
+
             // "PK 05 06" signature
-            b.writeUInt32LE(Constants.ENDSIG, 0);
-            b.writeUInt32LE(0, 4);
+            b.writeUInt32LE(Constants.ENDSIG, offset);
+            b.writeUInt32LE(0, offset + 4);
             // number of entries on this volume
-            b.writeUInt16LE(_volumeEntries, Constants.ENDSUB);
+            b.writeUInt16LE(Math.min(_volumeEntries, Constants.EF_ZIP64_OR_16), offset + Constants.ENDSUB);
             // total number of entries
-            b.writeUInt16LE(_totalEntries, Constants.ENDTOT);
+            b.writeUInt16LE(Math.min(_totalEntries, Constants.EF_ZIP64_OR_16), offset + Constants.ENDTOT);
             // central directory size in bytes
-            b.writeUInt32LE(_size, Constants.ENDSIZ);
+            b.writeUInt32LE(Math.min(_size, Constants.EF_ZIP64_OR_32), offset + Constants.ENDSIZ);
             // offset of first CEN header
-            b.writeUInt32LE(_offset, Constants.ENDOFF);
+            b.writeUInt32LE(Math.min(_offset, Constants.EF_ZIP64_OR_32), offset + Constants.ENDOFF);
             // zip file comment length
-            b.writeUInt16LE(_commentLength, Constants.ENDCOM);
+            b.writeUInt16LE(_commentLength, offset + Constants.ENDCOM);
             // fill comment memory with spaces so no garbage is left there
-            b.fill(" ", Constants.ENDHDR);
+            b.fill(" ", offset + Constants.ENDHDR);
 
             return b;
         },
@@ -17405,7 +19525,7 @@ module.exports = function () {
 
 /***/ }),
 
-/***/ 90858:
+/***/ 49466:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 module.exports = function (/*Buffer*/ inbuf) {
@@ -17445,20 +19565,20 @@ module.exports = function (/*Buffer*/ inbuf) {
 
 /***/ }),
 
-/***/ 93133:
+/***/ 70493:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
-exports.Deflater = __nccwpck_require__(90858);
-exports.Inflater = __nccwpck_require__(33938);
-exports.ZipCrypto = __nccwpck_require__(12759);
+exports.Deflater = __nccwpck_require__(49466);
+exports.Inflater = __nccwpck_require__(27298);
+exports.ZipCrypto = __nccwpck_require__(19687);
 
 
 /***/ }),
 
-/***/ 33938:
+/***/ 27298:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-const version = +(process.versions ? process.versions.node : "").split(".")[0] || 0;
+const version = +(process?.versions?.node ?? "").split(".")[0] || 0;
 
 module.exports = function (/*Buffer*/ inbuf, /*number*/ expectedLength) {
     var zlib = __nccwpck_require__(43106);
@@ -17496,7 +19616,7 @@ module.exports = function (/*Buffer*/ inbuf, /*number*/ expectedLength) {
 
 /***/ }),
 
-/***/ 12759:
+/***/ 19687:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -17505,7 +19625,7 @@ module.exports = function (/*Buffer*/ inbuf, /*number*/ expectedLength) {
 // node crypt, we use it for generate salt
 // eslint-disable-next-line node/no-unsupported-features/node-builtins
 const { randomFillSync } = __nccwpck_require__(76982);
-const Errors = __nccwpck_require__(68978);
+const Errors = __nccwpck_require__(9314);
 
 // generate CRC32 lookup table
 const crctable = new Uint32Array(256).map((t, crc) => {
@@ -17679,7 +19799,7 @@ module.exports = { decrypt, encrypt, _salter };
 
 /***/ }),
 
-/***/ 44436:
+/***/ 85604:
 /***/ ((module) => {
 
 module.exports = {
@@ -17828,7 +19948,7 @@ module.exports = {
 
 /***/ }),
 
-/***/ 40801:
+/***/ 95825:
 /***/ ((module) => {
 
 module.exports = {
@@ -17840,7 +19960,7 @@ module.exports = {
 
 /***/ }),
 
-/***/ 68978:
+/***/ 9314:
 /***/ ((__unused_webpack_module, exports) => {
 
 const errors = {
@@ -17910,7 +20030,7 @@ for (const msg of Object.keys(errors)) {
 
 /***/ }),
 
-/***/ 62328:
+/***/ 71560:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const pth = __nccwpck_require__(16928);
@@ -17993,25 +20113,25 @@ module.exports = function (/*String*/ path, /*Utils object*/ { fs }) {
 
 /***/ }),
 
-/***/ 28605:
+/***/ 91373:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-module.exports = __nccwpck_require__(32904);
-module.exports.Constants = __nccwpck_require__(44436);
-module.exports.Errors = __nccwpck_require__(68978);
-module.exports.FileAttr = __nccwpck_require__(62328);
-module.exports.decoder = __nccwpck_require__(40801);
+module.exports = __nccwpck_require__(12056);
+module.exports.Constants = __nccwpck_require__(85604);
+module.exports.Errors = __nccwpck_require__(9314);
+module.exports.FileAttr = __nccwpck_require__(71560);
+module.exports.decoder = __nccwpck_require__(95825);
 
 
 /***/ }),
 
-/***/ 32904:
+/***/ 12056:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 const fsystem = __nccwpck_require__(79896);
 const pth = __nccwpck_require__(16928);
-const Constants = __nccwpck_require__(44436);
-const Errors = __nccwpck_require__(68978);
+const Constants = __nccwpck_require__(85604);
+const Errors = __nccwpck_require__(9314);
 const isWin = typeof process === "object" && "win32" === process.platform;
 
 const is_Obj = (obj) => typeof obj === "object" && obj !== null;
@@ -18059,7 +20179,11 @@ Utils.prototype.makeDir = function (/*String*/ folder) {
             try {
                 stat = self.fs.statSync(resolvedPath);
             } catch (e) {
-                self.fs.mkdirSync(resolvedPath);
+                if (e.message && e.message.startsWith('ENOENT')) {
+                    self.fs.mkdirSync(resolvedPath);
+                } else {
+                    throw e;
+                }
             }
             if (stat && stat.isFile()) throw Errors.FILE_IN_THE_WAY(`"${resolvedPath}"`);
         });
@@ -18113,39 +20237,51 @@ Utils.prototype.writeFileToAsync = function (/*String*/ path, /*Buffer*/ content
         if (exist && !overwrite) return callback(false);
 
         self.fs.stat(path, function (err, stat) {
-            if (exist && stat.isDirectory()) {
+            if (exist && stat && stat.isDirectory()) {
                 return callback(false);
             }
 
             var folder = pth.dirname(path);
             self.fs.exists(folder, function (exists) {
-                if (!exists) self.makeDir(folder);
+                if (!exists) {
+                    // makeDir is synchronous and can throw (e.g. EACCES); report failure
+                    // rather than letting it escape this callback as an uncaught exception
+                    try {
+                        self.makeDir(folder);
+                    } catch (e) {
+                        return callback(false);
+                    }
+                }
+
+                // write the content to an open descriptor, then apply the attributes
+                const writeToFd = function (fd) {
+                    self.fs.write(fd, content, 0, content.length, 0, function (writeErr) {
+                        self.fs.close(fd, function () {
+                            // surface write failures instead of silently reporting success (issue #402)
+                            if (writeErr) return callback(false);
+                            self.fs.chmod(path, attr || 0o666, function () {
+                                callback(true);
+                            });
+                        });
+                    });
+                };
 
                 self.fs.open(path, "w", 0o666, function (err, fd) {
                     if (err) {
+                        // the target may exist but be read-only: make it writable and retry once
                         self.fs.chmod(path, 0o666, function () {
-                            self.fs.open(path, "w", 0o666, function (err, fd) {
-                                self.fs.write(fd, content, 0, content.length, 0, function () {
-                                    self.fs.close(fd, function () {
-                                        self.fs.chmod(path, attr || 0o666, function () {
-                                            callback(true);
-                                        });
-                                    });
-                                });
+                            self.fs.open(path, "w", 0o666, function (retryErr, fd) {
+                                // Previously the retry error was ignored and an undefined fd was
+                                // passed to fs.write, throwing an uncaught ERR_INVALID_ARG_TYPE that
+                                // crashed the process (issues #470, #459, #402). Report failure instead.
+                                if (retryErr || !fd) return callback(false);
+                                writeToFd(fd);
                             });
                         });
                     } else if (fd) {
-                        self.fs.write(fd, content, 0, content.length, 0, function () {
-                            self.fs.close(fd, function () {
-                                self.fs.chmod(path, attr || 0o666, function () {
-                                    callback(true);
-                                });
-                            });
-                        });
+                        writeToFd(fd);
                     } else {
-                        self.fs.chmod(path, attr || 0o666, function () {
-                            callback(true);
-                        });
+                        callback(false);
                     }
                 });
             });
@@ -18156,7 +20292,7 @@ Utils.prototype.writeFileToAsync = function (/*String*/ path, /*Buffer*/ content
 Utils.prototype.findFiles = function (/*String*/ path) {
     const self = this;
 
-    function findSync(/*String*/ dir, /*RegExp*/ pattern, /*Boolean*/ recursive) {
+    function findSync(/*String*/ dir, /*RegExp*/ pattern, /*Boolean*/ recursive, /*Set*/ visited) {
         if (typeof pattern === "boolean") {
             recursive = pattern;
             pattern = undefined;
@@ -18170,12 +20306,22 @@ Utils.prototype.findFiles = function (/*String*/ path) {
                 files.push(pth.normalize(path) + (stat.isDirectory() ? self.sep : ""));
             }
 
-            if (stat.isDirectory() && recursive) files = files.concat(findSync(path, pattern, recursive));
+            if (stat.isDirectory() && recursive) {
+                // Descend by resolved real path and skip directories we have already
+                // visited. This stops a symlink that points back to an ancestor from
+                // recursing forever until the path fails with ELOOP / ENAMETOOLONG
+                // (issue #541).
+                const realDir = self.fs.realpathSync(path);
+                if (!visited.has(realDir)) {
+                    visited.add(realDir);
+                    files = files.concat(findSync(path, pattern, recursive, visited));
+                }
+            }
         });
         return files;
     }
 
-    return findSync(path, undefined, true);
+    return findSync(path, undefined, true, new Set([self.fs.realpathSync(path)]));
 };
 
 /**
@@ -18193,29 +20339,54 @@ Utils.prototype.findFiles = function (/*String*/ path) {
  */
 Utils.prototype.findFilesAsync = function (dir, cb) {
     const self = this;
-    let results = [];
-    self.fs.readdir(dir, function (err, list) {
-        if (err) return cb(err);
-        let list_length = list.length;
-        if (!list_length) return cb(null, results);
-        list.forEach(function (file) {
-            file = pth.join(dir, file);
-            self.fs.stat(file, function (err, stat) {
-                if (err) return cb(err);
-                if (stat) {
+    const results = [];
+    let finished = false;
+    const finish = function (err) {
+        if (finished) return;
+        finished = true;
+        cb(err, err ? undefined : results);
+    };
+
+    // Descend by resolved real path and skip directories already visited, so a
+    // symlink pointing back to an ancestor cannot recurse forever (issue #541).
+    const walk = function (dir, visited, done) {
+        self.fs.readdir(dir, function (err, list) {
+            if (err) return done(err);
+            let pending = list.length;
+            if (!pending) return done();
+            list.forEach(function (name) {
+                const file = pth.join(dir, name);
+                self.fs.stat(file, function (err, stat) {
+                    if (err) return done(err);
+                    if (!stat) {
+                        if (!--pending) done();
+                        return;
+                    }
                     results.push(pth.normalize(file) + (stat.isDirectory() ? self.sep : ""));
-                    if (stat.isDirectory()) {
-                        self.findFilesAsync(file, function (err, res) {
-                            if (err) return cb(err);
-                            results = results.concat(res);
-                            if (!--list_length) cb(null, results);
-                        });
-                    } else {
-                        if (!--list_length) cb(null, results);
+                    if (!stat.isDirectory()) {
+                        if (!--pending) done();
+                        return;
                     }
-                }
+                    self.fs.realpath(file, function (err, realDir) {
+                        if (err) return done(err);
+                        if (visited.has(realDir)) {
+                            if (!--pending) done();
+                            return;
+                        }
+                        visited.add(realDir);
+                        walk(file, visited, function (err) {
+                            if (err) return done(err);
+                            if (!--pending) done();
+                        });
+                    });
+                });
             });
         });
+    };
+
+    self.fs.realpath(dir, function (err, realDir) {
+        if (err) return finish(err);
+        walk(dir, new Set([realDir]), finish);
     });
 };
 
@@ -18296,13 +20467,13 @@ Utils.findLast = function (arr, callback) {
     return void 0;
 };
 
-// make abolute paths taking prefix as root folder
+// make absolute paths taking prefix as root folder
 Utils.sanitize = function (/*string*/ prefix, /*string*/ name) {
     prefix = pth.resolve(pth.normalize(prefix));
     var parts = name.split("/");
     for (var i = 0, l = parts.length; i < l; i++) {
         var path = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
-        if (path.indexOf(prefix) === 0) {
+        if (path === prefix || path.startsWith(prefix + pth.sep)) {
             return path;
         }
     }
@@ -18322,10 +20493,16 @@ Utils.toBuffer = function toBuffer(/*buffer, Uint8Array, string*/ input, /* func
 };
 
 Utils.readBigUInt64LE = function (/*Buffer*/ buffer, /*int*/ index) {
-    var slice = Buffer.from(buffer.slice(index, index + 8));
-    slice.swap64();
+    const lo = buffer.readUInt32LE(index);
+    const hi = buffer.readUInt32LE(index + 4);
+    return hi * 0x100000000 + lo;
+};
 
-    return parseInt(`0x${slice.toString("hex")}`);
+Utils.writeBigUInt64LE = function (/*Buffer*/ buffer, /*Number*/ value, /*int*/ index) {
+    const lo = value >>> 0;
+    const hi = Math.floor(value / 0x100000000) >>> 0;
+    buffer.writeUInt32LE(lo, index);
+    buffer.writeUInt32LE(hi, index + 4);
 };
 
 Utils.fromDOS2Date = function (val) {
@@ -18348,13 +20525,13 @@ Utils.crcTable = crcTable;
 
 /***/ }),
 
-/***/ 59155:
+/***/ 58851:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-var Utils = __nccwpck_require__(28605),
-    Headers = __nccwpck_require__(57405),
+var Utils = __nccwpck_require__(91373),
+    Headers = __nccwpck_require__(77837),
     Constants = Utils.Constants,
-    Methods = __nccwpck_require__(93133);
+    Methods = __nccwpck_require__(70493);
 
 module.exports = function (/** object */ options, /*Buffer*/ input) {
     var _centralHeader = new Headers.EntryHeader(),
@@ -18382,48 +20559,23 @@ module.exports = function (/** object */ options, /*Buffer*/ input) {
     }
 
     function crc32OK(data) {
-        // if bit 3 (0x08) of the general-purpose flags field is set, then the CRC-32 and file sizes are not known when the local header is written
-        if (!_centralHeader.flags_desc) {
-            if (Utils.crc32(data) !== _centralHeader.localHeader.crc) {
-                return false;
-            }
-        } else {
-            const descriptor = {};
-            const dataEndOffset = _centralHeader.realDataOffset + _centralHeader.compressedSize;
-            // no descriptor after compressed data, instead new local header
-            if (input.readUInt32LE(dataEndOffset) == Constants.LOCSIG || input.readUInt32LE(dataEndOffset) == Constants.CENSIG) {
-                throw Utils.Errors.DESCRIPTOR_NOT_EXIST();
-            }
-
-            // get decriptor data
-            if (input.readUInt32LE(dataEndOffset) == Constants.EXTSIG) {
-                // descriptor with signature
-                descriptor.crc = input.readUInt32LE(dataEndOffset + Constants.EXTCRC);
-                descriptor.compressedSize = input.readUInt32LE(dataEndOffset + Constants.EXTSIZ);
-                descriptor.size = input.readUInt32LE(dataEndOffset + Constants.EXTLEN);
-            } else if (input.readUInt16LE(dataEndOffset + 12) === 0x4b50) {
-                // descriptor without signature (we check is new header starting where we expect)
-                descriptor.crc = input.readUInt32LE(dataEndOffset + Constants.EXTCRC - 4);
-                descriptor.compressedSize = input.readUInt32LE(dataEndOffset + Constants.EXTSIZ - 4);
-                descriptor.size = input.readUInt32LE(dataEndOffset + Constants.EXTLEN - 4);
-            } else {
-                throw Utils.Errors.DESCRIPTOR_UNKNOWN();
-            }
-
-            // check data integrity
-            if (descriptor.compressedSize !== _centralHeader.compressedSize || descriptor.size !== _centralHeader.size || descriptor.crc !== _centralHeader.crc) {
-                throw Utils.Errors.DESCRIPTOR_FAULTY();
-            }
-            if (Utils.crc32(data) !== descriptor.crc) {
-                return false;
-            }
+        // When bit 3 (0x08) of the general-purpose flags is set, the crc-32 and
+        // sizes were unknown when the local file header was written, so that
+        // header carries placeholder zeros and the real values are repeated in a
+        // data descriptor after the compressed data. adm-zip always parses the
+        // central directory, whose header holds the authoritative crc-32 and
+        // sizes, so we validate the payload against that value.
+        //
+        // Earlier versions instead located and parsed the trailing descriptor and
+        // threw when it was absent or in an unexpected shape. Many valid archives
+        // set the descriptor flag but write the real crc/sizes into the local and
+        // central headers without emitting a descriptor (or write one we did not
+        // recognise), so that strict handling rejected readable zips
+        // (issues #533, #548, #554). Trusting the central-directory crc keeps the
+        // integrity check while accepting those archives.
+        const expectedCrc = _centralHeader.flags_desc || _centralHeader.localHeader.flags_desc ? _centralHeader.crc : _centralHeader.localHeader.crc;
 
-            // @TODO: zip64 bit descriptor fields
-            // if bit 3 is set and any value in local header "zip64 Extended information" extra field are set 0 (place holder)
-            // then 64-bit descriptor format is used instead of 32-bit
-            // central header - "zip64 Extended information" extra field should store real values and not place holders
-        }
-        return true;
+        return Utils.crc32(data) === expectedCrc;
     }
 
     function decompress(/*Boolean*/ async, /*Function*/ callback, /*String, Buffer*/ pass) {
@@ -18453,10 +20605,16 @@ module.exports = function (/** object */ options, /*Buffer*/ input) {
             compressedData = Methods.ZipCrypto.decrypt(compressedData, _centralHeader, pass);
         }
 
-        var data = Buffer.alloc(_centralHeader.size);
+        var data;
 
         switch (_centralHeader.method) {
             case Utils.Constants.STORED:
+                // STORED entries are not compressed, so the uncompressed output is
+                // exactly the bytes present in the archive. Allocate from the real
+                // data length rather than the attacker-declared central-directory
+                // size, otherwise a tiny archive can declare a huge size and force a
+                // multi-gigabyte allocation before any validation (CVE-2026-39244).
+                data = Buffer.alloc(compressedData.length);
                 compressedData.copy(data);
                 if (!crc32OK(data)) {
                     if (async && callback) callback(data, Utils.Errors.BAD_CRC()); //si added error
@@ -18467,17 +20625,19 @@ module.exports = function (/** object */ options, /*Buffer*/ input) {
                     return data;
                 }
             case Utils.Constants.DEFLATED:
+                // Do not pre-allocate the declared uncompressed size. The inflater
+                // grows its output buffer as zlib emits data and caps the total at
+                // the declared size (maxOutputLength), so a bogus size can no longer
+                // trigger an eager allocation before the data is read (CVE-2026-39244).
                 var inflater = new Methods.Inflater(compressedData, _centralHeader.size);
                 if (!async) {
-                    const result = inflater.inflate(data);
-                    result.copy(data, 0);
+                    data = inflater.inflate();
                     if (!crc32OK(data)) {
                         throw Utils.Errors.BAD_CRC(`"${decoder.decode(_entryName)}"`);
                     }
                     return data;
                 } else {
                     inflater.inflateAsync(function (result) {
-                        result.copy(result, 0);
                         if (callback) {
                             if (!crc32OK(result)) {
                                 callback(result, Utils.Errors.BAD_CRC()); //si added error
@@ -18539,7 +20699,7 @@ module.exports = function (/** object */ options, /*Buffer*/ input) {
     }
 
     function readUInt64LE(buffer, offset) {
-        return (buffer.readUInt32LE(offset + 4) << 4) + buffer.readUInt32LE(offset);
+        return Utils.readBigUInt64LE(buffer, offset);
     }
 
     function parseExtra(data) {
@@ -18633,10 +20793,12 @@ module.exports = function (/** object */ options, /*Buffer*/ input) {
         },
 
         get name() {
-            var n = decoder.decode(_entryName);
+            const n = decoder.decode(_entryName);
+            // For directories the name is the last path segment; drop the trailing
+            // separator first so "a/b/c/" yields "c" and not "" (issue #466).
             return _isDirectory
                 ? n
-                      .substr(n.length - 1)
+                      .replace(/[/\\]$/, "")
                       .split("/")
                       .pop()
                 : n.split("/").pop();
@@ -18760,16 +20922,19 @@ module.exports = function (/** object */ options, /*Buffer*/ input) {
 
 /***/ }),
 
-/***/ 43985:
+/***/ 46593:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-const ZipEntry = __nccwpck_require__(59155);
-const Headers = __nccwpck_require__(57405);
-const Utils = __nccwpck_require__(28605);
+const ZipEntry = __nccwpck_require__(58851);
+const Headers = __nccwpck_require__(77837);
+const Utils = __nccwpck_require__(91373);
 
 module.exports = function (/*Buffer|null*/ inBuffer, /** object */ options) {
     var entryList = [],
-        entryTable = {},
+        // prototype-less: entry names come from untrusted input, so keys like
+        // "__proto__" or "constructor" must be plain data, not touch the prototype
+        // chain (which otherwise crashes addFile and hides such entries)
+        entryTable = Object.create(null),
         _comment = Buffer.alloc(0),
         mainHeader = new Headers.MainHeader(),
         loadedEntries = false;
@@ -18819,7 +20984,7 @@ module.exports = function (/*Buffer|null*/ inBuffer, /** object */ options) {
 
     function readEntries() {
         loadedEntries = true;
-        entryTable = {};
+        entryTable = Object.create(null);
         if (mainHeader.diskEntries > (inBuffer.length - mainHeader.offset) / Utils.Constants.CENHDR) {
             throw Utils.Errors.DISK_ENTRY_TOO_LARGE();
         }
@@ -18896,7 +21061,14 @@ module.exports = function (/*Buffer|null*/ inBuffer, /** object */ options) {
 
     function sortEntries() {
         if (entryList.length > 1 && !noSort) {
-            entryList.sort((a, b) => a.entryName.toLowerCase().localeCompare(b.entryName.toLowerCase()));
+            // Decode + lowercase each name once rather than on every comparison:
+            // the entryName getter re-decodes the underlying buffer on each access,
+            // so the previous inline comparator did O(n log n) redundant decoding.
+            // Ordering is unchanged (same localeCompare on the same keys).
+            entryList = entryList
+                .map((entry) => ({ entry, key: entry.entryName.toLowerCase() }))
+                .sort((a, b) => a.key.localeCompare(b.key))
+                .map((pair) => pair.entry);
         }
     }
 
@@ -19108,7 +21280,7 @@ module.exports = function (/*Buffer|null*/ inBuffer, /** object */ options) {
             // write main header
             const mh = mainHeader.toBinary();
             if (_comment) {
-                _comment.copy(mh, Utils.Constants.ENDHDR); // add zip file comment
+                _comment.copy(mh, mh.length - _comment.length); // add zip file comment
             }
             mh.copy(outBuffer, dindex);
 
@@ -19186,7 +21358,7 @@ module.exports = function (/*Buffer|null*/ inBuffer, /** object */ options) {
 
                         const mh = mainHeader.toBinary();
                         if (_comment) {
-                            _comment.copy(mh, Utils.Constants.ENDHDR); // add zip file comment
+                            _comment.copy(mh, mh.length - _comment.length); // add zip file comment
                         }
 
                         mh.copy(outBuffer, dindex); // write main header
@@ -128150,7 +130322,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-807f2ef.0","h_":"ckb development network for your first try"}');
 
 /***/ })