@offckb/cli 0.4.7-canary-dfe1b5f.0 → 0.4.7-canary-a078424.0

package/build/index.js

@@ -377,9 +377,9 @@ program
     const txHash = option.txHash;
     if (option.singleScript) {
         const { cellType, cellIndex, scriptType } = (0, debug_1.parseSingleScriptOption)(option.singleScript);
-        return (0, debug_1.debugSingleScript)(txHash, cellIndex, cellType, scriptType, option.network, option.bin);
+        return yield (0, debug_1.debugSingleScript)(txHash, cellIndex, cellType, scriptType, option.network, option.bin);
     }
-    return (0, debug_1.debugTransaction)(txHash, option.network);
+    return yield (0, debug_1.debugTransaction)(txHash, option.network);
 }));
 program
     .command('system-scripts')
@@ -975,12 +975,14 @@ const base_1 = __nccwpck_require__(69951);
 const encoding_1 = __nccwpck_require__(6851);
 const logger_1 = __nccwpck_require__(65370);
 function debugTransaction(txHash, network) {
-    const txFile = buildTxFileOptionBy(txHash, network);
-    const opts = buildTransactionDebugOptions(txHash, network);
-    for (const opt of opts) {
-        logger_1.logger.section(opt.name, [], 'info');
-        debugRaw(`${txFile} ${opt.cmdOption}`);
-    }
+    return __awaiter(this, void 0, void 0, function* () {
+        const txFile = yield buildTxFileOptionBy(txHash, network);
+        const opts = buildTransactionDebugOptions(txHash, network);
+        for (const opt of opts) {
+            logger_1.logger.section(opt.name, [], 'info');
+            debugRaw(`${txFile} ${opt.cmdOption}`);
+        }
+    });
 }
 function buildTransactionDebugOptions(txHash, network) {
     var _a;
@@ -1011,12 +1013,14 @@ function buildTransactionDebugOptions(txHash, network) {
     return result;
 }
 function debugSingleScript(txHash, cellIndex, cellType, scriptType, network, bin) {
-    const txFile = buildTxFileOptionBy(txHash, network);
-    let opt = `--cell-index ${cellIndex} --cell-type ${cellType} --script-group-type ${scriptType}`;
-    if (bin) {
-        opt = opt + ` --bin ${bin}`;
-    }
-    debugRaw(`${txFile} ${opt}`);
+    return __awaiter(this, void 0, void 0, function* () {
+        const txFile = yield buildTxFileOptionBy(txHash, network);
+        let opt = `--cell-index ${cellIndex} --cell-type ${cellType} --script-group-type ${scriptType}`;
+        if (bin) {
+            opt = opt + ` --bin ${bin}`;
+        }
+        debugRaw(`${txFile} ${opt}`);
+    });
 }
 // Helper function to validate and parse the --script value
 function parseSingleScriptOption(value) {
@@ -1033,18 +1037,20 @@ function parseSingleScriptOption(value) {
     };
 }
 function buildTxFileOptionBy(txHash, network) {
-    const settings = (0, setting_1.readSettings)();
-    const outputFilePath = buildDebugFullTransactionFilePath(network, txHash);
-    if (!fs_1.default.existsSync(outputFilePath)) {
-        const rpc = settings[network].rpcUrl;
-        const txJsonFilePath = buildTransactionJsonFilePath(network, txHash);
+    return __awaiter(this, void 0, void 0, function* () {
+        const settings = (0, setting_1.readSettings)();
+        const outputFilePath = buildDebugFullTransactionFilePath(network, txHash);
         if (!fs_1.default.existsSync(outputFilePath)) {
-            fs_1.default.mkdirSync(path_1.default.dirname(outputFilePath), { recursive: true });
+            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 });
+            }
+            yield (0, ckb_tx_dumper_1.dumpTransaction)({ rpc, txJsonFilePath, outputFilePath });
         }
-        (0, ckb_tx_dumper_1.dumpTransaction)({ rpc, txJsonFilePath, outputFilePath });
-    }
-    const opt = `--tx-file ${(0, encoding_1.encodeBinPathForTerminal)(outputFilePath)}`;
-    return opt;
+        const opt = `--tx-file ${(0, encoding_1.encodeBinPathForTerminal)(outputFilePath)}`;
+        return opt;
+    });
 }
 function buildTransactionJsonFilePath(network, txHash) {
     const settings = (0, setting_1.readSettings)();
@@ -5318,25 +5324,208 @@ CKBDebugger.wasmDebugger = null;
 
 "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.dumpTransaction = dumpTransaction;
+const fs_1 = __importDefault(__nccwpck_require__(79896));
 const path_1 = __importDefault(__nccwpck_require__(16928));
-const child_process_1 = __nccwpck_require__(35317);
-const setting_1 = __nccwpck_require__(25546);
+const core_1 = __nccwpck_require__(51981);
+const advanced_1 = __nccwpck_require__(97875);
 const logger_1 = __nccwpck_require__(65370);
-function dumpTransaction({ rpc, txJsonFilePath, outputFilePath }) {
-    const ckbTransactionDumperPath = path_1.default.resolve(setting_1.packageRootPath, 'node_modules/.bin/ckb-transaction-dumper');
-    const command = `${ckbTransactionDumperPath} --rpc ${rpc} --tx "${txJsonFilePath}" --output "${outputFilePath}"`;
-    try {
-        (0, child_process_1.execSync)(command, { stdio: 'inherit' });
-        logger_1.logger.debug('Dump transaction successfully');
-    }
-    catch (error) {
-        logger_1.logger.error('Command failed:', error.message);
-    }
+const OutPointCodec = core_1.ccc.mol.struct({
+    txHash: core_1.ccc.mol.Byte32,
+    index: core_1.ccc.mol.Uint32LE,
+});
+const OutPointVecCodec = core_1.ccc.mol.vector(OutPointCodec);
+function toMockScript(script) {
+    if (!script)
+        return null;
+    return {
+        code_hash: script.codeHash,
+        hash_type: script.hashType,
+        args: script.args,
+    };
+}
+function toDepType(depType) {
+    // Convert camelCase to snake_case for CKB JSON format
+    if (depType === 'depGroup')
+        return 'dep_group';
+    return depType;
+}
+function resolveCellDeps(client, cellDeps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resolved = [];
+        for (const cellDep of cellDeps) {
+            const cell = yield client.getCell(cellDep.outPoint);
+            if (!cell) {
+                throw new Error(`Cell not found: ${JSON.stringify(cellDep.outPoint)}`);
+            }
+            if (cellDep.depType === 'depGroup') {
+                resolved.push({
+                    cell_dep: {
+                        out_point: {
+                            tx_hash: cellDep.outPoint.txHash,
+                            index: '0x' + cellDep.outPoint.index.toString(16),
+                        },
+                        dep_type: toDepType(cellDep.depType),
+                    },
+                    output: {
+                        capacity: '0x' + cell.cellOutput.capacity.toString(16),
+                        lock: toMockScript(cell.cellOutput.lock),
+                        type: toMockScript(cell.cellOutput.type),
+                    },
+                    data: cell.outputData,
+                });
+                const data = cell.outputData;
+                if (data && data !== '0x') {
+                    const outpoints = OutPointVecCodec.decode(data);
+                    for (const op of outpoints) {
+                        const outPoint = core_1.ccc.OutPoint.from({
+                            txHash: op.txHash,
+                            index: '0x' + op.index.toString(16),
+                        });
+                        const refCell = yield client.getCell(outPoint);
+                        if (!refCell) {
+                            logger_1.logger.error(`Failed to resolve cell for depGroup out_point: tx_hash=${outPoint.txHash}, index=${outPoint.index.toString()}`);
+                            throw new Error('Failed to resolve all cells referenced by depGroup.');
+                        }
+                        resolved.push({
+                            cell_dep: {
+                                out_point: {
+                                    tx_hash: outPoint.txHash,
+                                    index: '0x' + outPoint.index.toString(16),
+                                },
+                                dep_type: 'code',
+                            },
+                            output: {
+                                capacity: '0x' + refCell.cellOutput.capacity.toString(16),
+                                lock: toMockScript(refCell.cellOutput.lock),
+                                type: toMockScript(refCell.cellOutput.type),
+                            },
+                            data: refCell.outputData,
+                        });
+                    }
+                }
+            }
+            else {
+                resolved.push({
+                    cell_dep: {
+                        out_point: {
+                            tx_hash: cellDep.outPoint.txHash,
+                            index: '0x' + cellDep.outPoint.index.toString(16),
+                        },
+                        dep_type: toDepType(cellDep.depType),
+                    },
+                    output: {
+                        capacity: '0x' + cell.cellOutput.capacity.toString(16),
+                        lock: toMockScript(cell.cellOutput.lock),
+                        type: toMockScript(cell.cellOutput.type),
+                    },
+                    data: cell.outputData,
+                });
+            }
+        }
+        return resolved;
+    });
+}
+function resolveInputs(client, inputs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resolved = [];
+        for (const input of inputs) {
+            const cell = yield client.getCell(input.previousOutput);
+            if (!cell) {
+                throw new Error(`Input cell not found: ${JSON.stringify(input.previousOutput)}`);
+            }
+            resolved.push({
+                input: {
+                    previous_output: {
+                        tx_hash: input.previousOutput.txHash,
+                        index: '0x' + input.previousOutput.index.toString(16),
+                    },
+                    since: '0x' + input.since.toString(16),
+                },
+                output: {
+                    capacity: '0x' + cell.cellOutput.capacity.toString(16),
+                    lock: toMockScript(cell.cellOutput.lock),
+                    type: toMockScript(cell.cellOutput.type),
+                },
+                data: cell.outputData,
+            });
+        }
+        return resolved;
+    });
+}
+function dumpTransaction(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ rpc, txJsonFilePath, outputFilePath }) {
+        try {
+            const isTestnet = /testnet/i.test(rpc);
+            const client = isTestnet
+                ? new core_1.ccc.ClientPublicTestnet({
+                    url: rpc,
+                    fallbacks: [],
+                })
+                : new core_1.ccc.ClientPublicMainnet({
+                    url: rpc,
+                    fallbacks: [],
+                });
+            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([
+                resolveCellDeps(client, tx.cellDeps),
+                resolveInputs(client, tx.inputs),
+            ]);
+            const mockTx = {
+                mock_info: {
+                    inputs,
+                    cell_deps,
+                    header_deps: tx.headerDeps.map((h) => h.toString()),
+                },
+                tx: {
+                    version: '0x' + tx.version.toString(16),
+                    cell_deps: tx.cellDeps.map((dep) => ({
+                        out_point: {
+                            tx_hash: dep.outPoint.txHash,
+                            index: '0x' + dep.outPoint.index.toString(16),
+                        },
+                        dep_type: toDepType(dep.depType),
+                    })),
+                    header_deps: tx.headerDeps.map((h) => h.toString()),
+                    inputs: tx.inputs.map((input) => ({
+                        previous_output: {
+                            tx_hash: input.previousOutput.txHash,
+                            index: '0x' + input.previousOutput.index.toString(16),
+                        },
+                        since: '0x' + input.since.toString(16),
+                    })),
+                    outputs: tx.outputs.map((output) => ({
+                        capacity: '0x' + output.capacity.toString(16),
+                        lock: toMockScript(output.lock),
+                        type: toMockScript(output.type),
+                    })),
+                    outputs_data: tx.outputsData,
+                    witnesses: tx.witnesses.map((w) => w.toString()),
+                },
+            };
+            fs_1.default.mkdirSync(path_1.default.dirname(outputFilePath), { recursive: true });
+            fs_1.default.writeFileSync(outputFilePath, JSON.stringify(mockTx, null, 2));
+            logger_1.logger.debug('Dump transaction successfully');
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to dump transaction:', error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    });
 }
 
 
@@ -147449,7 +147638,7 @@ module.exports = {"version":"3.17.0"};
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"rE":"0.4.7-canary-dfe1b5f.0","h_":"ckb development network for your first try"}');
+module.exports = /*#__PURE__*/JSON.parse('{"rE":"0.4.7-canary-a078424.0","h_":"ckb development network for your first try"}');
 
 /***/ })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offckb/cli",
-  "version": "0.4.7-canary-dfe1b5f.0",
+  "version": "0.4.7-canary-a078424.0",
   "description": "ckb development network for your first try",
   "author": "CKB EcoFund",
   "license": "MIT",
@@ -86,7 +86,6 @@
     "blessed": "0.1.81",
     "chalk": "4.1.2",
     "child_process": "^1.0.2",
-    "ckb-transaction-dumper": "^0.4.2",
     "commander": "^12.0.0",
     "http-proxy": "^1.18.1",
     "https-proxy-agent": "^7.0.5",