feat: replace ckb-transaction-dumper with ccc-based implementation (#420) (#431)

* feat: replace ckb-transaction-dumper with ccc-based implementation

- Rewrite src/tools/ckb-tx-dumper.ts to use ccc Client and molecule codecs
- Implement dep_group unpacking using ccc.mol
- Remove ckb-transaction-dumper from dependencies
- Eliminates external npm dependency for transaction dumping

* chore: add changeset for ckb-transaction-dumper replacement

* fix: address PR review comments for ckb-tx-dumper

- Remove .sisyphus/boulder.json and add to .gitignore
- Fix type field serialization: emit null instead of undefined
- Fix dep_type format: convert camelCase to snake_case (depGroup -> dep_group)
- Fix depGroup error handling: throw error when refCell not found
- Fix async race condition: make buildTxFileOptionBy and callers async

* fix: fix CCC-based transaction dumper for debug command

- Use cccA.JsonRpcTransformers.transactionTo() to handle snake_case input format
- Convert all numeric values to hex format (since, index, version, capacity)
- Add missing dep_group cell to mock_info.cell_deps before expansion
- Add fs.mkdirSync to ensure output directory exists

Fixes issues where debug command failed with 'undefined is not iterable',
'unprovided cell dep', or 'since is not a legal u64' errors.

* fix: address Copilot PR review comments for ccc-based tx dumper

- Select ClientPublicTestnet/Mainnet based on RPC URL pattern
- Use proper error type checking with instanceof Error

Author: RetricSu

.changeset/wise-candies-stop.md

@@ -0,0 +1,9 @@
+---
+'@offckb/cli': minor
+---
+
+Replace ckb-transaction-dumper with ccc-based implementation
+
+- Rewrite transaction dumper to use ccc Client and molecule codecs
+- Implement dep_group unpacking using ccc.mol
+- Remove ckb-transaction-dumper npm dependency

.gitignore

@@ -12,3 +12,6 @@ package-lock.json
 # Test coverage
 coverage/
 *.lcov
+
+# Sisyphus plans and sessions
+.sisyphus/

.sisyphus/plans/ckb-tx-dumper.md

@@ -0,0 +1,175 @@
+# Replace ckb-transaction-dumper with ccc-based implementation
+
+## TL;DR
+
+> **Quick Summary**: Replace `ckb-transaction-dumper` npm package with a pure ccc-based implementation.
+>
+> **Deliverables**:
+>
+> - New `src/tools/ckb-tx-dumper.ts` (replaces old implementation)
+> - Removed `ckb-transaction-dumper` from package.json
+>
+> **Estimated Effort**: Medium (2-3 hours)
+> **Parallel Execution**: NO - sequential
+
+---
+
+## Context
+
+### Request
+
+Replace `ckb-transaction-dumper` with ccc-based implementation (no external dependencies, use ccc throughout).
+
+### Current Implementation
+
+- `src/tools/ckb-tx-dumper.ts` spawns `ckb-transaction-dumper` binary
+- Depends on npm package `ckb-transaction-dumper@0.4.2`
+
+### What TransactionDumper Does
+
+1. Load transaction (from file or fetch by hash)
+2. Resolve cell deps (handle dep_group type)
+3. Resolve inputs
+4. Output mock transaction JSON for ckb-debugger
+
+### ccc Molecule Support
+
+ccc provides full molecule codec:
+
+- `ccc.molecule.struct()` - for OutPoint { tx_hash, index }
+- `ccc.molecule.vector()` - for OutPointVec
+- `ccc.Byte32`, `ccc.Uint32LE` - predefined codecs
+
+No manual bytes parsing needed!
+
+---
+
+## Work Objectives
+
+### Core Objective
+
+Replace `ckb-transaction-dumper` with pure ccc implementation.
+
+### Must Have
+
+- Keep `DumpOption` interface
+- Keep `dumpTransaction()` signature
+- Same JSON output format
+
+### Must NOT Have
+
+- Breaking API changes
+- New dependencies
+
+---
+
+## TODOs
+
+- [ ] 1. Implement ccc-based transaction dumper
+
+  **What to do**:
+
+  - Rewrite `src/tools/ckb-tx-dumper.ts`
+  - Use ccc Client for RPC calls
+  - Use ccc molecule codecs for dep_group unpacking
+
+  **Key implementation**:
+
+  ```typescript
+  import { ccc } from '@ckb-ccc/core';
+
+  // OutPoint codec for dep_group unpacking
+  const OutPointCodec = ccc.molecule.struct({
+    txHash: ccc.Byte32,
+    index: ccc.Uint32LE,
+  });
+
+  const OutPointVecCodec = ccc.molecule.vector(OutPointCodec);
+
+  // Unpack dep_group data
+  function unpackDepGroup(data: string): ccc.OutPoint[] {
+    return OutPointVecCodec.decode(data).map((o) =>
+      ccc.OutPoint.from({ txHash: o.txHash, index: '0x' + o.index.toString(16) }),
+    );
+  }
+  ```
+
+  **Acceptance Criteria**:
+
+  - [ ] Uses ccc Client for RPC
+  - [ ] Uses ccc molecule for dep_group
+  - [ ] Same output format
+
+  **QA Scenarios**:
+
+  ```
+  Scenario: Compiles successfully
+    Tool: Bash
+    Steps: npm run typecheck
+    Expected: No errors
+  ```
+
+  **Commit**: `feat: implement transaction dumper with ccc`
+
+---
+
+- [ ] 2. Remove ckb-transaction-dumper dependency
+
+  **What to do**:
+
+  - Remove from `package.json`
+  - Run `pnpm install`
+
+  **Commit**: `chore: remove ckb-transaction-dumper`
+
+---
+
+## Verification
+
+```bash
+npm run typecheck
+npm run lint
+grep -c "ckb-transaction-dumper" package.json || echo "Clean"
+```
+
+## Key Implementation Notes
+
+### Dep Group Unpacking with ccc
+
+```typescript
+const OutPointCodec = ccc.molecule.struct({
+  txHash: ccc.Byte32,
+  index: ccc.Uint32LE,
+});
+const OutPointVecCodec = ccc.molecule.vector(OutPointCodec);
+
+// Usage
+const outpoints = OutPointVecCodec.decode(cellData);
+```
+
+### Mock Transaction Structure
+
+```typescript
+interface MockTransaction {
+  mock_info: {
+    inputs: MockInput[];
+    cell_deps: MockCellDep[];
+    header_deps: any[];
+  };
+  tx: Transaction;
+}
+```
+
+### Algorithm
+
+1. Load tx from file
+2. For each cell_dep:
+   - Fetch cell
+   - If dep_type === 'dep_group':
+     - Decode cell.data as OutPointVec
+     - Fetch each referenced cell
+   - Add to mock_info.cell_deps
+3. For each input:
+   - Fetch referenced cell
+   - Add to mock_info.inputs
+4. Write JSON output

package.json

@@ -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",

pnpm-lock.yaml

@@ -81,9 +81,9 @@ program
     const txHash = option.txHash;
     if (option.singleScript) {
       const { cellType, cellIndex, scriptType } = parseSingleScriptOption(option.singleScript);
-      return debugSingleScript(txHash, cellIndex, cellType, scriptType, option.network, option.bin);
+      return await debugSingleScript(txHash, cellIndex, cellType, scriptType, option.network, option.bin);
     }
-    return debugTransaction(txHash, option.network);
+    return await debugTransaction(txHash, option.network);
   });
 
 program

src/cli.ts

@@ -8,8 +8,8 @@ import { Network } from '../type/base';
 import { encodeBinPathForTerminal } from '../util/encoding';
 import { logger } from '../util/logger';
 
-export function debugTransaction(txHash: string, network: Network) {
-  const txFile = buildTxFileOptionBy(txHash, network);
+export async function debugTransaction(txHash: string, network: Network) {
+  const txFile = await buildTxFileOptionBy(txHash, network);
   const opts = buildTransactionDebugOptions(txHash, network);
   for (const opt of opts) {
     logger.section(opt.name, [], 'info');
@@ -48,15 +48,15 @@ export function buildTransactionDebugOptions(txHash: string, network: Network) {
   return result;
 }
 
-export function debugSingleScript(
+export async function debugSingleScript(
   txHash: string,
   cellIndex: number,
   cellType: 'input' | 'output',
   scriptType: 'type' | 'lock',
   network: Network,
   bin?: string,
 ) {
-  const txFile = buildTxFileOptionBy(txHash, network);
+  const txFile = await buildTxFileOptionBy(txHash, network);
   let opt = `--cell-index ${cellIndex} --cell-type ${cellType} --script-group-type ${scriptType}`;
   if (bin) {
     opt = opt + ` --bin ${bin}`;
@@ -81,7 +81,7 @@ export function parseSingleScriptOption(value: string) {
   };
 }
 
-export function buildTxFileOptionBy(txHash: string, network: Network) {
+export async function buildTxFileOptionBy(txHash: string, network: Network) {
   const settings = readSettings();
   const outputFilePath = buildDebugFullTransactionFilePath(network, txHash);
   if (!fs.existsSync(outputFilePath)) {
@@ -90,7 +90,7 @@ export function buildTxFileOptionBy(txHash: string, network: Network) {
     if (!fs.existsSync(outputFilePath)) {
       fs.mkdirSync(path.dirname(outputFilePath), { recursive: true });
     }
-    dumpTransaction({ rpc, txJsonFilePath, outputFilePath });
+    await dumpTransaction({ rpc, txJsonFilePath, outputFilePath });
   }
   const opt = `--tx-file ${encodeBinPathForTerminal(outputFilePath)}`;
   return opt;