diff --git a/.github/workflows/cargo-publish-ckb-testtool.yml b/.github/workflows/cargo-publish-ckb-testtool.yml
deleted file mode 100644
index ff82579..0000000
--- a/.github/workflows/cargo-publish-ckb-testtool.yml
+++ /dev/null
@@ -1,19 +0,0 @@
-name: Cargo Publish
-
-on:
-  push:
-    tags:
-      - '*'
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v1
-    - name: Publish
-      env:
-        CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
-      working-directory: ./crates/testtool
-      run: cargo publish
diff --git a/Cargo.lock b/Cargo.lock
index 90bf829..eb55aa6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -639,7 +639,9 @@ checksum = "d4dc9b70fa7a9ecb0cf285cadab32139c58be9fee08b94e019b15d6b3f5296ef"
 
 [[package]]
 name = "ckb-testtool"
-version = "0.12.0"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b635fc26720bc75d363b3f5159574a09b4cc0cc767b02f315ae3abf7333d41d"
 dependencies = [
  "ckb-always-success-script",
  "ckb-chain-spec",
@@ -653,6 +655,7 @@ dependencies = [
  "ckb-traits",
  "ckb-types",
  "ckb-verification",
+ "faster-hex",
  "lazy_static",
  "rand 0.8.5",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 2c99899..5005f07 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,14 +38,13 @@ chrono = { version = "0.4.24", default-features = false, features = ["std"] }
 xshell = "=0.2.2"
 path_macro = "1.0.0"
 ckb-sdk = "3.1"
-ckb-testtool = { version = "0.12.0", path = "crates/testtool" }
+ckb-testtool = "0.13"
 
 [build-dependencies]
 includedir_codegen = "0.6"
 
 [workspace]
 members = [
-    "crates/testtool",
     "crates/tests",
 ]
 exclude = ["tmp", "tests/test-contract"]
diff --git a/README.md b/README.md
index 26ce2c6..1f882d0 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,6 @@
 Capsule consists of:
 
 - Capsule CLI - Scaffolding tool.
-- [CKB-testtool](https://github.com/nervosnetwork/capsule/tree/develop/crates/testtool) - CKB scripts testing framework.
 
 CKB supports several programming languages for writing scripts, and the language supporting libraries are maintained in the following repositories:
 
diff --git a/crates/tests/Cargo.toml b/crates/tests/Cargo.toml
index 0975d8a..51a5642 100644
--- a/crates/tests/Cargo.toml
+++ b/crates/tests/Cargo.toml
@@ -8,5 +8,5 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0"
-ckb-testtool = { path = "../testtool" }
+ckb-testtool = "0.13"
 ckb-system-scripts = "0.5"
diff --git a/crates/tests/test-contract/tests/Cargo.toml b/crates/tests/test-contract/tests/Cargo.toml
index 68c5ffd..632b2ac 100644
--- a/crates/tests/test-contract/tests/Cargo.toml
+++ b/crates/tests/test-contract/tests/Cargo.toml
@@ -6,4 +6,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-ckb-testtool = { path = "../testtool" }
+ckb-testtool = "0.13"
diff --git a/crates/testtool/Cargo.toml b/crates/testtool/Cargo.toml
deleted file mode 100644
index 686edbf..0000000
--- a/crates/testtool/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-name = "ckb-testtool"
-version = "0.12.0"
-authors = ["Nervos Network"]
-edition = "2021"
-license = "MIT"
-description = "CKB contract testing tools"
-repository = "https://github.com/nervosnetwork/capsule"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-ckb-always-success-script = "0.0.1"
-rand = "0.8"
-lazy_static = "1.4"
-ckb-chain-spec = "0.116.1"
-ckb-types = "0.116.1"
-ckb-error = "0.116.1"
-ckb-script = "0.116.1"
-ckb-hash = "0.116.1"
-ckb-jsonrpc-types = "0.116.1"
-ckb-crypto = "0.116.1"
-ckb-resource = "0.116.1"
-ckb-verification = "0.116.1"
-ckb-traits = "0.116.1"
-ckb-mock-tx-types = "0.116.1"
diff --git a/crates/testtool/src/builtin.rs b/crates/testtool/src/builtin.rs
deleted file mode 100644
index f7c372b..0000000
--- a/crates/testtool/src/builtin.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//! This module contains some builtin contracts
-
-use ckb_types::bytes::Bytes;
-use lazy_static::lazy_static;
-
-lazy_static! {
-    /// Always return success
-    pub static ref ALWAYS_SUCCESS: Bytes =
-        ckb_always_success_script::ALWAYS_SUCCESS.to_vec().into();
-}
diff --git a/crates/testtool/src/context.rs b/crates/testtool/src/context.rs
deleted file mode 100644
index 26cfce0..0000000
--- a/crates/testtool/src/context.rs
+++ /dev/null
@@ -1,488 +0,0 @@
-use crate::tx_verifier::OutputsDataVerifier;
-use ckb_chain_spec::consensus::{ConsensusBuilder, TYPE_ID_CODE_HASH};
-use ckb_error::Error as CKBError;
-use ckb_mock_tx_types::{MockCellDep, MockInfo, MockInput, MockTransaction, ReprMockTransaction};
-use ckb_script::{TransactionScriptsVerifier, TxVerifyEnv};
-use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
-use ckb_types::{
-    bytes::Bytes,
-    core::{
-        cell::{CellMeta, CellMetaBuilder, ResolvedTransaction},
-        hardfork::{HardForks, CKB2021, CKB2023},
-        Capacity, Cycle, DepType, EpochExt, HeaderBuilder, HeaderView, ScriptHashType,
-        TransactionInfo, TransactionView,
-    },
-    packed::{Byte32, CellDep, CellDepBuilder, CellOutput, OutPoint, OutPointVec, Script},
-    prelude::*,
-};
-use rand::{thread_rng, Rng};
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
-
-/// Return a random hash
-pub fn random_hash() -> Byte32 {
-    let mut rng = thread_rng();
-    let mut buf = [0u8; 32];
-    rng.fill(&mut buf);
-    buf.pack()
-}
-
-/// Return a random OutPoint
-pub fn random_out_point() -> OutPoint {
-    OutPoint::new_builder().tx_hash(random_hash()).build()
-}
-
-/// Return a random Type ID Script
-pub fn random_type_id_script() -> Script {
-    let args = random_hash().as_bytes();
-    debug_assert_eq!(args.len(), 32);
-    Script::new_builder()
-        .code_hash(TYPE_ID_CODE_HASH.pack())
-        .hash_type(ScriptHashType::Type.into())
-        .args(args.pack())
-        .build()
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct Message {
-    pub id: Byte32,
-    pub message: String,
-}
-
-/// Verification Context
-#[derive(Clone, Default)]
-pub struct Context {
-    pub cells: HashMap<OutPoint, (CellOutput, Bytes)>,
-    pub transaction_infos: HashMap<OutPoint, TransactionInfo>,
-    pub headers: HashMap<Byte32, HeaderView>,
-    pub epoches: HashMap<Byte32, EpochExt>,
-    pub block_extensions: HashMap<Byte32, Bytes>,
-    pub cells_by_data_hash: HashMap<Byte32, OutPoint>,
-    pub cells_by_type_hash: HashMap<Byte32, OutPoint>,
-    capture_debug: bool,
-    captured_messages: Arc<Mutex<Vec<Message>>>,
-}
-
-impl Context {
-    #[deprecated(since = "0.1.1", note = "Please use the deploy_cell function instead")]
-    pub fn deploy_contract(&mut self, data: Bytes) -> OutPoint {
-        self.deploy_cell(data)
-    }
-
-    /// Deploy a cell
-    /// return the out-point of the cell
-    pub fn deploy_cell(&mut self, data: Bytes) -> OutPoint {
-        let data_hash = CellOutput::calc_data_hash(&data);
-        if let Some(out_point) = self.cells_by_data_hash.get(&data_hash) {
-            // contract has been deployed
-            return out_point.to_owned();
-        }
-        let mut rng = thread_rng();
-        let tx_hash = {
-            let mut buf = [0u8; 32];
-            rng.fill(&mut buf);
-            buf.pack()
-        };
-        let out_point = OutPoint::new(tx_hash, 0);
-        let type_id_script = random_type_id_script();
-        let type_id_hash = type_id_script.calc_script_hash();
-        let cell = {
-            let cell = CellOutput::new_builder()
-                .type_(Some(type_id_script).pack())
-                .build();
-            let occupied_capacity = cell
-                .occupied_capacity(Capacity::bytes(data.len()).expect("data occupied capacity"))
-                .expect("cell capacity");
-            cell.as_builder().capacity(occupied_capacity.pack()).build()
-        };
-        self.cells.insert(out_point.clone(), (cell, data));
-        self.cells_by_data_hash.insert(data_hash, out_point.clone());
-        self.cells_by_type_hash
-            .insert(type_id_hash, out_point.clone());
-        out_point
-    }
-
-    /// Insert a block header into context
-    pub fn insert_header(&mut self, header: HeaderView) {
-        self.headers.insert(header.hash(), header);
-    }
-
-    /// Link a cell with a block
-    /// to make the load_header_by_cell syscalls works
-    pub fn link_cell_with_block(
-        &mut self,
-        out_point: OutPoint,
-        block_hash: Byte32,
-        tx_index: usize,
-    ) {
-        let header = self
-            .headers
-            .get(&block_hash)
-            .expect("can't find the header");
-        self.transaction_infos.insert(
-            out_point,
-            TransactionInfo::new(header.number(), header.epoch(), block_hash, tx_index),
-        );
-    }
-
-    #[deprecated(
-        since = "0.1.1",
-        note = "Please use the get_cell_by_data_hash function instead"
-    )]
-    pub fn get_contract_out_point(&self, data_hash: &Byte32) -> Option<OutPoint> {
-        self.get_cell_by_data_hash(data_hash)
-    }
-
-    /// Get the out-point of a cell by data_hash
-    /// the cell must has deployed to this context
-    pub fn get_cell_by_data_hash(&self, data_hash: &Byte32) -> Option<OutPoint> {
-        self.cells_by_data_hash.get(data_hash).cloned()
-    }
-
-    /// Create a cell with data
-    /// return the out-point
-    pub fn create_cell(&mut self, cell: CellOutput, data: Bytes) -> OutPoint {
-        let out_point = random_out_point();
-        self.create_cell_with_out_point(out_point.clone(), cell, data);
-        out_point
-    }
-
-    /// Create cell with specified out-point and cell data
-    pub fn create_cell_with_out_point(
-        &mut self,
-        out_point: OutPoint,
-        cell: CellOutput,
-        data: Bytes,
-    ) {
-        let data_hash = CellOutput::calc_data_hash(&data);
-        self.cells_by_data_hash.insert(data_hash, out_point.clone());
-        if let Some(_type) = cell.type_().to_opt() {
-            let type_hash = _type.calc_script_hash();
-            self.cells_by_type_hash.insert(type_hash, out_point.clone());
-        }
-        self.cells.insert(out_point, (cell, data));
-    }
-
-    #[deprecated(
-        since = "0.1.1",
-        note = "Please use the create_cell_with_out_point function instead"
-    )]
-    pub fn insert_cell(&mut self, out_point: OutPoint, cell: CellOutput, data: Bytes) {
-        self.create_cell_with_out_point(out_point, cell, data)
-    }
-
-    /// Get cell output and data by out-point
-    pub fn get_cell(&self, out_point: &OutPoint) -> Option<(CellOutput, Bytes)> {
-        self.cells.get(out_point).cloned()
-    }
-
-    /// Build script with out_point, hash_type, args
-    /// return none if the out-point is not exist
-    pub fn build_script_with_hash_type(
-        &mut self,
-        out_point: &OutPoint,
-        hash_type: ScriptHashType,
-        args: Bytes,
-    ) -> Option<Script> {
-        let (cell, contract_data) = self.cells.get(out_point)?;
-        let code_hash = match hash_type {
-            ScriptHashType::Data | ScriptHashType::Data1 | ScriptHashType::Data2 => {
-                CellOutput::calc_data_hash(contract_data)
-            }
-            ScriptHashType::Type => cell
-                .type_()
-                .to_opt()
-                .expect("get cell's type hash")
-                .calc_script_hash(),
-        };
-        Some(
-            Script::new_builder()
-                .code_hash(code_hash)
-                .hash_type(hash_type.into())
-                .args(args.pack())
-                .build(),
-        )
-    }
-    /// Build script with out_point, args and hash_type(ScriptHashType::Type)
-    /// return none if the out-point is not exist
-    pub fn build_script(&mut self, out_point: &OutPoint, args: Bytes) -> Option<Script> {
-        self.build_script_with_hash_type(out_point, ScriptHashType::Type, args)
-    }
-
-    fn find_cell_dep_for_script(&self, script: &Script) -> CellDep {
-        let out_point = match ScriptHashType::try_from(u8::from(script.hash_type()))
-            .expect("invalid script hash type")
-        {
-            ScriptHashType::Data | ScriptHashType::Data1 | ScriptHashType::Data2 => self
-                .get_cell_by_data_hash(&script.code_hash())
-                .expect("find contract out point by data_hash"),
-            ScriptHashType::Type => self
-                .cells_by_type_hash
-                .get(&script.code_hash())
-                .cloned()
-                .expect("find contract out point by type_hash"),
-        };
-
-        CellDep::new_builder()
-            .out_point(out_point)
-            .dep_type(DepType::Code.into())
-            .build()
-    }
-
-    /// Complete cell deps for a transaction
-    /// this function searches context cells; generate cell dep for referenced scripts.
-    pub fn complete_tx(&mut self, tx: TransactionView) -> TransactionView {
-        let mut cell_deps: Vec<CellDep> = Vec::new();
-
-        for cell_dep in tx.cell_deps_iter() {
-            cell_deps.push(cell_dep);
-        }
-
-        for i in tx.input_pts_iter() {
-            if let Some((cell, _data)) = self.cells.get(&i) {
-                let dep = self.find_cell_dep_for_script(&cell.lock());
-                if !cell_deps.contains(&dep) {
-                    cell_deps.push(dep);
-                }
-                if let Some(script) = cell.type_().to_opt() {
-                    let dep = self.find_cell_dep_for_script(&script);
-                    if !cell_deps.contains(&dep) {
-                        cell_deps.push(dep);
-                    }
-                }
-            }
-        }
-
-        for (cell, _data) in tx.outputs_with_data_iter() {
-            if let Some(script) = cell.type_().to_opt() {
-                let dep = self.find_cell_dep_for_script(&script);
-                if !cell_deps.contains(&dep) {
-                    cell_deps.push(dep);
-                }
-            }
-        }
-
-        tx.as_advanced_builder()
-            .set_cell_deps(Vec::new())
-            .cell_deps(cell_deps.pack())
-            .build()
-    }
-
-    fn build_resolved_tx(&self, tx: &TransactionView) -> ResolvedTransaction {
-        let input_cells = tx
-            .inputs()
-            .into_iter()
-            .map(|input| {
-                let previous_out_point = input.previous_output();
-                let (input_output, input_data) = self.cells.get(&previous_out_point).unwrap();
-                let tx_info_opt = self.transaction_infos.get(&previous_out_point);
-                let mut b = CellMetaBuilder::from_cell_output(
-                    input_output.to_owned(),
-                    input_data.to_vec().into(),
-                )
-                .out_point(previous_out_point);
-                if let Some(tx_info) = tx_info_opt {
-                    b = b.transaction_info(tx_info.to_owned());
-                }
-                b.build()
-            })
-            .collect();
-        let mut resolved_cell_deps = vec![];
-        let mut resolved_dep_groups = vec![];
-        tx.cell_deps().into_iter().for_each(|cell_dep| {
-            let mut out_points = vec![];
-            if cell_dep.dep_type() == DepType::DepGroup.into() {
-                let (dep_group_output, dep_group_data) =
-                    self.cells.get(&cell_dep.out_point()).unwrap();
-                let dep_group_tx_info_opt = self.transaction_infos.get(&cell_dep.out_point());
-                let mut b = CellMetaBuilder::from_cell_output(
-                    dep_group_output.to_owned(),
-                    dep_group_data.to_vec().into(),
-                )
-                .out_point(cell_dep.out_point());
-                if let Some(tx_info) = dep_group_tx_info_opt {
-                    b = b.transaction_info(tx_info.to_owned());
-                }
-                resolved_dep_groups.push(b.build());
-
-                let sub_out_points =
-                    OutPointVec::from_slice(dep_group_data).expect("Parsing dep group error!");
-                out_points.extend(sub_out_points.into_iter());
-            } else {
-                out_points.push(cell_dep.out_point());
-            }
-
-            for out_point in out_points {
-                let (dep_output, dep_data) = self.cells.get(&out_point).unwrap();
-                let tx_info_opt = self.transaction_infos.get(&out_point);
-                let mut b = CellMetaBuilder::from_cell_output(
-                    dep_output.to_owned(),
-                    dep_data.to_vec().into(),
-                )
-                .out_point(out_point);
-                if let Some(tx_info) = tx_info_opt {
-                    b = b.transaction_info(tx_info.to_owned());
-                }
-                resolved_cell_deps.push(b.build());
-            }
-        });
-        ResolvedTransaction {
-            transaction: tx.clone(),
-            resolved_cell_deps,
-            resolved_inputs: input_cells,
-            resolved_dep_groups,
-        }
-    }
-
-    // check format and consensus rules
-    fn verify_tx_consensus(&self, tx: &TransactionView) -> Result<(), CKBError> {
-        OutputsDataVerifier::new(tx).verify()?;
-        Ok(())
-    }
-
-    pub fn capture_debug(&self) -> bool {
-        self.capture_debug
-    }
-
-    /// Capture debug output, default value is false
-    pub fn set_capture_debug(&mut self, capture_debug: bool) {
-        self.capture_debug = capture_debug;
-    }
-
-    /// return captured messages
-    pub fn captured_messages(&self) -> Vec<Message> {
-        self.captured_messages.lock().unwrap().clone()
-    }
-
-    /// Verify the transaction in CKB-VM
-    pub fn verify_tx(&self, tx: &TransactionView, max_cycles: u64) -> Result<Cycle, CKBError> {
-        self.verify_tx_consensus(tx)?;
-        let resolved_tx = self.build_resolved_tx(tx);
-        let consensus = ConsensusBuilder::default()
-            .hardfork_switch(HardForks {
-                ckb2021: CKB2021::new_dev_default(),
-                ckb2023: CKB2023::new_dev_default(),
-            })
-            .build();
-        let tip = HeaderBuilder::default().number(0.pack()).build();
-        let tx_verify_env = TxVerifyEnv::new_submit(&tip);
-        let mut verifier = TransactionScriptsVerifier::new(
-            Arc::new(resolved_tx),
-            self.clone(),
-            Arc::new(consensus),
-            Arc::new(tx_verify_env),
-        );
-        if self.capture_debug {
-            let captured_messages = self.captured_messages.clone();
-            verifier.set_debug_printer(move |id, message| {
-                let msg = Message {
-                    id: id.clone(),
-                    message: message.to_string(),
-                };
-                captured_messages.lock().unwrap().push(msg);
-            });
-        } else {
-            verifier.set_debug_printer(|_id, msg| {
-                println!("[contract debug] {}", msg);
-            });
-        }
-        verifier.verify(max_cycles)
-    }
-
-    /// Dump the transaction in mock transaction format, so we can offload it to ckb debugger
-    pub fn dump_tx(&self, tx: &TransactionView) -> Result<ReprMockTransaction, CKBError> {
-        let rtx = self.build_resolved_tx(tx);
-        let mut inputs = Vec::with_capacity(rtx.resolved_inputs.len());
-        // We are doing it this way so we can keep original since value is available
-        for (i, input) in rtx.resolved_inputs.iter().enumerate() {
-            inputs.push(MockInput {
-                input: rtx.transaction.inputs().get(i).unwrap(),
-                output: input.cell_output.clone(),
-                data: input.mem_cell_data.clone().unwrap(),
-                header: input.transaction_info.clone().map(|info| info.block_hash),
-            });
-        }
-        // MockTransaction keeps both types of cell deps in a single array, the order does
-        // not really matter for now
-        let mut cell_deps =
-            Vec::with_capacity(rtx.resolved_cell_deps.len() + rtx.resolved_dep_groups.len());
-        for dep in rtx.resolved_cell_deps.iter() {
-            cell_deps.push(MockCellDep {
-                cell_dep: CellDepBuilder::default()
-                    .out_point(dep.out_point.clone())
-                    .dep_type(DepType::Code.into())
-                    .build(),
-                output: dep.cell_output.clone(),
-                data: dep.mem_cell_data.clone().unwrap(),
-                header: None,
-            });
-        }
-        for dep in rtx.resolved_dep_groups.iter() {
-            cell_deps.push(MockCellDep {
-                cell_dep: CellDepBuilder::default()
-                    .out_point(dep.out_point.clone())
-                    .dep_type(DepType::DepGroup.into())
-                    .build(),
-                output: dep.cell_output.clone(),
-                data: dep.mem_cell_data.clone().unwrap(),
-                header: None,
-            });
-        }
-        let mut header_deps = Vec::with_capacity(rtx.transaction.header_deps().len());
-        let mut extensions = Vec::new();
-        for header_hash in rtx.transaction.header_deps_iter() {
-            header_deps.push(self.get_header(&header_hash).unwrap());
-            if let Some(extension) = self.get_block_extension(&header_hash) {
-                extensions.push((header_hash, extension.unpack()));
-            }
-        }
-        Ok(MockTransaction {
-            mock_info: MockInfo {
-                inputs,
-                cell_deps,
-                header_deps,
-                extensions,
-            },
-            tx: rtx.transaction.data(),
-        }
-        .into())
-    }
-}
-
-impl CellDataProvider for Context {
-    // load Cell Data
-    fn load_cell_data(&self, cell: &CellMeta) -> Option<Bytes> {
-        cell.mem_cell_data
-            .as_ref()
-            .map(|data| Bytes::from(data.to_vec()))
-            .or_else(|| self.get_cell_data(&cell.out_point))
-    }
-
-    fn get_cell_data(&self, out_point: &OutPoint) -> Option<Bytes> {
-        self.cells
-            .get(out_point)
-            .map(|(_, data)| Bytes::from(data.to_vec()))
-    }
-
-    fn get_cell_data_hash(&self, out_point: &OutPoint) -> Option<Byte32> {
-        self.cells
-            .get(out_point)
-            .map(|(_, data)| CellOutput::calc_data_hash(data))
-    }
-}
-
-impl HeaderProvider for Context {
-    // load header
-    fn get_header(&self, block_hash: &Byte32) -> Option<HeaderView> {
-        self.headers.get(block_hash).cloned()
-    }
-}
-
-impl ExtensionProvider for Context {
-    fn get_block_extension(
-        &self,
-        hash: &ckb_types::packed::Byte32,
-    ) -> Option<ckb_types::packed::Bytes> {
-        self.block_extensions.get(hash).map(|b| b.pack())
-    }
-}
diff --git a/crates/testtool/src/lib.rs b/crates/testtool/src/lib.rs
deleted file mode 100644
index 1eee052..0000000
--- a/crates/testtool/src/lib.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-//! ckb-testtool
-//!
-//! This module provides testing context for CKB contracts.
-//!
-//! To setup a contract verification context, you may need to import ckb modules
-//! to build the transaction structure or calculate the hash result.
-//! `ckb-testtool` crate provides re-exports of ckb modules.
-//!
-//! # Example
-//!
-//! ``` rust
-//! use ckb_testtool::context::Context;
-//! use ckb_testtool::ckb_types::{
-//!     bytes::Bytes,
-//!     core::TransactionBuilder,
-//!     packed::*,
-//!     prelude::*,
-//! };
-//! use std::fs;
-//!
-//! // max cycles of verification
-//! const MAX_CYCLES: u64 = 10_000_000;
-//!
-//! #[test]
-//! fn test_basic() {
-//!     // Init testing context
-//!     let mut context = Context::default();
-//!     let contract_bin: Bytes = fs::read("my_contract").unwrap().into();
-//!
-//!     // deploy contract
-//!     let out_point = context.deploy_cell(contract_bin);
-//!
-//!     // prepare scripts and cell dep
-//!     let lock_script = context
-//!         .build_script(&out_point, Default::default())
-//!         .expect("script");
-//!
-//!     // prepare input cell
-//!     let input_out_point = context.create_cell(
-//!         CellOutput::new_builder()
-//!             .capacity(1000u64.pack())
-//!             .lock(lock_script.clone())
-//!             .build(),
-//!         Bytes::new(),
-//!     );
-//!     let input = CellInput::new_builder()
-//!         .previous_output(input_out_point)
-//!         .build();
-//!
-//!     // outputs
-//!     let outputs = vec![
-//!         CellOutput::new_builder()
-//!             .capacity(500u64.pack())
-//!             .lock(lock_script.clone())
-//!             .build(),
-//!         CellOutput::new_builder()
-//!             .capacity(500u64.pack())
-//!             .lock(lock_script)
-//!             .build(),
-//!     ];
-//!
-//!     let outputs_data = vec![Bytes::new(); 2];
-//!
-//!     // build transaction
-//!     let tx = TransactionBuilder::default()
-//!         .input(input)
-//!         .outputs(outputs)
-//!         .outputs_data(outputs_data.pack())
-//!         .build();
-//!
-//!     let tx = context.complete_tx(tx);
-//!
-//!     // run
-//!     let cycles = context
-//!         .verify_tx(&tx, MAX_CYCLES)
-//!         .expect("pass verification");
-//!     println!("consume cycles: {}", cycles);
-//! }
-//! ```
-
-pub mod builtin;
-pub mod context;
-mod tx_verifier;
-
-// re-exports
-pub use ckb_chain_spec;
-pub use ckb_crypto;
-pub use ckb_error;
-pub use ckb_hash;
-pub use ckb_jsonrpc_types;
-pub use ckb_script;
-pub use ckb_traits;
-pub use ckb_types;
-pub use ckb_types::bytes;
-pub use ckb_verification;
diff --git a/crates/testtool/src/tx_verifier.rs b/crates/testtool/src/tx_verifier.rs
deleted file mode 100644
index 2d91979..0000000
--- a/crates/testtool/src/tx_verifier.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use ckb_types::core::TransactionView;
-use ckb_verification::TransactionError;
-
-pub struct OutputsDataVerifier<'a> {
-    transaction: &'a TransactionView,
-}
-
-impl<'a> OutputsDataVerifier<'a> {
-    pub fn new(transaction: &'a TransactionView) -> Self {
-        Self { transaction }
-    }
-
-    pub fn verify(&self) -> Result<(), TransactionError> {
-        let outputs_len = self.transaction.outputs().len();
-        let outputs_data_len = self.transaction.outputs_data().len();
-
-        if outputs_len != outputs_data_len {
-            return Err(TransactionError::OutputsDataLengthMismatch {
-                outputs_data_len,
-                outputs_len,
-            });
-        }
-        Ok(())
-    }
-}
diff --git a/templates/rust/tests/Cargo-manifest.toml b/templates/rust/tests/Cargo-manifest.toml
index 68a1f23..632b2ac 100644
--- a/templates/rust/tests/Cargo-manifest.toml
+++ b/templates/rust/tests/Cargo-manifest.toml
@@ -6,4 +6,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-ckb-testtool = "0.11"
+ckb-testtool = "0.13"